1 ;;; ert-tests.el --- ERT's self-tests -*- lexical-binding: t -*-
3 ;; Copyright (C) 2007-2008, 2010-2013 Free Software Foundation, Inc.
5 ;; Author: Christian Ohler <ohler@gnu.org>
7 ;; This file is part of GNU Emacs.
9 ;; This program is free software: you can redistribute it and/or
10 ;; modify it under the terms of the GNU General Public License as
11 ;; published by the Free Software Foundation, either version 3 of the
12 ;; License, or (at your option) any later version.
14 ;; This program is distributed in the hope that it will be useful, but
15 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ;; General Public License for more details.
19 ;; You should have received a copy of the GNU General Public License
20 ;; along with this program. If not, see `http://www.gnu.org/licenses/'.
24 ;; This file is part of ERT, the Emacs Lisp Regression Testing tool.
25 ;; See ert.el or the texinfo manual for more details.
32 ;;; Self-test that doesn't rely on ERT, for bootstrapping.
34 ;; This is used to test that bodies actually run.
35 (defvar ert--test-body-was-run
)
36 (ert-deftest ert-test-body-runs
()
37 (setq ert--test-body-was-run t
))
39 (defun ert-self-test ()
40 "Run ERT's self-tests and make sure they actually ran."
41 (let ((window-configuration (current-window-configuration)))
42 (let ((ert--test-body-was-run nil
))
43 ;; The buffer name chosen here should not compete with the default
44 ;; results buffer name for completion in `switch-to-buffer'.
45 (let ((stats (ert-run-tests-interactively "^ert-" " *ert self-tests*")))
46 (cl-assert ert--test-body-was-run
)
47 (if (zerop (ert-stats-completed-unexpected stats
))
48 ;; Hide results window only when everything went well.
49 (set-window-configuration window-configuration
)
50 (error "ERT self-test failed"))))))
52 (defun ert-self-test-and-exit ()
53 "Run ERT's self-tests and exit Emacs.
55 The exit code will be zero if the tests passed, nonzero if they
56 failed or if there was a problem."
63 (message "Error running tests")
68 ;;; Further tests are defined using ERT.
70 (ert-deftest ert-test-nested-test-body-runs
()
71 "Test that nested test bodies run."
73 (let ((test (make-ert-test :body
(lambda ()
75 (cl-assert (not was-run
))
77 (cl-assert was-run
))))
80 ;;; Test that pass/fail works.
81 (ert-deftest ert-test-pass
()
82 (let ((test (make-ert-test :body
(lambda ()))))
83 (let ((result (ert-run-test test
)))
84 (cl-assert (ert-test-passed-p result
)))))
86 (ert-deftest ert-test-fail
()
87 (let ((test (make-ert-test :body
(lambda () (ert-fail "failure message")))))
88 (let ((result (let ((ert-debug-on-error nil
))
89 (ert-run-test test
))))
90 (cl-assert (ert-test-failed-p result
) t
)
91 (cl-assert (equal (ert-test-result-with-condition-condition result
)
92 '(ert-test-failed "failure message"))
95 (ert-deftest ert-test-fail-debug-with-condition-case
()
96 (let ((test (make-ert-test :body
(lambda () (ert-fail "failure message")))))
97 (condition-case condition
99 (let ((ert-debug-on-error t
))
103 (cl-assert (equal condition
'(ert-test-failed "failure message")) t
)))))
105 (ert-deftest ert-test-fail-debug-with-debugger-1
()
106 (let ((test (make-ert-test :body
(lambda () (ert-fail "failure message")))))
107 (let ((debugger (lambda (&rest _args
)
109 (let ((ert-debug-on-error nil
))
110 (ert-run-test test
)))))
112 (ert-deftest ert-test-fail-debug-with-debugger-2
()
113 (let ((test (make-ert-test :body
(lambda () (ert-fail "failure message")))))
115 (let ((debugger (lambda (&rest _args
)
116 (cl-return-from nil nil
))))
117 (let ((ert-debug-on-error t
))
121 (ert-deftest ert-test-fail-debug-nested-with-debugger
()
122 (let ((test (make-ert-test :body
(lambda ()
123 (let ((ert-debug-on-error t
))
124 (ert-fail "failure message"))))))
125 (let ((debugger (lambda (&rest _args
)
126 (cl-assert nil nil
"Assertion a"))))
127 (let ((ert-debug-on-error nil
))
128 (ert-run-test test
))))
129 (let ((test (make-ert-test :body
(lambda ()
130 (let ((ert-debug-on-error nil
))
131 (ert-fail "failure message"))))))
133 (let ((debugger (lambda (&rest _args
)
134 (cl-return-from nil nil
))))
135 (let ((ert-debug-on-error t
))
137 (cl-assert nil nil
"Assertion b")))))
139 (ert-deftest ert-test-error
()
140 (let ((test (make-ert-test :body
(lambda () (error "Error message")))))
141 (let ((result (let ((ert-debug-on-error nil
))
142 (ert-run-test test
))))
143 (cl-assert (ert-test-failed-p result
) t
)
144 (cl-assert (equal (ert-test-result-with-condition-condition result
)
145 '(error "Error message"))
148 (ert-deftest ert-test-error-debug
()
149 (let ((test (make-ert-test :body
(lambda () (error "Error message")))))
150 (condition-case condition
152 (let ((ert-debug-on-error t
))
156 (cl-assert (equal condition
'(error "Error message")) t
)))))
159 ;;; Test that `should' works.
160 (ert-deftest ert-test-should
()
161 (let ((test (make-ert-test :body
(lambda () (should nil
)))))
162 (let ((result (let ((ert-debug-on-error nil
))
163 (ert-run-test test
))))
164 (cl-assert (ert-test-failed-p result
) t
)
165 (cl-assert (equal (ert-test-result-with-condition-condition result
)
166 '(ert-test-failed ((should nil
) :form nil
:value nil
)))
168 (let ((test (make-ert-test :body
(lambda () (should t
)))))
169 (let ((result (ert-run-test test
)))
170 (cl-assert (ert-test-passed-p result
) t
))))
172 (ert-deftest ert-test-should-value
()
173 (should (eql (should 'foo
) 'foo
))
174 (should (eql (should 'bar
) 'bar
)))
176 (ert-deftest ert-test-should-not
()
177 (let ((test (make-ert-test :body
(lambda () (should-not t
)))))
178 (let ((result (let ((ert-debug-on-error nil
))
179 (ert-run-test test
))))
180 (cl-assert (ert-test-failed-p result
) t
)
181 (cl-assert (equal (ert-test-result-with-condition-condition result
)
182 '(ert-test-failed ((should-not t
) :form t
:value t
)))
184 (let ((test (make-ert-test :body
(lambda () (should-not nil
)))))
185 (let ((result (ert-run-test test
)))
186 (cl-assert (ert-test-passed-p result
)))))
189 (ert-deftest ert-test-should-with-macrolet
()
190 (let ((test (make-ert-test :body
(lambda ()
191 (cl-macrolet ((foo () `(progn t nil
)))
193 (let ((result (let ((ert-debug-on-error nil
))
194 (ert-run-test test
))))
195 (should (ert-test-failed-p result
))
197 (ert-test-result-with-condition-condition result
)
198 '(ert-test-failed ((should (foo))
202 (ert-deftest ert-test-should-error
()
204 (let ((test (make-ert-test :body
(lambda () (should-error (progn))))))
205 (let ((result (let ((ert-debug-on-error nil
))
206 (ert-run-test test
))))
207 (should (ert-test-failed-p result
))
208 (should (equal (ert-test-result-with-condition-condition result
)
210 ((should-error (progn))
213 :fail-reason
"did not signal an error"))))))
215 (should (equal (should-error (error "Foo"))
217 ;; Error of unexpected type.
218 (let ((test (make-ert-test :body
(lambda ()
219 (should-error (error "Foo")
220 :type
'singularity-error
)))))
221 (let ((result (ert-run-test test
)))
222 (should (ert-test-failed-p result
))
224 (ert-test-result-with-condition-condition result
)
226 ((should-error (error "Foo") :type
'singularity-error
)
228 :condition
(error "Foo")
230 "the error signaled did not have the expected type"))))))
231 ;; Error of the expected type.
236 (should-error (signal 'singularity-error nil
)
237 :type
'singularity-error
))))))
238 (let ((result (ert-run-test test
)))
239 (should (ert-test-passed-p result
))
240 (should (equal error
'(singularity-error))))))
242 (ert-deftest ert-test-should-error-subtypes
()
243 (should-error (signal 'singularity-error nil
)
244 :type
'singularity-error
246 (let ((test (make-ert-test
248 (should-error (signal 'arith-error nil
)
249 :type
'singularity-error
)))))
250 (let ((result (ert-run-test test
)))
251 (should (ert-test-failed-p result
))
253 (ert-test-result-with-condition-condition result
)
255 ((should-error (signal 'arith-error nil
)
256 :type
'singularity-error
)
257 :form
(signal arith-error nil
)
258 :condition
(arith-error)
260 "the error signaled did not have the expected type"))))))
261 (let ((test (make-ert-test
263 (should-error (signal 'arith-error nil
)
264 :type
'singularity-error
265 :exclude-subtypes t
)))))
266 (let ((result (ert-run-test test
)))
267 (should (ert-test-failed-p result
))
269 (ert-test-result-with-condition-condition result
)
271 ((should-error (signal 'arith-error nil
)
272 :type
'singularity-error
274 :form
(signal arith-error nil
)
275 :condition
(arith-error)
277 "the error signaled did not have the expected type"))))))
278 (let ((test (make-ert-test
280 (should-error (signal 'singularity-error nil
)
282 :exclude-subtypes t
)))))
283 (let ((result (ert-run-test test
)))
284 (should (ert-test-failed-p result
))
286 (ert-test-result-with-condition-condition result
)
288 ((should-error (signal 'singularity-error nil
)
291 :form
(signal singularity-error nil
)
292 :condition
(singularity-error)
294 "the error signaled was a subtype of the expected type")))))
297 (defmacro ert--test-my-list
(&rest args
)
298 "Don't use this. Instead, call `list' with ARGS, it does the same thing.
300 This macro is used to test if macroexpansion in `should' works."
303 (ert-deftest ert-test-should-failure-debugging
()
304 "Test that `should' errors contain the information we expect them to."
306 for
(body expected-condition
) in
307 `((,(lambda () (let ((x nil
)) (should x
)))
308 (ert-test-failed ((should x
) :form x
:value nil
)))
309 (,(lambda () (let ((x t
)) (should-not x
)))
310 (ert-test-failed ((should-not x
) :form x
:value t
)))
311 (,(lambda () (let ((x t
)) (should (not x
))))
312 (ert-test-failed ((should (not x
)) :form
(not t
) :value nil
)))
313 (,(lambda () (let ((x nil
)) (should-not (not x
))))
314 (ert-test-failed ((should-not (not x
)) :form
(not nil
) :value t
)))
315 (,(lambda () (let ((x t
) (y nil
)) (should-not
316 (ert--test-my-list x y
))))
318 ((should-not (ert--test-my-list x y
))
321 (,(lambda () (let ((_x t
)) (should (error "Foo"))))
324 (let ((test (make-ert-test :body body
)))
325 (condition-case actual-condition
327 (let ((ert-debug-on-error t
))
331 (should (equal actual-condition expected-condition
)))))))
333 (ert-deftest ert-test-deftest
()
334 (should (equal (macroexpand '(ert-deftest abc
() "foo" :tags
'(bar)))
337 (make-ert-test :name
'abc
341 (push '(ert-deftest . abc
) current-load-list
)
343 (should (equal (macroexpand '(ert-deftest def
()
344 :expected-result
':passed
))
347 (make-ert-test :name
'def
348 :expected-result-type
':passed
350 (push '(ert-deftest . def
) current-load-list
)
352 ;; :documentation keyword is forbidden
353 (should-error (macroexpand '(ert-deftest ghi
()
354 :documentation
"foo"))))
356 (ert-deftest ert-test-record-backtrace
()
357 (let ((test (make-ert-test :body
(lambda () (ert-fail "foo")))))
358 (let ((result (ert-run-test test
)))
359 (should (ert-test-failed-p result
))
361 (ert--print-backtrace (ert-test-failed-backtrace result
))
362 (goto-char (point-min))
364 (let ((first-line (buffer-substring-no-properties (point-min) (point))))
365 (should (equal first-line
" signal(ert-test-failed (\"foo\"))")))))))
367 (ert-deftest ert-test-messages
()
368 :tags
'(:causes-redisplay
)
369 (let* ((message-string "Test message")
370 (messages-buffer (get-buffer-create "*Messages*"))
371 (test (make-ert-test :body
(lambda () (message "%s" message-string
)))))
372 (with-current-buffer messages-buffer
373 (let ((result (ert-run-test test
)))
374 (should (equal (concat message-string
"\n")
375 (ert-test-result-messages result
)))))))
377 (ert-deftest ert-test-running-tests
()
378 (let ((outer-test (ert-get-test 'ert-test-running-tests
)))
379 (should (equal (ert-running-test) outer-test
))
380 (let (test1 test2 test3
)
381 (setq test1
(make-ert-test
384 (should (equal (ert-running-test) outer-test
))
385 (should (equal ert--running-tests
386 (list test1 test2 test3
391 (should (equal (ert-running-test) outer-test
))
392 (should (equal ert--running-tests
393 (list test3 test2 outer-test
)))
394 (ert-run-test test1
)))
398 (should (equal (ert-running-test) outer-test
))
399 (should (equal ert--running-tests
400 (list test3 outer-test
)))
401 (ert-run-test test2
))))
402 (should (ert-test-passed-p (ert-run-test test3
))))))
404 (ert-deftest ert-test-test-result-expected-p
()
405 "Test `ert-test-result-expected-p' and (implicitly) `ert-test-result-type-p'."
407 (let ((test (make-ert-test :body
(lambda ()))))
408 (should (ert-test-result-expected-p test
(ert-run-test test
))))
409 ;; unexpected failure
410 (let ((test (make-ert-test :body
(lambda () (ert-fail "failed")))))
411 (should-not (ert-test-result-expected-p test
(ert-run-test test
))))
413 (let ((test (make-ert-test :body
(lambda () (ert-fail "failed"))
414 :expected-result-type
':failed
)))
415 (should (ert-test-result-expected-p test
(ert-run-test test
))))
416 ;; `not' expected type
417 (let ((test (make-ert-test :body
(lambda ())
418 :expected-result-type
'(not :failed
))))
419 (should (ert-test-result-expected-p test
(ert-run-test test
))))
420 (let ((test (make-ert-test :body
(lambda ())
421 :expected-result-type
'(not :passed
))))
422 (should-not (ert-test-result-expected-p test
(ert-run-test test
))))
423 ;; `and' expected type
424 (let ((test (make-ert-test :body
(lambda ())
425 :expected-result-type
'(and :passed
:failed
))))
426 (should-not (ert-test-result-expected-p test
(ert-run-test test
))))
427 (let ((test (make-ert-test :body
(lambda ())
428 :expected-result-type
'(and :passed
430 (should (ert-test-result-expected-p test
(ert-run-test test
))))
431 ;; `or' expected type
432 (let ((test (make-ert-test :body
(lambda ())
433 :expected-result-type
'(or (and :passed
:failed
)
435 (should (ert-test-result-expected-p test
(ert-run-test test
))))
436 (let ((test (make-ert-test :body
(lambda ())
437 :expected-result-type
'(or (and :passed
:failed
)
439 (should-not (ert-test-result-expected-p test
(ert-run-test test
)))))
441 ;;; Test `ert-select-tests'.
442 (ert-deftest ert-test-select-regexp
()
443 (should (equal (ert-select-tests "^ert-test-select-regexp$" t
)
444 (list (ert-get-test 'ert-test-select-regexp
)))))
446 (ert-deftest ert-test-test-boundp
()
447 (should (ert-test-boundp 'ert-test-test-boundp
))
448 (should-not (ert-test-boundp (make-symbol "ert-not-a-test"))))
450 (ert-deftest ert-test-select-member
()
451 (should (equal (ert-select-tests '(member ert-test-select-member
) t
)
452 (list (ert-get-test 'ert-test-select-member
)))))
454 (ert-deftest ert-test-select-test
()
455 (should (equal (ert-select-tests (ert-get-test 'ert-test-select-test
) t
)
456 (list (ert-get-test 'ert-test-select-test
)))))
458 (ert-deftest ert-test-select-symbol
()
459 (should (equal (ert-select-tests 'ert-test-select-symbol t
)
460 (list (ert-get-test 'ert-test-select-symbol
)))))
462 (ert-deftest ert-test-select-and
()
463 (let ((test (make-ert-test
466 :most-recent-result
(make-ert-test-failed
470 (should (equal (ert-select-tests `(and (member ,test
) :failed
) t
)
473 (ert-deftest ert-test-select-tag
()
474 (let ((test (make-ert-test
478 (should (equal (ert-select-tests `(tag a
) (list test
)) (list test
)))
479 (should (equal (ert-select-tests `(tag b
) (list test
)) (list test
)))
480 (should (equal (ert-select-tests `(tag c
) (list test
)) '()))))
483 ;;; Tests for utility functions.
484 (ert-deftest ert-test-proper-list-p
()
485 (should (ert--proper-list-p '()))
486 (should (ert--proper-list-p '(1)))
487 (should (ert--proper-list-p '(1 2)))
488 (should (ert--proper-list-p '(1 2 3)))
489 (should (ert--proper-list-p '(1 2 3 4)))
490 (should (not (ert--proper-list-p 'a
)))
491 (should (not (ert--proper-list-p '(1 . a
))))
492 (should (not (ert--proper-list-p '(1 2 . a
))))
493 (should (not (ert--proper-list-p '(1 2 3 . a
))))
494 (should (not (ert--proper-list-p '(1 2 3 4 . a
))))
496 (setf (cdr (last a
)) a
)
497 (should (not (ert--proper-list-p a
))))
498 (let ((a (list 1 2)))
499 (setf (cdr (last a
)) a
)
500 (should (not (ert--proper-list-p a
))))
501 (let ((a (list 1 2 3)))
502 (setf (cdr (last a
)) a
)
503 (should (not (ert--proper-list-p a
))))
504 (let ((a (list 1 2 3 4)))
505 (setf (cdr (last a
)) a
)
506 (should (not (ert--proper-list-p a
))))
507 (let ((a (list 1 2)))
508 (setf (cdr (last a
)) (cdr a
))
509 (should (not (ert--proper-list-p a
))))
510 (let ((a (list 1 2 3)))
511 (setf (cdr (last a
)) (cdr a
))
512 (should (not (ert--proper-list-p a
))))
513 (let ((a (list 1 2 3 4)))
514 (setf (cdr (last a
)) (cdr a
))
515 (should (not (ert--proper-list-p a
))))
516 (let ((a (list 1 2 3)))
517 (setf (cdr (last a
)) (cddr a
))
518 (should (not (ert--proper-list-p a
))))
519 (let ((a (list 1 2 3 4)))
520 (setf (cdr (last a
)) (cddr a
))
521 (should (not (ert--proper-list-p a
))))
522 (let ((a (list 1 2 3 4)))
523 (setf (cdr (last a
)) (cl-cdddr a
))
524 (should (not (ert--proper-list-p a
)))))
526 (ert-deftest ert-test-parse-keys-and-body
()
527 (should (equal (ert--parse-keys-and-body '(foo)) '(nil (foo))))
528 (should (equal (ert--parse-keys-and-body '(:bar foo
)) '((:bar foo
) nil
)))
529 (should (equal (ert--parse-keys-and-body '(:bar foo a
(b)))
530 '((:bar foo
) (a (b)))))
531 (should (equal (ert--parse-keys-and-body '(:bar foo
:a
(b)))
532 '((:bar foo
:a
(b)) nil
)))
533 (should (equal (ert--parse-keys-and-body '(bar foo
:a
(b)))
534 '(nil (bar foo
:a
(b)))))
535 (should-error (ert--parse-keys-and-body '(:bar foo
:a
))))
538 (ert-deftest ert-test-run-tests-interactively
()
539 :tags
'(:causes-redisplay
)
540 (let ((passing-test (make-ert-test :name
'passing-test
541 :body
(lambda () (ert-pass))))
542 (failing-test (make-ert-test :name
'failing-test
543 :body
(lambda () (ert-fail
544 "failure message")))))
545 (let ((ert-debug-on-error nil
))
546 (let* ((buffer-name (generate-new-buffer-name " *ert-test-run-tests*"))
549 (lambda (format-string &rest args
)
550 (push (apply #'format format-string args
) messages
))))
551 (save-window-excursion
553 (let ((case-fold-search nil
))
554 (ert-run-tests-interactively
555 `(member ,passing-test
,failing-test
) buffer-name
557 (should (equal messages
`(,(concat
558 "Ran 2 tests, 1 results were "
559 "as expected, 1 unexpected"))))
560 (with-current-buffer buffer-name
561 (goto-char (point-min))
563 (buffer-substring (point-min)
568 "Selector: (member <passing-test> <failing-test>)\n"
570 "Failed: 1 (1 unexpected)\n"
572 (when (get-buffer buffer-name
)
573 (kill-buffer buffer-name
))))))))
575 (ert-deftest ert-test-special-operator-p
()
576 (should (ert--special-operator-p 'if
))
577 (should-not (ert--special-operator-p 'car
))
578 (should-not (ert--special-operator-p 'ert--special-operator-p
))
579 (let ((b (cl-gensym)))
580 (should-not (ert--special-operator-p b
))
582 (should (ert--special-operator-p b
))))
584 (ert-deftest ert-test-list-of-should-forms
()
585 (let ((test (make-ert-test :body
(lambda ()
590 (let ((result (let ((ert-debug-on-error nil
))
591 (ert-run-test test
))))
592 (should (equal (ert-test-result-should-forms result
)
593 '(((should t
) :form t
:value t
)
594 ((should (null '())) :form
(null nil
) :value t
)
595 ((should nil
) :form nil
:value nil
)))))))
597 (ert-deftest ert-test-list-of-should-forms-observers-should-not-stack
()
598 (let ((test (make-ert-test
600 (let ((test2 (make-ert-test
603 (let ((result (ert-run-test test2
)))
604 (should (ert-test-passed-p result
))))))))
605 (let ((result (let ((ert-debug-on-error nil
))
606 (ert-run-test test
))))
607 (should (ert-test-passed-p result
))
608 (should (eql (length (ert-test-result-should-forms result
))
611 (ert-deftest ert-test-list-of-should-forms-no-deep-copy
()
612 (let ((test (make-ert-test :body
(lambda ()
613 (let ((obj (list 'a
)))
614 (should (equal obj
'(a)))
616 (should (equal obj
'(b))))))))
617 (let ((result (let ((ert-debug-on-error nil
))
618 (ert-run-test test
))))
619 (should (ert-test-passed-p result
))
620 (should (equal (ert-test-result-should-forms result
)
621 '(((should (equal obj
'(a))) :form
(equal (b) (a)) :value t
623 ((should (equal obj
'(b))) :form
(equal (b) (b)) :value t
627 (ert-deftest ert-test-string-first-line
()
628 (should (equal (ert--string-first-line "") ""))
629 (should (equal (ert--string-first-line "abc") "abc"))
630 (should (equal (ert--string-first-line "abc\n") "abc"))
631 (should (equal (ert--string-first-line "foo\nbar") "foo"))
632 (should (equal (ert--string-first-line " foo\nbar\nbaz\n") " foo")))
634 (ert-deftest ert-test-explain-equal
()
635 (should (equal (ert--explain-equal nil
'foo
)
636 '(different-atoms nil foo
)))
637 (should (equal (ert--explain-equal '(a a
) '(a b
))
638 '(list-elt 1 (different-atoms a b
))))
639 (should (equal (ert--explain-equal '(1 48) '(1 49))
640 '(list-elt 1 (different-atoms (48 "#x30" "?0")
642 (should (equal (ert--explain-equal 'nil
'(a))
643 '(different-types nil
(a))))
644 (should (equal (ert--explain-equal '(a b c
) '(a b c d
))
645 '(proper-lists-of-different-length 3 4 (a b c
) (a b c d
)
646 first-mismatch-at
3)))
647 (let ((sym (make-symbol "a")))
648 (should (equal (ert--explain-equal 'a sym
)
649 `(different-symbols-with-the-same-name a
,sym
)))))
651 (ert-deftest ert-test-explain-equal-improper-list
()
652 (should (equal (ert--explain-equal '(a . b
) '(a . c
))
653 '(cdr (different-atoms b c
)))))
655 (ert-deftest ert-test-explain-equal-keymaps
()
656 ;; This used to be very slow.
657 (should (equal (make-keymap) (make-keymap)))
658 (should (equal (make-sparse-keymap) (make-sparse-keymap))))
660 (ert-deftest ert-test-significant-plist-keys
()
661 (should (equal (ert--significant-plist-keys '()) '()))
662 (should (equal (ert--significant-plist-keys '(a b c d e f c g p q r nil s t
))
665 (ert-deftest ert-test-plist-difference-explanation
()
666 (should (equal (ert--plist-difference-explanation
669 (should (equal (ert--plist-difference-explanation
671 '(different-properties-for-key c
(different-atoms t nil
))))
672 (should (equal (ert--plist-difference-explanation
673 '(a b c t
) '(c nil a b
))
674 '(different-properties-for-key c
(different-atoms t nil
))))
675 (should (equal (ert--plist-difference-explanation
676 '(a b c
(foo . bar
)) '(c (foo . baz
) a b
))
677 '(different-properties-for-key c
679 (different-atoms bar baz
))))))
681 (ert-deftest ert-test-abbreviate-string
()
682 (should (equal (ert--abbreviate-string "foo" 4 nil
) "foo"))
683 (should (equal (ert--abbreviate-string "foo" 3 nil
) "foo"))
684 (should (equal (ert--abbreviate-string "foo" 3 nil
) "foo"))
685 (should (equal (ert--abbreviate-string "foo" 2 nil
) "fo"))
686 (should (equal (ert--abbreviate-string "foo" 1 nil
) "f"))
687 (should (equal (ert--abbreviate-string "foo" 0 nil
) ""))
688 (should (equal (ert--abbreviate-string "bar" 4 t
) "bar"))
689 (should (equal (ert--abbreviate-string "bar" 3 t
) "bar"))
690 (should (equal (ert--abbreviate-string "bar" 3 t
) "bar"))
691 (should (equal (ert--abbreviate-string "bar" 2 t
) "ar"))
692 (should (equal (ert--abbreviate-string "bar" 1 t
) "r"))
693 (should (equal (ert--abbreviate-string "bar" 0 t
) "")))
695 (ert-deftest ert-test-explain-equal-string-properties
()
697 (equal (ert--explain-equal-including-properties #("foo" 0 1 (a b
))
700 (different-properties-for-key a
(different-atoms b nil
))
702 context-after
"oo")))
703 (should (equal (ert--explain-equal-including-properties
706 '(array-elt 0 (different-atoms (?f
"#x66" "?f")
709 (equal (ert--explain-equal-including-properties
710 #("foo" 0 1 (a b c d
) 1 3 (a b
))
711 #("foo" 0 1 (c d a b
) 1 2 (a foo
)))
712 '(char 1 "o" (different-properties-for-key a
(different-atoms b foo
))
713 context-before
"f" context-after
"o"))))
715 (ert-deftest ert-test-equal-including-properties
()
716 (should (equal-including-properties "foo" "foo"))
717 (should (ert-equal-including-properties "foo" "foo"))
719 (should (equal-including-properties #("foo" 0 3 (a b
))
720 (propertize "foo" 'a
'b
)))
721 (should (ert-equal-including-properties #("foo" 0 3 (a b
))
722 (propertize "foo" 'a
'b
)))
724 (should (equal-including-properties #("foo" 0 3 (a b c d
))
725 (propertize "foo" 'a
'b
'c
'd
)))
726 (should (ert-equal-including-properties #("foo" 0 3 (a b c d
))
727 (propertize "foo" 'a
'b
'c
'd
)))
729 (should-not (equal-including-properties #("foo" 0 3 (a b c e
))
730 (propertize "foo" 'a
'b
'c
'd
)))
731 (should-not (ert-equal-including-properties #("foo" 0 3 (a b c e
))
732 (propertize "foo" 'a
'b
'c
'd
)))
735 (should-not (equal-including-properties #("foo" 0 3 (a (t)))
736 (propertize "foo" 'a
(list t
))))
737 (should (ert-equal-including-properties #("foo" 0 3 (a (t)))
738 (propertize "foo" 'a
(list t
)))))
740 (ert-deftest ert-test-stats-set-test-and-result
()
741 (let* ((test-1 (make-ert-test :name
'test-1
742 :body
(lambda () nil
)))
743 (test-2 (make-ert-test :name
'test-2
744 :body
(lambda () nil
)))
745 (test-3 (make-ert-test :name
'test-2
746 :body
(lambda () nil
)))
747 (stats (ert--make-stats (list test-1 test-2
) 't
))
748 (failed (make-ert-test-failed :condition nil
751 (should (eql 2 (ert-stats-total stats
)))
752 (should (eql 0 (ert-stats-completed stats
)))
753 (should (eql 0 (ert-stats-completed-expected stats
)))
754 (should (eql 0 (ert-stats-completed-unexpected stats
)))
755 (ert--stats-set-test-and-result stats
0 test-1
(make-ert-test-passed))
756 (should (eql 2 (ert-stats-total stats
)))
757 (should (eql 1 (ert-stats-completed stats
)))
758 (should (eql 1 (ert-stats-completed-expected stats
)))
759 (should (eql 0 (ert-stats-completed-unexpected stats
)))
760 (ert--stats-set-test-and-result stats
0 test-1 failed
)
761 (should (eql 2 (ert-stats-total stats
)))
762 (should (eql 1 (ert-stats-completed stats
)))
763 (should (eql 0 (ert-stats-completed-expected stats
)))
764 (should (eql 1 (ert-stats-completed-unexpected stats
)))
765 (ert--stats-set-test-and-result stats
0 test-1 nil
)
766 (should (eql 2 (ert-stats-total stats
)))
767 (should (eql 0 (ert-stats-completed stats
)))
768 (should (eql 0 (ert-stats-completed-expected stats
)))
769 (should (eql 0 (ert-stats-completed-unexpected stats
)))
770 (ert--stats-set-test-and-result stats
0 test-3 failed
)
771 (should (eql 2 (ert-stats-total stats
)))
772 (should (eql 1 (ert-stats-completed stats
)))
773 (should (eql 0 (ert-stats-completed-expected stats
)))
774 (should (eql 1 (ert-stats-completed-unexpected stats
)))
775 (ert--stats-set-test-and-result stats
1 test-2
(make-ert-test-passed))
776 (should (eql 2 (ert-stats-total stats
)))
777 (should (eql 2 (ert-stats-completed stats
)))
778 (should (eql 1 (ert-stats-completed-expected stats
)))
779 (should (eql 1 (ert-stats-completed-unexpected stats
)))
780 (ert--stats-set-test-and-result stats
0 test-1
(make-ert-test-passed))
781 (should (eql 2 (ert-stats-total stats
)))
782 (should (eql 2 (ert-stats-completed stats
)))
783 (should (eql 2 (ert-stats-completed-expected stats
)))
784 (should (eql 0 (ert-stats-completed-unexpected stats
)))))
789 ;;; ert-tests.el ends here