[elpa] externals/compat 241e38bb45 5/5: Restore tests

[ELPA Syncer]

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

    Restore tests
---
 compat-tests.el | 164 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 80 insertions(+), 84 deletions(-)

diff --git a/compat-tests.el b/compat-tests.el
index 4cab1321d4..89bbb1cec9 100644
--- a/compat-tests.el
+++ b/compat-tests.el
@@ -53,6 +53,86 @@
     (should (eq (compat-call plist-get list "first" #'string=) 10))
     (should (eq (compat-call plist-get list "second" #'string=) 2))))
 
+(ert-deftest bool-vector-exclusive-or ()
+  (let ((a (bool-vector t t nil nil))
+        (b (bool-vector t nil t nil)))
+    (let ((c (make-bool-vector 4 nil))) ;; side effect test
+      (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))
+    (should-equal (bool-vector nil t t nil) (bool-vector-exclusive-or a b))
+    (should-equal (bool-vector nil t t nil) (bool-vector-exclusive-or b a))
+    (when (version<= "24.4" emacs-version)
+      (should-error (bool-vector-exclusive-or a (bool-vector)) :type 
'wrong-length-argument)
+      (should-error (bool-vector-exclusive-or a b (bool-vector)) :type 
'wrong-length-argument))
+    (should-error (bool-vector-exclusive-or (bool-vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (vector) (bool-vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (bool-vector) (bool-vector) 
(vector)) :type 'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (bool-vector) (vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (vector) (bool-vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-exclusive-or (vector) (vector) (vector)) :type 
'wrong-type-argument)))
+
+(ert-deftest bool-vector-union ()
+  (let ((a (bool-vector t t nil nil))
+        (b (bool-vector t nil t nil)))
+    (should-equal (bool-vector t t t nil) (bool-vector-union a b))
+    (should-equal (bool-vector t t t nil) (bool-vector-union b a))
+    (let ((c (make-bool-vector 4 nil))) ;; Side effects
+      (bool-vector-union a b c)
+      (should-equal (bool-vector t t t nil) c))
+    (when (version<= "24.4" emacs-version)
+      (should-error (bool-vector-union a (bool-vector)) :type 
'wrong-length-argument)
+      (should-error (bool-vector-union a b (bool-vector))) :type 
'wrong-length-argument)
+    (should-error (bool-vector-union (bool-vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-union (vector) (bool-vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-union (vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-union (bool-vector) (bool-vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-union (bool-vector) (vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-union (vector) (bool-vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-union (vector) (vector) (vector)))) :type 
'wrong-type-argument)
+
+(ert-deftest bool-vector-intersection ()
+  (let ((a (bool-vector t t nil nil))
+        (b (bool-vector t nil t nil)))
+    (should-equal (bool-vector t nil nil nil) (bool-vector-intersection a b))
+    (should-equal (bool-vector t nil nil nil) (bool-vector-intersection b a))
+    (let ((c (make-bool-vector 4 nil))) ;; side effect
+      (bool-vector-intersection a b c)
+      (should-equal (bool-vector t nil nil nil) c))
+    (when (version<= "24.4" emacs-version)
+      (should-error (bool-vector-intersection a (bool-vector)) :type 
'wrong-length-argument)
+      (should-error (bool-vector-intersection a b (bool-vector)) :type 
'wrong-length-argument))
+    (should-error (bool-vector-intersection (bool-vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-intersection (vector) (bool-vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-intersection (vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-intersection (bool-vector) (bool-vector) 
(vector)) :type 'wrong-type-argument)
+    (should-error (bool-vector-intersection (bool-vector) (vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-intersection (vector) (bool-vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-intersection (vector) (vector) (vector)))) 
:type 'wrong-type-argument)
+
+(ert-deftest bool-vector-set-difference ()
+  (let ((a (bool-vector t t nil nil))
+        (b (bool-vector t nil t nil)))
+    (should-equal (bool-vector nil t nil nil) (bool-vector-set-difference a b))
+    (should-equal (bool-vector nil nil t nil) (bool-vector-set-difference b a))
+    (let ((c (make-bool-vector 4 nil))) ;; side effect
+      (bool-vector-set-difference a b c)
+      (should-equal (bool-vector nil t nil nil) c))
+    (let ((c (make-bool-vector 4 nil))) ;; side effect
+      (bool-vector-set-difference b a c)
+      (should-equal (bool-vector nil nil t nil) c))
+    (when (version<= "24.4" emacs-version)
+      (should-error (bool-vector-set-difference a (bool-vector)) :type 
'wrong-length-argument)
+      (should-error (bool-vector-set-difference a b (bool-vector)) :type 
'wrong-length-argument))
+    (should-error (bool-vector-set-difference (bool-vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-set-difference (vector) (bool-vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-set-difference (vector) (vector)) :type 
'wrong-type-argument)
+    (should-error (bool-vector-set-difference (bool-vector) (bool-vector) 
(vector)) :type 'wrong-type-argument)
+    (should-error (bool-vector-set-difference (bool-vector) (vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-set-difference (vector) (bool-vector) (vector)) 
:type 'wrong-type-argument)
+    (should-error (bool-vector-set-difference (vector) (vector) (vector)))) 
:type 'wrong-type-argument)
+
 (ert-deftest bool-vector-not ()
   (should-equal (bool-vector) (bool-vector-not (bool-vector)))
   (should-equal (bool-vector t) (bool-vector-not (bool-vector nil)))
@@ -1394,90 +1474,6 @@
 ;;     (should-equal 'foo (list a-map b-map) "x")
 ;;     (should-equal 'bar (list b-map a-map) "x")))
 
-;; (let ((a (bool-vector t t nil nil))
-;;       (b (bool-vector t nil t nil)))
-;;   (ert-deftest bool-vector-exclusive-or
-;;     (should-equal (bool-vector nil t t nil) a b)
-;;     (should-equal (bool-vector nil t t nil) b a)
-;;     (ert-deftest 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)
-;;       (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
-;;     (should-equal (bool-vector t t t nil) a b)
-;;     (should-equal (bool-vector t t t nil) b a)
-;;     (ert-deftest 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)
-;;       (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
-;;     (should-equal (bool-vector t nil nil nil) a b)
-;;     (should-equal (bool-vector t nil nil nil) b a)
-;;     (ert-deftest 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)
-;;       (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
-;;     (should-equal (bool-vector nil t nil nil) a b)
-;;     (should-equal (bool-vector nil nil t nil) b a)
-;;     (ert-deftest bool-vector-set-difference-sideeffect ()
-;;       (let ((c (make-bool-vector 4 nil)))
-;;         (compat--t-bool-vector-set-difference a b c)
-;;         (should-equal (bool-vector nil t nil nil) c)))
-;;       (let ((c (make-bool-vector 4 nil)))
-;;         (compat--t-bool-vector-set-difference b a c)
-;;         (should-equal (bool-vector nil nil t nil) c))))
-;;     (when (version<= "24.4" emacs-version)
-;;       (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 color-values-from-color-spec
 ;;   ;; #RGB notation
 ;;   (should-equal '(0 0 0) "#000")