(require 'elk-test)

(deftest "deftest"
  (let ((elk-test-alist nil)
        (elk-test-run-on-define nil))
    (deftest "test1" (assert-equal t t))
    (assert-equal '((assert-equal t t)) (cdr (assoc "test1" elk-test-alist)))
    (assert-nil (cdr (assoc "test2" elk-test-alist)))

    (deftest "test2" (assert-equal nil nil))
    (assert-equal '((assert-equal nil nil))
                  (cdr (assoc "test2" elk-test-alist)))

    (assert-equal 2 (length elk-test-alist))

    (deftest "test1" (assert-equal t t))
    (assert-equal 2 (length elk-test-alist))
    ))

(deftest "assert-equal"
  (assert-nil (elk-test-run-internal '((assert-equal t t))))
  (assert-nil (elk-test-run-internal '((assert-equal nil nil))))
  (assert-nil (elk-test-run-internal '((assert-equal 5.0 5.0))))
  (assert-nonnil (elk-test-run-internal '((assert-equal t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-equal nil t))))
  (let ((foo t) (bar t))
    (assert-nonnil (elk-test-run-internal '((assert-equal 'foo 'bar))))
    (assert-nil (elk-test-run-internal '((assert-equal foo bar))))))

(deftest "assert-eq"
  (assert-nil (elk-test-run-internal '((assert-eq t t))))
  (assert-nil (elk-test-run-internal '((assert-eq nil nil))))
  (assert-nonnil (elk-test-run-internal '((assert-eq 5.0 5.0))))
  (assert-nonnil (elk-test-run-internal '((assert-eq t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-eq nil t))))
    (let ((foo t) (bar t) (more nil))
    (assert-nonnil (elk-test-run-internal '((assert-eq 'foo 'bar))))
    (assert-nil (elk-test-run-internal '((assert-eq foo bar))))
    (assert-nonnil (elk-test-run-internal '((assert-eq foo more))))))

(deftest "assert-eql"
  (assert-nil (elk-test-run-internal '((assert-eql t t))))
  (assert-nil (elk-test-run-internal '((assert-eql nil nil))))
  (assert-nil (elk-test-run-internal '((assert-eql 5.0 5.0))))
  (assert-nonnil (elk-test-run-internal '((assert-eql t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-eq nil t))))
  (let ((foo t) (bar t) (more nil))
    (assert-nonnil (elk-test-run-internal '((assert-eql 'foo 'bar))))
    (assert-nil (elk-test-run-internal '((assert-eql foo bar))))
    (assert-nonnil (elk-test-run-internal '((assert-eql foo more))))))

(deftest "assert-nonnil"
  (assert-nil (elk-test-run-internal '((assert-nonnil t))))
  (assert-nil (not (elk-test-run-internal '((assert-nonnil nil)))))
  (let ((foo t) (bar nil))
    (assert-nil (elk-test-run-internal '((assert-nonnil foo))))
    (assert-nil (not (elk-test-run-internal '((assert-nonnil bar)))))
    (assert-nil (elk-test-run-internal '((assert-nonnil 'foo))))))

(deftest "assert-t"
  (assert-nil (elk-test-run-internal '((assert-t t))))
  (assert-nonnil (elk-test-run-internal '((assert-t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-t 'nonnil))))
  (let ((foo t) (bar nil))
    (assert-nil (elk-test-run-internal '((assert-t foo))))
    (assert-nonnil (elk-test-run-internal '((assert-t bar))))
    (assert-nonnil (elk-test-run-internal '((assert-t 'foo))))))

(deftest "assert-nil"
  (assert-nonnil (elk-test-run-internal '((assert-nil t))))
  (assert-nonnil (not (elk-test-run-internal '((assert-nil nil)))))
  (assert-nonnil (elk-test-run-internal '((assert-nil 'nonnil))))
  (let ((foo t) (bar nil))
    (assert-nonnil (elk-test-run-internal '((assert-nil foo))))
    (assert-nonnil (not (elk-test-run-internal '((assert-nil bar)))))
    (assert-nonnil (elk-test-run-internal '((assert-nil 'foo))))))

(deftest "assert-error"
  (assert-nil (elk-test-run-internal '((assert-error "x" (error "x")))))
  (assert-nil (elk-test-run-internal '((assert-error "x" t (error "x")))))
  (assert-nonnil (elk-test-run-internal '((assert-error "y" (error "x")))))
  (assert-nonnil (elk-test-run-internal '((assert-error "y" t (error "x")))))
  (assert-nil (elk-test-run-internal '((assert-error nil (error "x")))))
  (assert-nil (elk-test-run-internal '((assert-error "x\\|y" (error "x")))))
  (assert-nil (elk-test-run-internal '((assert-error "x\\|y" (error "y")))))
  (assert-nonnil (elk-test-run-internal '((assert-error "x\\|y" (error "z")))))
  (assert-nonnil (elk-test-run-internal '((assert-error "y" nil nil))))
  (assert-nonnil (elk-test-run-internal '((assert-error "y" t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-error nil t nil))))
  (assert-nonnil (elk-test-run-internal '((assert-error "x\\|y" nil))))
  )

(deftest "assert-that"
  (assert-nil (elk-test-run-internal
               '((assert-that (lambda (result) (null result)) nil))))
  (assert-nonnil (elk-test-run-internal
                  '((assert-that (lambda (result) (null result)) t))))
  )

(deftest "run"
  (let ((elk-test-alist nil)
        (elk-test-run-on-define nil))

    (deftest "test" (assert-equal t nil))
    (assert-nonnil (elk-test-run "test"))

    (deftest "test2" (assert-equal t t))
    (assert-nil (elk-test-run "test2"))

    (elk-test-group "suite" "test" "test2")
    (assert-nonnil (elk-test-run "suite"))

    (deftest "test" (assert-equal t t))
    (assert-nil (elk-test-run "test"))

    (elk-test-group "suite" "test" "test2")
    (assert-nil (elk-test-run "suite"))
    ))