; Fix last change by using 'cl-oddp' and 'cl-evenp' (bug#75633).

(cherry picked from commit 840057bb1bfc05a52519793c620d729688ea1d8f)

diff --git a/test/lisp/emacs-lisp/cl-extra-tests.el b/test/lisp/emacs-lisp/cl-extra-tests.el
index dc1a52c9716ce10245ca5d2cf09d4cc6edeba327..e2a0276ae0ab6f0fed86ed92fe1e69c949126fd3 100644 (file)
--- a/test/lisp/emacs-lisp/cl-extra-tests.el
+++ b/test/lisp/emacs-lisp/cl-extra-tests.el
@@ -184,14 +184,14 @@
                  nil)))
 
 (ert-deftest cl-extra-test-notany ()
-  (should (equal (cl-notany #'oddp '(1 3 5)) nil))
-  (should (equal (cl-notany #'oddp '(2 4 6)) t))
-  (should (equal (cl-notany #'oddp '(1 2 3 4 5)) nil)))
+  (should (equal (cl-notany #'cl-oddp '(1 3 5)) nil))
+  (should (equal (cl-notany #'cl-oddp '(2 4 6)) t))
+  (should (equal (cl-notany #'cl-oddp '(1 2 3 4 5)) nil)))
 
 (ert-deftest cl-extra-test-notevery ()
-  (should (equal (cl-notevery #'oddp '(1 3 5)) nil))
-  (should (equal (cl-notevery #'oddp '(2 4 6)) t))
-  (should (equal (cl-notevery #'oddp '(1 2 3 4 5)) t)))
+  (should (equal (cl-notevery #'cl-oddp '(1 3 5)) nil))
+  (should (equal (cl-notevery #'cl-oddp '(2 4 6)) t))
+  (should (equal (cl-notevery #'cl-oddp '(1 2 3 4 5)) t)))
 
 (ert-deftest cl-extra-test-gcd ()
   (should (equal (cl-gcd 4) 4))

diff --git a/test/lisp/emacs-lisp/cl-seq-tests.el b/test/lisp/emacs-lisp/cl-seq-tests.el
index 59ece0e4006d5a0fba32bc79c9fe5ff07d07e804..3541a989d342538302b5e9a8c94514dba17225ba 100644 (file)
--- a/test/lisp/emacs-lisp/cl-seq-tests.el
+++ b/test/lisp/emacs-lisp/cl-seq-tests.el
@@ -133,23 +133,23 @@ Body are forms defining the test."
     (should (equal '(1 2 3 4 5 6) (cl-remove 2 list :from-end t :count 1)))))
 
 (ert-deftest cl-remove-if-test ()
-  (should (equal '(1 3) (cl-remove-if 'evenp '(1 2 3 4))))
-  (should (equal '(1 3) (cl-remove-if 'evenp '(1 2 3 4) :count 2)))
-  (should (equal '(1 3 4) (cl-remove-if 'evenp '(1 2 3 4) :start 1 :end 3)))
-  (should (equal '(1 3) (cl-remove-if 'evenp '(1 2 3 4) :from-end t)))
-  (should (equal '(2 4) (cl-remove-if 'oddp '(1 2 3 4))))
-  (should (equal '() (cl-remove-if 'evenp '())))
-  (should (equal '() (cl-remove-if 'evenp '(2)))))
+  (should (equal '(1 3) (cl-remove-if 'cl-evenp '(1 2 3 4))))
+  (should (equal '(1 3) (cl-remove-if 'cl-evenp '(1 2 3 4) :count 2)))
+  (should (equal '(1 3 4) (cl-remove-if 'cl-evenp '(1 2 3 4) :start 1 :end 3)))
+  (should (equal '(1 3) (cl-remove-if 'cl-evenp '(1 2 3 4) :from-end t)))
+  (should (equal '(2 4) (cl-remove-if 'cl-oddp '(1 2 3 4))))
+  (should (equal '() (cl-remove-if 'cl-evenp '())))
+  (should (equal '() (cl-remove-if 'cl-evenp '(2)))))
 
 (ert-deftest cl-remove-if-not-test ()
-  (should (equal '(2 4) (cl-remove-if-not 'evenp '(1 2 3 4))))
-  (should (equal '(2 4) (cl-remove-if-not 'evenp '(1 2 3 4) :count 2)))
-  (should (equal '(1 2 4) (cl-remove-if-not 'evenp '(1 2 3 4) :start 1 :end 3)))
-  (should (equal '(2 4) (cl-remove-if-not 'evenp '(1 2 3 4) :from-end t)))
-  (should (equal '(1 3) (cl-remove-if-not 'oddp '(1 2 3 4))))
-  (should (equal '() (cl-remove-if-not 'evenp '())))
-  (should (equal '(2) (cl-remove-if-not 'evenp '(2))))
-  (should (equal '(2) (cl-remove-if-not 'evenp '(2) :key #'(lambda (x) (- x))))))
+  (should (equal '(2 4) (cl-remove-if-not 'cl-evenp '(1 2 3 4))))
+  (should (equal '(2 4) (cl-remove-if-not 'cl-evenp '(1 2 3 4) :count 2)))
+  (should (equal '(1 2 4) (cl-remove-if-not 'cl-evenp '(1 2 3 4) :start 1 :end 3)))
+  (should (equal '(2 4) (cl-remove-if-not 'cl-evenp '(1 2 3 4) :from-end t)))
+  (should (equal '(1 3) (cl-remove-if-not 'cl-oddp '(1 2 3 4))))
+  (should (equal '() (cl-remove-if-not 'cl-evenp '())))
+  (should (equal '(2) (cl-remove-if-not 'cl-evenp '(2))))
+  (should (equal '(2) (cl-remove-if-not 'cl-evenp '(2) :key #'(lambda (x) (- x))))))
 
 ;; keywords supported:  :test :test-not :key :count :start :end :from-end
 (ert-deftest cl-seq-delete-test ()
@@ -176,19 +176,19 @@ Body are forms defining the test."
 
 (ert-deftest cl-delete-if-test ()
   (let ((list (list 1 2 3 4 5)))
-    (cl-delete-if 'evenp list)
+    (cl-delete-if 'cl-evenp list)
     (should (equal '(1 3 5) list))
-    (should (equal '(1 3 5) (cl-delete-if 'evenp (list 1 2 3 4 5) :start 0 :end 4)))
-    (should (equal '(1 3 5) (cl-delete-if 'evenp (list 1 2 3 4 5) :from-end t)))
-    (should (equal '(2 4) (cl-delete-if 'oddp (list 1 2 3 4 5))))
-    (should (equal '() (cl-delete-if 'evenp '())))
-    (should (equal '() (cl-delete-if 'evenp (list 2))))))
+    (should (equal '(1 3 5) (cl-delete-if 'cl-evenp (list 1 2 3 4 5) :start 0 :end 4)))
+    (should (equal '(1 3 5) (cl-delete-if 'cl-evenp (list 1 2 3 4 5) :from-end t)))
+    (should (equal '(2 4) (cl-delete-if 'cl-oddp (list 1 2 3 4 5))))
+    (should (equal '() (cl-delete-if 'cl-evenp '())))
+    (should (equal '() (cl-delete-if 'cl-evenp (list 2))))))
 
 (ert-deftest cl-delete-if-not-test ()
   (let ((list (list 1 2 3 4 5)))
-    (should (equal '(2 4) (cl-delete-if-not 'evenp list)))
-    (should (equal '() (cl-delete-if-not 'evenp '())))
-    (should (equal '() (cl-delete-if-not 'evenp (list 1))))))
+    (should (equal '(2 4) (cl-delete-if-not 'cl-evenp list)))
+    (should (equal '() (cl-delete-if-not 'cl-evenp '())))
+    (should (equal '() (cl-delete-if-not 'cl-evenp (list 1))))))
 
 (ert-deftest cl-delete-duplicates-test ()
   (let ((list (list 1 2 3 2 1)))
@@ -242,61 +242,61 @@ Body are forms defining the test."
                                                    :if-not (lambda (x) (> (cl-position x list :from-end t) 1)))))))
 
 (ert-deftest cl-seq-substitute-if-test ()
-  (let ((result (cl-substitute-if 'x #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-substitute-if 'x #'cl-evenp '(1 2 3 4 5))))
     (should (equal result '(1 x 3 x 5))))
-  (let ((result (cl-substitute-if 'x #'evenp '(1 3 5))))
+  (let ((result (cl-substitute-if 'x #'cl-evenp '(1 3 5))))
     (should (equal result '(1 3 5))))
   (let ((result (cl-substitute-if 'x #'(lambda (n) t) '(1 2 3 4 5))))
     (should (equal result '(x x x x x))))
-  (let ((result (cl-substitute-if 'x #'evenp '(1 2 3 4 5) :start 1 :end 4)))
+  (let ((result (cl-substitute-if 'x #'cl-evenp '(1 2 3 4 5) :start 1 :end 4)))
     (should (equal result '(1 x 3 x 5))))
-  (let ((result (cl-substitute-if 'x #'oddp '(1 2 3 4 5) :from-end t)))
+  (let ((result (cl-substitute-if 'x #'cl-oddp '(1 2 3 4 5) :from-end t)))
     (should (equal result '(x 2 x 4 x))))
   (let ((result (cl-substitute-if 'x (lambda (n) (= n 3)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result '(1 2 x 4 5)))))
 
 (ert-deftest cl-seq-substitute-if-not-test ()
-  (let ((result (cl-substitute-if-not 'x #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-substitute-if-not 'x #'cl-evenp '(1 2 3 4 5))))
     (should (equal result '(x 2 x 4 x))))
-  (let ((result (cl-substitute-if-not 'x #'evenp '(2 4 6))))
+  (let ((result (cl-substitute-if-not 'x #'cl-evenp '(2 4 6))))
     (should (equal result '(2 4 6))))
   (let ((result (cl-substitute-if-not 'x #'(lambda (n) (> n 5)) '(1 2 3 4 5))))
     (should (equal result '(x x x x x))))
-  (let ((result (cl-substitute-if-not 'x #'evenp '(1 2 3 4 5) :start 0 :end 4)))
+  (let ((result (cl-substitute-if-not 'x #'cl-evenp '(1 2 3 4 5) :start 0 :end 4)))
     (should (equal result '(x 2 x 4 5))))
-  (let ((result (cl-substitute-if-not 'x #'oddp '(1 2 3 4 5) :from-end t)))
+  (let ((result (cl-substitute-if-not 'x #'cl-oddp '(1 2 3 4 5) :from-end t)))
     (should (equal result '(1 x 3 x 5))))
   (let ((result (cl-substitute-if-not 'x (lambda (n) (= n 3)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result '(x x 3 x x)))))
 
 (ert-deftest cl-find-if-test ()
-  (let ((result (cl-find-if #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-find-if #'cl-evenp '(1 2 3 4 5))))
     (should (equal result 2)))
   (let ((result (cl-find-if #'(lambda (n) (> n 5)) '(1 2 3 4 5))))
     (should (equal result nil)))
   (let ((result (cl-find-if #'(lambda (n) (> n 3)) '(1 2 3 4 5 6 7))))
     (should (equal result 4)))
-  (let ((result (cl-find-if #'evenp '(1 2 3 4 5) :start 2)))
+  (let ((result (cl-find-if #'cl-evenp '(1 2 3 4 5) :start 2)))
     (should (equal result 4)))
-  (let ((result (cl-find-if #'evenp '(1 2 3 4 5) :end 1)))
+  (let ((result (cl-find-if #'cl-evenp '(1 2 3 4 5) :end 1)))
     (should (equal result nil)))
-  (let ((result (cl-find-if #'oddp '(2 4 5 6 7) :from-end t)))
+  (let ((result (cl-find-if #'cl-oddp '(2 4 5 6 7) :from-end t)))
     (should (equal result 7)))
   (let ((result (cl-find-if (lambda (n) (= n 4)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result 4))))
 
 (ert-deftest cl-find-if-not-test ()
-  (let ((result (cl-find-if-not #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-find-if-not #'cl-evenp '(1 2 3 4 5))))
     (should (equal result 1)))
-  (let ((result (cl-find-if-not #'oddp '(1 3 5))))
+  (let ((result (cl-find-if-not #'cl-oddp '(1 3 5))))
     (should (equal result nil)))
   (let ((result (cl-find-if-not #'(lambda (n) (< n 4)) '(1 2 3 4 5 6 7))))
     (should (equal result 4)))
-  (let ((result (cl-find-if-not #'evenp '(1 2 3 4 5) :start 2)))
+  (let ((result (cl-find-if-not #'cl-evenp '(1 2 3 4 5) :start 2)))
     (should (equal result 3)))
-  (let ((result (cl-find-if-not #'evenp '(1 2 3 4 5) :end 3)))
+  (let ((result (cl-find-if-not #'cl-evenp '(1 2 3 4 5) :end 3)))
     (should (equal result 1)))
-  (let ((result (cl-find-if-not #'oddp '(2 4 6 7 8) :from-end t)))
+  (let ((result (cl-find-if-not #'cl-oddp '(2 4 6 7 8) :from-end t)))
     (should (equal result 8)))
   (let ((result (cl-find-if-not (lambda (n) (= n 4)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result 1))))
@@ -357,17 +357,17 @@ Body are forms defining the test."
     (should (= 5 (cl-position 5 list :key (lambda (x) (1+ (* x x))) :from-end t)))))
 
 (ert-deftest cl-position-if-test ()
-  (let ((result (cl-position-if #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-position-if #'cl-evenp '(1 2 3 4 5))))
     (should (equal result 1)))
   (let ((result (cl-position-if #'(lambda (n) (> n 5)) '(1 2 3 4 5))))
     (should (equal result nil)))
   (let ((result (cl-position-if #'(lambda (n) (> n 3)) '(1 2 3 4 5 6 7))))
     (should (equal result 3)))
-  (let ((result (cl-position-if #'evenp '(1 2 3 4 5) :start 2)))
+  (let ((result (cl-position-if #'cl-evenp '(1 2 3 4 5) :start 2)))
     (should (equal result 3)))
-  (let ((result (cl-position-if #'evenp '(1 2 3 4 5) :end 1)))
+  (let ((result (cl-position-if #'cl-evenp '(1 2 3 4 5) :end 1)))
     (should (equal result nil)))
-  (let ((result (cl-position-if #'oddp '(2 4 5 6 7) :from-end t)))
+  (let ((result (cl-position-if #'cl-oddp '(2 4 5 6 7) :from-end t)))
     (should (equal result 4)))
   (let ((result (cl-position-if (lambda (n) (= n 4)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result 3))))
@@ -386,9 +386,9 @@ Body are forms defining the test."
                    (cl-count 'foo list :test-not (lambda (_a b) (cl-evenp b)))))))
 
 (ert-deftest cl-count-if-test ()
-  (let ((result (cl-count-if #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-count-if #'cl-evenp '(1 2 3 4 5))))
     (should (equal result 2)))
-  (let ((result (cl-count-if #'oddp '(2 4 6 8))))
+  (let ((result (cl-count-if #'cl-oddp '(2 4 6 8))))
     (should (equal result 0)))
   (let ((result (cl-count-if (lambda (x) t) '(1 2 3 4))))
     (should (equal result 4)))
@@ -396,11 +396,11 @@ Body are forms defining the test."
     (should (equal result 0)))
   (let ((result (cl-count-if #'(lambda (x) (> x 2)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result 3)))
-  (let ((result (cl-count-if #'evenp '(1 2 3 4 5) :start 2)))
+  (let ((result (cl-count-if #'cl-evenp '(1 2 3 4 5) :start 2)))
     (should (equal result 1)))
-  (let ((result (cl-count-if #'evenp '(1 2 3 4 5) :end 3)))
+  (let ((result (cl-count-if #'cl-evenp '(1 2 3 4 5) :end 3)))
     (should (equal result 1)))
-  (let ((result (cl-count-if #'evenp '())))
+  (let ((result (cl-count-if #'cl-evenp '())))
     (should (equal result 0)))
   (let ((result (cl-count-if #'(lambda (x) (numberp x)) '(1 "two" 3 4 "five" 6))))
     (should (equal result 4)))
@@ -408,9 +408,9 @@ Body are forms defining the test."
     (should (equal result 4))))
 
 (ert-deftest cl-count-if-not-test ()
-  (let ((result (cl-count-if-not #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-count-if-not #'cl-evenp '(1 2 3 4 5))))
     (should (equal result 3)))
-  (let ((result (cl-count-if-not #'oddp '(1 3 5))))
+  (let ((result (cl-count-if-not #'cl-oddp '(1 3 5))))
     (should (equal result 0)))
   (let ((result (cl-count-if-not (lambda (x) t) '(1 2 3 4))))
     (should (equal result 0)))
@@ -418,11 +418,11 @@ Body are forms defining the test."
     (should (equal result 4)))
   (let ((result (cl-count-if-not #'(lambda (x) (> x 3)) '(1 2 3 4 5) :key 'identity)))
     (should (equal result 3)))
-  (let ((result (cl-count-if-not #'evenp '(1 2 3 4 5) :start 2)))
+  (let ((result (cl-count-if-not #'cl-evenp '(1 2 3 4 5) :start 2)))
     (should (equal result 2)))
-  (let ((result (cl-count-if-not #'evenp '(1 2 3 4 5) :end 3)))
+  (let ((result (cl-count-if-not #'cl-evenp '(1 2 3 4 5) :end 3)))
     (should (equal result 2)))
-  (let ((result (cl-count-if-not #'evenp '())))
+  (let ((result (cl-count-if-not #'cl-evenp '())))
     (should (equal result 0)))
   (let ((result (cl-count-if-not #'(lambda (x) (numberp x)) '(1 "two" 3 4 "five" 6))))
     (should (equal result 2)))
@@ -584,7 +584,7 @@ Body are forms defining the test."
     (should (equal result '(2 3 4 5)))))
 
 (ert-deftest cl-member-if-test ()
-  (let ((result (cl-member-if #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-member-if #'cl-evenp '(1 2 3 4 5))))
     (should (equal result '(2 3 4 5))))
   (let ((result (cl-member-if #'(lambda (x) nil) '(1 2 3 4 5))))
     (should (equal result nil)))
@@ -592,13 +592,13 @@ Body are forms defining the test."
     (should (equal result '(1 2 3 4 5))))
   (let ((result (cl-member-if #'(lambda (x) (= x 1)) '(1 2 3 4 5))))
     (should (equal result '(1 2 3 4 5))))
-  (let ((result (cl-member-if #'(lambda (x) (and (numberp x) (evenp x))) '(1 3 5 4 2))))
+  (let ((result (cl-member-if #'(lambda (x) (and (numberp x) (cl-evenp x))) '(1 3 5 4 2))))
     (should (equal result '(4 2))))
   (let ((result (cl-member-if (lambda (x) (string= (number-to-string x) "3")) '(1 2 3 4 5) :key 'identity)))
     (should (equal result '(3 4 5))))
   (let ((result (cl-member-if #'(lambda (x) (eq x 'a)) '(a a a a))))
     (should (equal result '(a a a a))))
-  (let ((result (cl-member-if #'evenp '())))
+  (let ((result (cl-member-if #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-member-if #'(lambda (x) (< x 0)) '(1 2 3 4 5))))
     (should (equal result nil)))
@@ -608,9 +608,9 @@ Body are forms defining the test."
     (should (equal result '(6 7 8)))))
 
 (ert-deftest cl-member-if-not-test ()
-  (let ((result (cl-member-if-not #'evenp '(1 2 3 4 5))))
+  (let ((result (cl-member-if-not #'cl-evenp '(1 2 3 4 5))))
     (should (equal result '(1 2 3 4 5))))
-  (let ((result (cl-member-if-not #'evenp '(2 4 6 8 10 11))))
+  (let ((result (cl-member-if-not #'cl-evenp '(2 4 6 8 10 11))))
     (should (equal result '(11))))
   (let ((result (cl-member-if-not #'(lambda (x) (> x 5)) '(1 2 3 4 5))))
     (should (equal result '(1 2 3 4 5))))
@@ -620,7 +620,7 @@ Body are forms defining the test."
     (should (equal result '(2 3 4 5))))
   (let ((result (cl-member-if-not (lambda (x) (string= (number-to-string x) "2")) '(1 2 3 4 5) :key 'identity)))
     (should (equal result '(1 2 3 4 5))))
-  (let ((result (cl-member-if-not #'evenp '())))
+  (let ((result (cl-member-if-not #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-member-if-not #'(lambda (x) (eq x 'a)) '(a a a a))))
     (should (equal result nil)))
@@ -650,7 +650,7 @@ Body are forms defining the test."
     (should (equal result '(b . 2)))))
 
 (ert-deftest cl-assoc-if-test ()
-  (let ((result (cl-assoc-if #'evenp '((1 . "odd") (2 . "even") (3 . "odd") (4 . "even")))))
+  (let ((result (cl-assoc-if #'cl-evenp '((1 . "odd") (2 . "even") (3 . "odd") (4 . "even")))))
     (should (equal result '(2 . "even"))))
   (let ((result (cl-assoc-if #'(lambda (x) (= x 5)) '((1 . "one") (2 . "two") (3 . "three")))))
     (should (equal result nil)))
@@ -662,7 +662,7 @@ Body are forms defining the test."
     (should (equal result '(3 . "three"))))
   (let ((result (cl-assoc-if #'(lambda (x) (> x 1)) '((0 . "zero") (1 . "one") (2 . "two")))))
     (should (equal result '(2 . "two"))))
-  (let ((result (cl-assoc-if #'evenp '())))
+  (let ((result (cl-assoc-if #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-assoc-if #'(lambda (x) (eq x 'a)) '((a . "first") (a . "second") (b . "third")))))
     (should (equal result '(a . "first"))))
@@ -672,7 +672,7 @@ Body are forms defining the test."
     (should (equal result '((1 2) . "pair 1")))))
 
 (ert-deftest cl-assoc-if-not-test ()
-  (let ((result (cl-assoc-if-not #'evenp '((1 . "odd") (2 . "even") (3 . "odd") (4 . "even")))))
+  (let ((result (cl-assoc-if-not #'cl-evenp '((1 . "odd") (2 . "even") (3 . "odd") (4 . "even")))))
     (should (equal result '(1 . "odd"))))
   (let ((result (cl-assoc-if-not #'(lambda (x) (> x 0)) '((1 . "one") (2 . "two") (3 . "three")))))
     (should (equal result nil)))
@@ -686,7 +686,7 @@ Body are forms defining the test."
     (should (equal result '(1 . "one"))))
   (let ((result (cl-assoc-if-not #'(lambda (x) (symbolp x)) '((1 . "one") (b . "bee") (2 . "two")))))
     (should (equal result '(1 . "one"))))
-  (let ((result (cl-assoc-if-not #'evenp '())))
+  (let ((result (cl-assoc-if-not #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-assoc-if-not #'(lambda (x) (eq x 'a)) '((a . "first") (a . "second") (b . "third")))))
     (should (equal result '(b . "third")))))
@@ -710,9 +710,9 @@ Body are forms defining the test."
     (should (equal result nil))))
 
 (ert-deftest cl-rassoc-if-test ()
-  (let ((result (cl-rassoc-if #'evenp '(( "one" . 1) ("two" . 2) ("three" . 3)))))
+  (let ((result (cl-rassoc-if #'cl-evenp '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result '("two" . 2))))
-  (let ((result (cl-rassoc-if #'evenp '(( "one" . 1) ("three" . 3) ("five" . 5)))))
+  (let ((result (cl-rassoc-if #'cl-evenp '(( "one" . 1) ("three" . 3) ("five" . 5)))))
     (should (equal result nil)))
   (let ((result (cl-rassoc-if #'(lambda (x) (= x 1)) '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result '("one" . 1))))
@@ -720,7 +720,7 @@ Body are forms defining the test."
     (should (equal result '("two" . 2))))
   (let ((result (cl-rassoc-if #'(lambda (x) (and (numberp x) (< x 3))) '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result '("one" . 1))))
-  (let ((result (cl-rassoc-if #'evenp '())))
+  (let ((result (cl-rassoc-if #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-rassoc-if #'(lambda (x) (> x 0)) '(( "first" . 1) ("second" . 2) ("third" . 3)))))
     (should (equal result '("first" . 1))))
@@ -730,7 +730,7 @@ Body are forms defining the test."
     (should (equal result nil))))
 
 (ert-deftest cl-rassoc-if-not-test ()
-  (let ((result (cl-rassoc-if-not #'evenp '(( "one" . 1) ("two" . 2) ("three" . 3)))))
+  (let ((result (cl-rassoc-if-not #'cl-evenp '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result '("one" . 1))))
   (let ((result (cl-rassoc-if-not #'(lambda (x) (> x 0)) '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result nil)))
@@ -744,7 +744,7 @@ Body are forms defining the test."
     (should (equal result '("three" . 3))))
   (let ((result (cl-rassoc-if-not #'(lambda (x) (equal x 2)) '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result '("one" . 1))))
-  (let ((result (cl-rassoc-if-not #'evenp '())))
+  (let ((result (cl-rassoc-if-not #'cl-evenp '())))
     (should (equal result nil)))
   (let ((result (cl-rassoc-if-not #'(lambda (x) (numberp x)) '(( "one" . 1) ("two" . 2) ("three" . 3)))))
     (should (equal result nil)))