;;; ert-tests.el --- ERT's self-tests -*- lexical-binding: t -*-
-;; Copyright (C) 2007-2008, 2010-2012 Free Software Foundation, Inc.
+;; Copyright (C) 2007-2008, 2010-2014 Free Software Foundation, Inc.
;; Author: Christian Ohler <ohler@gnu.org>
;;; Code:
-(eval-when-compile
- (require 'cl-lib))
+(require 'cl-lib)
(require 'ert)
-
;;; Self-test that doesn't rely on ERT, for bootstrapping.
;; This is used to test that bodies actually run.
"the error signaled was a subtype of the expected type")))))
))
+(ert-deftest ert-test-skip-unless ()
+ ;; Don't skip.
+ (let ((test (make-ert-test :body (lambda () (skip-unless t)))))
+ (let ((result (ert-run-test test)))
+ (should (ert-test-passed-p result))))
+ ;; Skip.
+ (let ((test (make-ert-test :body (lambda () (skip-unless nil)))))
+ (let ((result (ert-run-test test)))
+ (should (ert-test-skipped-p result))))
+ ;; Skip in case of error.
+ (let ((test (make-ert-test :body (lambda () (skip-unless (error "Foo"))))))
+ (let ((result (ert-run-test test)))
+ (should (ert-test-skipped-p result)))))
+
(defmacro ert--test-my-list (&rest args)
"Don't use this. Instead, call `list' with ARGS, it does the same thing.
(ert-deftest ert-test-deftest ()
(should (equal (macroexpand '(ert-deftest abc () "foo" :tags '(bar)))
- '(progn
- (ert-set-test 'abc
- (make-ert-test :name 'abc
- :documentation "foo"
- :tags '(bar)
- :body (lambda ())))
- (push '(ert-deftest . abc) current-load-list)
- 'abc)))
+ '(progn
+ (ert-set-test 'abc
+ (progn
+ (vector 'cl-struct-ert-test 'abc "foo"
+ #'(lambda nil)
+ nil ':passed
+ '(bar))))
+ (setq current-load-list
+ (cons
+ '(ert-deftest . abc)
+ current-load-list))
+ 'abc)))
(should (equal (macroexpand '(ert-deftest def ()
:expected-result ':passed))
- '(progn
- (ert-set-test 'def
- (make-ert-test :name 'def
- :expected-result-type ':passed
- :body (lambda ())))
- (push '(ert-deftest . def) current-load-list)
- 'def)))
+ '(progn
+ (ert-set-test 'def
+ (progn
+ (vector 'cl-struct-ert-test 'def nil
+ #'(lambda nil)
+ nil ':passed 'nil)))
+ (setq current-load-list
+ (cons
+ '(ert-deftest . def)
+ current-load-list))
+ 'def)))
;; :documentation keyword is forbidden
(should-error (macroexpand '(ert-deftest ghi ()
:documentation "foo"))))
(with-temp-buffer
(ert--print-backtrace (ert-test-failed-backtrace result))
(goto-char (point-min))
- (end-of-line)
- (let ((first-line (buffer-substring-no-properties (point-min) (point))))
- (should (equal first-line " signal(ert-test-failed (\"foo\"))")))))))
+ (end-of-line)
+ (let ((first-line (buffer-substring-no-properties (point-min) (point))))
+ (should (equal first-line " (closure (ert--test-body-was-run t) nil (ert-fail \"foo\"))()")))))))
(ert-deftest ert-test-messages ()
:tags '(:causes-redisplay)
:body (lambda () (ert-pass))))
(failing-test (make-ert-test :name 'failing-test
:body (lambda () (ert-fail
- "failure message")))))
+ "failure message"))))
+ (skipped-test (make-ert-test :name 'skipped-test
+ :body (lambda () (ert-skip
+ "skip message")))))
(let ((ert-debug-on-error nil))
(let* ((buffer-name (generate-new-buffer-name " *ert-test-run-tests*"))
(messages nil)
(unwind-protect
(let ((case-fold-search nil))
(ert-run-tests-interactively
- `(member ,passing-test ,failing-test) buffer-name
+ `(member ,passing-test ,failing-test, skipped-test) buffer-name
mock-message-fn)
(should (equal messages `(,(concat
- "Ran 2 tests, 1 results were "
- "as expected, 1 unexpected"))))
+ "Ran 3 tests, 1 results were "
+ "as expected, 1 unexpected, "
+ "1 skipped"))))
(with-current-buffer buffer-name
(goto-char (point-min))
(should (equal
(buffer-substring (point-min)
(save-excursion
- (forward-line 4)
+ (forward-line 5)
(point)))
(concat
- "Selector: (member <passing-test> <failing-test>)\n"
- "Passed: 1\n"
- "Failed: 1 (1 unexpected)\n"
- "Total: 2/2\n")))))
+ "Selector: (member <passing-test> <failing-test> "
+ "<skipped-test>)\n"
+ "Passed: 1\n"
+ "Failed: 1 (1 unexpected)\n"
+ "Skipped: 1\n"
+ "Total: 3/3\n")))))
(when (get-buffer buffer-name)
(kill-buffer buffer-name))))))))
(should (ert--special-operator-p 'if))
(should-not (ert--special-operator-p 'car))
(should-not (ert--special-operator-p 'ert--special-operator-p))
- (let ((b (ert--gensym)))
+ (let ((b (cl-gensym)))
(should-not (ert--special-operator-p b))
(fset b 'if)
(should (ert--special-operator-p b))))
:explanation nil)
))))))
-(ert-deftest ert-test-remprop ()
- (let ((x (ert--gensym)))
- (should (equal (symbol-plist x) '()))
- ;; Remove nonexistent property on empty plist.
- (ert--remprop x 'b)
- (should (equal (symbol-plist x) '()))
- (put x 'a 1)
- (should (equal (symbol-plist x) '(a 1)))
- ;; Remove nonexistent property on nonempty plist.
- (ert--remprop x 'b)
- (should (equal (symbol-plist x) '(a 1)))
- (put x 'b 2)
- (put x 'c 3)
- (put x 'd 4)
- (should (equal (symbol-plist x) '(a 1 b 2 c 3 d 4)))
- ;; Remove property that is neither first nor last.
- (ert--remprop x 'c)
- (should (equal (symbol-plist x) '(a 1 b 2 d 4)))
- ;; Remove last property from a plist of length >1.
- (ert--remprop x 'd)
- (should (equal (symbol-plist x) '(a 1 b 2)))
- ;; Remove first property from a plist of length >1.
- (ert--remprop x 'a)
- (should (equal (symbol-plist x) '(b 2)))
- ;; Remove property when there is only one.
- (ert--remprop x 'b)
- (should (equal (symbol-plist x) '()))))
-
-(ert-deftest ert-test-remove-if-not ()
- (let ((list (list 'a 'b 'c 'd))
- (i 0))
- (let ((result (ert--remove-if-not (lambda (x)
- (should (eql x (nth i list)))
- (cl-incf i)
- (member i '(2 3)))
- list)))
- (should (equal i 4))
- (should (equal result '(b c)))
- (should (equal list '(a b c d)))))
- (should (equal '()
- (ert--remove-if-not (lambda (_x) (should nil)) '()))))
-
-(ert-deftest ert-test-remove* ()
- (let ((list (list 'a 'b 'c 'd))
- (key-index 0)
- (test-index 0))
- (let ((result
- (ert--remove* 'foo list
- :key (lambda (x)
- (should (eql x (nth key-index list)))
- (prog1
- (list key-index x)
- (cl-incf key-index)))
- :test
- (lambda (a b)
- (should (eql a 'foo))
- (should (equal b (list test-index
- (nth test-index list))))
- (cl-incf test-index)
- (member test-index '(2 3))))))
- (should (equal key-index 4))
- (should (equal test-index 4))
- (should (equal result '(a d)))
- (should (equal list '(a b c d)))))
- (let ((x (cons nil nil))
- (y (cons nil nil)))
- (should (equal (ert--remove* x (list x y))
- ;; or (list x), since we use `equal' -- the
- ;; important thing is that only one element got
- ;; removed, this proves that the default test is
- ;; `eql', not `equal'
- (list y)))))
-
-
-(ert-deftest ert-test-set-functions ()
- (let ((c1 (cons nil nil))
- (c2 (cons nil nil))
- (sym (make-symbol "a")))
- (let ((e '())
- (a (list 'a 'b sym nil "" "x" c1 c2))
- (b (list c1 'y 'b sym 'x)))
- (should (equal (ert--set-difference e e) e))
- (should (equal (ert--set-difference a e) a))
- (should (equal (ert--set-difference e a) e))
- (should (equal (ert--set-difference a a) e))
- (should (equal (ert--set-difference b e) b))
- (should (equal (ert--set-difference e b) e))
- (should (equal (ert--set-difference b b) e))
- (should (equal (ert--set-difference a b) (list 'a nil "" "x" c2)))
- (should (equal (ert--set-difference b a) (list 'y 'x)))
-
- ;; We aren't testing whether this is really using `eq' rather than `eql'.
- (should (equal (ert--set-difference-eq e e) e))
- (should (equal (ert--set-difference-eq a e) a))
- (should (equal (ert--set-difference-eq e a) e))
- (should (equal (ert--set-difference-eq a a) e))
- (should (equal (ert--set-difference-eq b e) b))
- (should (equal (ert--set-difference-eq e b) e))
- (should (equal (ert--set-difference-eq b b) e))
- (should (equal (ert--set-difference-eq a b) (list 'a nil "" "x" c2)))
- (should (equal (ert--set-difference-eq b a) (list 'y 'x)))
-
- (should (equal (ert--union e e) e))
- (should (equal (ert--union a e) a))
- (should (equal (ert--union e a) a))
- (should (equal (ert--union a a) a))
- (should (equal (ert--union b e) b))
- (should (equal (ert--union e b) b))
- (should (equal (ert--union b b) b))
- (should (equal (ert--union a b) (list 'a 'b sym nil "" "x" c1 c2 'y 'x)))
- (should (equal (ert--union b a) (list c1 'y 'b sym 'x 'a nil "" "x" c2)))
-
- (should (equal (ert--intersection e e) e))
- (should (equal (ert--intersection a e) e))
- (should (equal (ert--intersection e a) e))
- (should (equal (ert--intersection a a) a))
- (should (equal (ert--intersection b e) e))
- (should (equal (ert--intersection e b) e))
- (should (equal (ert--intersection b b) b))
- (should (equal (ert--intersection a b) (list 'b sym c1)))
- (should (equal (ert--intersection b a) (list c1 'b sym))))))
-
-(ert-deftest ert-test-gensym ()
- ;; Since the expansion of `should' calls `ert--gensym' and thus has a
- ;; side-effect on `ert--gensym-counter', we have to make sure all
- ;; macros in our test body are expanded before we rebind
- ;; `ert--gensym-counter' and run the body. Otherwise, the test would
- ;; fail if run interpreted.
- (let ((body (byte-compile
- '(lambda ()
- (should (equal (symbol-name (ert--gensym)) "G0"))
- (should (equal (symbol-name (ert--gensym)) "G1"))
- (should (equal (symbol-name (ert--gensym)) "G2"))
- (should (equal (symbol-name (ert--gensym "foo")) "foo3"))
- (should (equal (symbol-name (ert--gensym "bar")) "bar4"))
- (should (equal ert--gensym-counter 5))))))
- (let ((ert--gensym-counter 0))
- (funcall body))))
-
-(ert-deftest ert-test-coerce-to-vector ()
- (let* ((a (vector))
- (b (vector 1 a 3))
- (c (list))
- (d (list b a)))
- (should (eql (ert--coerce-to-vector a) a))
- (should (eql (ert--coerce-to-vector b) b))
- (should (equal (ert--coerce-to-vector c) (vector)))
- (should (equal (ert--coerce-to-vector d) (vector b a)))))
-
-(ert-deftest ert-test-string-position ()
- (should (eql (ert--string-position ?x "") nil))
- (should (eql (ert--string-position ?a "abc") 0))
- (should (eql (ert--string-position ?b "abc") 1))
- (should (eql (ert--string-position ?c "abc") 2))
- (should (eql (ert--string-position ?d "abc") nil))
- (should (eql (ert--string-position ?A "abc") nil)))
-
-(ert-deftest ert-test-mismatch ()
- (should (eql (ert--mismatch "" "") nil))
- (should (eql (ert--mismatch "" "a") 0))
- (should (eql (ert--mismatch "a" "a") nil))
- (should (eql (ert--mismatch "ab" "a") 1))
- (should (eql (ert--mismatch "Aa" "aA") 0))
- (should (eql (ert--mismatch '(a b c) '(a b d)) 2)))
-
(ert-deftest ert-test-string-first-line ()
(should (equal (ert--string-first-line "") ""))
(should (equal (ert--string-first-line "abc") "abc"))
(stats (ert--make-stats (list test-1 test-2) 't))
(failed (make-ert-test-failed :condition nil
:backtrace nil
- :infos nil)))
+ :infos nil))
+ (skipped (make-ert-test-skipped :condition nil
+ :backtrace nil
+ :infos nil)))
(should (eql 2 (ert-stats-total stats)))
(should (eql 0 (ert-stats-completed stats)))
(should (eql 0 (ert-stats-completed-expected stats)))
(should (eql 0 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 0 test-1 (make-ert-test-passed))
(should (eql 2 (ert-stats-total stats)))
(should (eql 1 (ert-stats-completed stats)))
(should (eql 1 (ert-stats-completed-expected stats)))
(should (eql 0 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 0 test-1 failed)
(should (eql 2 (ert-stats-total stats)))
(should (eql 1 (ert-stats-completed stats)))
(should (eql 0 (ert-stats-completed-expected stats)))
(should (eql 1 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 0 test-1 nil)
(should (eql 2 (ert-stats-total stats)))
(should (eql 0 (ert-stats-completed stats)))
(should (eql 0 (ert-stats-completed-expected stats)))
(should (eql 0 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 0 test-3 failed)
(should (eql 2 (ert-stats-total stats)))
(should (eql 1 (ert-stats-completed stats)))
(should (eql 0 (ert-stats-completed-expected stats)))
(should (eql 1 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 1 test-2 (make-ert-test-passed))
(should (eql 2 (ert-stats-total stats)))
(should (eql 2 (ert-stats-completed stats)))
(should (eql 1 (ert-stats-completed-expected stats)))
(should (eql 1 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
(ert--stats-set-test-and-result stats 0 test-1 (make-ert-test-passed))
(should (eql 2 (ert-stats-total stats)))
(should (eql 2 (ert-stats-completed stats)))
(should (eql 2 (ert-stats-completed-expected stats)))
- (should (eql 0 (ert-stats-completed-unexpected stats)))))
+ (should (eql 0 (ert-stats-completed-unexpected stats)))
+ (should (eql 0 (ert-stats-skipped stats)))
+ (ert--stats-set-test-and-result stats 0 test-1 skipped)
+ (should (eql 2 (ert-stats-total stats)))
+ (should (eql 2 (ert-stats-completed stats)))
+ (should (eql 1 (ert-stats-completed-expected stats)))
+ (should (eql 0 (ert-stats-completed-unexpected stats)))
+ (should (eql 1 (ert-stats-skipped stats)))))
(provide 'ert-tests)
;;; ert-tests.el ends here
+
+;; Local Variables:
+;; no-byte-compile: t
+;; End:
HCoop / bpt / emacs.git / blobdiff