Cleanup: Fix core-test Deps Order, Remove Unused, etc.

templates/test-template.cljc

@@ -1,6 +1,6 @@
 (ns {{base-ns}}-test.{{ns-suffix}}
   (:require {% if not base-ns = "clojure.core" %}{{base-ns}}
-            {% endif %}[clojure.test :as t :refer [deftest testing is are]]
+            {% endif %}[clojure.test :as t :refer [are deftest is testing]]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
 (when-var-exists {% if not base-ns = "clojure.core" %}{{base-ns}}/{% endif %}{{sym-name}}

test/clojure/core_test/abs.cljc

@@ -1,29 +1,32 @@
 (ns clojure.core-test.abs
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest is testing]]
             [clojure.core-test.number-range :as r]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/abs
+(when-var-exists abs
   (deftest test-abs
     (testing "common"
      (are [in ex] (= ex (abs in))
-       -1             1
-       1              1
-       (inc r/min-int)      (- (inc r/min-int))
-       #?@(:clj [r/min-int r/min-int])  ; fixed int 2's complement oddity, see below for :cljr
-       -1.0           1.0
-       -0.0           0.0
-       ##-Inf         ##Inf
-       ##Inf          ##Inf
-       -123.456M      123.456M
-       -123N          123N
+       -1              1
+       1               1
+       (inc r/min-int) (- (inc r/min-int))
+       -1.0            1.0
+       -0.0            0.0
+       ##-Inf          ##Inf
+       ##Inf           ##Inf
+       -123.456M       123.456M
+       -123N           123N
+
+       #?@(:cljr []
+           :clj [r/min-int r/min-int] ; fixed int 2's complement oddity, see below for :cljr
+           :default [r/min-int (* -1 r/min-int)])
        #?@(:cljs []
            :default
-           [-1/5           1/5]))
+           [-1/5 1/5]))
      (is (NaN? (abs ##NaN)))
-	 #?(:cljr (is (thrown? System.OverflowException (abs r/min-int))))
+     #?(:cljr (is (thrown? System.OverflowException (abs r/min-int))))
      #?(:cljs (is (zero? (abs nil)))
-        :default (is (thrown? #?(:clj Exception :cljr Exception) (abs nil)))))
+        :default (is (thrown? Exception (abs nil)))))
 
     (testing "unboxed"
       (let [a  42

test/clojure/core_test/aclone.cljc

@@ -1,8 +1,8 @@
 (ns clojure.core-test.aclone
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [deftest is testing]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/aclone
+(when-var-exists aclone
   (defn clone-test
     [a b]
     (aset a 0 1)

test/clojure/core_test/add_watch.cljc

@@ -1,8 +1,8 @@
 (ns clojure.core-test.add-watch
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists sleep]]))
+  (:require [clojure.test :as t :refer [deftest is testing]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists sleep]]))
 
-(when-var-exists clojure.core/add-watch
+(when-var-exists add-watch
   (deftest test-add-watch
     (testing "watch atom"
       ;; checks atoms and interspersed multiple watches
@@ -73,7 +73,9 @@
 
     #?@(:cljs []
         :default
-        [(def testvar-a 0)
+        [#_{:clj-kondo/ignore [:inline-def]}
+         (def testvar-a 0)
+         #_{:clj-kondo/ignore [:inline-def]}
          (def testvar-b 10)
 
          (testing "watch var"
@@ -156,7 +158,7 @@
                            (catch #?(:cljs :default
                                      :clj clojure.lang.ExceptionInfo
                                      :cljr clojure.lang.ExceptionInfo) e
-                             (let [{:keys [old] :as data} (ex-data e)]
+                             (let [{:keys [_old] :as data} (ex-data e)]
                                (vswap! state conj data)))))
                keyed (fn [k s] (filter #(= k (:key %)) s))]
 
@@ -216,14 +218,14 @@
         :default
         [(testing "watch agent"
            (let [state (volatile! [])
-                 tester1 (fn [key ref old new]
+                 tester1 (fn [key _ref old new]
                            (when (not= old new)
                              (vswap! state conj {:key key :old old :new new :tester 1})))
-                 tester2 (fn [key ref old new]
+                 tester2 (fn [key _ref old new]
                            (when (not= old new)
                              (vswap! state conj {:key key :old old :new new :tester 2})))
                  agent-end (promise)
-                 err (fn [key ref old new]
+                 err (fn [key _ref old new]
                        (deliver agent-end :done)
                        (throw (ex-info "test" {:key key :old old :new new :tester :err})))
                  g (agent 20)
@@ -232,7 +234,7 @@
                              (vswap! state conj (ex-data e))
                              (restart-agent g :ready))
                            (send g inc))
-                 keyed (fn [k s] (set (filter #(= k (:key %)) s)))]
+                 _keyed (fn [k s] (set (filter #(= k (:key %)) s)))]
 
              ;; add a watch to the agent
              (is (= g (add-watch g :g tester1)))

test/clojure/core_test/and.cljc

@@ -1,12 +1,14 @@
 (ns clojure.core-test.and
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is testing]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/and
+(when-var-exists and
   (deftest test-and
     (testing "common"
       (is (= true (and)))
-      (are [x] (= x (and x))
+      (are [x] (= x
+                  #_{:clj-kondo/ignore [:single-logical-operand]}
+                  (and x))
         true
         false
         nil
@@ -33,4 +35,6 @@
         (is (= nil (and nil nil nil nil nil nil nil nil nil nil nil nil true)))))
 
    (testing "infinite-sequence"
-     (is (some? (and (range)))))))
+     (is (some?
+          #_{:clj-kondo/ignore [:single-logical-operand]}
+          (and (range)))))))

test/clojure/core_test/any_qmark.cljc

@@ -1,8 +1,8 @@
 (ns clojure.core-test.any-qmark
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is testing]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/any?
+(when-var-exists any?
   (deftest test-any?
     (testing "common"
       (are [x] (= true (any? x))

test/clojure/core_test/assoc.cljc

@@ -1,5 +1,5 @@
 (ns clojure.core-test.assoc
-  (:require [clojure.test :refer [deftest testing is are]]
+  (:require [clojure.test :refer [are deftest is testing]]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
 (when-var-exists assoc

test/clojure/core_test/assoc_bang.cljc

@@ -1,5 +1,5 @@
 (ns clojure.core-test.assoc-bang
-  (:require [clojure.test :refer [deftest testing are]]
+  (:require [clojure.test :refer [are deftest testing]]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
 (when-var-exists assoc!

test/clojure/core_test/associative_qmark.cljc

@@ -1,5 +1,5 @@
 (ns clojure.core-test.associative-qmark
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest]]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
 
 (when-var-exists clojure.core/associative?

test/clojure/core_test/atom.cljc

@@ -1,6 +1,6 @@
 (ns clojure.core-test.atom
   (:require clojure.core
-            [clojure.test :as t :refer [deftest testing is are]]
+            [clojure.test :as t :refer [are deftest is testing]]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
 (when-var-exists clojure.core/atom

test/clojure/core_test/bigdec.cljc

@@ -1,8 +1,8 @@
 (ns clojure.core-test.bigdec
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [deftest is are]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bigdec
+(when-var-exists bigdec
   (deftest test-bigdec
     (are [expected x] (= expected (bigdec x))
       1M    1

test/clojure/core_test/bigint.cljc

@@ -1,17 +1,17 @@
 (ns clojure.core-test.bigint
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest is]]
             [clojure.core-test.number-range :as r]
             [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bigint
+(when-var-exists bigint
   (deftest test-bigint
     (are [expected x] (= expected (bigint x))
       1N  1
       0N  0
       -1N -1
       #?@(:cljs []
-          :clj [179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000N r/max-double]
-		  :clj [179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000N r/max-double])
+          :cljr [179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368N r/max-double]
+		      :default [179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000N r/max-double])
       1N  1.0
       0N  0.0
       -1N -1.0

test/clojure/core_test/binding.cljc

@@ -1,8 +1,8 @@
 (ns clojure.core-test.binding
   (:require [clojure.test :as t]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/binding
+(when-var-exists binding
   (def  ^:dynamic *x* :unset)
   (def  ^:dynamic *y* nil)
   (defn ^:dynamic *f* [x] (inc x))

test/clojure/core_test/bit_and.cljc

@@ -1,7 +1,7 @@
 (ns clojure.core-test.bit-and
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest is]]
             [clojure.core-test.number-range :as r]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
 (when-var-exists clojure.core/bit-and
   (deftest test-bit-and

test/clojure/core_test/bit_and_not.cljc

@@ -1,9 +1,9 @@
 (ns clojure.core-test.bit-and-not
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest is]]
             [clojure.core-test.number-range :as r]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-and-not
+(when-var-exists bit-and-not
   (deftest test-bit-and-not
     #?(:cljs (is (= 0 (bit-and-not nil 1)))
        :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-and-not nil 1))))

test/clojure/core_test/bit_clear.cljc

@@ -1,13 +1,13 @@
 (ns clojure.core-test.bit-clear
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-clear
+(when-var-exists bit-clear
   (deftest test-bit-clear
     #?(:cljs (is (= 0 (bit-clear nil 1)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-clear nil 1))))
+       :default (is (thrown? Exception (bit-clear nil 1))))
     #?(:cljs (is (= 0 (bit-clear 1 nil)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-clear 1 nil))))
+       :default (is (thrown? Exception (bit-clear 1 nil))))
 
     (are [ex a b] (= ex (bit-clear a b))
       3 11 3)))

test/clojure/core_test/bit_flip.cljc

@@ -1,13 +1,13 @@
 (ns clojure.core-test.bit-flip
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-flip
+(when-var-exists bit-flip
   (deftest test-bit-flip
     #?(:cljs (is (= 2 (bit-flip nil 1)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-flip nil 1))))
+       :default (is (thrown? Exception (bit-flip nil 1))))
     #?(:cljs (is (= 0 (bit-flip 1 nil)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-flip 1 nil))))
+       :default (is (thrown? Exception (bit-flip 1 nil))))
 
     (are [ex a b] (= ex (bit-flip a b))
       2r1111 2r1011 2

test/clojure/core_test/bit_not.cljc

@@ -1,11 +1,11 @@
 (ns clojure.core-test.bit-not
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-not
+(when-var-exists bit-not
   (deftest test-bit-not
     #?(:cljs (is (= -1 (bit-not nil)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-not nil))))
+       :default (is (thrown? Exception (bit-not nil))))
 
     (are [ex a] (= ex (bit-not a))
       -2r1000 2r0111

test/clojure/core_test/bit_or.cljc

@@ -1,14 +1,14 @@
 (ns clojure.core-test.bit-or
-  (:require [clojure.test :as t :refer [deftest testing is are]]
+  (:require [clojure.test :as t :refer [are deftest is]]
             [clojure.core-test.number-range :as r]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-or
+(when-var-exists bit-or
   (deftest test-bit-or
     #?(:cljs (is (bit-or nil 1))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-or nil 1))))
+       :default (is (thrown? Exception (bit-or nil 1))))
     #?(:cljs (is (bit-or 1 nil))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-or 1 nil))))
+       :default (is (thrown? Exception (bit-or 1 nil))))
 
     (are [ex a b] (= ex (bit-or a b))
       2r1101                   2r1100                   2r1001

test/clojure/core_test/bit_set.cljc

@@ -1,13 +1,13 @@
 (ns clojure.core-test.bit-set
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-set
+(when-var-exists bit-set
   (deftest test-bit-set
     #?(:cljs (is (bit-set nil 1))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-set nil 1))))
+       :default (is (thrown? Exception (bit-set nil 1))))
     #?(:cljs (is (bit-set 1 nil))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-set 1 nil))))
+       :default (is (thrown? Exception (bit-set 1 nil))))
 
     (are [ex a b] (= ex (bit-set a b))
       2r1111               2r1011 2

test/clojure/core_test/bit_shift_left.cljc

@@ -1,13 +1,13 @@
 (ns clojure.core-test.bit-shift-left
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-shift-left
+(when-var-exists bit-shift-left
   (deftest test-bit-shift-left
     #?(:cljs (is (= 0 (bit-shift-left nil 1)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-shift-left nil 1))))
+       :default (is (thrown? Exception (bit-shift-left nil 1))))
     #?(:cljs (is (= 1 (bit-shift-left 1 nil)))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-shift-left 1 nil))))
+       :default (is (thrown? Exception (bit-shift-left 1 nil))))
 
     (are [ex a b] (= ex (bit-shift-left a b))
       1024     1      10

test/clojure/core_test/bit_shift_right.cljc

@@ -1,13 +1,13 @@
 (ns clojure.core-test.bit-shift-right
-  (:require [clojure.test :as t :refer [deftest testing is are]]
-            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer)  [when-var-exists]]))
+  (:require [clojure.test :as t :refer [are deftest is]]
+            [clojure.core-test.portability #?(:cljs :refer-macros :default :refer) [when-var-exists]]))
 
-(when-var-exists clojure.core/bit-shift-right
+(when-var-exists bit-shift-right
   (deftest test-bit-shift-right
     #?(:cljs (is (bit-shift-right nil 1))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-shift-right nil 1))))
+       :default (is (thrown? Exception (bit-shift-right nil 1))))
     #?(:cljs (is (bit-shift-right 1 nil))
-       :default (is (thrown? #?(:clj Exception :cljr Exception) (bit-shift-right 1 nil))))
+       :default (is (thrown? Exception (bit-shift-right 1 nil))))
 
     (are [ex a b] (= ex (bit-shift-right a b))
       2r1101 2r1101 0