[elpa] externals/compat 38cfab4677 04/11: Restore tests

[ELPA Syncer]

branch: externals/compat
commit 38cfab467756734fc0b95bffc1889e867fa6c937
Author: Daniel Mendler <mail@daniel-mendler.de>
Commit: Daniel Mendler <mail@daniel-mendler.de>

    Restore tests
---
 compat-tests.el | 1548 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 775 insertions(+), 773 deletions(-)

diff --git a/compat-tests.el b/compat-tests.el
index b6c5f7d10b..2d81cba093 100644
--- a/compat-tests.el
+++ b/compat-tests.el
@@ -147,6 +147,66 @@
   (should (equal t (always 1)))                    ;; single argument
   (should (equal t (always 1 2 3 4))))             ;; multiple arguments
 
+(ert-deftest file-name-with-extension ()
+  (should (equal "file.ext" (file-name-with-extension "file" "ext")))
+  (should (equal "file.ext" (file-name-with-extension "file" ".ext")))
+  (should (equal "file.ext" (file-name-with-extension "file." ".ext")))
+  (should (equal "file..ext" (file-name-with-extension "file.." ".ext")))
+  (should (equal "file..ext" (file-name-with-extension "file." "..ext")))
+  (should (equal "file...ext" (file-name-with-extension "file.." "..ext")))
+  (should (equal "/abs/file.ext" (file-name-with-extension "/abs/file" "ext")))
+  (should (equal "/abs/file.ext" (file-name-with-extension "/abs/file" 
".ext")))
+  (should (equal "/abs/file.ext" (file-name-with-extension "/abs/file." 
".ext")))
+  (should (equal "/abs/file..ext" (file-name-with-extension "/abs/file.." 
".ext")))
+  (should (equal "/abs/file..ext" (file-name-with-extension "/abs/file." 
"..ext")))
+  (should (equal "/abs/file...ext" (file-name-with-extension "/abs/file.." 
"..ext")))
+  (should-error (file-name-with-extension "file" "") :type 'error)
+  (should-error (file-name-with-extension "" "ext") :type 'error)
+  (should-error (file-name-with-extension "file" "") :type 'error)
+  (should-error (file-name-with-extension "rel/" "ext") :type 'error)
+  (should-error (file-name-with-extension "/abs/" "ext")) :type 'error)
+
+(ert-deftest flatten-tree ()
+  ;; Example from docstring:
+  (should (equal '(1 2 3 4 5 6 7) (flatten-tree '(1 (2 . 3) nil (4 5 (6)) 7))))
+  ;; Trivial example
+  (should (equal nil (flatten-tree ())))
+  ;; Simple examples
+  (should (equal '(1) (flatten-tree '(1))))
+  (should (equal '(1 2) (flatten-tree '(1 2))))
+  (should (equal '(1 2 3) (flatten-tree '(1 2 3))))
+  ;; Regular sublists
+  (should (equal '(1) (flatten-tree '((1)))))
+  (should (equal '(1 2) (flatten-tree '((1) (2)))))
+  (should (equal '(1 2 3) (flatten-tree '((1) (2) (3)))))
+  ;; Complex examples
+  (should (equal '(1) (flatten-tree '(((((1))))))))
+  (should (equal '(1 2 3 4) (flatten-tree '((1) nil 2 ((3 4))))))
+  (should (equal '(1 2 3 4) (flatten-tree '(((1 nil)) 2 (((3 nil nil) 4)))))))
+
+(ert-deftest string-distance ()
+  (should (equal 3 (string-distance "kitten" "sitting")))    ;from wikipedia
+  (if (version<= "28" emacs-version) ;trivial examples
+      (should (equal 0 (string-distance "" "")))
+    ;; Up until Emacs 28, `string-distance' had a bug
+    ;; when comparing two empty strings. This was fixed
+    ;; in the following commit:
+    ;; https://git.savannah.gnu.org/cgit/emacs.git/commit/?id=c44190c
+    ;;
+    ;; Therefore, we must make sure, that the test
+    ;; doesn't fail because of this bug:
+    ;; TODO
+    ;; (should (= (string-distance "" "") 0))
+    )
+  (should (equal 0 (string-distance "a" "a")))
+  (should (equal 1 (string-distance "" "a")))
+  (should (equal 1 (string-distance "b" "a")))
+  (should (equal 2 (string-distance "aa" "bb")))
+  (should (equal 2 (string-distance "aa" "bba")))
+  (should (equal 2 (string-distance "aaa" "bba")))
+  (should (equal 3 (string-distance "a" "あ" t)))             ;byte example
+  (should (equal 1 (string-distance "a" "あ"))))
+
 (ert-deftest string-width ()
   (should (equal 0 (compat-string-width "")))                         ;; 
Obsolete
   (should (equal 0 (compat-call string-width "")))
@@ -640,64 +700,6 @@
 ;;           (insert-into-buffer other 2 3))
 ;;         (should (string= (buffer-string) "abce"))))))
 
-;; (ert-deftest file-name-with-extension
-;;   (ought "file.ext" "file" "ext")
-;;   (ought "file.ext" "file" ".ext")
-;;   (ought "file.ext" "file." ".ext")
-;;   (ought "file..ext" "file.." ".ext")
-;;   (ought "file..ext" "file." "..ext")
-;;   (ought "file...ext" "file.." "..ext")
-;;   (ought "/abs/file.ext" "/abs/file" "ext")
-;;   (ought "/abs/file.ext" "/abs/file" ".ext")
-;;   (ought "/abs/file.ext" "/abs/file." ".ext")
-;;   (ought "/abs/file..ext" "/abs/file.." ".ext")
-;;   (ought "/abs/file..ext" "/abs/file." "..ext")
-;;   (ought "/abs/file...ext" "/abs/file.." "..ext")
-;;   (expect error "file" "")
-;;   (expect error "" "ext")
-;;   (expect error "file" "")
-;;   (expect error "rel/" "ext")
-;;   (expect error "/abs/" "ext"))
-
-;; (ert-deftest flatten-tree
-;;   ;; Example from docstring:
-;;   (ought '(1 2 3 4 5 6 7) '(1 (2 . 3) nil (4 5 (6)) 7))
-;;   ;; Trivial example
-;;   (ought nil ())
-;;   ;; Simple examples
-;;   (ought '(1) '(1))
-;;   (ought '(1 2) '(1 2))
-;;   (ought '(1 2 3) '(1 2 3))
-;;   ;; Regular sublists
-;;   (ought '(1) '((1)))
-;;   (ought '(1 2) '((1) (2)))
-;;   (ought '(1 2 3) '((1) (2) (3)))
-;;   ;; Complex examples
-;;   (ought '(1) '(((((1))))))
-;;   (ought '(1 2 3 4) '((1) nil 2 ((3 4))))
-;;   (ought '(1 2 3 4) '(((1 nil)) 2 (((3 nil nil) 4)))))
-
-;; (ert-deftest string-distance
-;;   (ought 3 "kitten" "sitting")     ;from wikipedia
-;;   (if (version<= "28" emacs-version) ;trivial examples
-;;       (ought 0 "" "")
-;;     ;; Up until Emacs 28, `string-distance' had a bug
-;;     ;; when comparing two empty strings. This was fixed
-;;     ;; in the following commit:
-;;     ;; https://git.savannah.gnu.org/cgit/emacs.git/commit/?id=c44190c
-;;     ;;
-;;     ;; Therefore, we must make sure, that the test
-;;     ;; doesn't fail because of this bug:
-;;     (should (= (compat--t-string-distance "" "") 0)))
-;;   (ought 0 "a" "a")
-;;   (ought 1 "" "a")
-;;   (ought 1 "b" "a")
-;;   (ought 2 "aa" "bb")
-;;   (ought 2 "aa" "bba")
-;;   (ought 2 "aaa" "bba")
-;;   (ought 3 "a" "あ" t)             ;byte example
-;;   (ought 1 "a" "あ"))
-
 ;; (ert-deftest compat-regexp-unmatchable ()
 ;;   "Check if `compat--string-distance' was implemented correctly."
 ;;   (dolist (str '(""                     ;empty string
@@ -711,12 +713,12 @@
 ;; (ert-deftest compat-regexp-opt
 ;;   ;; Ensure `compat--regexp-opt' doesn't change the existing
 ;;   ;; behaviour:
-;;   (ought (regexp-opt '("a" "b" "c")) '("a" "b" "c"))
-;;   (ought (regexp-opt '("abc" "def" "ghe")) '("abc" "def" "ghe"))
-;;   (ought (regexp-opt '("a" "b" "c") 'words) '("a" "b" "c") 'words)
+;;   (should (equal (regexp-opt '("a" "b" "c")) '("a" "b" "c"))
+;;   (should (equal (regexp-opt '("abc" "def" "ghe")) '("abc" "def" "ghe"))
+;;   (should (equal (regexp-opt '("a" "b" "c") 'words) '("a" "b" "c") 'words)
 ;;   ;; Test empty list:
-;;   (ought "\\(?:\\`a\\`\\)" '())
-;;   (ought "\\<\\(\\`a\\`\\)\\>" '() 'words))
+;;   (should (equal "\\(?:\\`a\\`\\)" '())
+;;   (should (equal "\\<\\(\\`a\\`\\)\\>" '() 'words))
 
 ;; (ert-deftest compat-regexp-opt ()
 ;;   "Check if `compat--regexp-opt' advice was defined correctly."
@@ -729,20 +731,20 @@
 
 ;; (ert-deftest compat-assoc
 ;;   ;; Fallback behaviour:
-;;   (ought nil 1 nil)               ;empty list
-;;   (ought '(1) 1 '((1)))            ;single element list
-;;   (ought nil 1 '(1))
-;;   (ought '(2) 2 '((1) (2) (3)))    ;multiple element list
-;;   (ought nil 2 '(1 2 3))
-;;   (ought '(2) 2 '(1 (2) 3))
-;;   (ought nil 2 '((1) 2 (3)))
-;;   (ought '(1) 1 '((3) (2) (1)))
-;;   (ought '("a") "a" '(("a") ("b") ("c")))  ;non-primitive elements
-;;   (ought '("a" 0) "a" '(("c" . "a") "b" ("a" 0)))
+;;   (should (equal nil 1 nil)               ;empty list
+;;   (should (equal '(1) 1 '((1)))            ;single element list
+;;   (should (equal nil 1 '(1))
+;;   (should (equal '(2) 2 '((1) (2) (3)))    ;multiple element list
+;;   (should (equal nil 2 '(1 2 3))
+;;   (should (equal '(2) 2 '(1 (2) 3))
+;;   (should (equal nil 2 '((1) 2 (3)))
+;;   (should (equal '(1) 1 '((3) (2) (1)))
+;;   (should (equal '("a") "a" '(("a") ("b") ("c")))  ;non-primitive elements
+;;   (should (equal '("a" 0) "a" '(("c" . "a") "b" ("a" 0)))
 ;;   ;; With testfn (advised behaviour):
-;;   (ought '(1) 3 '((10) (4) (1) (9)) #'<)
-;;   (ought '("a") "b" '(("c") ("a") ("b")) #'string-lessp)
-;;   (ought '("b") "a" '(("a") ("a") ("b"))
+;;   (should (equal '(1) 3 '((10) (4) (1) (9)) #'<)
+;;   (should (equal '("a") "b" '(("c") ("a") ("b")) #'string-lessp)
+;;   (should (equal '("b") "a" '(("a") ("a") ("b"))
 ;;          (lambda (s1 s2) (not (string= s1 s2))))
 ;;   (ought
 ;;    '("\\.el\\'" . emacs-lisp-mode)
@@ -758,58 +760,58 @@
 ;; ;;     "Check if `compat--alist-get' was advised correctly."
 ;; ;;     (ert-deftest compat-alist-get
 ;; ;;       ;; Fallback behaviour:
-;; ;;       (ought nil 1 nil)                      ;empty list
-;; ;;       (ought 'a 1 '((1 . a)))                  ;single element list
-;; ;;       (ought nil 1 '(1))
-;; ;;       (ought 'b 2 '((1 . a) (2 . b) (3 . c)))  ;multiple element list
-;; ;;       (ought nil 2 '(1 2 3))
-;; ;;       (ought 'b 2 '(1 (2 . b) 3))
-;; ;;       (ought nil 2 '((1 . a) 2 (3 . c)))
-;; ;;       (ought 'a 1 '((3 . c) (2 . b) (1 . a)))
-;; ;;       (ought nil "a" '(("a" . 1) ("b" . 2) ("c" . 3)))  ;non-primitive 
elements
+;; ;;       (should (equal nil 1 nil)                      ;empty list
+;; ;;       (should (equal 'a 1 '((1 . a)))                  ;single element 
list
+;; ;;       (should (equal nil 1 '(1))
+;; ;;       (should (equal 'b 2 '((1 . a) (2 . b) (3 . c)))  ;multiple element 
list
+;; ;;       (should (equal nil 2 '(1 2 3))
+;; ;;       (should (equal 'b 2 '(1 (2 . b) 3))
+;; ;;       (should (equal nil 2 '((1 . a) 2 (3 . c)))
+;; ;;       (should (equal 'a 1 '((3 . c) (2 . b) (1 . a)))
+;; ;;       (should (equal nil "a" '(("a" . 1) ("b" . 2) ("c" . 3)))  
;non-primitive elements
 
 ;; ;;       ;; With testfn (advised behaviour):
-;; ;;       (ought 1 "a" '(("a" . 1) ("b" . 2) ("c" . 3)) nil nil #'equal)
-;; ;;       (ought 1 3 '((10 . 10) (4 . 4) (1 . 1) (9 . 9)) nil nil #'<)
-;; ;;       (ought '(a) "b" '(("c" c) ("a" a) ("b" b)) nil nil #'string-lessp)
-;; ;;       (ought 'c "a" '(("a" . a) ("a" . b) ("b" . c)) nil nil
+;; ;;       (should (equal 1 "a" '(("a" . 1) ("b" . 2) ("c" . 3)) nil nil 
#'equal)
+;; ;;       (should (equal 1 3 '((10 . 10) (4 . 4) (1 . 1) (9 . 9)) nil nil 
#'<)
+;; ;;       (should (equal '(a) "b" '(("c" c) ("a" a) ("b" b)) nil nil 
#'string-lessp)
+;; ;;       (should (equal 'c "a" '(("a" . a) ("a" . b) ("b" . c)) nil nil
 ;; ;;                        (lambda (s1 s2) (not (string= s1 s2))))
-;; ;;       (ought 'emacs-lisp-mode
+;; ;;       (should (equal 'emacs-lisp-mode
 ;; ;;                        "file.el"
 ;; ;;                        '(("\\.c\\'" . c-mode)
 ;; ;;                          ("\\.p\\'" . pascal-mode)
 ;; ;;                          ("\\.el\\'" . emacs-lisp-mode)
 ;; ;;                          ("\\.awk\\'" . awk-mode))
 ;; ;;                        nil nil #'string-match-p)
-;; ;;       (ought 'd 0 '((1 . a) (2 . b) (3 . c)) 'd) ;default value
-;; ;;       (ought 'd 2 '((1 . a) (2 . b) (3 . c)) 'd nil #'ignore))))
+;; ;;       (should (equal 'd 0 '((1 . a) (2 . b) (3 . c)) 'd) ;default value
+;; ;;       (should (equal 'd 2 '((1 . a) (2 . b) (3 . c)) 'd nil #'ignore))))
 
 ;; (ert-deftest (alist-get compat--alist-get-full-elisp)
 ;;   ;; Fallback behaviour:
-;;   (ought nil 1 nil)                      ;empty list
-;;   (ought 'a 1 '((1 . a)))                  ;single element list
-;;   (ought nil 1 '(1))
-;;   (ought 'b 2 '((1 . a) (2 . b) (3 . c)))  ;multiple element list
-;;   (ought nil 2 '(1 2 3))
-;;   (ought 'b 2 '(1 (2 . b) 3))
-;;   (ought nil 2 '((1 . a) 2 (3 . c)))
-;;   (ought 'a 1 '((3 . c) (2 . b) (1 . a)))
-;;   (ought nil "a" '(("a" . 1) ("b" . 2) ("c" . 3))) ;non-primitive elements
+;;   (should (equal nil 1 nil)                      ;empty list
+;;   (should (equal 'a 1 '((1 . a)))                  ;single element list
+;;   (should (equal nil 1 '(1))
+;;   (should (equal 'b 2 '((1 . a) (2 . b) (3 . c)))  ;multiple element list
+;;   (should (equal nil 2 '(1 2 3))
+;;   (should (equal 'b 2 '(1 (2 . b) 3))
+;;   (should (equal nil 2 '((1 . a) 2 (3 . c)))
+;;   (should (equal 'a 1 '((3 . c) (2 . b) (1 . a)))
+;;   (should (equal nil "a" '(("a" . 1) ("b" . 2) ("c" . 3))) ;non-primitive 
elements
 ;;   ;; With testfn (advised behaviour):
-;;   (ought 1 "a" '(("a" . 1) ("b" . 2) ("c" . 3)) nil nil #'equal)
-;;   (ought 1 3 '((10 . 10) (4 . 4) (1 . 1) (9 . 9)) nil nil #'<)
-;;   (ought '(a) "b" '(("c" c) ("a" a) ("b" b)) nil nil #'string-lessp)
-;;   (ought 'c "a" '(("a" . a) ("a" . b) ("b" . c)) nil nil
+;;   (should (equal 1 "a" '(("a" . 1) ("b" . 2) ("c" . 3)) nil nil #'equal)
+;;   (should (equal 1 3 '((10 . 10) (4 . 4) (1 . 1) (9 . 9)) nil nil #'<)
+;;   (should (equal '(a) "b" '(("c" c) ("a" a) ("b" b)) nil nil #'string-lessp)
+;;   (should (equal 'c "a" '(("a" . a) ("a" . b) ("b" . c)) nil nil
 ;;          (lambda (s1 s2) (not (string= s1 s2))))
-;;   (ought 'emacs-lisp-mode
+;;   (should (equal 'emacs-lisp-mode
 ;;          "file.el"
 ;;          '(("\\.c\\'" . c-mode)
 ;;            ("\\.p\\'" . pascal-mode)
 ;;            ("\\.el\\'" . emacs-lisp-mode)
 ;;            ("\\.awk\\'" . awk-mode))
 ;;          nil nil #'string-match-p)
-;;   (ought 'd 0 '((1 . a) (2 . b) (3 . c)) 'd) ;default value
-;;   (ought 'd 2 '((1 . a) (2 . b) (3 . c)) 'd nil #'ignore))
+;;   (should (equal 'd 0 '((1 . a) (2 . b) (3 . c)) 'd) ;default value
+;;   (should (equal 'd 2 '((1 . a) (2 . b) (3 . c)) 'd nil #'ignore))
 
 ;; ;; Note: as the cXXX+r implementations are relatively trivial, their
 ;; ;; tests are not as extensive.
@@ -824,358 +826,358 @@
 ;;   "Testcase for cXXXXr functions.")
 
 ;; (ert-deftest caaar
-;;   (ought nil ())
-;;   (ought 'a compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'a compat-cXXXr-test))
 
 ;; (ert-deftest caadr
-;;   (ought nil ())
-;;   (ought 'e compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'e compat-cXXXr-test))
 
 ;; (ert-deftest cadar
-;;   (ought nil ())
-;;   (ought 'c compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'c compat-cXXXr-test))
 
 ;; (ert-deftest caddr
-;;   (ought nil ())
-;;   (ought 'g compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'g compat-cXXXr-test))
 
 ;; (ert-deftest cdaar
-;;   (ought nil ())
-;;   (ought 'b compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'b compat-cXXXr-test))
 
 ;; (ert-deftest cdadr
-;;   (ought nil ())
-;;   (ought 'f compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'f compat-cXXXr-test))
 
 ;; (ert-deftest cddar
-;;   (ought nil ())
-;;   (ought 'd compat-cXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'd compat-cXXXr-test))
 
 ;; (ert-deftest cdddr
-;;   (ought nil ())
-;;   (ought 'h compat-cXXXr-test)
+;;   (should (equal nil ())
+;;   (should (equal 'h compat-cXXXr-test)
 ;;   #'cdddr)
 
 ;; (ert-deftest caaaar
-;;   (ought nil ())
-;;   (ought 'a compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'a compat-cXXXXr-test))
 
 ;; (ert-deftest caaadr
-;;   (ought nil ())
-;;   (ought 'i compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'i compat-cXXXXr-test))
 
 ;; (ert-deftest caadar
-;;   (ought nil ())
-;;   (ought 'e compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'e compat-cXXXXr-test))
 
 ;; (ert-deftest caaddr
-;;   (ought nil ())
-;;   (ought 'm compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'm compat-cXXXXr-test))
 
 ;; (ert-deftest cadaar
-;;   (ought nil ())
-;;   (ought 'c compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'c compat-cXXXXr-test))
 
 ;; (ert-deftest cadadr
-;;   (ought nil ())
-;;   (ought 'k compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'k compat-cXXXXr-test))
 
 ;; (ert-deftest caddar
-;;   (ought nil ())
-;;   (ought 'g compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'g compat-cXXXXr-test))
 
 ;; (ert-deftest cadddr
-;;   (ought nil ())
-;;   (ought 'o compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'o compat-cXXXXr-test))
 
 ;; (ert-deftest cdaaar
-;;   (ought nil ())
-;;   (ought 'b compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'b compat-cXXXXr-test))
 
 ;; (ert-deftest cdaadr
-;;   (ought nil ())
-;;   (ought 'j compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'j compat-cXXXXr-test))
 
 ;; (ert-deftest cdadar
-;;   (ought nil ())
-;;   (ought 'f compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'f compat-cXXXXr-test))
 
 ;; (ert-deftest cdaddr
-;;   (ought nil ())
-;;   (ought 'j compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'j compat-cXXXXr-test))
 
 ;; (ert-deftest cddaar
-;;   (ought nil ())
-;;   (ought 'd compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'd compat-cXXXXr-test))
 
 ;; (ert-deftest cddadr
-;;   (ought nil ())
-;;   (ought 'l compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'l compat-cXXXXr-test))
 
 ;; (ert-deftest cdddar
-;;   (ought nil ())
-;;   (ought 'h compat-cXXXXr-test))
+;;   (should (equal nil ())
+;;   (should (equal 'h compat-cXXXXr-test))
 
 ;; (ert-deftest string-greaterp
-;;   (ought t "b" "a")
-;;   (ought nil "a" "b")
-;;   (ought t "aaab" "aaaa")
-;;   (ought nil "aaaa" "aaab"))
+;;   (should (equal t "b" "a")
+;;   (should (equal nil "a" "b")
+;;   (should (equal t "aaab" "aaaa")
+;;   (should (equal nil "aaaa" "aaab"))
 
 ;; (ert-deftest compat-sort
-;;   (ought (list 1 2 3) (list 1 2 3) #'<)
-;;   (ought (list 1 2 3) (list 3 2 1) #'<)
-;;   (ought '[1 2 3] '[1 2 3] #'<)
-;;   (ought '[1 2 3] '[3 2 1] #'<))
+;;   (should (equal (list 1 2 3) (list 1 2 3) #'<)
+;;   (should (equal (list 1 2 3) (list 3 2 1) #'<)
+;;   (should (equal '[1 2 3] '[1 2 3] #'<)
+;;   (should (equal '[1 2 3] '[3 2 1] #'<))
 
 ;; (ert-deftest compat-=
-;;   (ought t 0 0)
-;;   (ought t 0 0 0)
-;;   (ought t 0 0 0 0)
-;;   (ought t 0 0 0 0 0)
-;;   (ought t 0.0 0.0)
-;;   (ought t +0.0 -0.0)
-;;   (ought t 0.0 0.0 0.0)
-;;   (ought t 0.0 0.0 0.0 0.0)
-;;   (ought nil 0 1)
-;;   (ought nil 0 0 1)
-;;   (ought nil 0 0 0 0 1)
-;;   (expect wrong-type-argument 0 0 'a)
-;;   (ought nil 0 1 'a)
-;;   (ought nil 0.0 0.0 0.0 0.1))
+;;   (should (equal t 0 0)
+;;   (should (equal t 0 0 0)
+;;   (should (equal t 0 0 0 0)
+;;   (should (equal t 0 0 0 0 0)
+;;   (should (equal t 0.0 0.0)
+;;   (should (equal t +0.0 -0.0)
+;;   (should (equal t 0.0 0.0 0.0)
+;;   (should (equal t 0.0 0.0 0.0 0.0)
+;;   (should (equal nil 0 1)
+;;   (should (equal nil 0 0 1)
+;;   (should (equal nil 0 0 0 0 1)
+;;   (should-error wrong-type-argument 0 0 'a)
+;;   (should (equal nil 0 1 'a)
+;;   (should (equal nil 0.0 0.0 0.0 0.1))
 
 ;; (ert-deftest compat-<
-;;   (ought nil 0 0)
-;;   (ought nil 0 0 0)
-;;   (ought nil 0 0 0 0)
-;;   (ought nil 0 0 0 0 0)
-;;   (ought nil 0.0 0.0)
-;;   (ought nil +0.0 -0.0)
-;;   (ought nil 0.0 0.0 0.0)
-;;   (ought nil 0.0 0.0 0.0 0.0)
-;;   (ought t 0 1)
-;;   (ought nil 1 0)
-;;   (ought nil 0 0 1)
-;;   (ought t 0 1 2)
-;;   (ought nil 2 1 0)
-;;   (ought nil 0 0 0 0 1)
-;;   (ought t 0 1 2 3 4)
-;;   (expect wrong-type-argument 0 1 'a)
-;;   (ought nil 0 0 'a)
-;;   (ought nil 0.0 0.0 0.0 0.1)
-;;   (ought t -0.1 0.0 0.2 0.4)
-;;   (ought t -0.1 0 0.2 0.4))
+;;   (should (equal nil 0 0)
+;;   (should (equal nil 0 0 0)
+;;   (should (equal nil 0 0 0 0)
+;;   (should (equal nil 0 0 0 0 0)
+;;   (should (equal nil 0.0 0.0)
+;;   (should (equal nil +0.0 -0.0)
+;;   (should (equal nil 0.0 0.0 0.0)
+;;   (should (equal nil 0.0 0.0 0.0 0.0)
+;;   (should (equal t 0 1)
+;;   (should (equal nil 1 0)
+;;   (should (equal nil 0 0 1)
+;;   (should (equal t 0 1 2)
+;;   (should (equal nil 2 1 0)
+;;   (should (equal nil 0 0 0 0 1)
+;;   (should (equal t 0 1 2 3 4)
+;;   (should-error wrong-type-argument 0 1 'a)
+;;   (should (equal nil 0 0 'a)
+;;   (should (equal nil 0.0 0.0 0.0 0.1)
+;;   (should (equal t -0.1 0.0 0.2 0.4)
+;;   (should (equal t -0.1 0 0.2 0.4))
 
 ;; (ert-deftest compat->
-;;   (ought nil 0 0)
-;;   (ought nil 0 0 0)
-;;   (ought nil 0 0 0 0)
-;;   (ought nil 0 0 0 0 0)
-;;   (ought nil 0.0 0.0)
-;;   (ought nil +0.0 -0.0)
-;;   (ought nil 0.0 0.0 0.0)
-;;   (ought nil 0.0 0.0 0.0 0.0)
-;;   (ought t 1 0)
-;;   (ought nil 1 0 0)
-;;   (ought nil 0 1 2)
-;;   (ought t 2 1 0)
-;;   (ought nil 1 0 0 0 0)
-;;   (ought t 4 3 2 1 0)
-;;   (ought nil 4 3 2 1 1)
-;;   (expect wrong-type-argument 1 0 'a)
-;;   (ought nil 0 0 'a)
-;;   (ought nil 0.1 0.0 0.0 0.0)
-;;   (ought t 0.4 0.2 0.0 -0.1)
-;;   (ought t 0.4 0.2 0 -0.1))
+;;   (should (equal nil 0 0)
+;;   (should (equal nil 0 0 0)
+;;   (should (equal nil 0 0 0 0)
+;;   (should (equal nil 0 0 0 0 0)
+;;   (should (equal nil 0.0 0.0)
+;;   (should (equal nil +0.0 -0.0)
+;;   (should (equal nil 0.0 0.0 0.0)
+;;   (should (equal nil 0.0 0.0 0.0 0.0)
+;;   (should (equal t 1 0)
+;;   (should (equal nil 1 0 0)
+;;   (should (equal nil 0 1 2)
+;;   (should (equal t 2 1 0)
+;;   (should (equal nil 1 0 0 0 0)
+;;   (should (equal t 4 3 2 1 0)
+;;   (should (equal nil 4 3 2 1 1)
+;;   (should-error wrong-type-argument 1 0 'a)
+;;   (should (equal nil 0 0 'a)
+;;   (should (equal nil 0.1 0.0 0.0 0.0)
+;;   (should (equal t 0.4 0.2 0.0 -0.1)
+;;   (should (equal t 0.4 0.2 0 -0.1))
 
 ;; (ert-deftest compat-<=
-;;   (ought t 0 0)
-;;   (ought t 0 0 0)
-;;   (ought t 0 0 0 0)
-;;   (ought t 0 0 0 0 0)
-;;   (ought t 0.0 0.0)
-;;   (ought t +0.0 -0.0)
-;;   (ought t 0.0 0.0 0.0)
-;;   (ought t 0.0 0.0 0.0 0.0)
-;;   (ought nil 1 0)
-;;   (ought nil 1 0 0)
-;;   (ought t 0 1 2)
-;;   (ought nil 2 1 0)
-;;   (ought nil 1 0 0 0 0)
-;;   (ought nil 4 3 2 1 0)
-;;   (ought nil 4 3 2 1 1)
-;;   (ought t 0 1 2 3 4)
-;;   (ought t 1 1 2 3 4)
-;;   (expect wrong-type-argument 0 0 'a)
-;;   (expect wrong-type-argument 0 1 'a)
-;;   (ought nil 1 0 'a)
-;;   (ought nil 0.1 0.0 0.0 0.0)
-;;   (ought t 0.0 0.0 0.0 0.1)
-;;   (ought t -0.1 0.0 0.2 0.4)
-;;   (ought t -0.1 0.0 0.0 0.2 0.4)
-;;   (ought t -0.1 0.0 0 0.2 0.4)
-;;   (ought t -0.1 0 0.2 0.4)
-;;   (ought nil 0.4 0.2 0.0 -0.1)
-;;   (ought nil 0.4 0.2 0.0 0.0 -0.1)
-;;   (ought nil 0.4 0.2 0 0.0 0.0 -0.1)
-;;   (ought nil 0.4 0.2 0 -0.1))
+;;   (should (equal t 0 0)
+;;   (should (equal t 0 0 0)
+;;   (should (equal t 0 0 0 0)
+;;   (should (equal t 0 0 0 0 0)
+;;   (should (equal t 0.0 0.0)
+;;   (should (equal t +0.0 -0.0)
+;;   (should (equal t 0.0 0.0 0.0)
+;;   (should (equal t 0.0 0.0 0.0 0.0)
+;;   (should (equal nil 1 0)
+;;   (should (equal nil 1 0 0)
+;;   (should (equal t 0 1 2)
+;;   (should (equal nil 2 1 0)
+;;   (should (equal nil 1 0 0 0 0)
+;;   (should (equal nil 4 3 2 1 0)
+;;   (should (equal nil 4 3 2 1 1)
+;;   (should (equal t 0 1 2 3 4)
+;;   (should (equal t 1 1 2 3 4)
+;;   (should-error wrong-type-argument 0 0 'a)
+;;   (should-error wrong-type-argument 0 1 'a)
+;;   (should (equal nil 1 0 'a)
+;;   (should (equal nil 0.1 0.0 0.0 0.0)
+;;   (should (equal t 0.0 0.0 0.0 0.1)
+;;   (should (equal t -0.1 0.0 0.2 0.4)
+;;   (should (equal t -0.1 0.0 0.0 0.2 0.4)
+;;   (should (equal t -0.1 0.0 0 0.2 0.4)
+;;   (should (equal t -0.1 0 0.2 0.4)
+;;   (should (equal nil 0.4 0.2 0.0 -0.1)
+;;   (should (equal nil 0.4 0.2 0.0 0.0 -0.1)
+;;   (should (equal nil 0.4 0.2 0 0.0 0.0 -0.1)
+;;   (should (equal nil 0.4 0.2 0 -0.1))
 
 ;; (ert-deftest compat->=
-;;   (ought t 0 0)
-;;   (ought t 0 0 0)
-;;   (ought t 0 0 0 0)
-;;   (ought t 0 0 0 0 0)
-;;   (ought t 0.0 0.0)
-;;   (ought t +0.0 -0.0)
-;;   (ought t 0.0 0.0 0.0)
-;;   (ought t 0.0 0.0 0.0 0.0)
-;;   (ought t 1 0)
-;;   (ought t 1 0 0)
-;;   (ought nil 0 1 2)
-;;   (ought t 2 1 0)
-;;   (ought t 1 0 0 0 0)
-;;   (ought t 4 3 2 1 0)
-;;   (ought t 4 3 2 1 1)
-;;   (expect wrong-type-argument 0 0 'a)
-;;   (expect wrong-type-argument 1 0 'a)
-;;   (ought nil 0 1 'a)
-;;   (ought t 0.1 0.0 0.0 0.0)
-;;   (ought nil 0.0 0.0 0.0 0.1)
-;;   (ought nil -0.1 0.0 0.2 0.4)
-;;   (ought nil -0.1 0.0 0.0 0.2 0.4)
-;;   (ought nil -0.1 0.0 0 0.2 0.4)
-;;   (ought nil -0.1 0 0.2 0.4)
-;;   (ought t 0.4 0.2 0.0 -0.1)
-;;   (ought t 0.4 0.2 0.0 0.0 -0.1)
-;;   (ought t 0.4 0.2 0 0.0 0.0 -0.1)
-;;   (ought t 0.4 0.2 0 -0.1))
+;;   (should (equal t 0 0)
+;;   (should (equal t 0 0 0)
+;;   (should (equal t 0 0 0 0)
+;;   (should (equal t 0 0 0 0 0)
+;;   (should (equal t 0.0 0.0)
+;;   (should (equal t +0.0 -0.0)
+;;   (should (equal t 0.0 0.0 0.0)
+;;   (should (equal t 0.0 0.0 0.0 0.0)
+;;   (should (equal t 1 0)
+;;   (should (equal t 1 0 0)
+;;   (should (equal nil 0 1 2)
+;;   (should (equal t 2 1 0)
+;;   (should (equal t 1 0 0 0 0)
+;;   (should (equal t 4 3 2 1 0)
+;;   (should (equal t 4 3 2 1 1)
+;;   (should-error wrong-type-argument 0 0 'a)
+;;   (should-error wrong-type-argument 1 0 'a)
+;;   (should (equal nil 0 1 'a)
+;;   (should (equal t 0.1 0.0 0.0 0.0)
+;;   (should (equal nil 0.0 0.0 0.0 0.1)
+;;   (should (equal nil -0.1 0.0 0.2 0.4)
+;;   (should (equal nil -0.1 0.0 0.0 0.2 0.4)
+;;   (should (equal nil -0.1 0.0 0 0.2 0.4)
+;;   (should (equal nil -0.1 0 0.2 0.4)
+;;   (should (equal t 0.4 0.2 0.0 -0.1)
+;;   (should (equal t 0.4 0.2 0.0 0.0 -0.1)
+;;   (should (equal t 0.4 0.2 0 0.0 0.0 -0.1)
+;;   (should (equal t 0.4 0.2 0 -0.1))
 
 ;; (ert-deftest special-form-p
-;;   (ought t 'if)
-;;   (ought t 'cond)
-;;   (ought nil 'when)
-;;   (ought nil 'defun)
-;;   (ought nil '+)
-;;   (ought nil nil)
-;;   (ought nil "macro")
-;;   (ought nil '(macro . +)))
+;;   (should (equal t 'if)
+;;   (should (equal t 'cond)
+;;   (should (equal nil 'when)
+;;   (should (equal nil 'defun)
+;;   (should (equal nil '+)
+;;   (should (equal nil nil)
+;;   (should (equal nil "macro")
+;;   (should (equal nil '(macro . +)))
 
 ;; (ert-deftest macrop
-;;   (ought t 'lambda)
-;;   (ought t 'defun)
-;;   (ought t 'defmacro)
-;;   (ought nil 'defalias)
-;;   (ought nil 'foobar)
-;;   (ought nil 'if)
-;;   (ought nil '+)
-;;   (ought nil 1)
-;;   (ought nil nil)
-;;   (ought nil "macro")
-;;   (ought t '(macro . +)))
+;;   (should (equal t 'lambda)
+;;   (should (equal t 'defun)
+;;   (should (equal t 'defmacro)
+;;   (should (equal nil 'defalias)
+;;   (should (equal nil 'foobar)
+;;   (should (equal nil 'if)
+;;   (should (equal nil '+)
+;;   (should (equal nil 1)
+;;   (should (equal nil nil)
+;;   (should (equal nil "macro")
+;;   (should (equal t '(macro . +)))
 
 ;; (ert-deftest string-suffix-p
-;;   (ought t "a" "abba")
-;;   (ought t "ba" "abba")
-;;   (ought t "abba" "abba")
-;;   (ought nil "a" "ABBA")
-;;   (ought nil "bA" "ABBA")
-;;   (ought nil "aBBA" "ABBA")
-;;   (ought nil "c" "ABBA")
-;;   (ought nil "c" "abba")
-;;   (ought nil "cddc" "abba")
-;;   (ought nil "aabba" "abba"))
+;;   (should (equal t "a" "abba")
+;;   (should (equal t "ba" "abba")
+;;   (should (equal t "abba" "abba")
+;;   (should (equal nil "a" "ABBA")
+;;   (should (equal nil "bA" "ABBA")
+;;   (should (equal nil "aBBA" "ABBA")
+;;   (should (equal nil "c" "ABBA")
+;;   (should (equal nil "c" "abba")
+;;   (should (equal nil "cddc" "abba")
+;;   (should (equal nil "aabba" "abba"))
 
 ;; (ert-deftest compat-split-string
-;;   (ought '("a" "b" "c") "a b c")
-;;   (ought '("..a.." "..b.." "..c..") "..a.. ..b.. ..c..")
-;;   (ought '("a" "b" "c") "..a.. ..b.. ..c.." nil nil "\\.+"))
+;;   (should (equal '("a" "b" "c") "a b c")
+;;   (should (equal '("..a.." "..b.." "..c..") "..a.. ..b.. ..c..")
+;;   (should (equal '("a" "b" "c") "..a.. ..b.. ..c.." nil nil "\\.+"))
 
 ;; (ert-deftest delete-consecutive-dups
-;;   (ought '(1 2 3 4) '(1 2 3 4))
-;;   (ought '(1 2 3 4) '(1 2 2 3 4 4))
-;;   (ought '(1 2 3 2 4) '(1 2 2 3 2 4 4)))
+;;   (should (equal '(1 2 3 4) '(1 2 3 4))
+;;   (should (equal '(1 2 3 4) '(1 2 2 3 4 4))
+;;   (should (equal '(1 2 3 2 4) '(1 2 2 3 2 4 4)))
 
 ;; (ert-deftest string-clean-whitespace
-;;   (ought "a b c" "a b c")
-;;   (ought "a b c" "   a b c")
-;;   (ought "a b c" "a b c   ")
-;;   (ought "a b c" "a    b c")
-;;   (ought "a b c" "a b    c")
-;;   (ought "a b c" "a    b    c")
-;;   (ought "a b c" "   a    b    c")
-;;   (ought "a b c" "a    b    c    ")
-;;   (ought "a b c" "   a    b    c    ")
-;;   (ought "aa bb cc" "aa bb cc")
-;;   (ought "aa bb cc" "   aa bb cc")
-;;   (ought "aa bb cc" "aa bb cc   ")
-;;   (ought "aa bb cc" "aa    bb cc")
-;;   (ought "aa bb cc" "aa bb    cc")
-;;   (ought "aa bb cc" "aa    bb    cc")
-;;   (ought "aa bb cc" "   aa    bb    cc")
-;;   (ought "aa bb cc" "aa    bb    cc    ")
-;;   (ought "aa bb cc" "   aa    bb    cc    "))
+;;   (should (equal "a b c" "a b c")
+;;   (should (equal "a b c" "   a b c")
+;;   (should (equal "a b c" "a b c   ")
+;;   (should (equal "a b c" "a    b c")
+;;   (should (equal "a b c" "a b    c")
+;;   (should (equal "a b c" "a    b    c")
+;;   (should (equal "a b c" "   a    b    c")
+;;   (should (equal "a b c" "a    b    c    ")
+;;   (should (equal "a b c" "   a    b    c    ")
+;;   (should (equal "aa bb cc" "aa bb cc")
+;;   (should (equal "aa bb cc" "   aa bb cc")
+;;   (should (equal "aa bb cc" "aa bb cc   ")
+;;   (should (equal "aa bb cc" "aa    bb cc")
+;;   (should (equal "aa bb cc" "aa bb    cc")
+;;   (should (equal "aa bb cc" "aa    bb    cc")
+;;   (should (equal "aa bb cc" "   aa    bb    cc")
+;;   (should (equal "aa bb cc" "aa    bb    cc    ")
+;;   (should (equal "aa bb cc" "   aa    bb    cc    "))
 
 ;; (ert-deftest string-fill
-;;   (ought "a a a a a" "a a a a a" 9)
-;;   (ought "a a a a a" "a a a a a" 10)
-;;   (ought "a a a a\na" "a a a a a" 8)
-;;   (ought "a a a a\na" "a  a  a  a  a" 8)
-;;   (ought "a a\na a\na" "a a a a a" 4)
-;;   (ought "a\na\na\na\na" "a a a a a" 2)
-;;   (ought "a\na\na\na\na" "a a a a a" 1))
+;;   (should (equal "a a a a a" "a a a a a" 9)
+;;   (should (equal "a a a a a" "a a a a a" 10)
+;;   (should (equal "a a a a\na" "a a a a a" 8)
+;;   (should (equal "a a a a\na" "a  a  a  a  a" 8)
+;;   (should (equal "a a\na a\na" "a a a a a" 4)
+;;   (should (equal "a\na\na\na\na" "a a a a a" 2)
+;;   (should (equal "a\na\na\na\na" "a a a a a" 1))
 
 ;; (ert-deftest string-lines
-;;   (ought '("a" "b" "c") "a\nb\nc")
-;;   (ought '("a" "b" "c" "") "a\nb\nc\n")
-;;   (ought '("a" "b" "c") "a\nb\nc\n" t)
-;;   (ought '("abc" "bcd" "cde") "abc\nbcd\ncde")
-;;   (ought '(" abc" " bcd " "cde ") " abc\n bcd \ncde "))
+;;   (should (equal '("a" "b" "c") "a\nb\nc")
+;;   (should (equal '("a" "b" "c" "") "a\nb\nc\n")
+;;   (should (equal '("a" "b" "c") "a\nb\nc\n" t)
+;;   (should (equal '("abc" "bcd" "cde") "abc\nbcd\ncde")
+;;   (should (equal '(" abc" " bcd " "cde ") " abc\n bcd \ncde "))
 
 ;; (ert-deftest string-pad
-;;   (ought "a   " "a" 4)
-;;   (ought "aaaa" "aaaa" 4)
-;;   (ought "aaaaaa" "aaaaaa" 4)
-;;   (ought "a..." "a" 4 ?.)
-;;   (ought "   a" "a" 4 nil t)
-;;   (ought "...a" "a" 4 ?. t))
+;;   (should (equal "a   " "a" 4)
+;;   (should (equal "aaaa" "aaaa" 4)
+;;   (should (equal "aaaaaa" "aaaaaa" 4)
+;;   (should (equal "a..." "a" 4 ?.)
+;;   (should (equal "   a" "a" 4 nil t)
+;;   (should (equal "...a" "a" 4 ?. t))
 
 ;; (ert-deftest string-chop-newline
-;;   (ought "" "")
-;;   (ought "" "\n")
-;;   (ought "aaa" "aaa")
-;;   (ought "aaa" "aaa\n")
-;;   (ought "aaa\n" "aaa\n\n"))
+;;   (should (equal "" "")
+;;   (should (equal "" "\n")
+;;   (should (equal "aaa" "aaa")
+;;   (should (equal "aaa" "aaa\n")
+;;   (should (equal "aaa\n" "aaa\n\n"))
 
 ;; (ert-deftest macroexpand-1
-;;   (ought '(if a b c) '(if a b c))
-;;   (ought '(if a (progn b)) '(when a b))
-;;   (ought '(if a (progn (unless b c))) '(when a (unless b c))))
+;;   (should (equal '(if a b c) '(if a b c))
+;;   (should (equal '(if a (progn b)) '(when a b))
+;;   (should (equal '(if a (progn (unless b c))) '(when a (unless b c))))
 
 ;; (ert-deftest compat-file-size-human-readable
-;;     (ought "1000" 1000)
-;;     (ought "1k" 1024)
-;;     (ought "1M" (* 1024 1024))
-;;     (ought "1G" (expt 1024 3))
-;;     (ought "1T" (expt 1024 4))
-;;     (ought "1k" 1000 'si)
-;;     (ought "1KiB" 1024 'iec)
-;;     (ought "1KiB" 1024 'iec)
-;;     (ought "1 KiB" 1024 'iec " ")
-;;     (ought "1KiA" 1024 'iec nil "A")
-;;     (ought "1 KiA" 1024 'iec " " "A")
-;;     (ought "1kA" 1000 'si nil "A")
-;;     (ought "1 k" 1000 'si " ")
-;;     (ought "1 kA" 1000 'si " " "A"))
+;;     (should (equal "1000" 1000)
+;;     (should (equal "1k" 1024)
+;;     (should (equal "1M" (* 1024 1024))
+;;     (should (equal "1G" (expt 1024 3))
+;;     (should (equal "1T" (expt 1024 4))
+;;     (should (equal "1k" 1000 'si)
+;;     (should (equal "1KiB" 1024 'iec)
+;;     (should (equal "1KiB" 1024 'iec)
+;;     (should (equal "1 KiB" 1024 'iec " ")
+;;     (should (equal "1KiA" 1024 'iec nil "A")
+;;     (should (equal "1 KiA" 1024 'iec " " "A")
+;;     (should (equal "1kA" 1000 'si nil "A")
+;;     (should (equal "1 k" 1000 'si " ")
+;;     (should (equal "1 kA" 1000 'si " " "A"))
 
 ;; (ert-deftest format-prompt
-;;   (ought "Prompt: " "Prompt" nil)
-;;   (ought "Prompt: " "Prompt" "")
-;;   (ought "Prompt (default  ): " "Prompt" " ")
-;;   (ought "Prompt (default 3): " "Prompt" 3)
-;;   (ought "Prompt (default abc): " "Prompt" "abc")
-;;   (ought "Prompt (default abc def): " "Prompt" "abc def")
-;;   (ought "Prompt 10: " "Prompt %d" nil 10)
-;;   (ought "Prompt \"abc\" (default 3): " "Prompt %S" 3 "abc"))
+;;   (should (equal "Prompt: " "Prompt" nil)
+;;   (should (equal "Prompt: " "Prompt" "")
+;;   (should (equal "Prompt (default  ): " "Prompt" " ")
+;;   (should (equal "Prompt (default 3): " "Prompt" 3)
+;;   (should (equal "Prompt (default abc): " "Prompt" "abc")
+;;   (should (equal "Prompt (default abc def): " "Prompt" "abc def")
+;;   (should (equal "Prompt 10: " "Prompt %d" nil 10)
+;;   (should (equal "Prompt \"abc\" (default 3): " "Prompt %S" 3 "abc"))
 
 ;; ;; TODO fix broken test
 ;; ;;(ert-deftest directory-files-recursively
@@ -1184,18 +1186,18 @@
 ;; ;;           '("./.github/workflows/makefile.yml" "./COPYING" 
"./Makefile"))))
 
 ;; (ert-deftest directory-name-p
-;;   (ought t "/")
-;;   (ought nil "/file")
-;;   (ought nil "/dir/file")
-;;   (ought t "/dir/")
-;;   (ought nil "/dir")
-;;   (ought t "/dir/subdir/")
-;;   (ought nil "/dir/subdir")
-;;   (ought t "dir/")
-;;   (ought nil "file")
-;;   (ought nil "dir/file")
-;;   (ought t "dir/subdir/")
-;;   (ought nil "dir/subdir"))
+;;   (should (equal t "/")
+;;   (should (equal nil "/file")
+;;   (should (equal nil "/dir/file")
+;;   (should (equal t "/dir/")
+;;   (should (equal nil "/dir")
+;;   (should (equal t "/dir/subdir/")
+;;   (should (equal nil "/dir/subdir")
+;;   (should (equal t "dir/")
+;;   (should (equal nil "file")
+;;   (should (equal nil "dir/file")
+;;   (should (equal t "dir/subdir/")
+;;   (should (equal nil "dir/subdir"))
 
 ;; (ert-deftest compat-if-let* ()
 ;;   "Check if `compat--t-if-let*' was implemented properly."
@@ -1244,134 +1246,134 @@
 ;;    (compat--t-and-let* (((= 5 6))) t)))
 
 ;; (ert-deftest compat-json-parse-string
-;;   (ought 0 "0")
-;;   (ought 1 "1")
-;;   (ought 0.5 "0.5")
-;;   (ought [1 2 3] "[1,2,3]")
-;;   (ought ["a" 2 3] "[\"a\",2,3]")
-;;   (ought [["a" 2] 3] "[[\"a\",2],3]")
-;;   (ought '(("a" 2) 3) "[[\"a\",2],3]" :array-type 'list)
-;;   (ought 'foo "null" :null-object 'foo)
-;;   (ought ["false" t] "[false, true]" :false-object "false"))
+;;   (should (equal 0 "0")
+;;   (should (equal 1 "1")
+;;   (should (equal 0.5 "0.5")
+;;   (should (equal [1 2 3] "[1,2,3]")
+;;   (should (equal ["a" 2 3] "[\"a\",2,3]")
+;;   (should (equal [["a" 2] 3] "[[\"a\",2],3]")
+;;   (should (equal '(("a" 2) 3) "[[\"a\",2],3]" :array-type 'list)
+;;   (should (equal 'foo "null" :null-object 'foo)
+;;   (should (equal ["false" t] "[false, true]" :false-object "false"))
 
 ;; (ert-deftest compat-lookup-key
 ;;   (let ((a-map (make-sparse-keymap))
 ;;         (b-map (make-sparse-keymap)))
 ;;     (define-key a-map "x" 'foo)
 ;;     (define-key b-map "x" 'bar)
-;;     (ought 'foo a-map "x")
-;;     (ought 'bar b-map "x")
-;;     (ought 'foo (list a-map b-map) "x")
-;;     (ought 'bar (list b-map a-map) "x")))
+;;     (should (equal 'foo a-map "x")
+;;     (should (equal 'bar b-map "x")
+;;     (should (equal 'foo (list a-map b-map) "x")
+;;     (should (equal 'bar (list b-map a-map) "x")))
 
 ;; (ert-deftest string-empty-p
-;;   (ought t "")
-;;   (ought nil " ")
-;;   (ought t (make-string 0 ?x))
-;;   (ought nil (make-string 1 ?x)))
+;;   (should (equal t "")
+;;   (should (equal nil " ")
+;;   (should (equal t (make-string 0 ?x))
+;;   (should (equal nil (make-string 1 ?x)))
 
 ;; (ert-deftest string-join
-;;   (ought "" '(""))
-;;   (ought "" '("") " ")
-;;   (ought "a" '("a"))
-;;   (ought "a" '("a") " ")
-;;   (ought "abc" '("a" "b" "c"))
-;;   (ought "a b c" '("a" "b" "c") " "))
+;;   (should (equal "" '(""))
+;;   (should (equal "" '("") " ")
+;;   (should (equal "a" '("a"))
+;;   (should (equal "a" '("a") " ")
+;;   (should (equal "abc" '("a" "b" "c"))
+;;   (should (equal "a b c" '("a" "b" "c") " "))
 
 ;; (ert-deftest string-blank-p
-;;   (ought 0 "")
-;;   (ought 0 " ")
-;;   (ought 0 (make-string 0 ?x))
-;;   (ought nil (make-string 1 ?x)))
+;;   (should (equal 0 "")
+;;   (should (equal 0 " ")
+;;   (should (equal 0 (make-string 0 ?x))
+;;   (should (equal nil (make-string 1 ?x)))
 
 ;; (ert-deftest string-remove-prefix
-;;   (ought "" "" "")
-;;   (ought "a" "" "a")
-;;   (ought "" "a" "")
-;;   (ought "bc" "a" "abc")
-;;   (ought "abc" "c" "abc")
-;;   (ought "bbcc" "aa" "aabbcc")
-;;   (ought "aabbcc" "bb" "aabbcc")
-;;   (ought "aabbcc" "cc" "aabbcc")
-;;   (ought "aabbcc" "dd" "aabbcc"))
+;;   (should (equal "" "" "")
+;;   (should (equal "a" "" "a")
+;;   (should (equal "" "a" "")
+;;   (should (equal "bc" "a" "abc")
+;;   (should (equal "abc" "c" "abc")
+;;   (should (equal "bbcc" "aa" "aabbcc")
+;;   (should (equal "aabbcc" "bb" "aabbcc")
+;;   (should (equal "aabbcc" "cc" "aabbcc")
+;;   (should (equal "aabbcc" "dd" "aabbcc"))
 
 ;; (ert-deftest string-remove-suffix
-;;   (ought "" "" "")
-;;   (ought "a" "" "a")
-;;   (ought "" "a" "")
-;;   (ought "abc" "a" "abc")
-;;   (ought "ab" "c" "abc")
-;;   (ought "aabbcc" "aa" "aabbcc")
-;;   (ought "aabbcc" "bb" "aabbcc")
-;;   (ought "aabb" "cc" "aabbcc")
-;;   (ought "aabbcc" "dd" "aabbcc"))
+;;   (should (equal "" "" "")
+;;   (should (equal "a" "" "a")
+;;   (should (equal "" "a" "")
+;;   (should (equal "abc" "a" "abc")
+;;   (should (equal "ab" "c" "abc")
+;;   (should (equal "aabbcc" "aa" "aabbcc")
+;;   (should (equal "aabbcc" "bb" "aabbcc")
+;;   (should (equal "aabb" "cc" "aabbcc")
+;;   (should (equal "aabbcc" "dd" "aabbcc"))
 
 ;; (let ((a (bool-vector t t nil nil))
 ;;       (b (bool-vector t nil t nil)))
 ;;   (ert-deftest bool-vector-exclusive-or
-;;     (ought (bool-vector nil t t nil) a b)
-;;     (ought (bool-vector nil t t nil) b a)
+;;     (should (equal (bool-vector nil t t nil) a b)
+;;     (should (equal (bool-vector nil t t nil) b a)
 ;;     (ert-deftest compat-bool-vector-exclusive-or-sideeffect ()
 ;;       (let ((c (make-bool-vector 4 nil)))
 ;;         (compat--t-bool-vector-exclusive-or a b c)
 ;;         (should (equal (bool-vector nil t t nil) c))
 ;;         (should (equal (bool-vector nil t t nil) c))))
 ;;     (when (version<= "24.4" emacs-version)
-;;       (expect wrong-length-argument a (bool-vector))
-;;       (expect wrong-length-argument a b (bool-vector)))
-;;     (expect wrong-type-argument (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector))
-;;     (expect wrong-type-argument (vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (vector) (vector))))
+;;       (should-error wrong-length-argument a (bool-vector))
+;;       (should-error wrong-length-argument a b (bool-vector)))
+;;     (should-error wrong-type-argument (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector))
+;;     (should-error wrong-type-argument (vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (vector) (vector))))
 
 ;; (let ((a (bool-vector t t nil nil))
 ;;       (b (bool-vector t nil t nil)))
 ;;   (ert-deftest bool-vector-union
-;;     (ought (bool-vector t t t nil) a b)
-;;     (ought (bool-vector t t t nil) b a)
+;;     (should (equal (bool-vector t t t nil) a b)
+;;     (should (equal (bool-vector t t t nil) b a)
 ;;     (ert-deftest compat-bool-vector-union-sideeffect ()
 ;;       (let ((c (make-bool-vector 4 nil)))
 ;;         (compat--t-bool-vector-union a b c)
 ;;         (should (equal (bool-vector t t t nil) c))))
 ;;     (when (version<= "24.4" emacs-version)
-;;       (expect wrong-length-argument a (bool-vector))
-;;       (expect wrong-length-argument a b (bool-vector)))
-;;     (expect wrong-type-argument (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector))
-;;     (expect wrong-type-argument (vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (vector) (vector))))
+;;       (should-error wrong-length-argument a (bool-vector))
+;;       (should-error wrong-length-argument a b (bool-vector)))
+;;     (should-error wrong-type-argument (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector))
+;;     (should-error wrong-type-argument (vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (vector) (vector))))
 
 ;; (let ((a (bool-vector t t nil nil))
 ;;       (b (bool-vector t nil t nil)))
 ;;   (ert-deftest bool-vector-intersection
-;;     (ought (bool-vector t nil nil nil) a b)
-;;     (ought (bool-vector t nil nil nil) b a)
+;;     (should (equal (bool-vector t nil nil nil) a b)
+;;     (should (equal (bool-vector t nil nil nil) b a)
 ;;     (ert-deftest compat-bool-vector-intersection-sideeffect ()
 ;;       (let ((c (make-bool-vector 4 nil)))
 ;;         (compat--t-bool-vector-intersection a b c)
 ;;         (should (equal (bool-vector t nil nil nil) c))))
 ;;     (when (version<= "24.4" emacs-version)
-;;       (expect wrong-length-argument a (bool-vector))
-;;       (expect wrong-length-argument a b (bool-vector)))
-;;     (expect wrong-type-argument (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector))
-;;     (expect wrong-type-argument (vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (vector) (vector))))
+;;       (should-error wrong-length-argument a (bool-vector))
+;;       (should-error wrong-length-argument a b (bool-vector)))
+;;     (should-error wrong-type-argument (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector))
+;;     (should-error wrong-type-argument (vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (vector) (vector))))
 
 ;; (let ((a (bool-vector t t nil nil))
 ;;       (b (bool-vector t nil t nil)))
 ;;   (ert-deftest bool-vector-set-difference
-;;     (ought (bool-vector nil t nil nil) a b)
-;;     (ought (bool-vector nil nil t nil) b a)
+;;     (should (equal (bool-vector nil t nil nil) a b)
+;;     (should (equal (bool-vector nil nil t nil) b a)
 ;;     (ert-deftest compat-bool-vector-set-difference-sideeffect ()
 ;;       (let ((c (make-bool-vector 4 nil)))
 ;;         (compat--t-bool-vector-set-difference a b c)
@@ -1380,348 +1382,348 @@
 ;;         (compat--t-bool-vector-set-difference b a c)
 ;;         (should (equal (bool-vector nil nil t nil) c))))
 ;;     (when (version<= "24.4" emacs-version)
-;;       (expect wrong-length-argument a (bool-vector))
-;;       (expect wrong-length-argument a b (bool-vector)))
-;;     (expect wrong-type-argument (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector))
-;;     (expect wrong-type-argument (vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (bool-vector) (vector) (vector))
-;;     (expect wrong-type-argument (vector) (bool-vector) (vector))
-;;     (expect wrong-type-argument (vector) (vector) (vector))))
+;;       (should-error wrong-length-argument a (bool-vector))
+;;       (should-error wrong-length-argument a b (bool-vector)))
+;;     (should-error wrong-type-argument (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector))
+;;     (should-error wrong-type-argument (vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (bool-vector) (vector) (vector))
+;;     (should-error wrong-type-argument (vector) (bool-vector) (vector))
+;;     (should-error wrong-type-argument (vector) (vector) (vector))))
 
 ;; (ert-deftest bool-vector-not
-;;   (ought (bool-vector) (bool-vector))
-;;   (ought (bool-vector t) (bool-vector nil))
-;;   (ought (bool-vector nil) (bool-vector t))
-;;   (ought (bool-vector t t) (bool-vector nil nil))
-;;   (ought (bool-vector t nil) (bool-vector nil t))
-;;   (ought (bool-vector nil t) (bool-vector t nil))
-;;   (ought (bool-vector nil nil) (bool-vector t t))
-;;   (expect wrong-type-argument (vector))
-;;   (expect wrong-type-argument (vector) (vector)))
+;;   (should (equal (bool-vector) (bool-vector))
+;;   (should (equal (bool-vector t) (bool-vector nil))
+;;   (should (equal (bool-vector nil) (bool-vector t))
+;;   (should (equal (bool-vector t t) (bool-vector nil nil))
+;;   (should (equal (bool-vector t nil) (bool-vector nil t))
+;;   (should (equal (bool-vector nil t) (bool-vector t nil))
+;;   (should (equal (bool-vector nil nil) (bool-vector t t))
+;;   (should-error wrong-type-argument (vector))
+;;   (should-error wrong-type-argument (vector) (vector)))
 
 ;; (ert-deftest bool-vector-subsetp
-;;   (ought t (bool-vector) (bool-vector))
-;;   (ought t (bool-vector t) (bool-vector t))
-;;   (ought t (bool-vector nil) (bool-vector t))
-;;   (ought nil (bool-vector t) (bool-vector nil))
-;;   (ought t (bool-vector nil) (bool-vector nil))
-;;   (ought t (bool-vector t t) (bool-vector t t))
-;;   (ought t (bool-vector nil nil) (bool-vector t t))
-;;   (ought t (bool-vector nil nil) (bool-vector t nil))
-;;   (ought t (bool-vector nil nil) (bool-vector nil t))
-;;   (ought nil (bool-vector t nil) (bool-vector nil nil))
-;;   (ought nil (bool-vector nil t) (bool-vector nil nil))
+;;   (should (equal t (bool-vector) (bool-vector))
+;;   (should (equal t (bool-vector t) (bool-vector t))
+;;   (should (equal t (bool-vector nil) (bool-vector t))
+;;   (should (equal nil (bool-vector t) (bool-vector nil))
+;;   (should (equal t (bool-vector nil) (bool-vector nil))
+;;   (should (equal t (bool-vector t t) (bool-vector t t))
+;;   (should (equal t (bool-vector nil nil) (bool-vector t t))
+;;   (should (equal t (bool-vector nil nil) (bool-vector t nil))
+;;   (should (equal t (bool-vector nil nil) (bool-vector nil t))
+;;   (should (equal nil (bool-vector t nil) (bool-vector nil nil))
+;;   (should (equal nil (bool-vector nil t) (bool-vector nil nil))
 ;;   (when (version<= "24.4" emacs-version)
-;;     (expect wrong-length-argument (bool-vector nil) (bool-vector nil nil)))
-;;   (expect wrong-type-argument (bool-vector) (vector))
-;;   (expect wrong-type-argument (vector) (bool-vector))
-;;   (expect wrong-type-argument (vector) (vector)))
+;;     (should-error wrong-length-argument (bool-vector nil) (bool-vector nil 
nil)))
+;;   (should-error wrong-type-argument (bool-vector) (vector))
+;;   (should-error wrong-type-argument (vector) (bool-vector))
+;;   (should-error wrong-type-argument (vector) (vector)))
 
 ;; (ert-deftest bool-vector-count-consecutive
-;;   (ought 0 (bool-vector nil) (bool-vector nil) 0)
-;;   (ought 0 (make-bool-vector 10 nil) t 0)
-;;   (ought 10 (make-bool-vector 10 nil) nil 0)
-;;   (ought 0 (make-bool-vector 10 nil) t 1)
-;;   (ought 9 (make-bool-vector 10 nil) nil 1)
-;;   (ought 0 (make-bool-vector 10 nil) t 1)
-;;   (ought 9 (make-bool-vector 10 t) t 1)
-;;   (ought 0 (make-bool-vector 10 nil) t 8)
-;;   (ought 2 (make-bool-vector 10 nil) nil 8)
-;;   (ought 2 (make-bool-vector 10 t) t 8)
-;;   (ought 10 (make-bool-vector 10 t) (make-bool-vector 10 t) 0)
-;;   (ought 4 (bool-vector t t t t nil t t t t t) t 0)
-;;   (ought 0 (bool-vector t t t t nil t t t t t) t 4)
-;;   (ought 5 (bool-vector t t t t nil t t t t t) t 5)
-;;   (expect wrong-type-argument (vector) nil 0))
+;;   (should (equal 0 (bool-vector nil) (bool-vector nil) 0)
+;;   (should (equal 0 (make-bool-vector 10 nil) t 0)
+;;   (should (equal 10 (make-bool-vector 10 nil) nil 0)
+;;   (should (equal 0 (make-bool-vector 10 nil) t 1)
+;;   (should (equal 9 (make-bool-vector 10 nil) nil 1)
+;;   (should (equal 0 (make-bool-vector 10 nil) t 1)
+;;   (should (equal 9 (make-bool-vector 10 t) t 1)
+;;   (should (equal 0 (make-bool-vector 10 nil) t 8)
+;;   (should (equal 2 (make-bool-vector 10 nil) nil 8)
+;;   (should (equal 2 (make-bool-vector 10 t) t 8)
+;;   (should (equal 10 (make-bool-vector 10 t) (make-bool-vector 10 t) 0)
+;;   (should (equal 4 (bool-vector t t t t nil t t t t t) t 0)
+;;   (should (equal 0 (bool-vector t t t t nil t t t t t) t 4)
+;;   (should (equal 5 (bool-vector t t t t nil t t t t t) t 5)
+;;   (should-error wrong-type-argument (vector) nil 0))
 
 ;; (ert-deftest bool-vector-count-population
-;;   (ought  0 (bool-vector))
-;;   (ought  0 (make-bool-vector 10 nil))
-;;   (ought 10 (make-bool-vector 10 t))
-;;   (ought  1 (bool-vector nil nil t nil))
-;;   (ought  1 (bool-vector nil nil nil t))
-;;   (ought  1 (bool-vector t nil nil nil))
-;;   (ought  2 (bool-vector t nil nil t))
-;;   (ought  2 (bool-vector t nil t nil))
-;;   (ought  3 (bool-vector t nil t t))
-;;   (expect wrong-type-argument (vector)))
+;;   (should (equal  0 (bool-vector))
+;;   (should (equal  0 (make-bool-vector 10 nil))
+;;   (should (equal 10 (make-bool-vector 10 t))
+;;   (should (equal  1 (bool-vector nil nil t nil))
+;;   (should (equal  1 (bool-vector nil nil nil t))
+;;   (should (equal  1 (bool-vector t nil nil nil))
+;;   (should (equal  2 (bool-vector t nil nil t))
+;;   (should (equal  2 (bool-vector t nil t nil))
+;;   (should (equal  3 (bool-vector t nil t t))
+;;   (should-error wrong-type-argument (vector)))
 
 ;; (ert-deftest compat-assoc-delete-all
-;;   (ought (list) 0 (list))
+;;   (should (equal (list) 0 (list))
 ;;   ;; Test `eq'
-;;   (ought '((1 . one)) 0 (list (cons 1 'one)))
-;;   (ought '((1 . one) a) 0 (list (cons 1 'one) 'a))
-;;   (ought '((1 . one)) 0 (list (cons 0 'zero) (cons 1 'one)))
-;;   (ought '((1 . one)) 0 (list (cons 0 'zero) (cons 0 'zero) (cons 1 'one)))
-;;   (ought '((1 . one)) 0 (list (cons 0 'zero) (cons 1 'one) (cons 0 'zero)))
-;;   (ought '((1 . one) a) 0 (list (cons 0 'zero) (cons 1 'one) 'a  (cons 0 
'zero)))
-;;   (ought '(a (1 . one)) 0 (list 'a (cons 0 'zero) (cons 1 'one) (cons 0 
'zero)))
+;;   (should (equal '((1 . one)) 0 (list (cons 1 'one)))
+;;   (should (equal '((1 . one) a) 0 (list (cons 1 'one) 'a))
+;;   (should (equal '((1 . one)) 0 (list (cons 0 'zero) (cons 1 'one)))
+;;   (should (equal '((1 . one)) 0 (list (cons 0 'zero) (cons 0 'zero) (cons 1 
'one)))
+;;   (should (equal '((1 . one)) 0 (list (cons 0 'zero) (cons 1 'one) (cons 0 
'zero)))
+;;   (should (equal '((1 . one) a) 0 (list (cons 0 'zero) (cons 1 'one) 'a  
(cons 0 'zero)))
+;;   (should (equal '(a (1 . one)) 0 (list 'a (cons 0 'zero) (cons 1 'one) 
(cons 0 'zero)))
 ;;   ;; Test `equal'
-;;   (ought '(("one" . one)) "zero" (list (cons "one" 'one)))
-;;   (ought '(("one" . one) a) "zero" (list (cons "one" 'one) 'a))
-;;   (ought '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons "one" 
'one)))
-;;   (ought '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons "zero" 
'zero) (cons "one" 'one)))
-;;   (ought '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons "one" 
'one) (cons "zero" 'zero)))
-;;   (ought '(("one" . one) a) "zero" (list (cons "zero" 'zero) (cons "one" 
'one) 'a  (cons "zero" 'zero)))
-;;   (ought '(a ("one" . one)) "zero" (list 'a (cons "zero" 'zero) (cons "one" 
'one) (cons "zero" 'zero)))
+;;   (should (equal '(("one" . one)) "zero" (list (cons "one" 'one)))
+;;   (should (equal '(("one" . one) a) "zero" (list (cons "one" 'one) 'a))
+;;   (should (equal '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons 
"one" 'one)))
+;;   (should (equal '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons 
"zero" 'zero) (cons "one" 'one)))
+;;   (should (equal '(("one" . one)) "zero" (list (cons "zero" 'zero) (cons 
"one" 'one) (cons "zero" 'zero)))
+;;   (should (equal '(("one" . one) a) "zero" (list (cons "zero" 'zero) (cons 
"one" 'one) 'a  (cons "zero" 'zero)))
+;;   (should (equal '(a ("one" . one)) "zero" (list 'a (cons "zero" 'zero) 
(cons "one" 'one) (cons "zero" 'zero)))
 ;;   ;; Test custom predicate
-;;   (ought '() 0 (list (cons 1 'one)) #'/=)
-;;   (ought '(a) 0 (list (cons 1 'one) 'a) #'/=)
-;;   (ought '((0 . zero)) 0 (list (cons 0 'zero) (cons 1 'one)) #'/=)
-;;   (ought '((0 . zero) (0 . zero)) 0 (list (cons 0 'zero) (cons 0 'zero) 
(cons 1 'one)) #'/=)
-;;   (ought '((0 . zero) (0 . zero)) 0 (list (cons 0 'zero) (cons 1 'one) 
(cons 0 'zero)) #'/=)
-;;   (ought '((0 . zero) a (0 . zero)) 0 (list (cons 0 'zero) (cons 1 'one) 'a 
 (cons 0 'zero)) #'/=)
-;;   (ought '(a (0 . zero) (0 . zero)) 0 (list 'a (cons 0 'zero) (cons 1 'one) 
(cons 0 'zero)) #'/=))
+;;   (should (equal '() 0 (list (cons 1 'one)) #'/=)
+;;   (should (equal '(a) 0 (list (cons 1 'one) 'a) #'/=)
+;;   (should (equal '((0 . zero)) 0 (list (cons 0 'zero) (cons 1 'one)) #'/=)
+;;   (should (equal '((0 . zero) (0 . zero)) 0 (list (cons 0 'zero) (cons 0 
'zero) (cons 1 'one)) #'/=)
+;;   (should (equal '((0 . zero) (0 . zero)) 0 (list (cons 0 'zero) (cons 1 
'one) (cons 0 'zero)) #'/=)
+;;   (should (equal '((0 . zero) a (0 . zero)) 0 (list (cons 0 'zero) (cons 1 
'one) 'a  (cons 0 'zero)) #'/=)
+;;   (should (equal '(a (0 . zero) (0 . zero)) 0 (list 'a (cons 0 'zero) (cons 
1 'one) (cons 0 'zero)) #'/=))
 
 ;; (ert-deftest color-values-from-color-spec
 ;;   ;; #RGB notation
-;;   (ought '(0 0 0) "#000")
-;;   (ought '(0 0 0) "#000000")
-;;   (ought '(0 0 0) "#000000000")
-;;   (ought '(0 0 0) "#000000000000")
-;;   (ought '(0 0 65535) "#00F")
-;;   (ought '(0 0 65535) "#0000FF")
-;;   (ought '(0 0 65535) "#000000FFF")
-;;   (ought '(0 0 65535) "#00000000FFFF")
-;;   (ought '(0 0 65535) "#00f")
-;;   (ought '(0 0 65535) "#0000ff")
-;;   (ought '(0 0 65535) "#000000fff")
-;;   (ought '(0 0 65535) "#00000000ffff")
-;;   (ought '(0 0 65535) "#00000000ffFF")
-;;   (ought '(#xffff #x0000 #x5555) "#f05")
-;;   (ought '(#x1f1f #xb0b0 #xc5c5) "#1fb0C5")
-;;   (ought '(#x1f83 #xb0ad #xc5e2) "#1f83b0ADC5e2")
-;;   (ought nil "")
-;;   (ought nil "#")
-;;   (ought nil "#0")
-;;   (ought nil "#00")
-;;   (ought nil "#0000FG")
-;;   (ought nil "#0000FFF")
-;;   (ought nil "#0000FFFF")
-;;   (ought '(0 4080 65535) "#0000FFFFF")
-;;   (ought nil "#000FF")
-;;   (ought nil "#0000F")
-;;   (ought nil " #000000")
-;;   (ought nil "#000000 ")
-;;   (ought nil " #000000 ")
-;;   (ought nil "#1f83b0ADC5e2g")
-;;   (ought nil "#1f83b0ADC5e20")
-;;   (ought nil "#12345")
+;;   (should (equal '(0 0 0) "#000")
+;;   (should (equal '(0 0 0) "#000000")
+;;   (should (equal '(0 0 0) "#000000000")
+;;   (should (equal '(0 0 0) "#000000000000")
+;;   (should (equal '(0 0 65535) "#00F")
+;;   (should (equal '(0 0 65535) "#0000FF")
+;;   (should (equal '(0 0 65535) "#000000FFF")
+;;   (should (equal '(0 0 65535) "#00000000FFFF")
+;;   (should (equal '(0 0 65535) "#00f")
+;;   (should (equal '(0 0 65535) "#0000ff")
+;;   (should (equal '(0 0 65535) "#000000fff")
+;;   (should (equal '(0 0 65535) "#00000000ffff")
+;;   (should (equal '(0 0 65535) "#00000000ffFF")
+;;   (should (equal '(#xffff #x0000 #x5555) "#f05")
+;;   (should (equal '(#x1f1f #xb0b0 #xc5c5) "#1fb0C5")
+;;   (should (equal '(#x1f83 #xb0ad #xc5e2) "#1f83b0ADC5e2")
+;;   (should (equal nil "")
+;;   (should (equal nil "#")
+;;   (should (equal nil "#0")
+;;   (should (equal nil "#00")
+;;   (should (equal nil "#0000FG")
+;;   (should (equal nil "#0000FFF")
+;;   (should (equal nil "#0000FFFF")
+;;   (should (equal '(0 4080 65535) "#0000FFFFF")
+;;   (should (equal nil "#000FF")
+;;   (should (equal nil "#0000F")
+;;   (should (equal nil " #000000")
+;;   (should (equal nil "#000000 ")
+;;   (should (equal nil " #000000 ")
+;;   (should (equal nil "#1f83b0ADC5e2g")
+;;   (should (equal nil "#1f83b0ADC5e20")
+;;   (should (equal nil "#12345")
 ;;   ;; rgb: notation
-;;   (ought '(0 0 0) "rgb:0/0/0")
-;;   (ought '(0 0 0) "rgb:0/0/00")
-;;   (ought '(0 0 0) "rgb:0/00/000")
-;;   (ought '(0 0 0) "rgb:0/000/0000")
-;;   (ought '(0 0 0) "rgb:000/0000/0")
-;;   (ought '(0 0 65535) "rgb:000/0000/F")
-;;   (ought '(65535 0 65535) "rgb:FFF/0000/F")
-;;   (ought '(65535 0 65535) "rgb:FFFF/0000/FFFF")
-;;   (ought '(0 255 65535) "rgb:0/00FF/FFFF")
-;;   (ought '(#xffff #x2323 #x28a2) "rgb:f/23/28a")
-;;   (ought '(#x1234 #x5678 #x09ab) "rgb:1234/5678/09ab")
-;;   (ought nil "rgb:/0000/FFFF")
-;;   (ought nil "rgb:0000/0000/FFFG")
-;;   (ought nil "rgb:0000/0000/FFFFF")
-;;   (ought nil "rgb:0000/0000")
-;;   (ought nil "rg:0000/0000/0000")
-;;   (ought nil "rgb: 0000/0000/0000")
-;;   (ought nil "rgbb:0000/0000/0000")
-;;   (ought nil "rgb:0000/0000/0000   ")
-;;   (ought nil " rgb:0000/0000/0000  ")
-;;   (ought nil "  rgb:0000/0000/0000")
-;;   (ought nil "rgb:0000/ 0000 /0000")
-;;   (ought nil "rgb: 0000 /0000 /0000")
-;;   (ought nil "rgb:0//0")
+;;   (should (equal '(0 0 0) "rgb:0/0/0")
+;;   (should (equal '(0 0 0) "rgb:0/0/00")
+;;   (should (equal '(0 0 0) "rgb:0/00/000")
+;;   (should (equal '(0 0 0) "rgb:0/000/0000")
+;;   (should (equal '(0 0 0) "rgb:000/0000/0")
+;;   (should (equal '(0 0 65535) "rgb:000/0000/F")
+;;   (should (equal '(65535 0 65535) "rgb:FFF/0000/F")
+;;   (should (equal '(65535 0 65535) "rgb:FFFF/0000/FFFF")
+;;   (should (equal '(0 255 65535) "rgb:0/00FF/FFFF")
+;;   (should (equal '(#xffff #x2323 #x28a2) "rgb:f/23/28a")
+;;   (should (equal '(#x1234 #x5678 #x09ab) "rgb:1234/5678/09ab")
+;;   (should (equal nil "rgb:/0000/FFFF")
+;;   (should (equal nil "rgb:0000/0000/FFFG")
+;;   (should (equal nil "rgb:0000/0000/FFFFF")
+;;   (should (equal nil "rgb:0000/0000")
+;;   (should (equal nil "rg:0000/0000/0000")
+;;   (should (equal nil "rgb: 0000/0000/0000")
+;;   (should (equal nil "rgbb:0000/0000/0000")
+;;   (should (equal nil "rgb:0000/0000/0000   ")
+;;   (should (equal nil " rgb:0000/0000/0000  ")
+;;   (should (equal nil "  rgb:0000/0000/0000")
+;;   (should (equal nil "rgb:0000/ 0000 /0000")
+;;   (should (equal nil "rgb: 0000 /0000 /0000")
+;;   (should (equal nil "rgb:0//0")
 ;;   ;; rgbi: notation
-;;   (ought '(0 0 0) "rgbi:0/0/0")
-;;   (ought '(0 0 0) "rgbi:0.0/0.0/0.0")
-;;   (ought '(0 0 0) "rgbi:0.0/0/0")
-;;   (ought '(0 0 0) "rgbi:0.0/0/0")
-;;   (ought '(0 0 0) "rgbi:0/0/0.")
-;;   (ought '(0 0 0) "rgbi:0/0/0.0000")
-;;   (ought '(0 0 0) "rgbi:0/0/.0")
-;;   (ought '(0 0 0) "rgbi:0/0/.0000")
-;;   (ought '(65535 0 0) "rgbi:1/0/0.0000")
-;;   (ought '(65535 0 0) "rgbi:1./0/0.0000")
-;;   (ought '(65535 0 0) "rgbi:1.0/0/0.0000")
-;;   (ought '(65535 32768 0) "rgbi:1.0/0.5/0.0000")
-;;   (ought '(6554 21843 65469) "rgbi:0.1/0.3333/0.999")
-;;   (ought '(0 32768 6554) "rgbi:0/0.5/0.1")
-;;   (ought '(66 655 65535) "rgbi:1e-3/1.0e-2/1e0")
-;;   (ought '(6554 21843 65469) "rgbi:1e-1/+0.3333/0.00999e2")
-;;   (ought nil "rgbi:1.0001/0/0")
-;;   (ought nil "rgbi:2/0/0")
-;;   (ought nil "rgbi:0.a/0/0")
-;;   (ought nil "rgbi:./0/0")
-;;   (ought nil "rgbi:./0/0")
-;;   (ought nil " rgbi:0/0/0")
-;;   (ought nil "rgbi:0/0/0 ")
-;;   (ought nil "      rgbi:0/0/0 ")
-;;   (ought nil "rgbi:0 /0/ 0")
-;;   (ought nil "rgbi:0/ 0 /0")
-;;   (ought nil "rgbii:0/0/0")
-;;   (ought nil "rgbi :0/0/0")
+;;   (should (equal '(0 0 0) "rgbi:0/0/0")
+;;   (should (equal '(0 0 0) "rgbi:0.0/0.0/0.0")
+;;   (should (equal '(0 0 0) "rgbi:0.0/0/0")
+;;   (should (equal '(0 0 0) "rgbi:0.0/0/0")
+;;   (should (equal '(0 0 0) "rgbi:0/0/0.")
+;;   (should (equal '(0 0 0) "rgbi:0/0/0.0000")
+;;   (should (equal '(0 0 0) "rgbi:0/0/.0")
+;;   (should (equal '(0 0 0) "rgbi:0/0/.0000")
+;;   (should (equal '(65535 0 0) "rgbi:1/0/0.0000")
+;;   (should (equal '(65535 0 0) "rgbi:1./0/0.0000")
+;;   (should (equal '(65535 0 0) "rgbi:1.0/0/0.0000")
+;;   (should (equal '(65535 32768 0) "rgbi:1.0/0.5/0.0000")
+;;   (should (equal '(6554 21843 65469) "rgbi:0.1/0.3333/0.999")
+;;   (should (equal '(0 32768 6554) "rgbi:0/0.5/0.1")
+;;   (should (equal '(66 655 65535) "rgbi:1e-3/1.0e-2/1e0")
+;;   (should (equal '(6554 21843 65469) "rgbi:1e-1/+0.3333/0.00999e2")
+;;   (should (equal nil "rgbi:1.0001/0/0")
+;;   (should (equal nil "rgbi:2/0/0")
+;;   (should (equal nil "rgbi:0.a/0/0")
+;;   (should (equal nil "rgbi:./0/0")
+;;   (should (equal nil "rgbi:./0/0")
+;;   (should (equal nil " rgbi:0/0/0")
+;;   (should (equal nil "rgbi:0/0/0 ")
+;;   (should (equal nil "      rgbi:0/0/0 ")
+;;   (should (equal nil "rgbi:0 /0/ 0")
+;;   (should (equal nil "rgbi:0/ 0 /0")
+;;   (should (equal nil "rgbii:0/0/0")
+;;   (should (equal nil "rgbi :0/0/0")
 ;;   ;; strtod ignores leading whitespace, making these legal colour
 ;;   ;; specifications:
 ;;   ;;
-;;   ;; (ought nil "rgbi: 0/0/0")
-;;   ;; (ought nil "rgbi: 0/ 0/ 0")
-;;   (ought nil "rgbi : 0/0/0")
-;;   (ought nil "rgbi:0/0.5/10"))
+;;   ;; (should (equal nil "rgbi: 0/0/0")
+;;   ;; (should (equal nil "rgbi: 0/ 0/ 0")
+;;   (should (equal nil "rgbi : 0/0/0")
+;;   (should (equal nil "rgbi:0/0.5/10"))
 
 ;; (ert-deftest file-modes-number-to-symbolic
-;;   (ought "-rwx------" #o700)
-;;   (ought "-rwxrwx---" #o770)
-;;   (ought "-rwx---rwx" #o707)
-;;   (ought "-rw-r-xr--" #o654)
-;;   (ought "--wx-w---x" #o321)
-;;   (ought "drwx------" #o700 ?d)
-;;   (ought "?rwx------" #o700 ??)
-;;   (ought "lrwx------" #o120700)
-;;   (ought "prwx------" #o10700)
-;;   (ought "-rwx------" #o30700))
+;;   (should (equal "-rwx------" #o700)
+;;   (should (equal "-rwxrwx---" #o770)
+;;   (should (equal "-rwx---rwx" #o707)
+;;   (should (equal "-rw-r-xr--" #o654)
+;;   (should (equal "--wx-w---x" #o321)
+;;   (should (equal "drwx------" #o700 ?d)
+;;   (should (equal "?rwx------" #o700 ??)
+;;   (should (equal "lrwx------" #o120700)
+;;   (should (equal "prwx------" #o10700)
+;;   (should (equal "-rwx------" #o30700))
 
 ;; (ert-deftest file-local-name
-;;   (ought "" "")
-;;   (ought "foo" "foo")
-;;   (ought "/bar/foo" "/bar/foo")
+;;   (should (equal "" "")
+;;   (should (equal "foo" "foo")
+;;   (should (equal "/bar/foo" "/bar/foo")
 ;;   ;; These tests fails prior to Emacs 26, because /ssh:foo was a valid
 ;;   ;; TRAMP path back then.
 ;;   ;;
-;;   ;; (ought "/ssh:foo" "/ssh:foo")
-;;   ;; (ought "/ssh:/bar/foo" "/ssh:/bar/foo")
-;;   (ought "foo" "/ssh::foo")
-;;   (ought "/bar/foo" "/ssh::/bar/foo")
-;;   (ought ":foo" "/ssh:::foo")
-;;   (ought ":/bar/foo" "/ssh:::/bar/foo"))
+;;   ;; (should (equal "/ssh:foo" "/ssh:foo")
+;;   ;; (should (equal "/ssh:/bar/foo" "/ssh:/bar/foo")
+;;   (should (equal "foo" "/ssh::foo")
+;;   (should (equal "/bar/foo" "/ssh::/bar/foo")
+;;   (should (equal ":foo" "/ssh:::foo")
+;;   (should (equal ":/bar/foo" "/ssh:::/bar/foo"))
 
 ;; (ert-deftest file-name-quoted-p
-;;   (ought nil "")
-;;   (ought t "/:")
-;;   (ought nil "//:")
-;;   (ought t "/::")
-;;   (ought nil "/ssh::")
-;;   (ought nil "/ssh::a")
-;;   (ought t "/ssh::/:a")
+;;   (should (equal nil "")
+;;   (should (equal t "/:")
+;;   (should (equal nil "//:")
+;;   (should (equal t "/::")
+;;   (should (equal nil "/ssh::")
+;;   (should (equal nil "/ssh::a")
+;;   (should (equal t "/ssh::/:a")
 ;;   ;; These tests fails prior to Emacs 26, because /ssh:foo was a valid
 ;;   ;; TRAMP path back then.
 ;;   ;;
-;;   ;; (ought nil "/ssh:/:a")
+;;   ;; (should (equal nil "/ssh:/:a")
 ;;   )
 
 ;; (ert-deftest file-name-quote
-;;   (ought "/:" "")
-;;   (ought "/::" ":")
-;;   (ought "/:/" "/")
-;;   (ought "/:" "/:")
-;;   (ought "/:a" "a")
-;;   (ought "/::a" ":a")
-;;   (ought "/:/a" "/a")
-;;   (ought "/:a" "/:a")
-;;   (ought (concat "/ssh:" (system-name) ":/:a") "/ssh::a"))
+;;   (should (equal "/:" "")
+;;   (should (equal "/::" ":")
+;;   (should (equal "/:/" "/")
+;;   (should (equal "/:" "/:")
+;;   (should (equal "/:a" "a")
+;;   (should (equal "/::a" ":a")
+;;   (should (equal "/:/a" "/a")
+;;   (should (equal "/:a" "/:a")
+;;   (should (equal (concat "/ssh:" (system-name) ":/:a") "/ssh::a"))
 
 ;; (ert-deftest make-lock-file-name
-;;   (ought (expand-file-name ".#") "")
-;;   (ought (expand-file-name ".#a") "a")
-;;   (ought (expand-file-name ".#foo") "foo")
-;;   (ought (expand-file-name ".#.") ".")
-;;   (ought (expand-file-name ".#.#") ".#")
-;;   (ought (expand-file-name ".#.a") ".a")
-;;   (ought (expand-file-name ".#.#") ".#")
-;;   (ought (expand-file-name "a/.#") "a/")
-;;   (ought (expand-file-name "a/.#b") "a/b")
-;;   (ought (expand-file-name "a/.#.#") "a/.#")
-;;   (ought (expand-file-name "a/.#.") "a/.")
-;;   (ought (expand-file-name "a/.#.b") "a/.b")
-;;   (ought (expand-file-name "a/.#foo") "a/foo")
-;;   (ought (expand-file-name "bar/.#b") "bar/b")
-;;   (ought (expand-file-name "bar/.#foo") "bar/foo"))
+;;   (should (equal (expand-file-name ".#") "")
+;;   (should (equal (expand-file-name ".#a") "a")
+;;   (should (equal (expand-file-name ".#foo") "foo")
+;;   (should (equal (expand-file-name ".#.") ".")
+;;   (should (equal (expand-file-name ".#.#") ".#")
+;;   (should (equal (expand-file-name ".#.a") ".a")
+;;   (should (equal (expand-file-name ".#.#") ".#")
+;;   (should (equal (expand-file-name "a/.#") "a/")
+;;   (should (equal (expand-file-name "a/.#b") "a/b")
+;;   (should (equal (expand-file-name "a/.#.#") "a/.#")
+;;   (should (equal (expand-file-name "a/.#.") "a/.")
+;;   (should (equal (expand-file-name "a/.#.b") "a/.b")
+;;   (should (equal (expand-file-name "a/.#foo") "a/foo")
+;;   (should (equal (expand-file-name "bar/.#b") "bar/b")
+;;   (should (equal (expand-file-name "bar/.#foo") "bar/foo"))
 
 ;; (ert-deftest time-equal-p
-;;   (ought t nil nil)
+;;   (should (equal t nil nil)
 
 ;;   ;; FIXME: Testing these values can be tricky, because the timestamp
 ;;   ;; might change between evaluating (current-time) and evaluating
 ;;   ;; `time-equal-p', especially in the interpreted compatibility
 ;;   ;; version.
 
-;;   ;; (ought t (current-time) nil)
-;;   ;; (ought t nil (current-time))
+;;   ;; (should (equal t (current-time) nil)
+;;   ;; (should (equal t nil (current-time))
 
 ;;   ;; While `sleep-for' returns nil, indicating the current time, this
 ;;   ;; behaviour seems to be undefined.  Relying on it is therefore not
 ;;   ;; advised.
-;;   (ought nil (current-time) (ignore (sleep-for 0.01)))
-;;   (ought nil (current-time) (progn
+;;   (should (equal nil (current-time) (ignore (sleep-for 0.01)))
+;;   (should (equal nil (current-time) (progn
 ;;                               (sleep-for 0.01)
 ;;                               (current-time)))
-;;   (ought t '(1 2 3 4) '(1 2 3 4))
-;;   (ought nil '(1 2 3 4) '(1 2 3 5))
-;;   (ought nil '(1 2 3 5) '(1 2 3 4))
-;;   (ought nil '(1 2 3 4) '(1 2 4 4))
-;;   (ought nil '(1 2 4 4) '(1 2 3 4))
-;;   (ought nil '(1 2 3 4) '(1 3 3 4))
-;;   (ought nil '(1 3 3 4) '(1 2 3 4))
-;;   (ought nil '(1 2 3 4) '(2 2 3 4))
-;;   (ought nil '(2 2 3 4) '(1 2 3 4)))
+;;   (should (equal t '(1 2 3 4) '(1 2 3 4))
+;;   (should (equal nil '(1 2 3 4) '(1 2 3 5))
+;;   (should (equal nil '(1 2 3 5) '(1 2 3 4))
+;;   (should (equal nil '(1 2 3 4) '(1 2 4 4))
+;;   (should (equal nil '(1 2 4 4) '(1 2 3 4))
+;;   (should (equal nil '(1 2 3 4) '(1 3 3 4))
+;;   (should (equal nil '(1 3 3 4) '(1 2 3 4))
+;;   (should (equal nil '(1 2 3 4) '(2 2 3 4))
+;;   (should (equal nil '(2 2 3 4) '(1 2 3 4)))
 
 ;; (ert-deftest date-days-in-month
-;;   (ought 31 2020 1)
-;;   (ought 30 2020 4)
-;;   (ought 29 2020 2)
-;;   (ought 28 2021 2))
+;;   (should (equal 31 2020 1)
+;;   (should (equal 30 2020 4)
+;;   (should (equal 29 2020 2)
+;;   (should (equal 28 2021 2))
 
 ;; (ert-deftest decoded-time-period
-;;   (ought 0 '())
-;;   (ought 0 '(0))
-;;   (ought 1 '(1))
-;;   (ought 0.125 '((1 . 8)))
-
-;;   (ought 60 '(0 1))
-;;   (ought 61 '(1 1))
-;;   (ought -59 '(1 -1))
-
-;;   (ought (* 60 60) '(0 0 1))
-;;   (ought (+ (* 60 60) 60) '(0 1 1))
-;;   (ought (+ (* 60 60) 120 1) '(1 2 1))
-
-;;   (ought (* 60 60 24) '(0 0 0 1))
-;;   (ought (+ (* 60 60 24) 1) '(1 0 0 1))
-;;   (ought (+ (* 60 60 24) (* 60 60) 60 1) '(1 1 1 1))
-;;   (ought (+ (* 60 60 24) (* 60 60) 120 1) '(1 2 1 1))
-
-;;   (ought (* 60 60 24 30) '(0 0 0 0 1))
-;;   (ought (+ (* 60 60 24 30) 1) '(1 0 0 0 1))
-;;   (ought (+ (* 60 60 24 30) 60 1) '(1 1 0 0 1))
-;;   (ought (+ (* 60 60 24 30) (* 60 60) 60 1)
+;;   (should (equal 0 '())
+;;   (should (equal 0 '(0))
+;;   (should (equal 1 '(1))
+;;   (should (equal 0.125 '((1 . 8)))
+
+;;   (should (equal 60 '(0 1))
+;;   (should (equal 61 '(1 1))
+;;   (should (equal -59 '(1 -1))
+
+;;   (should (equal (* 60 60) '(0 0 1))
+;;   (should (equal (+ (* 60 60) 60) '(0 1 1))
+;;   (should (equal (+ (* 60 60) 120 1) '(1 2 1))
+
+;;   (should (equal (* 60 60 24) '(0 0 0 1))
+;;   (should (equal (+ (* 60 60 24) 1) '(1 0 0 1))
+;;   (should (equal (+ (* 60 60 24) (* 60 60) 60 1) '(1 1 1 1))
+;;   (should (equal (+ (* 60 60 24) (* 60 60) 120 1) '(1 2 1 1))
+
+;;   (should (equal (* 60 60 24 30) '(0 0 0 0 1))
+;;   (should (equal (+ (* 60 60 24 30) 1) '(1 0 0 0 1))
+;;   (should (equal (+ (* 60 60 24 30) 60 1) '(1 1 0 0 1))
+;;   (should (equal (+ (* 60 60 24 30) (* 60 60) 60 1)
 ;;          '(1 1 1 0 1))
-;;   (ought (+ (* 60 60 24 30) (* 60 60 24) (* 60 60) 120 1)
+;;   (should (equal (+ (* 60 60 24 30) (* 60 60 24) (* 60 60) 120 1)
 ;;          '(1 2 1 1 1))
 
-;;   (ought (* 60 60 24 365) '(0 0 0 0 0 1))
-;;   (ought (+ (* 60 60 24 365) 1)
+;;   (should (equal (* 60 60 24 365) '(0 0 0 0 0 1))
+;;   (should (equal (+ (* 60 60 24 365) 1)
 ;;          '(1 0 0 0 0 1))
-;;   (ought (+ (* 60 60 24 365) 60 1)
+;;   (should (equal (+ (* 60 60 24 365) 60 1)
 ;;          '(1 1 0 0 0 1))
-;;   (ought (+ (* 60 60 24 365) (* 60 60) 60 1)
+;;   (should (equal (+ (* 60 60 24 365) (* 60 60) 60 1)
 ;;          '(1 1 1 0 0 1))
-;;   (ought (+ (* 60 60 24 365) (* 60 60 24) (* 60 60) 60 1)
+;;   (should (equal (+ (* 60 60 24 365) (* 60 60 24) (* 60 60) 60 1)
 ;;          '(1 1 1 1 0 1))
-;;   (ought (+ (* 60 60 24 365)
+;;   (should (equal (+ (* 60 60 24 365)
 ;;             (* 60 60 24 30)
 ;;             (* 60 60 24)
 ;;             (* 60 60)
 ;;             120 1)
 ;;          '(1 2 1 1 1 1))
 
-;;   (expect wrong-type-argument 'a)
-;;   (expect wrong-type-argument '(0 a))
-;;   (expect wrong-type-argument '(0 0 a))
-;;   (expect wrong-type-argument '(0 0 0 a))
-;;   (expect wrong-type-argument '(0 0 0 0 a))
-;;   (expect wrong-type-argument '(0 0 0 0 0 a)))
+;;   (should-error wrong-type-argument 'a)
+;;   (should-error wrong-type-argument '(0 a))
+;;   (should-error wrong-type-argument '(0 0 a))
+;;   (should-error wrong-type-argument '(0 0 0 a))
+;;   (should-error wrong-type-argument '(0 0 0 0 a))
+;;   (should-error wrong-type-argument '(0 0 0 0 0 a)))
 
 ;; ;; TODO func-arity seems broken
 ;; ;; (ert-deftest func-arity
@@ -1729,33 +1731,33 @@
 ;; ;;   (should (equal '(1 . 1) (func-arity (lambda (x) x))))
 ;; ;;   (should (equal '(1 . 2) (func-arity (lambda (x &optional _) x))))
 ;; ;;   (should (equal '(0 . many) (func-arity (lambda (&rest _)))))
-;; ;;   (ought '(1 . 1) 'identity)
-;; ;;   (ought '(0 . many) 'ignore)
-;; ;;   (ought '(2 . many) 'defun)
-;; ;;   (ought '(2 . 3) 'defalias)
-;; ;;   (ought '(1 . unevalled) 'defvar))
+;; ;;   (should (equal '(1 . 1) 'identity)
+;; ;;   (should (equal '(0 . many) 'ignore)
+;; ;;   (should (equal '(2 . many) 'defun)
+;; ;;   (should (equal '(2 . 3) 'defalias)
+;; ;;   (should (equal '(1 . unevalled) 'defvar))
 
 ;; (ert-deftest subr-primitive-p
-;;   (ought t (symbol-function 'identity))       ;function from fns.c
+;;   (should (equal t (symbol-function 'identity))       ;function from fns.c
 ;;   (unless (fboundp 'subr-native-elisp-p)
-;;     (ought nil (symbol-function 'match-string))) ;function from subr.el
-;;   (ought nil (symbol-function 'defun))        ;macro from subr.el
-;;   (ought nil nil))
+;;     (should (equal nil (symbol-function 'match-string))) ;function from 
subr.el
+;;   (should (equal nil (symbol-function 'defun))        ;macro from subr.el
+;;   (should (equal nil nil))
 
 ;; (ert-deftest file-name-absolute-p   ;assuming unix
-;;   (ought t "/")
-;;   (ought t "/a")
-;;   (ought nil "a")
-;;   (ought nil "a/b")
-;;   (ought nil "a/b/")
-;;   (ought t "~")
+;;   (should (equal t "/")
+;;   (should (equal t "/a")
+;;   (should (equal nil "a")
+;;   (should (equal nil "a/b")
+;;   (should (equal nil "a/b/")
+;;   (should (equal t "~")
 ;;   (when (version< "27.1" emacs-version)
-;;     (ought t "~/foo")
-;;     (ought nil "~foo")
-;;     (ought nil "~foo/"))
-;;   (ought t "~root")
-;;   (ought t "~root/")
-;;   (ought t "~root/file"))
+;;     (should (equal t "~/foo")
+;;     (should (equal nil "~foo")
+;;     (should (equal nil "~foo/"))
+;;   (should (equal t "~root")
+;;   (should (equal t "~root/")
+;;   (should (equal t "~root/file"))
 
 ;; (let ((one (make-symbol "1"))
 ;;       (two (make-symbol "2"))
@@ -1766,19 +1768,19 @@
 ;;   (put one.5 'derived-mode-parent one)
 ;;   (put three 'derived-mode-parent two)
 ;;   (ert-deftest provided-mode-derived-p
-;;     (ought one one one)
-;;     (ought one two one)
-;;     (ought one three one)
-;;     (ought nil one eins)
-;;     (ought nil two eins)
-;;     (ought nil two one.5)
-;;     (ought one two one.5 one)
-;;     (ought two two one.5 two)
-;;     (ought one three one.5 one)
-;;     (ought two three one.5 one two)
-;;     (ought two three one.5 two one)
-;;     (ought three three one.5 two one three)
-;;     (ought three three one.5 three two one)))
+;;     (should (equal one one one)
+;;     (should (equal one two one)
+;;     (should (equal one three one)
+;;     (should (equal nil one eins)
+;;     (should (equal nil two eins)
+;;     (should (equal nil two one.5)
+;;     (should (equal one two one.5 one)
+;;     (should (equal two two one.5 two)
+;;     (should (equal one three one.5 one)
+;;     (should (equal two three one.5 one two)
+;;     (should (equal two three one.5 two one)
+;;     (should (equal three three one.5 two one three)
+;;     (should (equal three three one.5 three two one)))
 
 ;; (unless (fboundp 'make-prop-match)
 ;;   (defalias 'make-prop-match