diff options
Diffstat (limited to 'tests/core.fnl')
| -rw-r--r-- | tests/core.fnl | 1415 |
1 files changed, 743 insertions, 672 deletions
diff --git a/tests/core.fnl b/tests/core.fnl index bdb2ede..e550b4b 100644 --- a/tests/core.fnl +++ b/tests/core.fnl @@ -1,364 +1,288 @@ -(require-macros :init-macros) +(import-macros clj :init-macros) (require-macros :fennel-test) -(local {: add - : apply - : assoc - : boolean? - : butlast - : comp - : complement - : concat - : conj - : cons - : constantly - : dec - : disj - : dissoc - : div - : double? - : empty? - : eq - : even? - : every? - : false? - : filter - : find - : first - : ge - : get - : get-in - : get-method - : gt - : hash-map - : hash-set - : identity - : inc - : int? - : keys - : kvseq - : last - : le - : lt - : map? - : mapv - : memoize - : methods - : mul - : multifn? - : neg-int? - : neg? - : nil? - : not-any? - : not-empty - : nthrest - : odd? - : ordered-set - : partition - : pos-int? - : pos? - : range - : reduce - : reduce-kv - : reduced - : remove-all-methods - : remove-method - : rest - : reverse - : seq - : set? - : some - : string? - : sub - : take - : true? - : vals - : vector - : vector? - : zero?} (require :init)) +(local core (require :init)) (deftest test-equality (testing "comparing base-types" - (assert-not (pcall eq)) - (assert-eq 1 1) - (assert-ne 1 2) - (assert-is (eq 1 1 1 1 1)) - (assert-eq 1.0 1.0) - (assert-is (eq 1.0 1.0 1.0)) - (assert-is (eq 1.0 1.0 1.0)) - (assert-is (eq "1" "1" "1" "1" "1"))) + (assert-is (core.eq)) + (assert-is (core.eq 1 1)) + (assert-not (core.eq 1 2)) + (assert-is (core.eq 1 1 1 1 1)) + (assert-is (core.eq 1.0 1.0)) + (assert-is (core.eq 1.0 1.0 1.0)) + (assert-is (core.eq 1.0 1.0 1.0)) + (assert-is (core.eq "1" "1" "1" "1" "1"))) (testing "deep comparison" - (assert-is (eq [])) - (assert-eq [] []) - (assert-eq [] {}) - (assert-eq [1 2] [1 2]) - (assert-eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]]) - (assert-is (eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]])) - (assert-is (eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]])) - (assert-not (eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] - [[1 [2 [3]] {[6] {:a [1 [1 [1 [1]]]]}}]])) - (assert-ne [1] [1 2]) - (assert-ne [1 2] [1]) - (assert-is (eq [1 [2]] [1 [2]] [1 [2]])) - (assert-is (eq [1 [2]] [1 [2]] [1 [2]])) - (assert-not (eq [1 [2]] [1 [2]] [1 [2 [3]]])) - (assert-not (eq {:a {:b 2}} {:a {:b 2}} {:a {:b 3}})) + (assert-is (core.eq [])) + (assert-is (core.eq [] [])) + (assert-is (core.eq [] {})) + (assert-is (core.eq [1 2] [1 2])) + (assert-is (core.eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]])) + (assert-is (core.eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]])) + (assert-is (core.eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]])) + (assert-not (core.eq [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[5] {:a [1 [1 [1 [1]]]]}}]] + [[1 [2 [3]] {[6] {:a [1 [1 [1 [1]]]]}}]])) + (assert-not (core.eq [1] [1 2])) + (assert-not (core.eq [1 2] [1])) + (assert-is (core.eq [1 [2]] [1 [2]] [1 [2]])) + (assert-is (core.eq [1 [2]] [1 [2]] [1 [2]])) + (assert-not (core.eq [1 [2]] [1 [2]] [1 [2 [3]]])) + (assert-not (core.eq {:a {:b 2}} {:a {:b 2}} {:a {:b 3}})) (let [a {:a 1 :b 2} b {:a 1 :b 2}] (table.insert b 10) - (assert-ne a b)) + (assert-not (core.eq a b))) (let [a [1 2 3] b [1 2 3]] (tset b :a 10) - (assert-ne a b)) + (assert-not (core.eq a b))) - (assert-eq [1 2 3] {1 1 2 2 3 3}) - (assert-eq {4 1} [nil nil nil 1]))) + (assert-is (core.eq [1 2 3] {1 1 2 2 3 3})) + (assert-is (core.eq {4 1} [nil nil nil 1])))) (deftest test-range (testing "range" - (assert-not (pcall range)) - (assert-eq (range 10) [0 1 2 3 4 5 6 7 8 9]) - (assert-eq (range -5 5) [-5 -4 -3 -2 -1 0 1 2 3 4]) - (assert-eq [0 0.2 0.4 0.6 0.8] [0 0.2 0.4 0.6 0.8]) - (assert-eq (range 0 1 0.2) (range 0 1 0.2)))) + (assert-is (core.range)) + (assert-eq (core.range 10) (core.list 0 1 2 3 4 5 6 7 8 9)) + (assert-eq (core.range -5 5) (core.list -5 -4 -3 -2 -1 0 1 2 3 4)) + (assert-eq (core.range 0 1 0.2) (core.range 0 1 0.2)))) + +(deftest test-empty + (testing "empty map" + (assert-not (pcall core.empty)) + (assert-eq (core.empty {}) {}) + (assert-eq (core.empty "") "") + (assert-eq (core.hash-set) (core.empty (core.hash-set :a :b :c))) + (assert-eq (core.hash-map) (core.empty (core.hash-map :a :b :c :d))) + (assert-eq (core.vector) (core.empty (core.vector :a :b :c :d))) + (assert-eq (core.list) (core.empty (core.list :a :b :c :d))) + (let [a {:a 1 :b 2}] + (assert-eq (core.empty a) {})) + (let [a {}] + (assert-eq (core.empty a) [])))) (deftest test-predicates (testing "zero?" - (assert-is (zero? 0)) - (assert-is (zero? -0)) - (assert-not (zero? 1)) - (assert-not (pcall zero?)) - (assert-not (pcall zero? 1 2))) + (assert-is (core.zero? 0)) + (assert-is (core.zero? -0)) + (assert-not (core.zero? 1)) + (assert-not (pcall core.zero?)) + (assert-not (pcall core.zero? 1 2))) (testing "int?" - (assert-is (int? 1)) - (assert-not (int? 1.1)) - (assert-not (pcall int?)) - (assert-not (pcall int? 1 2))) + (assert-is (core.int? 1)) + (assert-not (core.int? 1.1)) + (assert-not (pcall core.int?)) + (assert-not (pcall core.int? 1 2))) (testing "pos?" - (assert-is (pos? 1)) - (assert-is (and (not (pos? 0)) (not (pos? -1)))) - (assert-not (pcall pos?)) - (assert-not (pcall pos? 1 2))) + (assert-is (core.pos? 1)) + (assert-is (and (not (core.pos? 0)) (not (core.pos? -1)))) + (assert-not (pcall core.pos?)) + (assert-not (pcall core.pos? 1 2))) (testing "neg?" - (assert-is (neg? -1)) - (assert-is (and (not (neg? 0)) (not (neg? 1)))) - (assert-not (pcall neg?)) - (assert-not (pcall neg? 1 2))) + (assert-is (core.neg? -1)) + (assert-is (and (not (core.neg? 0)) (not (core.neg? 1)))) + (assert-not (pcall core.neg?)) + (assert-not (pcall core.neg? 1 2))) (testing "pos-int?" - (assert-is (pos-int? 42)) - (assert-not (pos-int? 4.2)) - (assert-not (pcall pos-int?)) - (assert-not (pcall pos-int? 1 2))) + (assert-is (core.pos-int? 42)) + (assert-not (core.pos-int? 4.2)) + (assert-not (pcall core.pos-int?)) + (assert-not (pcall core.pos-int? 1 2))) (testing "neg-int?" - (assert-is (neg-int? -42)) - ;; (assert-not (neg-int? -4.2)) - (assert-not (pcall neg-int?)) - (assert-not (pcall neg-int? 1 2))) + (assert-is (core.neg-int? -42)) + (assert-not (core.neg-int? -4.2)) + (assert-not (pcall core.neg-int?)) + (assert-not (pcall core.neg-int? 1 2))) (testing "string?" - (assert-is (string? :s)) - (assert-not (pcall string?)) - (assert-not (pcall string? 1 2))) + (assert-is (core.string? :s)) + (assert-not (pcall core.string?)) + (assert-not (pcall core.string? 1 2))) (testing "double?" - (assert-is (double? 3.3)) - (assert-not (double? 3.0)) - (assert-not (pcall double?)) - (assert-not (pcall double? 1 2))) + (assert-is (core.double? 3.3)) + (assert-not (core.double? 3.0)) + (assert-not (pcall core.double?)) + (assert-not (pcall core.double? 1 2))) (testing "map?" - (assert-is (map? {:a 1})) - (assert-not (map? {})) - (assert-is (map? (empty {}))) - (assert-not (map? (empty []))) - (assert-not (pcall map?)) - (assert-not (pcall map? 1 2))) + (assert-is (core.map? {:a 1})) + (assert-not (core.map? {})) + (assert-is (core.map? (core.empty (core.hash-map)))) + (assert-not (core.map? (core.empty []))) + (assert-not (pcall core.map?)) + (assert-not (pcall core.map? 1 2))) (testing "vector?" - (assert-not (vector? [])) - (assert-is (vector? [{:a 1}])) - (assert-not (vector? {})) - (assert-not (vector? {:a 1})) - (assert-is (vector? (empty []))) - (assert-not (vector? (empty {}))) - (assert-not (pcall vector?)) - (assert-not (pcall vector? 1 2))) + (assert-not (core.vector? [])) + (assert-is (core.vector? [{:a 1}])) + (assert-not (core.vector? {})) + (assert-not (core.vector? {:a 1})) + (assert-is (core.vector? (core.empty (core.vector)))) + (assert-not (core.vector? (core.empty {}))) + (assert-not (pcall core.vector?)) + (assert-not (pcall core.vector? 1 2))) (testing "multifn?" - (assert-not (multifn? [])) - (assert-is (multifn? (do (defmulti f identity) f))) - (assert-not (pcall multifn?)) - (assert-not (pcall multifn? 1 2))) + (assert-not (core.multifn? [])) + (assert-is (core.multifn? (do (clj.defmulti f core.identity) f))) + (assert-not (pcall core.multifn?)) + (assert-not (pcall core.multifn? 1 2))) (testing "set?" - (assert-is (set? (ordered-set))) - (assert-is (set? (hash-set))) - (assert-eq (set? (hash-set)) :cljlib/hash-set) - (assert-eq (set? (ordered-set)) :cljlib/ordered-set) - (assert-not (pcall set?)) - (assert-not (pcall set? 1 2))) + (assert-is (core.set? (core.hash-set))) + (assert-not (core.set? {})) + (assert-not (core.set? (core.hash-map))) + (assert-not (pcall core.set?)) + (assert-not (pcall core.set? 1 2))) + + (testing "seq?" + (assert-is (core.seq? (core.list))) + (assert-not (core.seq? {})) + (assert-not (core.seq? (core.hash-map))) + (assert-not (pcall core.seq?)) + (assert-not (pcall core.seq? 1 2))) (testing "nil?" - (assert-is (nil?)) - (assert-is (nil? nil)) - (assert-not (nil? 1)) - (assert-not (pcall nil? 1 2))) + (assert-is (core.nil?)) + (assert-is (core.nil? nil)) + (assert-not (core.nil? 1)) + (assert-not (pcall core.nil? 1 2))) (testing "odd?" - (assert-is (odd? 3)) - (assert-is (odd? -3)) - (assert-not (odd? 2)) - (assert-not (odd? -2)) - (assert-not (pcall odd?)) - (assert-not (pcall odd? 1 2))) + (assert-is (core.odd? 3)) + (assert-is (core.odd? -3)) + (assert-not (core.odd? 2)) + (assert-not (core.odd? -2)) + (assert-not (pcall core.odd?)) + (assert-not (pcall core.odd? 1 2))) (testing "even?" - (assert-is (even? 2)) - (assert-is (even? -2)) - (assert-not (even? 23)) - (assert-not (even? -23)) - (assert-not (pcall even?)) - (assert-not (pcall even? 1 2))) + (assert-is (core.even? 2)) + (assert-is (core.even? -2)) + (assert-not (core.even? 23)) + (assert-not (core.even? -23)) + (assert-not (pcall core.even?)) + (assert-not (pcall core.even? 1 2))) (testing "true?" - (assert-is (true? true)) - (assert-not (true? false)) - (assert-not (true? 10)) - (assert-not (true? :true)) - (assert-not (pcall true?)) - (assert-not (pcall true? 1 2))) + (assert-is (core.true? true)) + (assert-not (core.true? false)) + (assert-not (core.true? 10)) + (assert-not (core.true? :true)) + (assert-not (pcall core.true?)) + (assert-not (pcall core.true? 1 2))) (testing "false?" - (assert-is (false? false)) - (assert-not (false? true)) - (assert-not (false? 10)) - (assert-not (false? :true)) - (assert-not (pcall false?)) - (assert-not (pcall false? 1 2))) + (assert-is (core.false? false)) + (assert-not (core.false? true)) + (assert-not (core.false? 10)) + (assert-not (core.false? :true)) + (assert-not (pcall core.false?)) + (assert-not (pcall core.false? 1 2))) (testing "boolean?" - (assert-is (boolean? true)) - (assert-is (boolean? false)) - (assert-not (boolean? :false)) - (assert-not (boolean? (fn [] true))) - (assert-not (pcall boolean?)) - (assert-not (pcall boolean? 1 2)))) + (assert-is (core.boolean? true)) + (assert-is (core.boolean? false)) + (assert-not (core.boolean? :false)) + (assert-not (core.boolean? (fn [] true))) + (assert-not (pcall core.boolean?)) + (assert-not (pcall core.boolean? 1 2)))) (deftest test-sequence-functions (testing "seq" - (assert-not (pcall seq)) - (assert-not (pcall seq [] [])) - (assert-eq (seq []) nil) - (assert-eq (seq {}) nil) - (assert-eq (seq [1]) [1]) - (assert-eq (seq [1 2 3]) [1 2 3]) - (assert-eq (seq {:a 1}) [["a" 1]]) - (assert-eq (seq "abc") ["a" "b" "c"]) - (when _G.utf8 (assert-eq (seq "абв") ["а" "б" "в"])) - (assert-eq (seq {12345 123}) [[12345 123]]) - (assert-eq (seq (ordered-set 1 2 3)) [1 2 3]) - (assert-eq (length (seq (ordered-set 1 2 3))) 3) - (assert-eq (seq (hash-set 1)) [1]) - (assert-eq (length (seq (hash-set 1 2 3))) 3)) - - (testing "kvseq" - (assert-not (pcall kvseq)) - (assert-not (pcall kvseq [] [])) - (assert-eq (kvseq nil) nil) - (assert-eq (kvseq []) nil) - (assert-eq (kvseq {123 456}) [[123 456]]) - (assert-eq (kvseq {:a 1}) [[:a 1]]) - (assert-eq (kvseq [0 0 0 10]) [[1 0] [2 0] [3 0] [4 10]]) - (assert-eq (kvseq (ordered-set :a :b :c)) [[:a :a] [:b :b] [:c :c]]) - (assert-eq (kvseq (hash-set :a)) [[:a :a]]) - (assert-eq (kvseq "abc") [[1 "a"] [2 "b"] [3 "c"]])) + (assert-not (pcall core.seq)) + (assert-not (pcall core.seq [] [])) + (assert-eq (core.seq []) nil) + (assert-eq (core.seq {}) nil) + (assert-eq (core.seq [1]) (core.list 1)) + (assert-eq (core.seq [1 2 3]) (core.list 1 2 3)) + (assert-eq (core.seq {:a 1}) (core.list (core.vec ["a" 1]))) + (assert-eq (core.seq "abc") (core.list "a" "b" "c")) + (when _G.utf8 (assert-eq (core.seq "абв") (core.list "а" "б" "в"))) + (assert-eq (core.seq {12345 123}) (core.list (core.vec [12345 123]))) + (assert-eq (core.seq (core.hash-set 1)) (core.list 1)) + (assert-eq (length (core.seq (core.hash-set 1 2 3))) 3)) (testing "mapv" - (assert-not (pcall mapv)) - (assert-not (pcall mapv #(do nil))) - (assert-eq (mapv #(* $ $) [1 2 3 4]) [1 4 9 16]) - - (assert-eq (into {} (mapv (fn [[k v]] [k (* v v)]) {:a 1 :b 2 :c 3})) - (into {} [[:a 1] [:b 4] [:c 9]])) - - (assert-eq (into {} (mapv (fn [[k1 v1] [k2 v2]] [k1 (* v1 v2)]) - {:a 1 :b 2 :c 3} - {:a -1 :b 0 :c 2})) + (assert-not (pcall core.mapv)) + (assert-not (pcall core.mapv #(do nil))) + (assert-eq (core.mapv #(* $ $) [1 2 3 4]) [1 4 9 16]) + + (assert-eq (core.into (core.hash-map) + (core.mapv (fn [[k v]] [k (* v v)]) {:a 1 :b 2 :c 3})) + (core.into (core.hash-map) + [[:a 1] [:b 4] [:c 9]])) + + (assert-eq (core.into (core.hash-map) + (core.mapv (fn [[k1 v1] [k2 v2]] [k1 (* v1 v2)]) + {:a 1 :b 2 :c 3} + {:a -1 :b 0 :c 2})) {:a -1 :b 0 :c 6}) - (assert-eq (mapv #(* $1 $2 $3) [1] [2] [-1]) [-2]) - (assert-eq (mapv string.upper ["a" "b" "c"]) ["A" "B" "C"]) - (assert-eq (mapv #(+ $1 $2 $3 $4) [1 -1] [2 -2] [3 -3] [4 -4]) [(+ 1 2 3 4) (+ -1 -2 -3 -4)]) - (assert-eq (mapv (fn [f-name s-name company position] - (.. f-name " " s-name " works as " position " at " company)) - ["Bob" "Alice"] - ["Smith" "Watson"] - ["Happy Days co." "Coffee With You"] - ["secretary" "chief officer"]) + (assert-eq (core.mapv #(* $1 $2 $3) [1] [2] [-1]) [-2]) + (assert-eq (core.mapv string.upper ["a" "b" "c"]) ["A" "B" "C"]) + (assert-eq (core.mapv #(+ $1 $2 $3 $4) [1 -1] [2 -2] [3 -3] [4 -4]) [(+ 1 2 3 4) (+ -1 -2 -3 -4)]) + (assert-eq (core.mapv (fn [f-name s-name company position] + (.. f-name " " s-name " works as " position " at " company)) + ["Bob" "Alice"] + ["Smith" "Watson"] + ["Happy Days co." "Coffee With You"] + ["secretary" "chief officer"]) ["Bob Smith works as secretary at Happy Days co." "Alice Watson works as chief officer at Coffee With You"]) - (assert-eq (table.concat (mapv string.upper "vaiv")) "VAIV")) + (assert-eq (table.concat (icollect [_ v (ipairs (core.mapv string.upper "vaiv"))] v)) "VAIV")) (testing "partition" - (assert-not (pcall partition)) - (assert-not (pcall partition 1)) - (assert-eq (partition 1 [1 2 3 4]) [[1] [2] [3] [4]]) - (assert-eq (partition 1 2 [1 2 3 4]) [[1] [3]]) - (assert-eq (partition 3 2 [1 2 3 4 5]) [[1 2 3] [3 4 5]]) - (assert-eq (partition 3 3 [0 -1 -2 -3] [1 2 3 4]) [[1 2 3] [4 0 -1]])) + (assert-not (pcall core.partition)) + (assert-not (pcall core.partition 1)) + (assert-eq (core.partition 1 [1 2 3 4]) (core.list (core.list 1) (core.list 2) (core.list 3) (core.list 4))) + (assert-eq (core.partition 1 2 [1 2 3 4]) (core.list (core.list 1) (core.list 3))) + (assert-eq (core.partition 3 2 [1 2 3 4 5]) (core.list (core.list 1 2 3) (core.list 3 4 5))) + (assert-eq (core.partition 3 3 [0 -1 -2 -3] [1 2 3 4]) (core.list (core.list 1 2 3) (core.list 4 0 -1)))) (testing "nthrest" - (assert-not (pcall nthrest)) - (assert-not (pcall nthrest [])) - (assert-eq (nthrest [1 2 3] 0) [1 2 3]) - (assert-eq (nthrest [1 2 3] 1) [2 3]) - (assert-eq (nthrest [1 2 3] 2) [3]) - (assert-eq (nthrest [1 2 3] 3) [])) + (assert-not (pcall core.nthrest)) + (assert-not (pcall core.nthrest [])) + (assert-eq (core.nthrest [1 2 3] 0) [1 2 3]) + (assert-eq (core.nthrest [1 2 3] 1) (core.list 2 3)) + (assert-eq (core.nthrest [1 2 3] 2) (core.list 3)) + (assert-eq (core.nthrest [1 2 3] 3) (core.list))) (testing "take" - (assert-not (pcall take)) - (assert-not (pcall take [])) - (assert-not (pcall take :a [])) - (assert-not (pcall take -1 [])) - (assert-eq (take 0 [1 2 3]) []) - (assert-eq (take 1 {:a 1}) [[:a 1]]) - (assert-eq (take 10 [1 2 3]) [1 2 3]) - (assert-eq (take 1 [1 2 3]) [1])) + (assert-not (pcall core.take)) + (assert-is (core.take [])) + (assert-not (pcall core.dorun (core.take :a []))) + (assert-is (core.take -1 [])) + (assert-eq (core.take 0 [1 2 3]) []) + (assert-eq (core.take 1 {:a 1}) (core.list [:a 1])) + (assert-eq (core.take 10 [1 2 3]) (core.list 1 2 3)) + (assert-eq (core.take 1 [1 2 3]) (core.list 1))) (testing "reduce" - (fn* add - ([] 0) - ([a] a) - ([a b] (+ a b)) - ([a b & c] - (var res (+ a b)) - (each [_ v (ipairs c)] - (set res (+ res v))) - res)) - - (assert-eq (reduce add []) 0) - (assert-eq (reduce add [1]) 1) - (assert-eq (reduce add [1 2]) 3) - (assert-eq (reduce add (range 10)) 45) - (assert-eq (reduce add -3 (range 10)) 42) - (assert-eq (reduce add 10 []) 10) - (assert-eq (reduce add 10 [1]) 11) - (assert-eq (reduce add 10 nil) 10) - (assert-not (pcall reduce)) - (assert-not (pcall reduce add))) + (assert-eq (core.reduce core.add []) 0) + (assert-eq (core.reduce core.add [1]) 1) + (assert-eq (core.reduce core.add [1 2]) 3) + (assert-eq (core.reduce core.add (core.range 10)) 45) + (assert-eq (core.reduce core.add -3 (core.range 10)) 42) + (assert-eq (core.reduce core.add 10 []) 10) + (assert-eq (core.reduce core.add 10 [1]) 11) + (assert-eq (core.reduce core.add 10 nil) 10) + (assert-not (pcall core.reduce)) + (assert-not (pcall core.reduce core.add))) (testing "reduce reference implementation" (fn mapping [f] @@ -369,462 +293,609 @@ (fn -reduce [f init [x & tbl]] (if x (-reduce f (f init x) tbl) init)) - (assert-eq (reduce add (range 10)) (-reduce add 0 (range 10))) - (assert-eq (reduce ((mapping inc) add) 0 (range 10)) - (-reduce ((mapping inc) add) 0 (range 10)))) + (assert-eq (core.reduce core.add (core.range 10)) (-reduce core.add 0 (core.range 10))) + (assert-eq (core.reduce ((mapping core.inc) core.add) 0 (core.range 10)) + (-reduce ((mapping core.inc) core.add) 0 (core.range 10)))) (testing "filter" - (assert-not (pcall filter)) - (assert-not (pcall filter even?)) - (assert-eq (filter even? (range 10)) [0 2 4 6 8]) - (assert-eq (filter odd? (range 10)) [1 3 5 7 9]) - (assert-eq (filter map? [{:a 1} {5 1} [1 2] [] {}]) [{:a 1} {5 1}]) - (assert-eq (filter vector? [{:a 1} {5 1} [1 2] [] {}]) [[1 2]])) + (assert-not (pcall core.filter)) + (assert-is (core.filter core.even?)) + (assert-eq (core.filter core.even? (core.range 10)) (core.list 0 2 4 6 8)) + (assert-eq (core.filter core.odd? (core.range 10)) (core.list 1 3 5 7 9)) + (assert-eq (core.filter core.map? [{:a 1} {5 1} [1 2] [] {}]) (core.list {:a 1} {5 1})) + (assert-eq (core.filter core.vector? [{:a 1} {5 1} [1 2] [] {}]) (core.list [1 2]))) (testing "concat" - (assert-eq (concat) nil) - (assert-eq (concat []) []) - (assert-eq (concat [1 2 3]) [1 2 3]) - (assert-eq (concat [1 2 3] [4 5 6]) [1 2 3 4 5 6]) - (assert-eq (concat [1 2] [3 4] [5 6]) [1 2 3 4 5 6]) - (assert-eq (concat {:a 1} {:b 2}) [[:a 1] [:b 2]]) - (assert-eq (concat [[:a 1]] {:b 2}) [[:a 1] [:b 2]]) - (assert-eq (concat {:a 1} [[:b 2]]) [[:a 1] [:b 2]]) - (assert-eq (concat [] [[:b 2]]) [[:b 2]]) - (assert-eq (concat [] []) []) - (assert-not (pcall concat 1)) - (assert-not (pcall concat 1 2)) - (assert-not (pcall concat 1 [])) - (assert-not (pcall concat [] 2)) - (assert-not (pcall concat [1] 2))) + (assert-eq (core.concat) (core.list)) + (assert-eq (core.concat []) (core.list)) + (assert-eq (core.concat [1 2 3]) (core.list 1 2 3)) + (assert-eq (core.concat [1 2 3] [4 5 6]) (core.list 1 2 3 4 5 6)) + (assert-eq (core.concat [1 2] [3 4] [5 6]) (core.list 1 2 3 4 5 6)) + (assert-eq (core.concat {:a 1} {:b 2}) (core.list [:a 1] [:b 2])) + (assert-eq (core.concat [[:a 1]] {:b 2}) (core.list [:a 1] [:b 2])) + (assert-eq (core.concat {:a 1} [[:b 2]]) (core.list [:a 1] [:b 2])) + (assert-eq (core.concat [] [[:b 2]]) (core.list [:b 2])) + (assert-eq (core.concat [] []) (core.list)) + (assert-not (pcall core.dorun (core.concat 1))) + (assert-not (pcall core.dorun (core.concat 1 2))) + (assert-not (pcall core.dorun (core.concat 1 []))) + (assert-not (pcall core.dorun (core.concat [] 2))) + (assert-not (pcall core.dorun (core.concat [1] 2)))) (testing "reverse" - (assert-not (pcall reverse)) - (assert-not (pcall reverse [] [])) - (assert-eq (reverse []) nil) - (assert-eq (reverse [1 2 3]) [3 2 1]) - (assert-eq (reverse {:a 1}) [[:a 1]])) + (assert-not (pcall core.reverse)) + (assert-not (pcall core.reverse [] [])) + (assert-eq (core.reverse []) (core.list)) + (assert-eq (core.reverse [1 2 3]) (core.list 3 2 1)) + (assert-eq (core.reverse {:a 1}) (core.list [:a 1]))) (testing "conj" - (assert-eq (conj) []) - (assert-eq (conj [1]) [1]) - (assert-eq (conj [] 1 2 3) [1 2 3]) - (assert-eq (conj [0] 1 2 3) [0 1 2 3]) - (assert-eq (conj {:a 1} [:b 2]) {:a 1 :b 2}) - (assert-eq (conj {:a 1}) {:a 1}) - (assert-eq (conj [1] 2 3 4 5 6 7) [1 2 3 4 5 6 7])) + (assert-eq (core.conj) []) + (assert-eq (core.conj [1]) [1]) + (assert-eq (core.conj (core.vector) 1 2 3) [1 2 3]) + (assert-eq (core.conj [0] 1 2 3) [0 1 2 3]) + (assert-eq (core.conj {:a 1} [:b 2]) {:a 1 :b 2}) + (assert-eq (core.conj {:a 1}) {:a 1}) + (assert-eq (core.conj [1] 2 3 4 5 6 7) [1 2 3 4 5 6 7])) (testing "disj" - (assert-not (pcall disj)) - (assert-not (pcall disj [1])) - (assert-not (pcall disj [1] 1)) - (assert-eq (disj (ordered-set)) (ordered-set)) - (assert-eq (disj (ordered-set 1 3 2 5) 3) (ordered-set 1 2 5)) - (assert-eq (disj (ordered-set 1 3 2 5) 3 1 5) (ordered-set 2))) + (assert-not (pcall core.disj)) + (assert-is (core.disj [1])) + (assert-not (pcall core.disj [1] 1)) + (assert-eq (core.disj (core.hash-set)) (core.hash-set)) + (assert-eq (core.disj (core.hash-set 1 3 2 5) 3) (core.hash-set 1 2 5)) + (assert-eq (core.disj (core.hash-set 1 3 2 5) 3 1 5) (core.hash-set 2))) (testing "cons" - (assert-not (pcall cons)) - (assert-not (pcall cons [] [] [])) - (assert-eq (cons nil [1]) [1]) - (assert-eq (cons 1 []) [1]) - (assert-eq (cons 1 [0]) [1 0])) + (assert-not (pcall core.cons)) + (assert-not (pcall core.cons [] [] [])) + (assert-eq (core.cons nil [1]) (core.list nil 1)) + (assert-eq (core.cons 1 []) (core.list 1)) + (assert-eq (core.cons 1 [0]) (core.list 1 0))) (testing "first" - (assert-not (pcall first)) - (assert-not (pcall first [] [])) - (assert-eq (first [1 2 3]) 1) - (assert-eq (first {:a 1}) [:a 1]) - (assert-eq (first []) nil)) + (assert-not (pcall core.first)) + (assert-not (pcall core.first [] [])) + (assert-eq (core.first [1 2 3]) 1) + (assert-eq (core.first {:a 1}) [:a 1]) + (assert-eq (core.first []) nil)) (testing "last" - (assert-not (pcall last)) - (assert-not (pcall last [] [])) - (assert-eq (last [1 2 3]) 3) - (assert-eq (last []) nil) - (assert-eq (last nil) nil) - (assert-eq (last {:a 1}) [:a 1])) + (assert-not (pcall core.last)) + (assert-not (pcall core.last [] [])) + (assert-eq (core.last [1 2 3]) 3) + (assert-eq (core.last []) nil) + (assert-eq (core.last nil) nil) + (assert-eq (core.last {:a 1}) [:a 1])) (testing "rest" - (assert-not (pcall rest)) - (assert-not (pcall rest [] [])) - (assert-eq (rest [1 2 3]) [2 3]) - (assert-eq (rest {:a 1}) []) - (assert-eq (rest []) []) - (assert-eq (rest nil) [])) + (assert-not (pcall core.rest)) + (assert-not (pcall core.rest [] [])) + (assert-eq (core.rest [1 2 3]) (core.list 2 3)) + (assert-eq (core.rest {:a 1}) (core.list)) + (assert-eq (core.rest []) (core.list)) + (assert-eq (core.rest nil) (core.list))) (testing "butlast" - (assert-not (pcall butlast)) - (assert-not (pcall butlast [] [])) - (assert-eq (butlast [1 2 3]) [1 2]) - (assert-eq (butlast {:a 1}) nil) - (assert-eq (butlast []) nil) - (assert-eq (butlast nil) nil)) + (assert-not (pcall core.butlast)) + (assert-not (pcall core.butlast [] [])) + (assert-eq (core.butlast [1 2 3]) (core.list 1 2)) + (assert-eq (core.butlast {:a 1}) nil) + (assert-eq (core.butlast []) nil) + (assert-eq (core.butlast nil) nil)) (testing "reduce-kv" - (assert-eq (reduce-kv #(+ $1 $3) 0 {:a 1 :b 2 :c 3}) 6) - (assert-eq (reduce-kv #(+ $1 $3) 0 [1 2 3]) 6) - (assert-not (pcall reduce-kv #(+ $1 $3) 0)) - (assert-not (pcall reduce-kv #(+ $1 $3))) - (assert-not (pcall reduce-kv))) + (assert-eq (core.reduce-kv #(+ $1 $3) 0 {:a 1 :b 2 :c 3}) 6) + (assert-eq (core.reduce-kv #(+ $1 $3) 0 [1 2 3]) 6) + (assert-not (pcall core.reduce-kv #(+ $1 $3) 0)) + (assert-not (pcall core.reduce-kv #(+ $1 $3))) + (assert-not (pcall core.reduce-kv))) (testing "reduced" - (assert-not (pcall reduced)) - (assert-not (pcall reduced 1 2 3)) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) [1]) 1) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) [1 2]) 3) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) [1 2 3 4]) 10) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) [1 2 3 4 5]) 15) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) [1 2 3 4 5 6]) -1) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) 10 [1]) 11) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) 10 [1 2]) -1) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) 0 [10 5]) 15) - (assert-eq (reduce #(if (> $1 10) (reduced -1) (+ $1 $2)) 1 [10 7]) -1) - - (assert-eq (reduce #(if (> $1 10) (reduced false) (+ $1 $2)) 1 [10 7]) false) - (assert-eq (reduce #(if (> $1 10) (reduced nil) (+ $1 $2)) 1 [10 7]) nil) - - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced -1) (+ res v))) 0 {:a 1 :b 2}) 3) - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced -1) (+ res v))) 0 {:a 10 :b 2}) 12) - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced -1) (+ res v))) 1 {:a 3 :b 3 :c 3 :d 3}) 13) - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced -1) (+ res v))) 2 {:a 3 :b 3 :c 3 :d 3}) -1) - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced -1) (+ res v))) 1 [10 12]) -1) - - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced false) (+ res v))) 1 [10 12]) false) - (assert-eq (reduce-kv (fn [res _ v] (if (> res 10) (reduced nil) (+ res v))) 1 [10 12]) nil)) + (assert-not (pcall core.reduced)) + (assert-not (pcall core.reduced 1 2 3)) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) [1]) 1) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) [1 2]) 3) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) [1 2 3 4]) 10) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) [1 2 3 4 5]) 15) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) [1 2 3 4 5 6]) -1) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) 10 [1]) 11) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) 10 [1 2]) -1) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) 0 [10 5]) 15) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced -1) (+ $1 $2)) 1 [10 7]) -1) + + (assert-eq (core.reduce #(if (> $1 10) (core.reduced false) (+ $1 $2)) 1 [10 7]) false) + (assert-eq (core.reduce #(if (> $1 10) (core.reduced nil) (+ $1 $2)) 1 [10 7]) nil) + + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced -1) (+ res v))) 0 {:a 1 :b 2}) 3) + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced -1) (+ res v))) 0 {:a 10 :b 2}) 12) + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced -1) (+ res v))) 1 {:a 3 :b 3 :c 3 :d 3}) 13) + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced -1) (+ res v))) 2 {:a 3 :b 3 :c 3 :d 3}) -1) + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced -1) (+ res v))) 1 [10 12]) -1) + + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced false) (+ res v))) 1 [10 12]) false) + (assert-eq (core.reduce-kv (fn [res _ v] (if (> res 10) (core.reduced nil) (+ res v))) 1 [10 12]) nil)) (testing "assoc" - (assert-not (pcall assoc)) - (assert-not (pcall assoc {})) - (assert-eq (assoc {} :a 1) {:a 1}) - (assert-eq (assoc {} :a 1 :b 2 :c 3 :d 4) {:a 1 :b 2 :c 3 :d 4})) + (assert-not (pcall core.assoc)) + (assert-is (core.assoc {})) + (assert-eq (core.assoc {} :a 1) {:a 1}) + (assert-eq (core.assoc {} :a 1 :b 2 :c 3 :d 4) {:a 1 :b 2 :c 3 :d 4})) (testing "dissoc" - (assert-not (pcall dissoc)) - (assert-eq (dissoc {}) {}) - (assert-eq (dissoc {:a 1 :b 2} :b) {:a 1}) - (assert-eq (dissoc {:a 1 :b 2 :c 3} :a :c) {:b 2})) + (assert-not (pcall core.dissoc)) + (assert-eq (core.dissoc {}) {}) + (assert-eq (core.dissoc {:a 1 :b 2} :b) {:a 1}) + (assert-eq (core.dissoc {:a 1 :b 2 :c 3} :a :c) {:b 2})) (testing "find, keys and vals" - (assert-not (pcall keys)) - (assert-not (pcall keys {} {} {})) - (assert-not (pcall vals)) - (assert-not (pcall vals {} {} {})) - (assert-not (pcall find)) - (assert-not (pcall find {} {} {})) - (assert-eq (keys {:a 1}) [:a]) - (assert-eq (vals {:a 1}) [1]) - (match (pcall #(assert-eq (keys {:a 1 :b 2 :c 3}) (hash-set :a :b :c))) - (false msg) (io.stderr:write "WARNING: " msg)) - (match (pcall #(assert-eq (vals {:a 1 :b 2 :c 3}) (hash-set 1 2 3))) - (false msg) (io.stderr:write "WARNING: " msg)) - (assert-eq (find {:a 1 :b 2 :c 3} :c) [:c 3]) - (assert-eq (find {:a 1 :b 2 :c 3} :d) nil))) - - -(deftest test-function-manipulation + (assert-not (pcall core.keys)) + (assert-not (pcall core.keys {} {} {})) + (assert-not (pcall core.vals)) + (assert-not (pcall core.vals {} {} {})) + (assert-not (pcall core.find)) + (assert-not (pcall core.find {} {} {})) + (assert-eq (core.keys {:a 1}) (core.list :a)) + (assert-eq (core.vals {:a 1}) (core.list 1)) + (assert-eq (core.keys {:a 1}) (core.list :a)) + (assert-eq (core.vals {:a 1}) (core.list 1)) + (assert-eq (core.find {:a 1 :b 2 :c 3} :c) [:c 3]) + (assert-eq (core.find {:a 1 :b 2 :c 3} :d) nil))) + +(deftest transients + (testing "transient from collections" + (assert-is (core.transient (core.vector))) + (assert-is (core.transient (core.hash-map))) + (assert-is (core.transient (core.hash-set))) + (assert-not (pcall core.transient [])) + (assert-not (pcall core.transient (core.list)))) + + (testing "transient conj!" + (assert-eq (core.conj!) (core.transient (core.vector))) + (assert-eq (core.conj! (core.transient (core.vec [1]))) []) + (assert-eq (core.conj! (core.transient (core.vector)) 1) [1]) + (assert-eq (core.conj! (core.transient (core.vec [0])) 1) [nil 1]) + (assert-eq (core.conj! (core.transient (core.hash-map :a 1)) [:b 2]) {:b 2}) + (assert-eq (. (core.conj! (core.transient (core.hash-map :a 1)) [:a 2]) :a) 2) + (assert-eq (core.conj! (core.transient (core.hash-map :a 1))) {}) + (assert-eq (. (core.conj! (core.transient (core.hash-map :a 1))) :a) 1)) + + (testing "transient disj!" + (assert-not (pcall core.disj!)) + (assert-is (core.disj! [1])) + (assert-not (pcall core.disj! [1] 1)) + (assert-eq (core.disj! (core.transient (core.hash-set))) (core.hash-set)) + (assert-eq (core.disj! (core.transient (core.hash-set 1 3 2 5)) 3) {}) + (assert-eq (. (core.disj! (core.transient (core.hash-set 1 3 2 5)) 3) 2) 2) + (assert-eq (. (core.disj! (core.transient (core.hash-set 1 3 2 5)) 3) 3) nil)) + + (testing "transient pop!" + (assert-not (pcall core.pop!)) + (assert-is (core.pop! (core.transient (core.vec [1])))) + (assert-not (pcall core.pop! [1] 1)) + (assert-not (pcall core.pop! (core.transient (core.vector)))) + (assert-eq (core.pop! (-> (core.transient (core.vector)) + (core.conj! 1) + (core.conj! 2) + (core.conj! 3))) + [1 2])) + + (testing "transient can't be modified after persisted" + (let [t (core.transient (core.vector))] + (core.persistent! t) + (assert-not (pcall core.conj! t 10)) + (assert-not (pcall #(tset $1 (length $1) $2) t 10))) + (let [t (core.transient (core.hash-map))] + (core.persistent! t) + (assert-not (pcall core.conj! t 10)) + (assert-not (pcall #(tset $1 (length $1) $2) t 10))) + (let [t (core.transient (core.hash-set))] + (core.persistent! t) + (assert-not (pcall core.conj! t 10)) + (assert-not (pcall #(tset $1 (length $1) $2) t 10))))) + +(deftest test-into + (testing "into" + (assert-eq (core.into [] nil) []) + (assert-eq (core.into nil nil) nil) + (assert-eq (core.into nil [1 2 3]) (core.list 3 2 1)) + + (assert-eq (core.into [] []) []) + (assert-eq (core.into [1 2 3] []) [1 2 3]) + (assert-eq (core.into [1 2 3] [4 5 6]) [1 2 3 4 5 6]) + + (assert-eq (core.into {} {}) {}) + (assert-eq (core.into {:a 1} {}) {:a 1}) + (assert-eq (core.into {:a 1} {:b 2}) {:a 1 :b 2}) + + ;; different bodies are being used at compile time so worth testing + (assert-eq (core.into [] {}) []) + (assert-eq (core.into {} []) []) + (assert-eq (. (getmetatable (core.into (core.vector) {})) :cljlib/type) :vector) + (assert-eq (. (getmetatable (core.into (core.hash-map) [])) :cljlib/type) :hash-map) + (let [a (core.vector)] + (assert-eq (. (getmetatable (core.into a a)) :cljlib/type) :vector)) + + ;; can't transform table with more than one key-value pair, as order + ;; is undeterminitive + (assert-eq (core.into [] {:a 1}) [[:a 1]]) + (assert-eq (core.into [[:b 2]] {:a 1}) [[:b 2] [:a 1]]) + (assert-eq (core.into [[:c 3]] {}) [[:c 3]]) + + (assert-eq (core.into (core.hash-map) [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3}) + (assert-eq (core.into {:d 4} [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3 :d 4}) + (assert-eq (core.into {:a 0 :b 0 :c 0} [[:c 3] [:a 1] [:b 2]]) {:a 1 :b 2 :c 3}) + + (let [a (fn [] {:a 1}) + b (fn [] [[:b 2]])] + (assert-eq (core.into (a) (b)) {:a 1 :b 2}) + (assert-eq (core.into (b) (a)) [[:b 2] [:a 1]]) + (let [c []] + (assert-eq (core.into c (b)) [[:b 2]])) + (let [c []] + (assert-eq (core.into c (a)) [[:a 1]])) + (let [c []] + (assert-eq (core.into (b) c) (b)) + (assert-eq (core.into (a) c) (a)))) + + (let [a {} + b []] + (assert-eq (core.into a [1 2 3]) [1 2 3]) + (assert-eq (core.into b [1 2 3]) [1 2 3])) + (let [a {} + b []] + (assert-eq (core.into b {:a 1}) [[:a 1]])) + + (let [a {} + b []] + (assert-eq (core.into a "vaiv") ["v" "a" "i" "v"]) + (when _G.utf8 (assert-eq (core.into b "ваыв") ["в" "а" "ы" "в"]))) + (assert-eq (core.into [] "vaiv") ["v" "a" "i" "v"]) + (when _G.utf8 (assert-eq (core.into [] "ваыв") ["в" "а" "ы" "в"])))) + +(deftest transducers-test + (testing "transduce" + (assert-eq (core.transduce (core.map core.inc) + core.conj + (core.vector) + (core.vector 1 2 3)) + [2 3 4]) + (assert-eq (core.transduce (core.comp (core.map core.inc) + (core.filter core.odd?)) + core.conj + (core.vector) + (core.vector 1 2 3)) + [3])) + (testing "sequence" + (assert-eq (core.sequence (core.map core.inc) + (core.vector 1 2 3)) + (core.list 2 3 4)) + (assert-eq (core.sequence (core.comp (core.map core.inc) + (core.filter core.odd?)) + (core.vector 1 2 3)) + (core.list 3))) + (testing "into" + (assert-eq (core.into (core.vector) + (core.map core.inc) + (core.vector 1 2 3)) + [2 3 4]) + (assert-eq (core.into (core.vector) + (core.comp (core.map core.inc) + (core.filter core.odd?)) + (core.vector 1 2 3)) + [3]))) + +(deftest class-test + (testing "class" + (assert-eq (core.class (core.hash-set)) "hash-set") + (assert-eq (core.class (core.hash-map)) "hash-map") + (assert-eq (core.class (core.vector)) "vector") + (assert-eq (core.class [1 2 3]) "table"))) + +(deftest deref-test + (assert-not (pcall core.deref [])) + (assert-eq 10 (core.deref (core.reduced 10)))) + +(deftest function-manipulation-test (testing "constantly" - (assert-not (pcall constantly)) - (assert-not (pcall constantly nil nil)) - (let [always-nil (constantly nil)] + (assert-not (pcall core.constantly)) + (assert-not (pcall core.constantly nil nil)) + (let [always-nil (core.constantly nil)] (assert-eq (always-nil) nil) (assert-eq (always-nil 1) nil) (assert-eq (always-nil 1 2 3 4 "5") nil)) - (let [always-true (constantly true)] + (let [always-true (core.constantly true)] (assert-is (always-true)) (assert-is (always-true false)))) (testing "complement" - (assert-not (pcall complement)) - (assert-not (pcall complement #nil #nil)) - (assert-is ((complement #(do false)))) - (assert-is ((complement nil?) 10)) - (assert-is ((complement every?) double? [1 2 3 4])) - (assert-is ((complement #(= $1 $2 $3)) 1 1 2 1)) - (assert-is ((complement #(= $1 $2)) 1 2))) + (assert-not (pcall core.complement)) + (assert-not (pcall core.complement #nil #nil)) + (assert-is ((core.complement #(do false)))) + (assert-is ((core.complement core.nil?) 10)) + (assert-is ((core.complement core.every?) core.double? [1 2 3 4])) + (assert-is ((core.complement #(= $1 $2 $3)) 1 1 2 1)) + (assert-is ((core.complement #(= $1 $2)) 1 2))) (testing "apply" - (fn* add - ([x] x) - ([x y] (+ x y)) - ([x y & zs] - (add (+ x y) ((or _G.unpack table.unpack) zs)))) - (assert-eq (apply add [1 2 3 4]) 10) - (assert-eq (apply add -1 [1 2 3 4]) 9) - (assert-eq (apply add -2 -1 [1 2 3 4]) 7) - (assert-eq (apply add -3 -2 -1 [1 2 3 4]) 4) - (assert-eq (apply add -4 -3 -2 -1 [1 2 3 4]) 0) - (assert-eq (apply add -5 -4 -3 -2 -1 [1 2 3 4]) -5) - (assert-not (pcall apply)) - (assert-not (pcall apply add))) + (assert-eq (core.apply core.add [1 2 3 4]) 10) + (assert-eq (core.apply core.add -1 [1 2 3 4]) 9) + (assert-eq (core.apply core.add -2 -1 [1 2 3 4]) 7) + (assert-eq (core.apply core.add -3 -2 -1 [1 2 3 4]) 4) + (assert-eq (core.apply core.add -4 -3 -2 -1 [1 2 3 4]) 0) + (assert-eq (core.apply core.add -5 -4 -3 -2 -1 [1 2 3 4]) -5) + (assert-eq (core.apply core.add -7 -6 -5 -4 -3 -2 -1 [1 2 3 4]) -18) + (assert-not (pcall core.apply)) + (assert-not (pcall core.apply core.add))) (testing "comp" - (assert-eq ((comp) 10) 10) - (assert-eq ((comp #10)) 10) + (assert-eq ((core.comp) 10) 10) + (assert-eq ((core.comp #10)) 10) (fn square [x] (* x x)) - (assert-eq (comp square) square) - (assert-eq ((comp square inc) 6) 49) - (assert-eq ((comp #(- $ 7) square inc inc inc inc inc inc inc) 0) 42) + (assert-eq (core.comp square) square) + (assert-eq ((core.comp square core.inc) 6) 49) + (assert-eq ((core.comp #(- $ 7) square core.inc core.inc core.inc core.inc core.inc core.inc core.inc) 0) 42) (fn sum-squares [x y] (+ (* x x) (* y y))) - (assert-eq ((comp square inc sum-squares) 2 3) 196) + (assert-eq ((core.comp square core.inc sum-squares) 2 3) 196) (fn f [a b c] (+ a b c)) - (assert-eq ((comp inc f) 1 2 3) 7) + (assert-eq ((core.comp core.inc f) 1 2 3) 7) (fn g [a b c d] (+ a b c d)) - (assert-eq ((comp inc g) 1 2 3 4) 11) + (assert-eq ((core.comp core.inc g) 1 2 3 4) 11) (fn h [a b c d e f] (+ a b c d e f)) - (assert-eq ((comp inc h) 1 2 3 4 5 6) 22)) + (assert-eq ((core.comp core.inc h) 1 2 3 4 5 6) 22)) (testing "identity" (fn f [] nil) (local a {}) - (assert-not (pcall identity)) - (assert-not (pcall identity 1 2)) - (assert-eq (identity 1) 1) - (assert-eq (identity {:a 1 :b 2}) {:a 1 :b 2}) - (assert-eq (identity [1 2 3]) [1 2 3]) - (assert-eq (identity "abc") "abc") - (assert-eq (identity f) f) - (assert-eq (identity a) a))) + (assert-not (pcall core.identity)) + (assert-not (pcall core.identity 1 2)) + (assert-eq (core.identity 1) 1) + (assert-eq (core.identity {:a 1 :b 2}) {:a 1 :b 2}) + (assert-eq (core.identity [1 2 3]) [1 2 3]) + (assert-eq (core.identity "abc") "abc") + (assert-eq (core.identity f) f) + (assert-eq (core.identity a) a))) (deftest test-sequence-predicates (testing "some" - (assert-not (pcall some)) - (assert-not (pcall some pos-int?)) - (assert-is (some pos-int? [-1 1.1 2.3 -55 42 10 -27])) - (assert-not (some pos-int? {:a 1})) - (assert-is (some pos-int? [{:a 1} "1" -1 1]))) + (assert-not (pcall core.some)) + (assert-not (pcall core.some core.pos-int?)) + (assert-is (core.some core.pos-int? [-1 1.1 2.3 -55 42 10 -27])) + (assert-not (core.some core.pos-int? {:a 1})) + (assert-is (core.some core.pos-int? [{:a 1} "1" -1 1]))) (testing "not-any?" - (assert-not (pcall not-any?)) - (assert-not (pcall not-any? pos-int?)) - (assert-is (not-any? pos-int? [-1 1.1 2.3 -55 -42 -10 -27])) - (assert-is (not-any? pos-int? {:a 1})) - (assert-not (not-any? pos-int? [1 2 3 4 5]))) + (assert-not (pcall core.not-any?)) + (assert-not (pcall core.not-any? core.pos-int?)) + (assert-is (core.not-any? core.pos-int? [-1 1.1 2.3 -55 -42 -10 -27])) + (assert-is (core.not-any? core.pos-int? {:a 1})) + (assert-not (core.not-any? core.pos-int? [1 2 3 4 5]))) (testing "every?" - (assert-not (pcall every?)) - (assert-not (pcall every? pos-int?)) - (assert-not (every? pos-int? [-1 1.1 2.3 -55 42 10 -27])) - (assert-not (every? pos-int? {:a 1})) - (assert-is (every? pos-int? [1 2 3 4 5]))) + (assert-not (pcall core.every?)) + (assert-not (pcall core.every? core.pos-int?)) + (assert-not (core.every? core.pos-int? [-1 1.1 2.3 -55 42 10 -27])) + (assert-not (core.every? core.pos-int? {:a 1})) + (assert-is (core.every? core.pos-int? [1 2 3 4 5]))) (testing "empty?" - (assert-not (pcall empty?)) - (assert-is (empty? [])) - (assert-is (empty? {})) - (assert-is (empty? "")) - (assert-not (empty? "1")) - (assert-not (empty? [1])) - (assert-not (empty? {:a 1})) - (assert-not (pcall empty? 10))) + (assert-not (pcall core.empty?)) + (assert-is (core.empty? [])) + (assert-is (core.empty? {})) + (assert-is (core.empty? "")) + (assert-not (core.empty? "1")) + (assert-not (core.empty? [1])) + (assert-not (core.empty? {:a 1})) + (assert-not (pcall core.empty? 10))) (testing "not-empty" - (assert-not (pcall not-empty)) - (assert-eq (not-empty []) nil) - (assert-eq (not-empty {}) nil) - (assert-eq (not-empty "") nil) - (assert-eq (not-empty "1") "1") - (assert-eq (not-empty [1]) [1]) - (assert-eq (not-empty {:a 1}) {:a 1}))) + (assert-not (pcall core.not-empty)) + (assert-eq (core.not-empty []) nil) + (assert-eq (core.not-empty {}) nil) + (assert-eq (core.not-empty "") nil) + (assert-eq (core.not-empty "1") "1") + (assert-eq (core.not-empty [1]) [1]) + (assert-eq (core.not-empty {:a 1}) {:a 1}))) (deftest test-math-functions (testing "inc" - (assert-eq (inc 1) 2) - (assert-eq (inc -1) 0) - (assert-not (pcall inc)) - (assert-not (pcall inc nil))) + (assert-eq (core.inc 1) 2) + (assert-eq (core.inc -1) 0) + (assert-not (pcall core.inc)) + (assert-not (pcall core.inc nil))) (testing "dec" - (assert-eq (dec 1) 0) - (assert-eq (dec -1) -2) - (assert-not (pcall dec)) - (assert-not (pcall dec nil)))) + (assert-eq (core.dec 1) 0) + (assert-eq (core.dec -1) -2) + (assert-not (pcall core.dec)) + (assert-not (pcall core.dec nil)))) (deftest test-table-access (testing "get" - (assert-eq (get {:key1 10 :key2 20} :key1) 10) - (assert-eq (get {:key1 10 :key2 20} :key1 false) 10) - (assert-eq (get {:key1 10 :key2 20} :key3 false) false) - (assert-eq (get {:key1 10 :key2 20} :key3) nil) - (assert-not (pcall get)) - (assert-not (pcall get {}))) + (assert-eq (core.get {:key1 10 :key2 20} :key1) 10) + (assert-eq (core.get {:key1 10 :key2 20} :key1 false) 10) + (assert-eq (core.get {:key1 10 :key2 20} :key3 false) false) + (assert-eq (core.get {:key1 10 :key2 20} :key3) nil) + (assert-not (pcall core.get)) + (assert-not (pcall core.get {}))) (testing "get-in" (local t {:a {:b {:c 10}}}) - (assert-eq (get-in t [:a]) {:b {:c 10}}) - (assert-eq (get-in t [:a :b]) {:c 10}) - (assert-eq (get-in t [:a :b :c]) 10) - (assert-eq (get-in t [:a :b :c] false) 10) - (assert-eq (get-in t [:a :b :d] false) false) - (assert-eq (get-in t [:a :b :d]) nil) - (assert-eq (get-in t []) t) - (assert-not (pcall get-in)) - (assert-not (pcall get-in {})))) + (assert-eq (core.get-in t [:a]) {:b {:c 10}}) + (assert-eq (core.get-in t [:a :b]) {:c 10}) + (assert-eq (core.get-in t [:a :b :c]) 10) + (assert-eq (core.get-in t [:a :b :c] false) 10) + (assert-eq (core.get-in t [:a :b :d] false) false) + (assert-eq (core.get-in t [:a :b :d]) nil) + (assert-eq (core.get-in t []) t) + (assert-not (pcall core.get-in)) + (assert-not (pcall core.get-in {})))) (deftest test-methods (testing "methods" - (defmulti f identity) - (defmethod f :a [_] :a) - (defmethod f :b [_] :b) - (defmethod f :c [x] (* x x)) - (assert-eq (methods f) f) - (assert-not (pcall methods)) - (assert-not (pcall methods [])) - (assert-not (pcall methods f f))) + (clj.defmulti f core.identity) + (clj.defmethod f :a [_] :a) + (clj.defmethod f :b [_] :b) + (clj.defmethod f :c [x] (* x x)) + (assert-eq (core.methods f) f) + (assert-not (pcall core.methods)) + (assert-not (pcall core.methods [])) + (assert-not (pcall core.methods f f))) (testing "get-method" - (defmulti f identity) - (defmethod f :a [_] :a) - (defmethod f :b [_] :b) - (defmethod f :c [x] (* x x)) - (assert-eq ((get-method f :a) 10) :a) - (assert-eq ((get-method f :b) 20) :b) - (assert-eq ((get-method f :c) 4) 16) - (assert-not (pcall get-method)) - (assert-not (pcall get-method [])) - (assert-not (pcall get-method [] :a)) - (assert-not (pcall get-method f)) - (assert-not (pcall get-method f :a :b))) + (clj.defmulti f core.identity) + (clj.defmethod f :a [_] :a) + (clj.defmethod f :b [_] :b) + (clj.defmethod f :c [x] (* x x)) + (assert-eq ((core.get-method f :a) 10) :a) + (assert-eq ((core.get-method f :b) 20) :b) + (assert-eq ((core.get-method f :c) 4) 16) + (assert-not (pcall core.get-method)) + (assert-not (pcall core.get-method [])) + (assert-not (pcall core.get-method [] :a)) + (assert-not (pcall core.get-method f)) + (assert-not (pcall core.get-method f :a :b))) (testing "remove-method" - (defmulti f identity) - (defmethod f :a [_] :a) - (defmethod f :b [_] :b) - (remove-method f :a) - (assert-eq (get-method f :a) nil) - (defmethod f :default [_] :default) - (assert-eq (get-method f :a) (get-method f :default)) - (assert-not (pcall remove-method)) - (assert-not (pcall remove-method [])) - (assert-not (pcall remove-method [] :a)) - (assert-not (pcall remove-method f)) - (assert-not (pcall remove-method f :a :b))) + (clj.defmulti f core.identity) + (clj.defmethod f :a [_] :a) + (clj.defmethod f :b [_] :b) + (core.remove-method f :a) + (assert-eq (core.get-method f :a) nil) + (clj.defmethod f :default [_] :default) + (assert-eq (core.get-method f :a) (core.get-method f :default)) + (assert-not (pcall core.remove-method)) + (assert-not (pcall core.remove-method [])) + (assert-not (pcall core.remove-method [] :a)) + (assert-not (pcall core.remove-method f)) + (assert-not (pcall core.remove-method f :a :b))) (testing "remove-all-methods" - (defmulti f identity) - (defmethod f :a [_] :a) - (defmethod f :b [_] :b) - (defmethod f :default [_] :default) - (remove-all-methods f) - (assert-eq (methods f) {}) - (assert-not (pcall remove-all-methods)) - (assert-not (pcall remove-all-methods [])) - (assert-not (pcall remove-all-methods f f)))) + (clj.defmulti f core.identity) + (clj.defmethod f :a [_] :a) + (clj.defmethod f :b [_] :b) + (clj.defmethod f :default [_] :default) + (core.remove-all-methods f) + (assert-eq (core.methods f) {}) + (assert-not (pcall core.remove-all-methods)) + (assert-not (pcall core.remove-all-methods [])) + (assert-not (pcall core.remove-all-methods f f)))) (deftest test-math-functions (testing "add" - (assert-eq (add) 0) - (assert-eq (add 1) 1) - (assert-eq (add -1) -1) - (assert-eq (add 1 2) 3) - (assert-eq (add 1 2 3) 6) - (assert-eq (add 1 2 3 4) 10) - (assert-eq (add 1 2 3 4 5) 15)) + (assert-eq (core.add) 0) + (assert-eq (core.add 1) 1) + (assert-eq (core.add -1) -1) + (assert-eq (core.add 1 2) 3) + (assert-eq (core.add 1 2 3) 6) + (assert-eq (core.add 1 2 3 4) 10) + (assert-eq (core.add 1 2 3 4 5) 15)) (testing "sub" - (assert-eq (sub) 0) - (assert-eq (sub 1) -1) - (assert-eq (sub -1) 1) - (assert-eq (sub 1 2) -1) - (assert-eq (sub 1 2 3) -4) - (assert-eq (sub 1 2 3 4) -8) - (assert-eq (sub 1 2 3 4 5) -13)) + (assert-eq (core.sub) 0) + (assert-eq (core.sub 1) -1) + (assert-eq (core.sub -1) 1) + (assert-eq (core.sub 1 2) -1) + (assert-eq (core.sub 1 2 3) -4) + (assert-eq (core.sub 1 2 3 4) -8) + (assert-eq (core.sub 1 2 3 4 5) -13)) (testing "mul" - (assert-eq (mul) 1) - (assert-eq (mul 1) 1) - (assert-eq (mul -1) -1) - (assert-eq (mul 1 2) 2) - (assert-eq (mul 1 2 3) 6) - (assert-eq (mul 1 2 3 4) 24) - (assert-eq (mul 1 2 3 4 5) 120)) + (assert-eq (core.mul) 1) + (assert-eq (core.mul 1) 1) + (assert-eq (core.mul -1) -1) + (assert-eq (core.mul 1 2) 2) + (assert-eq (core.mul 1 2 3) 6) + (assert-eq (core.mul 1 2 3 4) 24) + (assert-eq (core.mul 1 2 3 4 5) 120)) (testing "div" - (assert-not (pcall div)) - (assert-eq (div 1) 1) - (assert-eq (div -1) -1) - (assert-eq (div 1 2) (/ 1 2)) - (assert-eq (div 1 2 3) (/ 1 2 3)) - (assert-eq (div 1 2 3 4) (/ 1 2 3 4)) - (assert-eq (div 1 2 3 4 5) (/ 1 2 3 4 5)))) + (assert-not (pcall core.div)) + (assert-eq (core.div 1) 1) + (assert-eq (core.div -1) -1) + (assert-eq (core.div 1 2) (/ 1 2)) + (assert-eq (core.div 1 2 3) (/ 1 2 3)) + (assert-eq (core.div 1 2 3 4) (/ 1 2 3 4)) + (assert-eq (core.div 1 2 3 4 5) (/ 1 2 3 4 5)))) (deftest test-comparison-functions (testing "le" - (assert-not (pcall le)) - (assert-is (le 1)) - (assert-is (le 1 2)) - (assert-is (le 1 2 2)) - (assert-is (le 1 2 3 4)) - (assert-not (le 2 1)) - (assert-not (le 2 2 1)) - (assert-not (le 2 1 3)) - (assert-not (le 1 2 4 3))) + (assert-not (pcall core.le)) + (assert-is (core.le 1)) + (assert-is (core.le 1 2)) + (assert-is (core.le 1 2 2)) + (assert-is (core.le 1 2 3 4)) + (assert-not (core.le 2 1)) + (assert-not (core.le 2 2 1)) + (assert-not (core.le 2 1 3)) + (assert-not (core.le 1 2 4 3))) (testing "lt" - (assert-not (pcall lt)) - (assert-is (lt 1)) - (assert-is (lt 1 2)) - (assert-is (lt 1 2 3)) - (assert-is (lt 1 2 3 4)) - (assert-not (lt 2 1)) - (assert-not (lt 2 2 1)) - (assert-not (lt 2 1 3)) - (assert-not (lt 1 2 4 4))) + (assert-not (pcall core.lt)) + (assert-is (core.lt 1)) + (assert-is (core.lt 1 2)) + (assert-is (core.lt 1 2 3)) + (assert-is (core.lt 1 2 3 4)) + (assert-not (core.lt 2 1)) + (assert-not (core.lt 2 2 1)) + (assert-not (core.lt 2 1 3)) + (assert-not (core.lt 1 2 4 4))) (testing "ge" - (assert-not (pcall ge)) - (assert-is (ge 2)) - (assert-is (ge 2 1)) - (assert-is (ge 3 3 2)) - (assert-is (ge 4 3 2 -1)) - (assert-not (ge 1 2)) - (assert-not (ge 1 1 2)) - (assert-not (ge 2 1 3)) - (assert-not (ge 1 2 4 4))) + (assert-not (pcall core.ge)) + (assert-is (core.ge 2)) + (assert-is (core.ge 2 1)) + (assert-is (core.ge 3 3 2)) + (assert-is (core.ge 4 3 2 -1)) + (assert-not (core.ge 1 2)) + (assert-not (core.ge 1 1 2)) + (assert-not (core.ge 2 1 3)) + (assert-not (core.ge 1 2 4 4))) (testing "gt" - (assert-not (pcall gt)) - (assert-is (gt 2)) - (assert-is (gt 2 1)) - (assert-is (gt 3 2 1)) - (assert-is (gt 4 3 2 -1)) - (assert-not (gt 1 2)) - (assert-not (gt 1 1 2)) - (assert-not (gt 2 1 3)) - (assert-not (gt 1 2 4 4)))) + (assert-not (pcall core.gt)) + (assert-is (core.gt 2)) + (assert-is (core.gt 2 1)) + (assert-is (core.gt 3 2 1)) + (assert-is (core.gt 4 3 2 -1)) + (assert-not (core.gt 1 2)) + (assert-not (core.gt 1 1 2)) + (assert-not (core.gt 2 1 3)) + (assert-not (core.gt 1 2 4 4)))) (deftest test-vector (testing "vector" - (assert-eq (vector) []) - (assert-eq (vector 1) [1]) - (assert-eq (vector 1 2 3) [1 2 3]) - (assert-eq (getmetatable (vector 1 2 3)) {:cljlib/type :seq}))) + (assert-eq (core.vector) []) + (assert-eq (core.vector 1) [1]) + (assert-eq (core.vector 1 2 3) [1 2 3]) + (assert-eq (. (getmetatable (core.vector 1 2 3)) :cljlib/type) :vector))) (deftest test-hash-map (testing "hash-map" - (assert-not (pcall hash-map :a)) - (assert-eq (hash-map) {}) - (assert-eq (hash-map :a 1) {:a 1}) - (assert-eq (hash-map :a 1 :b 2 :c 3) {:a 1 :b 2 :c 3}) - (assert-eq (getmetatable (hash-map)) {:cljlib/type :table}) - (assert-not (pcall hash-map nil 1)))) + (assert-not (pcall core.hash-map :a)) + (assert-eq (core.hash-map) {}) + (assert-eq (core.hash-map :a 1) {:a 1}) + (assert-eq (core.hash-map :a 1 :b 2 :c 3) {:a 1 :b 2 :c 3}) + (assert-eq (. (getmetatable (core.hash-map)) :cljlib/type) :hash-map) + (assert-not (pcall core.hash-map nil 1)))) (deftest test-sets (testing "hash-set" - (let [h1 (hash-set [1] [1] [2] [3] [:a]) - h2 (hash-set [1] [2] [3] [:a])] - (assert-is (eq h1 h2))) + (let [h1 (core.hash-set [1] [1] [2] [3] [:a]) + h2 (core.hash-set [1] [2] [3] [:a])] + (assert-is (core.eq h1 h2))) - (let [h3 (hash-set [1] [1] [2] [3] [:a]) - h4 (hash-set [1] [1] [3] [:a])] - (assert-not (eq h3 h4))) + (let [h3 (core.hash-set [1] [1] [2] [3] [:a]) + h4 (core.hash-set [1] [1] [3] [:a])] + (assert-not (core.eq h3 h4))) - (assert-eq (. (hash-set [1]) [1]) [1]) - (assert-eq (. (hash-set [1]) [2]) nil) - (assert-eq ((hash-set [1]) [1]) [1]) - (assert-eq ((hash-set [1]) [2]) nil)) + (assert-eq (. (core.hash-set [1]) [1]) [1]) + (assert-eq (. (core.hash-set [1]) [2]) nil) + (assert-eq ((core.hash-set [1]) [1]) [1]) + (assert-eq ((core.hash-set [1]) [2]) nil)) - (testing "ordered-set" + (comment testing "ordered-set" (let [o1 (ordered-set [1] [1] [2] [3] [:a]) o2 (ordered-set [1] [2] [3] [:a])] (assert-eq o1 o2)) @@ -839,53 +910,53 @@ (assert-eq ((ordered-set [1]) [2]) nil)) (testing "set equality" - (let [o1 (ordered-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) - h1 (hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2)] - (assert-eq o1 h1)) + (let [o1 (core.hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) + h1 (core.hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2)] + (assert-is (core.eq o1 h1))) - (let [o2 (ordered-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) - h2 (hash-set [1] [[-1 1] 1] [2] [3] [:a] :a 2)] - (assert-ne o2 h2)) + (let [o2 (core.hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) + h2 (core.hash-set [1] [[-1 1] 1] [2] [3] [:a] :a 2)] + (assert-not (core.eq o2 h2))) - (let [o3 (ordered-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) - h3 (hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2)] - (assert-eq (disj o3 [2]) (disj h3 [2])) - (assert-ne (disj o3 :a) h3) - (assert-eq (disj h3 :a) o3)) + (let [o3 (core.hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2) + h3 (core.hash-set [1] [[-1 0] 1] [2] [3] [:a] :a 2)] + (assert-is (core.eq (core.disj o3 [2]) (core.disj h3 [2]))) + (assert-not (core.eq (core.disj o3 :a) h3))) - (let [o4 (ordered-set [1] [[-1 5] 1] [3] [:a] :a 2) - h4 (hash-set [1] [[-1 5] 1] [2] [3] [:a] :a 2)] - (assert-eq (conj o4 [2]) (conj (disj h4 [2]) [2])))) + (let [o4 (core.hash-set [1] [[-1 5] 1] [3] [:a] :a 2) + h4 (core.hash-set [1] [[-1 5] 1] [2] [3] [:a] :a 2)] + (assert-is (core.eq (core.conj o4 [2]) (core.conj (core.disj h4 [2]) [2]))))) (testing "empty sets" - (assert-eq (empty (ordered-set)) (ordered-set)) - (assert-eq (empty (ordered-set 1 2 3)) (ordered-set)) - (assert-eq (. (getmetatable (empty (ordered-set))) :cljlib/type ) :cljlib/ordered-set) + (assert-eq (core.empty (core.hash-set)) (core.hash-set)) + (assert-eq (core.empty (core.hash-set 1 2 3)) (core.hash-set)) + (assert-eq (. (getmetatable (core.empty (core.hash-set))) :cljlib/type) :hash-set) - (assert-eq (empty (hash-set)) (hash-set)) - (assert-eq (empty (hash-set 1 2 3)) (hash-set)) - (assert-eq (. (getmetatable (empty (hash-set))) :cljlib/type ) :cljlib/hash-set)) + (assert-eq (core.empty (core.hash-set)) (core.hash-set)) + (assert-eq (core.empty (core.hash-set 1 2 3)) (core.hash-set)) + (assert-eq (. (getmetatable (core.empty (core.hash-set))) :cljlib/type) :hash-set)) (testing "into sets" - (assert-eq (into (ordered-set) [1 2 3]) (ordered-set 1 2 3)) - (assert-eq (into (ordered-set) {:a 1 :b 2}) (ordered-set [:a 1] [:b 2])) - (assert-eq (into (ordered-set) "vaiv") (ordered-set "v" "a" "i" "v")) - (assert-eq (into (hash-set) [1 2 3]) (hash-set 1 2 3)) - (assert-eq (into (hash-set) {:a 1 :b 2}) (hash-set [:a 1] [:b 2])) - (assert-eq (into (hash-set) "vaiv") (hash-set "v" "a" "i" "v"))) + (assert-eq (core.into (core.hash-set) [1 2 3]) (core.hash-set 1 2 3)) + (assert-eq (core.into (core.hash-set) {:a 1 :b 2}) (core.hash-set [:a 1] [:b 2])) + (assert-eq (core.into (core.hash-set) "vaiv") (core.hash-set "v" "a" "i" "v")) + (assert-eq (core.into (core.hash-set) [1 2 3]) (core.hash-set 1 2 3)) + (assert-eq (core.into (core.hash-set) {:a 1 :b 2}) (core.hash-set [:a 1] [:b 2])) + (assert-eq (core.into (core.hash-set) "vaiv") (core.hash-set "v" "a" "i" "v"))) (testing "sets into tables" - (assert-eq (into [] (ordered-set 1 2 3)) [1 2 3]) - (assert-eq (into [] (ordered-set :a :b :c)) [:a :b :c]) - (assert-eq (into {} (ordered-set [:a 1] [:b 2])) {:a 1 :b 2}))) + (assert-eq (core.into (core.vector) (core.hash-set 1 2 3)) [1 2 3]) + (assert-eq (core.into (core.vector) (core.hash-set :a)) [:a]) + (assert-eq (core.into (core.hash-map) (core.hash-set [:a 1] [:b 2])) {:a 1 :b 2}))) (deftest test-memoization (testing "memoize" - (macros {:time #`(let [clock# os.clock - start# (clock#) - res# ,$ - end# (clock#)] - (values res# (* 1000 (- end# start#))))}) + (macro time [expr] + `(let [clock# os.clock + start# (clock#) + res# ,expr + end# (clock#)] + (values res# (* 1000 (- end# start#))))) (fn sleep [ms] (let [clock os.clock @@ -894,22 +965,22 @@ (fn slow [x] (sleep 100) x) - (assert-not (pcall memoize)) - (assert-not (pcall memoize slow 2)) + (assert-not (pcall core.memoize)) + (assert-not (pcall core.memoize slow 2)) - (local fast (memoize slow)) + (local fast (core.memoize slow)) (let [(res1 time1) (time (fast 42)) (res2 time2) (time (fast 42))] - (assert-is (eq res1 res2 42)) + (assert-is (core.eq res1 res2 42)) (assert-is (< time2 time1))) (let [(res1 time1) (time (fast [10])) (res2 time2) (time (fast [10]))] - (assert-is (eq res1 res2 [10])) + (assert-is (core.eq res1 res2 [10])) (assert-is (< time2 time1))) (let [(res1 time1) (time (fast {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}})) (res2 time2) (time (fast {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}}))] - (assert-is (eq res1 res2 {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}})) + (assert-is (core.eq res1 res2 {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}})) (assert-is (< time2 time1))))) |