move some more primitive tests

Author: dnolen

src/test/cljs/cljs/core_test.cljs

@@ -47,70 +47,6 @@
     (is (= {"x" "y"} (meta ^{"x" "y"} [])))
     ))
 
-(deftest test-bit-operations
-  (testing "Testing bit operations"
-    (is (= [1 0 0 40 43 49 49])
-        [(bit-xor 0 1)
-         (bit-xor 1 1)
-         (bit-xor 1 0)
-         (bit-xor 41 1)
-         (bit-xor 42 1)
-         (bit-xor 42 1 26)
-         (apply bit-xor [42 1 26])])
-    (is (= [0 0 1 0 1 1 1]
-          [(bit-and 1 0)
-           (bit-and 0 0)
-           (bit-and 1 1)
-           (bit-and 42 1)
-           (bit-and 41 1)
-           (bit-and 41 1 27)
-           (apply bit-and [41 1 27])]))
-    (is (= [1 0 1 43 41 59 59]
-          [(bit-or 1 0)
-           (bit-or 0 0)
-           (bit-or 1 1)
-           (bit-or 42 1)
-           (bit-or 41 1)
-           (bit-or 41 1 26)
-           (apply bit-or [41 1 26])]))
-    (is (= [1 0 0 42 32 32]
-          [(bit-and-not 1 0)
-           (bit-and-not 0 0)
-           (bit-and-not 1 1)
-           (bit-and-not 42 1)
-           (bit-and-not 41 1 27)
-           (apply bit-and-not [41 1 27])]))
-    (is (= [0 2 968 16649 0]
-          [(bit-clear 1 0)
-           (bit-clear 2 0)
-           (bit-clear 1000 5)
-           (bit-clear 16713 6)
-           (bit-clear 1024 10)]))
-    (is (= [0 0 992 18761 0]
-          [(bit-flip 1 0)
-           (bit-flip 2 1)
-           (bit-flip 1000 3)
-           (bit-flip 16713 11)
-           (bit-flip 1024 10)]))
-    (is (= [-2 -3 999 -16714 -1025]
-          [(bit-not 1)
-           (bit-not 2)
-           (bit-not -1000)
-           (bit-not 16713)
-           (bit-not 1024)]))
-    (is (= [1 2 1000 18761 1024]
-          [(bit-set 1 0)
-           (bit-set 2 1)
-           (bit-set 1000 3)
-           (bit-set 16713 11)
-           (bit-set 1024 10)]))
-    (is (= [true true true false true]
-          [(bit-test 1 0)
-           (bit-test 2 1)
-           (bit-test 1000 3)
-           (bit-test 16713 11)
-           (bit-test 1024 10)]))))
-
 (deftest test-vectors
   (testing "Testing vectors"
     (is (= :a (nth [:a :b :c :d] 0)))
@@ -185,73 +121,6 @@
     (is (= () (rest [1])))
     (is (= () (rest (array 1))))))
 
-(deftest test-apply
-  (testing "Testing apply"
-    (is (= 0 (apply + nil)))
-    (is (= 0 (apply + (list))))
-    (is (= 1 (apply + (list 1))))
-    (is (= 3 (apply + 1 (list 2))))
-    (is (= 7 (apply + 1 2 (list 4))))
-    (is (= 15 (apply + 1 2 4 (list 8))))
-    (is (= 31 (apply + 1 2 4 8 (list 16))))
-    (is (= 63 (apply + 1 2 4 8 16 (list 32))))
-    (is (= 127 (apply + 1 2 4 8 16 (list 32 64))))
-    (is (= 4950 (apply + (take 100 (iterate inc 0)))))
-    (is (= () (apply list [])))
-    (is (= [1 2 3] (apply list [1 2 3])))
-    (is (= 6 (apply apply [+ [1 2 3]])))
-    ;; apply with infinite sequence
-    (is (= 3 (apply (fn [& args]
-                          (+ (nth args 0)
-                            (nth args 1)
-                            (nth args 2)))
-                   (iterate inc 0))))
-    (is (= [0 1 2 3 4] (take 5 (apply (fn [& m] m) (iterate inc 0)))))
-    (is (= [1 2 3 4 5] (take 5 (apply (fn [x & m] m) (iterate inc 0)))))
-    (is (= [2 3 4 5 6] (take 5 (apply (fn [x y & m] m) (iterate inc 0)))))
-    (is (= [3 4 5 6 7] (take 5 (apply (fn [x y z & m] m) (iterate inc 0)))))
-    (is (= [4 5 6 7 8] (take 5 (apply (fn [x y z a & m] m) (iterate inc 0)))))
-    (is (= [5 6 7 8 9] (take 5 (apply (fn [x y z a b & m] m) (iterate inc 0)))))
-    ;; apply arity tests
-    (let [single-arity-non-variadic (fn [x y z] [z y x])
-          multiple-arity-non-variadic (fn ([x] x) ([x y] [y x]) ([x y z] [z y x]))
-          single-arity-variadic-fixedargs (fn [x y & more] [more y x])
-          single-arity-variadic-nofixedargs (fn [& more] more)
-          multiple-arity-variadic (fn ([x] x) ([x y] [y x]) ([x y & more] [more y x]))]
-      (testing "arities"
-        (is (= [3 2 1] (apply single-arity-non-variadic [1 2 3])))
-        (is (= [3 2 1] (apply single-arity-non-variadic 1 [2 3])))
-        (is (= [3 2 1] (apply single-arity-non-variadic 1 2 [3])))
-        (is (= 42 (apply multiple-arity-non-variadic [42])))
-        (is (= [2 1] (apply multiple-arity-non-variadic [1 2])))
-        (is (= [2 1] (apply multiple-arity-non-variadic 1 [2])))
-        (is (= [3 2 1] (apply multiple-arity-non-variadic [1 2 3])))
-        (is (= [3 2 1] (apply multiple-arity-non-variadic 1 [2 3])))
-        (is (= [3 2 1] (apply multiple-arity-non-variadic 1 2 [3])))
-        (is (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs [1 2 3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 [2 3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 [3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 3 [4 5])))
-        (is (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 3 4 [5])))
-        (is (= [3 4 5] (take 3 (first (apply single-arity-variadic-fixedargs (iterate inc 1))))))
-        (is (= [2 1] (rest (apply single-arity-variadic-fixedargs (iterate inc 1)))))
-        (is (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs [1 2 3 4 5])))
-        (is (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 [2 3 4 5])))
-        (is (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 [3 4 5])))
-        (is (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 3 [4 5])))
-        (is (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 3 4 [5])))
-        (is (= [1 2 3 4 5] (take 5 (apply single-arity-variadic-nofixedargs (iterate inc 1)))))
-        (is (= 42 (apply multiple-arity-variadic [42])))
-        (is (= [2 1] (apply multiple-arity-variadic [1 2])))
-        (is (= [2 1] (apply multiple-arity-variadic 1 [2])))
-        (is (= [[3 4 5] 2 1] (apply multiple-arity-variadic [1 2 3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 [2 3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 [3 4 5])))
-        (is (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 3 [4 5])))
-        (is (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 3 4 [5])))
-        (is (= [3 4 5] (take 3 (first (apply multiple-arity-variadic (iterate inc 1))))))
-        (is (= [2 1] (rest (apply multiple-arity-variadic (iterate inc 1)))))))))
-
 ;; this fails in v8 - why?
 ;; (assert (= "symbol\"'string" (pr-str (str 'symbol \" \' "string"))))
 (deftest test-misc
@@ -398,20 +267,6 @@
     (is (try (do (take-nth nil [1 2 3]) false)
              (catch js/Error e true)))))
 
-(deftest test-booleans
-  (testing "Testing boolean predicates"
-    (is (= [true false true false false false true true false false]
-          [(true? true)
-           (true? false)
-           (false? false)
-           (false? true)
-           (true? js/undefined)
-           (false? js/undefined)
-           (boolean? true)
-           (boolean? false)
-           (boolean? nil)
-           (boolean? js/undefined)]))))
-
 (deftest test-fn-with-metadata
   (let [f (fn [x] (* x 2))
         m {:foo "bar"}
@@ -513,51 +368,6 @@
         (is (empty? e-queue))
         (is (= {:b :c} (meta e-queue)))))))
 
-(deftest test-try-catch
-  (let [a (atom nil)]
-    (testing "Testing try/catch"
-      (is (= 1 (try 1)))
-      (is (= 2 (try 1 (throw (js/Error.)) (catch js/Error e 2))))
-      (is (= 2 (try 1 (throw (js/Error.)) (catch js/Error e 1 2))))
-      (is (= 2 (try 1 (throw (js/Error.)) (catch js/Error e 2) (catch :default e 3))))
-      (is (= 3 (try 1 (throw true) (catch js/Error e 2) (catch :default e 3))))
-      (is (= 2 (try 1 (throw 2) (catch js/Error e 3) (catch :default e e))))
-      (is (= 1 (try 1 (finally (reset! a 42)))))
-      (is (= 42 (deref a))))))
-
-(deftest test-list-comprehensions
-  (let [v [1 2 3]]
-    (testing "Testing list comprehensions"
-      (is (= v (for [e v] e)))
-      (is (= [[1 1] [2 4] [3 9]] (for [e v :let [m (* e e)]] [e m])))
-      (is (= [1 2] (for [e v :while (< e 3)] e)))
-      (is (= [3] (for [e v :when (> e 2)] e)))
-      (is (= [[1 1] [2 4]] (for [e v :while (< e 3) :let [m (* e e)]] [e m]))))))
-
-(deftest test-partial-and-comp
-  (let [a10 (partial + 10)
-        a20 (partial + 10 10)
-        a21 (partial + 10 10 1)
-        a22 (partial + 10 5  4 3)
-        a23 (partial + 10 5  4 3 1)]
-    (testing "Testing partial"
-      (is (= 110 (a10 100)))
-      (is (= 120 (a20 100)))
-      (is (= 121 (a21 100)))
-      (is (= 122 (a22 100)))
-      (is (= 123 (a23 100)))))
-  (let [n2 (comp first rest)
-        n3 (comp first rest rest)
-        n4 (comp first rest rest rest)
-        n5 (comp first rest rest rest rest)
-        n6 (comp first rest rest rest rest rest)]
-    (testing "Testing comp"
-      (is (= 2 (n2 [1 2 3 4 5 6 7])))
-      (is (= 3 (n3 [1 2 3 4 5 6 7])))
-      (is (= 4 (n4 [1 2 3 4 5 6 7])))
-      (is (= 5 (n5 [1 2 3 4 5 6 7])))
-      (is (= 6 (n6 [1 2 3 4 5 6 7]))))))
-
 (deftest test-sets
   (testing "Testing persistent sets"
     (is (set []))
@@ -636,23 +446,6 @@
     (is (= (distinct [#{1 2} #{1 2}]) [#{1 2}]))
     (is (= (distinct [#{} #{}]) [#{}]))))
 
-(deftest test-regexps
-  (testing "Testing regexps"
-    (let [r1 #"foo", r2 (re-pattern r1)]
-      (is (= r1 r2)))
-    (is (= (str (re-pattern "f(.)o")) (str (js* "/f(.)o/"))))
-    (is (= (re-find (re-pattern "foo") "foo bar foo baz foo zot") "foo"))
-    (is (= (re-find (re-pattern "f(.)o") "foo bar foo baz foo zot") ["foo" "o"]))
-    (is (= (re-matches (re-pattern "foo") "foo") "foo"))
-    (is (= (re-matches (re-pattern "foo") "foo bar foo baz foo zot") nil))
-    (is (= (re-matches (re-pattern "foo.*") "foo bar foo baz foo zot") "foo bar foo baz foo zot"))
-    (is (= (re-seq (re-pattern "foo") "foo bar foo baz foo zot") (list "foo" "foo" "foo")))
-    (is (= (re-seq (re-pattern "f(.)o") "foo bar foo baz foo zot") (list ["foo" "o"] ["foo" "o"] ["foo" "o"])))
-    (is (= (re-matches (re-pattern "(?i)foo") "Foo") "Foo"))
-                                        ; new RegExp("").source => "(?:)" on webkit-family envs, "" elsewhere
-    (is (#{"#\"\"" "#\"(?:)\""} (pr-str #"")))
-    (is (= (re-find (re-pattern "[\u2028]") " \u2028 ") "\u2028")))) ; regression test for CLJS-889
-
 (deftest test-destructuring
   (testing "Testing destructuring"
     (is (= [2 1] (let [[a b] [1 2]] [b a])))