Created
January 19, 2013 18:18
-
-
Save kanaka/4574095 to your computer and use it in GitHub Desktop.
clojurescript/test/cljs/cljs/core_test.cljs with breaking tests commented out with TODOs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
(ns cljs.core-test) | |
(defn test-stuff [] | |
(println "Starting tests") | |
;; js primitives | |
(let [keys #(vec (js-keys %))] | |
(assert (= [] (keys (js-obj)) (keys (apply js-obj [])))) | |
(assert (= ["x"] (keys (js-obj "x" "y")) (keys (apply js-obj ["x" "y"]))))) | |
;; -equiv | |
(assert (= 1)) | |
(assert (= 1 1)) | |
(assert (= 1 1 1)) | |
(assert (= 1 1 1 1)) | |
(assert (not (= 1 2))) | |
(assert (not (= 1 2 1))) | |
(assert (not (= 1 1 2))) | |
(assert (not (= 1 1 2 1))) | |
(assert (not (= 1 1 1 2))) | |
;; arithmetic | |
(assert (= (+) 0)) | |
(assert (= (apply + []) 0)) | |
(assert (= (+ 1) 1)) | |
(assert (= (apply + [1]) 1)) | |
(assert (= (+ 1 1) 2)) | |
(assert (= (apply + [1 1]) 2)) | |
(assert (= (+ 1 2 3) 6)) | |
(assert (= (apply + [1 2 3]) 6)) | |
(assert (= (- 1) -1)) | |
(assert (= (apply - [1]) -1)) | |
(assert (= (- 1 1) 0)) | |
(assert (= (apply - [1 1]) 0)) | |
(assert (= (- 3 2 1) 0)) | |
(assert (= (apply - [3 2 1]) 0)) | |
(assert (= (*) 1)) | |
(assert (= (apply * []) 1)) | |
(assert (= (* 2) 2)) | |
(assert (= (apply * [2]) 2)) | |
(assert (= (* 2 3) 6)) | |
(assert (= (apply * [2 3]) 6)) | |
(assert (= (/ 2) 0.5)) | |
(assert (= (apply / [2]) 0.5)) | |
(assert (= (/ 6 2) 3)) | |
(assert (= (apply / [6 2]) 3)) | |
(assert (= (/ 6 3 2) 1)) | |
(assert (= (apply / [6 3 2]) 1)) | |
(assert (= (< 1) true)) | |
(assert (= (apply < [1]) true)) | |
(assert (= (< 1 2) true)) | |
(assert (= (apply < [1 2]) true)) | |
(assert (= (< 1 1) false)) | |
(assert (= (apply < [1 1]) false)) | |
(assert (= (< 2 1) false)) | |
(assert (= (apply < [2 1]) false)) | |
(assert (= (< 1 2 3) true)) | |
(assert (= (apply < [1 2 3]) true)) | |
(assert (= (< 1 1 3) false)) | |
(assert (= (apply < [1 1 3]) false)) | |
(assert (= (< 3 1 1) false)) | |
(assert (= (apply < [3 1 1]) false)) | |
(assert (= (<= 1) true)) | |
(assert (= (apply <= [1]) true)) | |
(assert (= (<= 1 1) true)) | |
(assert (= (apply <= [1 1]) true)) | |
(assert (= (<= 1 2) true)) | |
(assert (= (apply <= [1 2]) true)) | |
(assert (= (<= 2 1) false)) | |
(assert (= (apply <= [2 1]) false)) | |
(assert (= (<= 1 2 3) true)) | |
(assert (= (apply <= [1 2 3]) true)) | |
(assert (= (<= 1 1 3) true)) | |
(assert (= (apply <= [1 1 3]) true)) | |
(assert (= (<= 3 1 1) false)) | |
(assert (= (apply <= [3 1 1]) false)) | |
(assert (= (> 1) true)) | |
(assert (= (apply > [1]) true)) | |
(assert (= (> 2 1) true)) | |
(assert (= (apply > [2 1]) true)) | |
(assert (= (> 1 1) false)) | |
(assert (= (apply > [1 1]) false)) | |
(assert (= (> 1 2) false)) | |
(assert (= (apply > [1 2]) false)) | |
(assert (= (> 3 2 1) true)) | |
(assert (= (apply > [3 2 1]) true)) | |
(assert (= (> 3 1 1) false)) | |
(assert (= (apply > [3 1 1]) false)) | |
(assert (= (> 1 1 3) false)) | |
(assert (= (apply > [1 1 3]) false)) | |
(assert (= (>= 1) true)) | |
(assert (= (apply >= [1]) true)) | |
(assert (= (>= 2 1) true)) | |
(assert (= (apply >= [2 1]) true)) | |
(assert (= (>= 1 1) true)) | |
(assert (= (apply >= [1 1]) true)) | |
(assert (= (>= 1 2) false)) | |
(assert (= (apply >= [1 2]) false)) | |
(assert (= (>= 3 2 1) true)) | |
(assert (= (apply >= [3 2 1]) true)) | |
(assert (= (>= 3 1 1) true)) | |
(assert (= (apply >= [3 1 1]) true)) | |
(assert (= (>= 3 1 2) false)) | |
(assert (= (apply >= [3 1 2]) false)) | |
(assert (= (>= 1 1 3) false)) | |
(assert (= (apply >= [1 1 3]) false)) | |
(assert (= (dec 1) 0)) | |
(assert (= (apply dec [1]) 0)) | |
(assert (= (inc 0) 1)) | |
(assert (= (apply inc [0]) 1)) | |
(assert (= (zero? 0) true)) | |
(assert (= (apply zero? [0]) true)) | |
(assert (= (zero? 1) false)) | |
(assert (= (apply zero? [1]) false)) | |
(assert (= (zero? -11) false)) | |
(assert (= (apply zero? [-11]) false)) | |
(assert (= (pos? 0) false)) | |
(assert (= (apply pos? [0]) false)) | |
(assert (= (pos? 1) true)) | |
(assert (= (apply pos? [1]) true)) | |
(assert (= (pos? -1) false)) | |
(assert (= (apply pos? [-1]) false)) | |
(assert (= (neg? -1) true)) | |
(assert (= (apply neg? [-1]) true)) | |
(assert (= (max 1) 1)) | |
(assert (= (apply max [1]) 1)) | |
(assert (= (max 1 2) 2)) | |
(assert (= (apply max [1 2]) 2)) | |
(assert (= (max 2 1) 2)) | |
(assert (= (apply max [2 1]) 2)) | |
(assert (= (max 1 2 3) 3)) | |
(assert (= (apply max [1 2 3]) 3)) | |
(assert (= (max 1 3 2) 3)) | |
(assert (= (apply max [1 3 2]) 3)) | |
(assert (= (min 1) 1)) | |
(assert (= (apply min [1]) 1)) | |
(assert (= (min 1 2) 1)) | |
(assert (= (apply min [1 2]) 1)) | |
(assert (= (min 2 1) 1)) | |
(assert (= (apply min [2 1]) 1)) | |
(assert (= (min 1 2 3) 1)) | |
(assert (= (apply min [1 2 3]) 1)) | |
(assert (= (min 2 1 3) 1)) | |
(assert (= (apply min [3 1 3]) 1)) | |
(assert (= (mod 4 2) 0)) | |
(assert (= (apply mod [4 2]) 0)) | |
(assert (= (mod 3 2) 1)) | |
(assert (= (apply mod [3 2]) 1)) | |
(assert (= [4 3 2 1 0] (loop [i 0 j ()] | |
(if (< i 5) | |
(recur (inc i) (conj j (fn [] i))) | |
(map #(%) j))))) | |
(assert (= [[1 1] [1 2] [1 3] [2 1] [2 2] [2 3]] | |
(map #(%) (for [i [1 2] j [1 2 3]] (fn [] [i j]))))) | |
(assert (integer? 0)) | |
(assert (integer? 42)) | |
(assert (integer? -42)) | |
(assert (not (integer? ""))) | |
(assert (not (integer? 1e308))) | |
(assert (not (integer? js/Infinity))) | |
(assert (not (integer? (- js/Infinity)))) | |
(assert (not (integer? js/NaN))) | |
(assert (= 42 (int 42.5))) | |
(assert (integer? (int 42.5))) | |
(assert (= 42 (long 42.5))) | |
(assert (integer? (long 42.5))) | |
(assert (= -1 (int -1.5))) | |
(assert (= -9 (long -9.8))) | |
(assert (= 2 (:b {:a 1 :b 2}))) | |
(assert (= 2 ('b '{:a 1 b 2}))) | |
(assert (= 2 ({:a 1 :b 2} :b))) | |
(assert (= 2 ({1 1 2 2} 2))) | |
(assert (= 2 (:a {:b 1} 2))) | |
(assert (= 2 (:a {} 2))) | |
(assert (= 2 ({:b 1} :a 2))) | |
(assert (= 2 ({} :a 2))) | |
(assert (= nil (:a {}))) | |
(assert (= 2 (#{1 2 3} 2))) | |
(assert (zero? (hash (aget (js-obj) "foo")))) | |
(assert (= 1 (apply :a '[{:a 1 a 2}]))) | |
(assert (= 1 (apply 'a '[{a 1 :b 2}]))) | |
(assert (= 1 (apply {:a 1} [:a]))) | |
(assert (= 2 (apply {:a 1} [:b 2]))) | |
(assert (= "baz" (name 'foo/bar/baz))) | |
(assert (= "foo/bar" (namespace 'foo/bar/baz))) | |
(assert (= "baz" (name :foo/bar/baz))) | |
;(assert (= "foo/bar" (namespace :foo/bar/baz))) | |
; str | |
(assert (= ":hello" (str :hello))) | |
(assert (= "hello" (str 'hello))) | |
(assert (= "hello:world" (str "hello" :world))) | |
(assert (= ":helloworld" (str :hello 'world))) | |
; symbol | |
(assert (= 'a (symbol 'a))) | |
;; format | |
(assert (= "01: 2.000000" (format "%02d: %.6f" 1 2))) | |
;; misc | |
(assert (= {:a :b} (get {[1 2 3] {:a :b}, 4 5} [1 2 3]))) | |
(assert (= :a (nth [:a :b :c :d] 0))) | |
(assert (= :a (nth [:a :b :c :d] 0.1)) ) | |
(assert (not (= {:a :b :c nil} {:a :b :d nil}))) | |
(assert (= (list 3 2 1) [3 2 1])) | |
(assert (= [3 2 1] (seq (array 3 2 1)))) | |
(assert (= 9 (reduce + (next (seq (array 1 2 3 4)))))) | |
(assert (= () (rest nil))) | |
(assert (= () (rest ()))) | |
(assert (= () (rest [1]))) | |
(assert (= () (rest (array 1)))) | |
;; TODO: this works without the assert but with it complains: | |
;; No protocol method EmitConstant.emit-constant defined for type object: {"x" "y"} | |
;; (assert (= {"x" "y"} (meta ^{"x" "y"} []))) | |
(assert (= {:a :b} (dissoc {:a :b :c :d} :c))) | |
(assert (= (hash-map :foo 5) | |
(assoc (cljs.core.ObjMap. nil (array) (js-obj)) :foo 5))) | |
(assert (= "\"asdf\" \"asdf\"" (pr-str "asdf" "asdf"))) | |
(assert (= "[1 true {:a 2, :b #\"x\\\"y\"} #<Array [3, 4]>]" | |
(pr-str [1 true {:a 2 :b #"x\"y"} (array 3 4)]))) | |
(assert (= "\"asdf\"\n" (prn-str "asdf"))) | |
(assert (= "[1 true {:a 2, :b 42} #<Array [3, 4]>]\n" | |
(prn-str [1 true {:a 2 :b 42} (array 3 4)]))) | |
(assert (= "asdf" (print-str "asdf"))) | |
(assert (= "asdf\n" (println-str "asdf"))) | |
(assert (= "" (pr-str))) | |
(assert (= "\n" (prn-str))) | |
(assert (= "12" (with-out-str (print 1) (print 2)))) | |
(assert (= "12" (with-out-str (*print-fn* 1) (*print-fn* 2)))) | |
;;this fails in v8 - why? | |
;(assert (= "symbol\"'string" (pr-str (str 'symbol \" \' "string")))) | |
(assert (not (= "one" "two"))) | |
(assert (= 3 (-count "abc"))) | |
(assert (= 4 (-count (array 1 2 3 4)))) | |
(assert (= "c" (-nth "abc" 2))) | |
(assert (= "quux" (-nth "abc" 3 "quux"))) | |
(assert (= 1 (-nth (array 1 2 3 4) 0))) | |
(assert (= "val" (-nth (array 1 2 3 4) 4 "val"))) | |
(assert (= "b" (-lookup "abc" 1))) | |
(assert (= "harriet" (-lookup "abcd" 4 "harriet"))) | |
(assert (= 4 (-lookup (array 1 2 3 4) 3))) | |
(assert (= "zot" (-lookup (array 1 2 3 4) 4 "zot"))) | |
(assert (= 10 (-reduce (array 1 2 3 4) +))) | |
(assert (= 20 (-reduce (array 1 2 3 4) + 10))) | |
(assert (= "cabd" (let | |
[jumble (fn [a b] (str (apply str (reverse (str a))) b))] | |
(-reduce "abcd" jumble)))) | |
(assert (= "cafrogbd" (let | |
[jumble (fn [a b] (str (apply str (reverse (str a))) b))] | |
(-reduce "abcd" jumble "frog")))) | |
;; bit ops | |
(assert (= [0 0 1 0 1] | |
[(bit-and 1 0) | |
(bit-and 0 0) | |
(bit-and 1 1) | |
(bit-and 42 1) | |
(bit-and 41 1)])) | |
(assert (= [1 0 1 43 41] | |
[(bit-or 1 0) | |
(bit-or 0 0) | |
(bit-or 1 1) | |
(bit-or 42 1) | |
(bit-or 41 1)])) | |
(assert (= [1 0 0 42 40] | |
[(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)])) | |
(assert (= [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)])) | |
(assert (= [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)])) | |
(assert (= [-2 -3 999 -16714 -1025] | |
[(bit-not 1) | |
(bit-not 2) | |
(bit-not -1000) | |
(bit-not 16713) | |
(bit-not 1024)])) | |
(assert (= [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)])) | |
(assert (= [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)])) | |
(assert (= [true false true false false false] | |
[(true? true) | |
(true? false) | |
(false? false) | |
(false? true) | |
(true? js/undefined) | |
(false? js/undefined)])) | |
;; apply | |
(assert (= 0 (apply + nil))) | |
(assert (= 0 (apply + (list)))) | |
(assert (= 1 (apply + (list 1)))) | |
(assert (= 3 (apply + 1 (list 2)))) | |
(assert (= 7 (apply + 1 2 (list 4)))) | |
(assert (= 15 (apply + 1 2 4 (list 8)))) | |
(assert (= 31 (apply + 1 2 4 8 (list 16)))) | |
(assert (= 63 (apply + 1 2 4 8 16 (list 32)))) | |
(assert (= 127 (apply + 1 2 4 8 16 (list 32 64)))) | |
(assert (= 4950 (apply + (take 100 (iterate inc 0))))) | |
(assert (= () (apply list []))) | |
(assert (= [1 2 3] (apply list [1 2 3]))) | |
(assert (= 6 (apply apply [+ [1 2 3]]))) | |
;; apply with infinite sequence | |
(assert (= 3 (apply (fn [& args] | |
(+ (nth args 0) | |
(nth args 1) | |
(nth args 2))) | |
(iterate inc 0)))) | |
(assert (= [0 1 2 3 4] (take 5 (apply (fn [& m] m) (iterate inc 0))))) | |
(assert (= [1 2 3 4 5] (take 5 (apply (fn [x & m] m) (iterate inc 0))))) | |
(assert (= [2 3 4 5 6] (take 5 (apply (fn [x y & m] m) (iterate inc 0))))) | |
(assert (= [3 4 5 6 7] (take 5 (apply (fn [x y z & m] m) (iterate inc 0))))) | |
(assert (= [4 5 6 7 8] (take 5 (apply (fn [x y z a & m] m) (iterate inc 0))))) | |
(assert (= [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]))] | |
(assert (= [3 2 1] (apply single-arity-non-variadic [1 2 3]))) | |
(assert (= [3 2 1] (apply single-arity-non-variadic 1 [2 3]))) | |
(assert (= [3 2 1] (apply single-arity-non-variadic 1 2 [3]))) | |
(assert (= 42 (apply multiple-arity-non-variadic [42]))) | |
(assert (= [2 1] (apply multiple-arity-non-variadic [1 2]))) | |
(assert (= [2 1] (apply multiple-arity-non-variadic 1 [2]))) | |
(assert (= [3 2 1] (apply multiple-arity-non-variadic [1 2 3]))) | |
(assert (= [3 2 1] (apply multiple-arity-non-variadic 1 [2 3]))) | |
(assert (= [3 2 1] (apply multiple-arity-non-variadic 1 2 [3]))) | |
(assert (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs [1 2 3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 [2 3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 [3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 3 [4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply single-arity-variadic-fixedargs 1 2 3 4 [5]))) | |
(assert (= [3 4 5] (take 3 (first (apply single-arity-variadic-fixedargs (iterate inc 1)))))) | |
(assert (= [2 1] (rest (apply single-arity-variadic-fixedargs (iterate inc 1))))) | |
(assert (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs [1 2 3 4 5]))) | |
(assert (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 [2 3 4 5]))) | |
(assert (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 [3 4 5]))) | |
(assert (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 3 [4 5]))) | |
(assert (= [1 2 3 4 5] (apply single-arity-variadic-nofixedargs 1 2 3 4 [5]))) | |
(assert (= [1 2 3 4 5] (take 5 (apply single-arity-variadic-nofixedargs (iterate inc 1))))) | |
(assert (= 42 (apply multiple-arity-variadic [42]))) | |
(assert (= [2 1] (apply multiple-arity-variadic [1 2]))) | |
(assert (= [2 1] (apply multiple-arity-variadic 1 [2]))) | |
(assert (= [[3 4 5] 2 1] (apply multiple-arity-variadic [1 2 3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 [2 3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 [3 4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 3 [4 5]))) | |
(assert (= [[3 4 5] 2 1] (apply multiple-arity-variadic 1 2 3 4 [5]))) | |
(assert (= [3 4 5] (take 3 (first (apply multiple-arity-variadic (iterate inc 1)))))) | |
(assert (= [2 1] (rest (apply multiple-arity-variadic (iterate inc 1)))))) | |
;; CLJS-383 | |
(let [f1 (fn f1 ([] 0) ([a] 1) ([a b] 2) ([a b c & more] 3)) | |
f2 (fn f2 ([x] :foo) ([x y & more] (apply f1 y more)))] | |
(assert (= 1 (f2 1 2)))) | |
(let [f (fn ([]) ([a & more] more))] | |
(assert (nil? (f :foo)))) | |
(assert (nil? (array-seq (array 1) 1))) | |
(let [a (atom 0)] | |
(assert (= 0 (deref a))) | |
(assert (= 1 (swap! a inc))) | |
(assert (= false (compare-and-set! a 0 42))) | |
(assert (= true (compare-and-set! a 1 7))) | |
(assert (nil? (meta a))) | |
(assert (nil? (get-validator a)))) | |
(let [a (atom 0)] | |
(assert (= 1 (swap! a + 1))) | |
(assert (= 4 (swap! a + 1 2))) | |
(assert (= 10 (swap! a + 1 2 3))) | |
(assert (= 20 (swap! a + 1 2 3 4)))) | |
(let [a (atom [1] :validator coll? :meta {:a 1})] | |
(assert (= coll? (get-validator a))) | |
(assert (= {:a 1} (meta a))) | |
(alter-meta! a assoc :b 2) | |
(assert (= {:a 1 :b 2} (meta a)))) | |
(assert (nil? (empty nil))) | |
(let [e-lazy-seq (empty (with-meta (lazy-seq (cons :a nil)) {:b :c}))] | |
(assert (seq? e-lazy-seq)) | |
(assert (empty? e-lazy-seq)) | |
(assert (= {:b :c} (meta e-lazy-seq)))) | |
;; TODO: fix quoted meta-data | |
;; (let [e-list (empty '^{:b :c} (1 2 3))] | |
;; (assert (seq? e-list)) | |
;; (assert (empty? e-list))) | |
;; (let [e-elist (empty '^{:b :c} ())] | |
;; (assert (seq? e-elist)) | |
;; (assert (empty? e-elist)) | |
;; (assert (= :c (get (meta e-elist) :b)))) | |
(let [e-cons (empty (with-meta (cons :a nil) {:b :c}))] | |
(assert (seq? e-cons)) | |
(assert (empty? e-cons)) | |
(assert (= {:b :c} (meta e-cons)))) | |
(let [e-vec (empty ^{:b :c} [:a :d :g])] | |
(assert (vector? e-vec)) | |
(assert (empty? e-vec)) | |
(assert (= {:b :c} (meta e-vec)))) | |
(let [e-omap (empty ^{:b :c} {:a :d :g :h})] | |
(assert (map? e-omap)) | |
(assert (empty? e-omap)) | |
(assert (= {:b :c} (meta e-omap)))) | |
(let [e-hmap (empty ^{:b :c} {[1 2] :d :g :h})] | |
(assert (map? e-hmap)) | |
(assert (empty? e-hmap)) | |
(assert (= {:b :c} (meta e-hmap)))) | |
;;this fails in v8 advanced mode - what's e? | |
#_(let [a (atom nil)] | |
(assert (= 1 (try* 1))) | |
(assert (= 2 (try* 1 (throw 3) (catch e 2)))) | |
(assert (= 3 (try* 1 (throw 3) (catch e e)))) | |
(assert (= 1 (try* 1 (finally (reset! a 42))))) | |
(assert (= 42 (deref a)))) | |
(let [a (atom nil)] | |
(assert (= 1 (try 1))) | |
(assert (= 2 (try 1 (throw (js/Error.)) (catch js/Error e 2)))) | |
(assert (= 2 (try 1 (throw (js/Error.)) (catch js/Error e 1 2)))) | |
(assert (= 1 (try 1 (finally (reset! a 42))))) | |
(assert (= 42 (deref a)))) | |
(println "Completed 25% of tests") | |
(assert (= [3] (nthnext [1 2 3] 2))) | |
(let [v [1 2 3]] | |
(assert (= v (for [e v] e))) | |
(assert (= [[1 1] [2 4] [3 9]] (for [e v :let [m (* e e)]] [e m]))) | |
(assert (= [1 2] (for [e v :while (< e 3)] e))) | |
(assert (= [3] (for [e v :when (> e 2)] e))) | |
(assert (= [[1 1] [2 4]] (for [e v :while (< e 3) :let [m (* e e)]] [e m])))) | |
(assert (not= 1 2)) | |
(assert (not (not= 1 1))) | |
(assert (not (not-empty []))) | |
(assert (boolean (not-empty [1 2 3]))) | |
(assert (= "joel" (min-key count "joel" "tom servo" "crooooooooow"))) | |
(assert (= "crooooooooow" (max-key count "joel" "tom servo" "crooooooooow"))) | |
(assert (= (partition-all 4 [1 2 3 4 5 6 7 8 9]) | |
[[1 2 3 4] [5 6 7 8] [9]])) | |
(assert (= (partition-all 4 2 [1 2 3 4 5 6 7 8 9]) | |
[[1 2 3 4] [3 4 5 6] [5 6 7 8] [7 8 9] [9]])) | |
(assert (= [true true] (take-while true? [true true 2 3 4]))) | |
(assert (= [[true true] [false false false] [true true]] | |
(partition-by true? [true true false false false true true]))) | |
(assert (= [0 2 4 6 8 10] (take-nth 2 [0 1 2 3 4 5 6 7 8 9 10]))) | |
(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)] | |
(assert (= 110 (a10 100))) | |
(assert (= 120 (a20 100))) | |
(assert (= 121 (a21 100))) | |
(assert (= 122 (a22 100))) | |
(assert (= 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)] | |
(assert (= 2 (n2 [1 2 3 4 5 6 7]))) | |
(assert (= 3 (n3 [1 2 3 4 5 6 7]))) | |
(assert (= 4 (n4 [1 2 3 4 5 6 7]))) | |
(assert (= 5 (n5 [1 2 3 4 5 6 7]))) | |
(assert (= 6 (n6 [1 2 3 4 5 6 7])))) | |
(let [sf (some-fn number? keyword? symbol?)] | |
(assert (sf :foo 1)) | |
(assert (sf :foo)) | |
(assert (sf 'bar 1)) | |
(assert (not (sf [] ())))) | |
(let [ep (every-pred number? zero?)] | |
(assert (ep 0 0 0)) | |
(assert (not (ep 1 2 3 0)))) | |
(assert ((complement number?) :foo)) | |
(assert (= [1 [2 3] [1 2 3]] ((juxt first rest seq) [1 2 3]))) | |
(assert (= 5 (max 1 2 3 4 5))) | |
(assert (= 5 (max 5 4 3 2 1))) | |
(assert (= 5.5 (max 1 2 3 4 5 5.5))) | |
(assert (= 1 (min 5 4 3 2 1))) | |
(assert (= 1 (min 1 2 3 4 5))) | |
(assert (= 0.5 (min 5 4 3 0.5 2 1))) | |
(let [x (array 1 2 3)] | |
(set! (.-foo x) :hello) | |
(assert (= (.-foo x) :hello))) | |
;; sets | |
(assert (set [])) | |
(assert (= #{} (set []))) | |
(assert (= #{} (hash-set))) | |
(assert (identical? cljs.core.PersistentHashSet (type (hash-set)))) | |
(assert (= #{"foo"} (set ["foo"]))) | |
(assert (= #{"foo"} (hash-set "foo"))) | |
(assert (= #{1 2 3} #{1 3 2})) | |
(assert (= #{#{1 2 3} [4 5 6] {7 8} 9 10} | |
#{10 9 [4 5 6] {7 8} #{1 2 3}})) | |
(assert (not (= #{nil [] {} 0 #{}} #{}))) | |
(assert (= (count #{nil [] {} 0 #{}}) 5)) | |
(assert (= (conj #{1} 1) #{1})) | |
(assert (= (conj #{1} 2) #{2 1})) | |
(assert (= #{} (-empty #{1 2 3 4}))) | |
(assert (= (reduce + #{1 2 3 4 5}) 15)) | |
(assert (= 4 (get #{1 2 3 4} 4))) | |
(assert (contains? #{1 2 3 4} 4)) | |
(assert (contains? #{[] nil 0 {} #{}} {})) | |
(assert (contains? #{[1 2 3]} [1 2 3])) | |
(assert (not (contains? (-disjoin #{1 2 3} 3) 3))) | |
(assert (neg? -1)) | |
(assert (not (neg? 1))) | |
(assert (neg? -1.765)) | |
(assert (not (neg? 0))) | |
;; TODO: support for 0x7e7 type numbers | |
;; (assert (= [true false true false true false true false] | |
;; (map integer? | |
;; [1 1.00001 0x7e7 [] (- 88 1001991881) :foo 0 "0"]))) | |
(assert (= [true false true false true false] | |
(map odd? [1 2 3 4 -1 0]))) | |
(assert (= [true false true false true true] | |
(map even? [2 3 4 5 -2 0]))) | |
(assert (contains? {:a 1 :b 2} :a)) | |
(assert (not (contains? {:a 1 :b 2} :z))) | |
(assert (contains? [5 6 7] 1)) | |
(assert (contains? [5 6 7] 2)) | |
(assert (not (contains? [5 6 7] 3))) | |
(assert (contains? (to-array [5 6 7]) 1)) | |
(assert (contains? (to-array [5 6 7]) 2)) | |
(assert (not (contains? (to-array [5 6 7]) 3))) | |
(assert (not (contains? nil 42))) | |
(assert (contains? "f" 0)) | |
(assert (not (contains? "f" 55))) | |
(assert (distinct? 1 2 3)) | |
(assert (not (distinct? 1 2 3 1))) | |
;; distinct | |
(assert (= (distinct ()) ())) | |
(assert (= (distinct '(1)) '(1))) | |
(assert (= (distinct '(1 2 3 1 1 1)) '(1 2 3))) | |
(assert (= (distinct [1 1 1 2]) '(1 2))) | |
(assert (= (distinct [1 2 1 2]) '(1 2))) | |
(assert (= (distinct "a") ["a"])) | |
(assert (= (distinct "abcabab") ["a" "b" "c"])) | |
(assert (= (distinct ["abc" "abc"]) ["abc"])) | |
(assert (= (distinct [nil nil]) [nil])) | |
(assert (= (distinct [0.0 0.0]) [0.0])) | |
(assert (= (distinct ['sym 'sym]) '[sym])) | |
(assert (= (distinct [:kw :kw]) [:kw])) | |
(assert (= (distinct [42 42]) [42])) | |
(assert (= (distinct [[] []]) [[]])) | |
(assert (= (distinct ['(1 2) '(1 2)]) '[(1 2)])) | |
(assert (= (distinct [() ()]) [()])) | |
(assert (= (distinct [[1 2] [1 2]]) [[1 2]])) | |
(assert (= (distinct [{:a 1 :b 2} {:a 1 :b 2}]) [{:a 1 :b 2}])) | |
(assert (= (distinct [{} {}]) [{}])) | |
(assert (= (distinct [#{1 2} #{1 2}]) [#{1 2}])) | |
(assert (= (distinct [#{} #{}]) [#{}])) | |
;;regexps | |
(assert (= (str (re-pattern "f(.)o")) (str (js* "/f(.)o/")))) | |
(assert (= (re-find (re-pattern "foo") "foo bar foo baz foo zot") "foo")) | |
(assert (= (re-find (re-pattern "f(.)o") "foo bar foo baz foo zot") ["foo" "o"])) | |
(assert (= (re-matches (re-pattern "foo") "foo") "foo")) | |
(assert (= (re-matches (re-pattern "foo") "foo bar foo baz foo zot") nil)) | |
(assert (= (re-matches (re-pattern "foo.*") "foo bar foo baz foo zot") "foo bar foo baz foo zot")) | |
(assert (= (re-seq (re-pattern "foo") "foo bar foo baz foo zot") (list "foo" "foo" "foo"))) | |
(assert (= (re-seq (re-pattern "f(.)o") "foo bar foo baz foo zot") (list ["foo" "o"] ["foo" "o"] ["foo" "o"]))) | |
(assert (= (re-matches (re-pattern "(?i)foo") "Foo") "Foo")) | |
;; destructuring | |
(assert (= [2 1] (let [[a b] [1 2]] [b a]))) | |
(assert (= #{1 2} (let [[a b] [1 2]] #{a b}))) | |
(assert (= [1 2] (let [{a :a b :b} {:a 1 :b 2}] [a b]))) | |
(assert (= [1 2] (let [{:keys [a b]} {:a 1 :b 2}] [a b]))) | |
(assert (= [1 2 [1 2]] (let [[a b :as v] [1 2]] [a b v]))) | |
(assert (= [1 42] (let [{:keys [a b] :or {b 42}} {:a 1}] [a b]))) | |
(assert (= [1 nil] (let [{:keys [a b] :or {c 42}} {:a 1}] [a b]))) | |
(assert (= [2 1] (let [[a b] '(1 2)] [b a]))) | |
(assert (= {1 2} (let [[a b] [1 2]] {a b}))) | |
(assert (= [2 1] (let [[a b] (seq [1 2])] [b a]))) | |
;; update-in | |
(assert (= {:foo {:bar {:baz 1}}} | |
(update-in {:foo {:bar {:baz 0}}} [:foo :bar :baz] inc))) | |
(assert (= {:foo 1 :bar 2 :baz 10} | |
(update-in {:foo 1 :bar 2 :baz 3} [:baz] + 7))) | |
(assert (= [{:foo 1, :bar 2} {:foo 1, :bar 3}] | |
(update-in [{:foo 1 :bar 2}, {:foo 1 :bar 2}] [1 :bar] inc))) | |
(assert (= [{:foo {:bar 2}} {:foo {:bar 3}}] | |
(update-in [{:foo {:bar 2}}, {:foo {:bar 2}}] [1 :foo :bar] inc))) | |
;; assoc-in | |
(assert (= {:foo {:bar {:baz 100}}} | |
(assoc-in {:foo {:bar {:baz 0}}} [:foo :bar :baz] 100))) | |
(assert (= {:foo 1 :bar 2 :baz 100} | |
(assoc-in {:foo 1 :bar 2 :baz 3} [:baz] 100))) | |
(assert (= [{:foo [{:bar 2} {:baz 3}]} {:foo [{:bar 2} {:baz 100}]}] | |
(assoc-in [{:foo [{:bar 2} {:baz 3}]}, {:foo [{:bar 2} {:baz 3}]}] | |
[1 :foo 1 :baz] 100))) | |
(assert (= [{:foo 1, :bar 2} {:foo 1, :bar 100}] | |
(assoc-in [{:foo 1 :bar 2}, {:foo 1 :bar 2}] [1 :bar] 100))) | |
;; get-in | |
(assert (= 1 (get-in {:foo 1 :bar 2} [:foo]))) | |
(assert (= 2 (get-in {:foo {:bar 2}} [:foo :bar]))) | |
(assert (= 1 (get-in [{:foo 1}, {:foo 2}] [0 :foo]))) | |
(assert (= 4 (get-in [{:foo 1 :bar [{:baz 1}, {:buzz 2}]}, {:foo 3 :bar [{:baz 3}, {:buzz 4}]}] | |
[1 :bar 1 :buzz]))) | |
;; arrays | |
(let [a (to-array [1 2 3])] | |
(assert (= [10 20 30] (seq (amap a i ret (* 10 (aget a i)))))) | |
(assert (= 6 (areduce a i ret 0 (+ ret (aget a i))))) | |
(assert (= (seq a) (seq (to-array [1 2 3])))) | |
(assert (= 42 (aset a 0 42))) | |
(assert (not= (seq a) (seq (to-array [1 2 3])))) | |
(assert (not= a (aclone a)))) | |
(let [a (array (array 1 2 3) (array 4 5 6))] | |
(assert (= (aget a 0 1) 2)) | |
(assert (= (apply aget a [0 1]) 2)) | |
(assert (= (aget a 1 1) 5)) | |
(assert (= (apply aget a [1 1]) 5))) | |
;; sort | |
(assert (= [1 2 3 4 5] (sort [5 3 1 4 2]))) | |
(assert (= [1 2 3 4 5] (sort < [5 3 1 4 2]))) | |
(assert (= [5 4 3 2 1] (sort > [5 3 1 4 2]))) | |
;; sort-by | |
(assert (= ["a" [ 1 2] "foo"] (sort-by count ["foo" "a" [1 2]]))) | |
(assert (= ["foo" [1 2] "a"] (sort-by count > ["foo" "a" [1 2]]))) | |
;; shuffle | |
(let [coll [1 2 3 4 5 6 7 8 9 10] | |
; while it is technically possible for this test to fail with a false negative, | |
; it's _extraordinarily_ unlikely. | |
shuffles (filter #(not= coll %) (take 100 (iterate shuffle coll)))] | |
(assert (not (empty? shuffles)))) | |
;; js->clj | |
(assert (= {"a" 1, "b" 2} (js->clj (js* "{\"a\":1,\"b\":2}")))) | |
(assert (= {"a" nil} (js->clj (js* "{\"a\":null}")))) | |
(assert (= {"a" true, "b" false} (js->clj (js* "{\"a\":true,\"b\":false}")))) | |
(assert (= {:a 1, :b 2} (js->clj (js* "{\"a\":1,\"b\":2}") :keywordize-keys true))) | |
(assert (= [[{:a 1, :b 2} {:a 1, :b 2}]] | |
(js->clj (js* "[[{\"a\":1,\"b\":2}, {\"a\":1,\"b\":2}]]") :keywordize-keys true))) | |
(assert (= [[{:a 1, :b 2} {:a 1, :b 2}]] | |
(js->clj [[{:a 1, :b 2} {:a 1, :b 2}]]))) | |
;; last | |
(assert (= nil (last nil))) | |
(assert (= 3 (last [1 2 3]))) | |
;; dotimes | |
(let [s (atom [])] | |
(dotimes [n 5] | |
(swap! s conj n)) | |
(assert (= [0 1 2 3 4] @s))) | |
;; doseq | |
(let [v [1 2 3 4 5] | |
s (atom ())] | |
(doseq [n v] (swap! s conj n)) | |
(assert (= @s (reverse v)))) | |
;; delay | |
(let [a (atom 0) | |
d (delay (swap! a inc))] | |
(assert (false? (realized? d))) | |
(assert (zero? @a)) ;; delay hasn't triggered yet | |
(assert (= 1 @d)) ;; trigger it | |
(assert (= 1 @a)) ;; make sure side effect has happened | |
(assert (true? (realized? d))) | |
(assert (= 1 @d)) ;; body doesn't happen again | |
(assert (= 1 @a)) ;; atom hasn't changed either | |
(assert (= (force d) @d)) | |
(assert (= 1 (force 1)))) ;; you can safely force non-delays | |
;; assoc | |
(assert (= {1 2 3 4} (assoc {} 1 2 3 4))) | |
(assert (= {1 2} (assoc {} 1 2))) | |
(assert (= [42 2] (assoc [1 2] 0 42))) | |
;; dissoc | |
(assert (= {} (dissoc {1 2 3 4} 1 3))) | |
(assert (= {1 2} (dissoc {1 2 3 4} 3))) | |
;; disj | |
(assert (= #{1 2 3} (disj #{1 2 3}))) | |
(assert (= #{1 2} (disj #{1 2 3} 3))) | |
(assert (= #{1} (disj #{1 2 3} 2 3))) | |
;; memoize | |
(let [f (memoize (fn [] (rand)))] | |
(f) | |
(assert (= (f) (f)))) | |
;; find | |
(assert (= (find {} :a) nil)) | |
(assert (= (find {:a 1} :a) [:a 1])) | |
(assert (= (find {:a 1} :b) nil)) | |
(assert (= (find {:a 1 :b 2} :a) [:a 1])) | |
(assert (= (find {:a 1 :b 2} :b) [:b 2])) | |
(assert (= (find {:a 1 :b 2} :c) nil)) | |
(assert (= (find {} nil) nil)) | |
(assert (= (find {:a 1} nil) nil)) | |
(assert (= (find {:a 1 :b 2} nil) nil)) | |
(assert (= (find [1 2 3] 0) [0 1])) | |
;; mod,quot,rem | |
(assert (= (quot 4 2) 2)) | |
(assert (= (quot 3 2) 1)) | |
(assert (= (quot 6 4) 1)) | |
(assert (= (quot 0 5) 0)) | |
(assert (= (quot 42 5) 8)) | |
(assert (= (quot 42 -5) -8)) | |
(assert (= (quot -42 -5) 8)) | |
(assert (= (quot 9 3) 3)) | |
(assert (= (quot 9 -3) -3)) | |
(assert (= (quot -9 3) -3)) | |
(assert (= (quot 2 -5) 0)) | |
(assert (= (quot -2 5) 0)) | |
(assert (= (quot 0 3) 0)) | |
(assert (= (quot 0 -3) 0)) | |
(assert (= (mod 4 2) 0)) | |
(assert (= (mod 3 2) 1)) | |
(assert (= (mod 6 4) 2)) | |
(assert (= (mod 0 5) 0)) | |
(assert (= (mod 4.5 2.0) 0.5)) | |
(assert (= (mod 42 5) 2)) | |
(assert (= (mod 9 3) 0)) | |
(assert (= (mod 9 -3) 0)) | |
(assert (= (mod -9 3) 0)) | |
(assert (= (mod -9 -3) 0)) | |
(assert (= (mod 0 3) 0)) | |
(assert (= (mod 3216478362187432 432143214) 120355456)) | |
(assert (= (rem 4 2) 0)) | |
(assert (= (rem 0 5) 0)) | |
(assert (= (rem 4.5 2.0) 0.5)) | |
(assert (= (rem 42 5) 2)) | |
(assert (= (rem 2 5) 2)) | |
(assert (= (rem 2 -5) 2)) | |
(assert (= (rem 0 3) 0)) | |
;; range | |
(assert (= (range 10) (list 0 1 2 3 4 5 6 7 8 9))) | |
(assert (= (range 10 20) (list 10 11 12 13 14 15 16 17 18 19))) | |
(assert (= (range 10 20 2) (list 10 12 14 16 18))) | |
(assert (= (take 20 (range)) (list 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19))) | |
;; group-by | |
(let [d (group-by second {:a 1 :b 2 :c 1 :d 4 :e 1 :f 2})] | |
(assert (= 3 (count (get d 1)))) | |
(assert (= 2 (count (get d 2)))) | |
(assert (= 1 (count (get d 4))))) | |
(assert (= {1 2 3 4 5 6} (merge {1 2} {3 4} {5 6}))) | |
(assert (= {1 2 3 4} (merge {1 2} {3 4} nil))) | |
;; frequencies | |
(assert (= {:a 3 :b 2} (frequencies [:a :b :a :b :a]))) | |
;; reductions | |
(assert (= [1 3 6 10 15] (reductions + [1 2 3 4 5]))) | |
;; keep | |
(assert (= [1 3 5 7 9] (keep #(if (odd? %) %) [1 2 3 4 5 6 7 8 9 10]))) | |
(assert (= [2 4 6 8 10] (keep #(if (even? %) %) [1 2 3 4 5 6 7 8 9 10]))) | |
;; keep-indexed | |
(assert (= [1 3 5 7 9] (keep-indexed #(if (odd? %1) %2) [0 1 2 3 4 5 6 7 8 9 10]))) | |
(assert (= [2 4 5] (keep-indexed #(if (pos? %2) %1) [-9 0 29 -7 45 3 -8]))) | |
;; map-indexed | |
(assert (= [[0 :a] [1 :b] [2 :c]] (map-indexed #(vector % %2) [:a :b :c]))) | |
;; merge-with | |
(assert (= '{"Foo" ("foo" "FOO" "fOo"), "Bar" ("bar" "BAR" "BAr"), "Baz" ["baz"], "Qux" ["qux" "quux"]} | |
(merge-with concat | |
{"Foo" ["foo" "FOO"] | |
"Bar" ["bar" "BAR"] | |
"Baz" ["baz"]} | |
{"Foo" ["fOo"] | |
"Bar" ["BAr"] | |
"Qux" ["qux" "quux"]}))) | |
(assert (= {:a 111, :b 102, :c 13} | |
(merge-with + | |
{:a 1 :b 2 :c 3} | |
{:a 10 :c 10} | |
{:a 100 :b 100}))) | |
(assert (= {:a 3, :b 102, :c 13} | |
(apply merge-with [+ | |
{:a 1 :b 100} | |
{:a 1 :b 2 :c 3} | |
{:a 1 :c 10}]))) | |
(assert (= '[a c e] (replace '[a b c d e] [0 2 4]))) | |
(assert (= [:one :zero :two :zero] | |
(replace {0 :zero 1 :one 2 :two} '(1 0 2 0)))) | |
;; split-at | |
(assert (= [[1 2] [3 4 5]] (split-at 2 [1 2 3 4 5]))) | |
;; split-with | |
(assert (= [[1 2 3] [4 5]] (split-with (partial >= 3) [1 2 3 4 5]))) | |
;; trampoline | |
(assert (= 10000 (trampoline (fn f [n] (if (>= n 10000) n #(f (inc n)))) 0))) | |
;; vary-meta | |
(assert (= {:a 1} (meta (vary-meta [] assoc :a 1)))) | |
(assert (= {:a 1 :b 2} (meta (vary-meta (with-meta [] {:b 2}) assoc :a 1)))) | |
(println "Completed 50% of tests") | |
;; multi-methods | |
(swap! global-hierarchy make-hierarchy) | |
;; hierarchy tests | |
(derive ::rect ::shape) | |
(derive ::square ::rect) | |
(assert (= #{:cljs.core-test/shape} (parents ::rect))) | |
(assert (= #{:cljs.core-test/rect :cljs.core-test/shape} (ancestors ::square))) | |
(assert (= #{:cljs.core-test/rect :cljs.core-test/square} (descendants ::shape))) | |
(assert (true? (isa? 42 42))) | |
(assert (true? (isa? ::square ::shape))) | |
(derive cljs.core.ObjMap ::collection) | |
(derive cljs.core.PersistentHashSet ::collection) | |
(assert (true? (isa? cljs.core.ObjMap ::collection))) | |
(assert (true? (isa? cljs.core.PersistentHashSet ::collection))) | |
(assert (false? (isa? cljs.core.IndexedSeq ::collection))) | |
;; ?? (isa? String Object) | |
(assert (true? (isa? [::square ::rect] [::shape ::shape]))) | |
;; ?? (ancestors java.util.ArrayList) | |
;; ?? isa? based dispatch tests | |
;; prefer-method test | |
(defmulti bar (fn [x y] [x y])) | |
(defmethod bar [::rect ::shape] [x y] :rect-shape) | |
(defmethod bar [::shape ::rect] [x y] :shape-rect) | |
;;(bar ::rect ::rect) | |
;; -> java.lang.IllegalArgumentException: | |
;; Multiple methods match dispatch value: | |
;; [:cljs.core-test/rect :cljs.core-test/rect] -> [:cljs.core-test/rect :cljs.core-test/shape] | |
;; and [:cljs.core-test/shape :cljs.core-test/rect], | |
;; and neither is preferred | |
(assert (zero? (count (prefers bar)))) | |
(prefer-method bar [::rect ::shape] [::shape ::rect]) | |
(assert (= 1 (count (prefers bar)))) | |
(assert (= :rect-shape (bar ::rect ::rect))) | |
(assert (= :rect-shape (apply (-get-method bar [::rect ::shape]) [::rect ::shape]))) | |
;; nested data structures tests | |
(defmulti nested-dispatch (fn [m] (-> m :a :b))) | |
(defmethod nested-dispatch :c [m] :nested-a) | |
(defmethod nested-dispatch :default [m] :nested-default) | |
(assert (= :nested-a (nested-dispatch {:a {:b :c}}))) | |
(defmulti nested-dispatch2 ffirst) | |
(defmethod nested-dispatch2 :a [m] :nested-a) | |
(defmethod nested-dispatch2 :default [m] :nested-default) | |
(assert (= :nested-a (nested-dispatch2 [[:a :b]]))) | |
;; general tests | |
(defmulti foo1 (fn [& args] (first args))) | |
(defmethod foo1 :a [& args] :a-return) | |
(defmethod foo1 :default [& args] :default-return) | |
(assert (= :a-return (foo1 :a))) | |
(assert (= :default-return (foo1 1))) | |
(defmulti area :Shape) | |
(defn rect [wd ht] {:Shape :Rect :wd wd :ht ht}) | |
(defn circle [radius] {:Shape :Circle :radius radius}) | |
(defmethod area :Rect [r] | |
(* (:wd r) (:ht r))) | |
(defmethod area :Circle [c] | |
(* Math/PI (* (:radius c) (:radius c)))) | |
(defmethod area :default [x] :oops) | |
(def r (rect 4 13)) | |
(def c (circle 12)) | |
(assert (= 52 (area r))) | |
(assert (= :oops (area {}))) | |
;; remove method tests | |
(assert (= 2 (count (methods bar)))) | |
(remove-method bar [::rect ::shape]) | |
(assert (= 1 (count (methods bar)))) | |
(remove-all-methods bar) | |
(assert (zero? (count (methods bar)))) | |
;; test apply | |
(defmulti apply-multi-test (fn ([_] 0) ([_ _] 0) ([_ _ _] 0))) | |
(defmethod apply-multi-test 0 | |
([x] :one) | |
([x y] :two) | |
([x y & r] [:three r])) | |
(assert (= [:three '(2)] (apply apply-multi-test [0 1 2]))) | |
;; Range | |
(assert (= (range 0 10 3) (list 0 3 6 9))) | |
(assert (= (count (range 0 10 3)) 4)) | |
(assert (= (range 0 -10 -3) (list 0 -3 -6 -9))) | |
(assert (= (count (range 0 -10 -3)) 4)) | |
(assert (= (range -10 10 3) (list -10 -7 -4 -1 2 5 8))) | |
(assert (= (count (range -10 10 3)) 7)) | |
(assert (= (range 0 1 1) (list 0))) | |
(assert (= (range 0 -3 -1) (list 0 -1 -2))) | |
(assert (= (range 3 0 -1) (list 3 2 1))) | |
(assert (= (range 0 10 -1) (list))) | |
(assert (= (range 0 1 0) (list))) | |
(assert (= (range 10 0 1) (list))) | |
(assert (= (range 0 0 0) (list))) | |
(assert (= (count (range 0 10 -1)) 0)) | |
(assert (= (count (range 0 1 0)) 0)) | |
(assert (= (count (range 10 0 1)) 0)) | |
(assert (= (count (range 0 0 0)) 0)) | |
(assert (= (take 3 (range 1 0 0)) (list 1 1 1))) | |
(assert (= (take 3 (range 3 1 0)) (list 3 3 3))) | |
;; PersistentVector | |
(let [pv (vec (range 97))] | |
(assert (= (nth pv 96) 96)) | |
(assert (= (nth pv 97 nil) nil)) | |
(assert (= (pv 96) 96))) | |
(let [pv (vec (range 33))] | |
(assert (= pv | |
(-> pv | |
pop | |
pop | |
(conj 31) | |
(conj 32))))) | |
(let [stack1 (pop (vec (range 97))) | |
stack2 (pop stack1)] | |
(assert (= 95 (peek stack1))) | |
(assert (= 94 (peek stack2)))) | |
;; subvec | |
(let [v (vec (range 10)) | |
s (subvec v 2 8)] | |
(assert (= s | |
(-> v | |
(subvec 2) | |
(subvec 0 6)) | |
(->> v | |
(drop 2) | |
(take 6)))) | |
(assert (= 6 (count s))) | |
(assert (= [2 3 4 5 6] (pop s))) | |
(assert (= 7 (peek s))) | |
(assert (= [2 3 4 5 6 7 1] | |
(assoc s 6 1) | |
(conj s 1))) | |
(assert (= 27 (reduce + s))) | |
(assert (= s (vec s))) ; pour into plain vector | |
(let [m {:x 1}] (assert (= m (meta (with-meta s m)))))) | |
;; TransientVector | |
(let [v1 (vec (range 15 48)) | |
v2 (vec (range 40 57)) | |
v1 (persistent! (assoc! (conj! (pop! (transient v1)) :foo) 0 :quux)) | |
v2 (persistent! (assoc! (conj! (transient v2) :bar) 0 :quux)) | |
v (into v1 v2)] | |
(assert (= v (vec (concat [:quux] (range 16 47) [:foo] | |
[:quux] (range 41 57) [:bar]))))) | |
(loop [v (transient []) | |
xs (range 100)] | |
(if-let [x (first xs)] | |
(recur | |
(condp #(%1 (mod %2 3)) x | |
#{0 2} (conj! v x) | |
#{1} (assoc! v (count v) x)) | |
(next xs)) | |
(assert (= (vec (range 100)) (persistent! v))))) | |
;; PersistentHashMap & TransientHashMap | |
(loop [m1 cljs.core.PersistentHashMap/EMPTY | |
m2 (transient cljs.core.PersistentHashMap/EMPTY) | |
i 0] | |
(if (< i 100) | |
(recur (assoc m1 i i) (assoc! m2 i i) (inc i)) | |
(let [m2 (persistent! m2)] | |
(assert (= (count m1) 100)) | |
(assert (= (count m2) 100)) | |
(assert (= m1 m2)) | |
(loop [i 0] | |
(if (< i 100) | |
(do (assert (= (m1 i) i)) | |
(assert (= (m2 i) i)) | |
(assert (= (get m1 i) i)) | |
(assert (= (get m2 i) i)) | |
(assert (contains? m1 i)) | |
(assert (contains? m2 i)) | |
(recur (inc i))))) | |
(assert (= (map vector (range 100) (range 100)) (sort-by first (seq m1)))) | |
(assert (= (map vector (range 100) (range 100)) (sort-by first (seq m2)))) | |
(assert (not (contains? (dissoc m1 3) 3)))))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentHashMap/EMPTY)) | |
(dissoc 3 5 7))] | |
(assert (= (count m) 7)) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9}))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentHashMap/EMPTY)) | |
(conj [:foo 1]))] | |
(assert (= (count m) 11)) | |
(assert (= m {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 :foo 1}))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentHashMap/EMPTY) | |
transient) | |
(conj! [:foo 1]) | |
persistent!)] | |
(assert (= (count m) 11)) | |
(assert (= m {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 :foo 1}))) | |
(let [tm (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentHashMap/EMPTY) | |
transient)] | |
(loop [tm tm ks [3 5 7]] | |
(if-let [k (first ks)] | |
(recur (dissoc! tm k) (next ks)) | |
(let [m (persistent! tm)] | |
(assert (= (count m) 7)) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9})))))) | |
(let [tm (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentHashMap/EMPTY)) | |
(dissoc 3 5 7) | |
transient)] | |
(doseq [k [0 1 2 4 6 8 9]] | |
(assert (= k (get tm k)))) | |
(let [m (persistent! tm)] | |
(assert (= 2 (try (dissoc! tm 1) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (assoc! tm 10 10) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (persistent! tm) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (count tm) 1 (catch js/Error e 2)))) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9})))) | |
(deftype FixedHash [h v] | |
IHash | |
(-hash [this] h) | |
IEquiv | |
(-equiv [this other] | |
(and (instance? FixedHash other) (= v (.-v other))))) | |
(def fixed-hash-foo (FixedHash. 0 :foo)) | |
(def fixed-hash-bar (FixedHash. 0 :bar)) | |
(let [m (assoc cljs.core.PersistentHashMap/EMPTY | |
fixed-hash-foo 1 | |
fixed-hash-bar 2)] | |
(assert (= (get m fixed-hash-foo) 1)) | |
(assert (= (get m fixed-hash-bar) 2)) | |
(assert (= (count m) 2)) | |
(let [m (dissoc m fixed-hash-foo)] | |
(assert (= (get m fixed-hash-bar) 2)) | |
(assert (not (contains? m fixed-hash-foo))) | |
(assert (= (count m) 1)))) | |
(let [m (into cljs.core.PersistentHashMap/EMPTY ; make sure we're testing | |
(zipmap (range 100) (range 100))) ; the correct map type | |
m (assoc m fixed-hash-foo 1 fixed-hash-bar 2)] | |
(assert (= (count m) 102)) | |
(assert (= (get m fixed-hash-foo) 1)) | |
(assert (= (get m fixed-hash-bar) 2)) | |
(let [m (dissoc m 3 5 7 fixed-hash-foo)] | |
(assert (= (get m fixed-hash-bar) 2)) | |
(assert (not (contains? m fixed-hash-foo))) | |
(assert (= (count m) 98)))) | |
(let [m (into cljs.core.PersistentHashMap/EMPTY ; make sure we're testing | |
(zipmap (range 100) (range 100))) ; the correct map type | |
m (transient m) | |
m (assoc! m fixed-hash-foo 1) | |
m (assoc! m fixed-hash-bar 2) | |
m (persistent! m)] | |
(assert (= (count m) 102)) | |
(assert (= (get m fixed-hash-foo) 1)) | |
(assert (= (get m fixed-hash-bar) 2)) | |
(let [m (dissoc m 3 5 7 fixed-hash-foo)] | |
(assert (= (get m fixed-hash-bar) 2)) | |
(assert (not (contains? m fixed-hash-foo))) | |
(assert (= (count m) 98)))) | |
;; PersistentArrayMap & TransientArrayMap | |
(def array-map-conversion-threshold | |
cljs.core.PersistentArrayMap/HASHMAP_THRESHOLD) | |
(loop [m1 cljs.core.PersistentArrayMap/EMPTY | |
m2 (transient cljs.core.PersistentArrayMap/EMPTY) | |
i 0] | |
(if (< i array-map-conversion-threshold) | |
(recur (assoc m1 i i) (assoc! m2 i i) (inc i)) | |
(let [m2 (persistent! m2)] | |
(assert (= (count m1) array-map-conversion-threshold)) | |
(assert (= (count m2) array-map-conversion-threshold)) | |
(assert (= m1 m2)) | |
(loop [i 0] | |
(if (< i array-map-conversion-threshold) | |
(do (assert (= (m1 i) i)) | |
(assert (= (m2 i) i)) | |
(assert (= (get m1 i) i)) | |
(assert (= (get m2 i) i)) | |
(assert (contains? m1 i)) | |
(assert (contains? m2 i)) | |
(recur (inc i))))) | |
(assert (= (map vector | |
(range array-map-conversion-threshold) | |
(range array-map-conversion-threshold)) | |
(sort-by first (seq m1)))) | |
(assert (= (map vector | |
(range array-map-conversion-threshold) | |
(range array-map-conversion-threshold)) | |
(sort-by first (seq m2)))) | |
(assert (not (contains? (dissoc m1 3) 3)))))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentArrayMap/EMPTY)) | |
(dissoc 3 5 7))] | |
(assert (= (count m) 7)) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9}))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentArrayMap/EMPTY)) | |
(conj [:foo 1]))] | |
(assert (= (count m) 11)) | |
(assert (= m {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 :foo 1}))) | |
(let [m (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentArrayMap/EMPTY) | |
transient) | |
(conj! [:foo 1]) | |
persistent!)] | |
(assert (= (count m) 11)) | |
(assert (= m {0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 :foo 1}))) | |
(let [tm (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentArrayMap/EMPTY) | |
transient)] | |
(loop [tm tm ks [3 5 7]] | |
(if-let [k (first ks)] | |
(recur (dissoc! tm k) (next ks)) | |
(let [m (persistent! tm)] | |
(assert (= (count m) 7)) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9})))))) | |
(let [tm (-> (->> (interleave (range 10) (range 10)) | |
(apply assoc cljs.core.PersistentArrayMap/EMPTY)) | |
(dissoc 3 5 7) | |
transient)] | |
(doseq [k [0 1 2 4 6 8 9]] | |
(assert (= k (get tm k)))) | |
(let [m (persistent! tm)] | |
(assert (= 2 (try (dissoc! tm 1) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (assoc! tm 10 10) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (persistent! tm) 1 (catch js/Error e 2)))) | |
(assert (= 2 (try (count tm) 1 (catch js/Error e 2)))) | |
(assert (= m {0 0 1 1 2 2 4 4 6 6 8 8 9 9})))) | |
(let [m (apply assoc cljs.core.PersistentArrayMap/EMPTY | |
(interleave (range (* 2 array-map-conversion-threshold)) | |
(range (* 2 array-map-conversion-threshold))))] | |
(assert (= (count m) (* 2 array-map-conversion-threshold))) | |
(assert (= (m array-map-conversion-threshold) array-map-conversion-threshold)) | |
(assert (= m (into cljs.core.PersistentHashMap/EMPTY | |
(map #(vector % %) | |
(range (* 2 array-map-conversion-threshold))))))) | |
;; literal maps | |
(loop [m1 {} m2 {} i 0] | |
(if (< i 100) | |
(recur (assoc m1 i i) (assoc m2 (str "foo" i) i) (inc i)) | |
(do (assert (= m1 (into cljs.core.PersistentHashMap/EMPTY | |
(map vector (range 100) (range 100))))) | |
(assert (= m2 (into cljs.core.PersistentHashMap/EMPTY | |
(map vector | |
(map (partial str "foo") (range 100)) | |
(range 100))))) | |
(assert (= (count m1) 100)) | |
(assert (= (count m2) 100))))) | |
;; TransientHashSet | |
(loop [s (transient #{}) | |
i 0] | |
(if (< i 100) | |
(recur (conj! s i) (inc i)) | |
(loop [s s i 0] | |
(if (< i 100) | |
(if (zero? (mod i 3)) | |
(recur (disj! s i) (inc i)) | |
(recur s (inc i))) | |
(let [s (persistent! s)] | |
(assert (= s (loop [s #{} xs (remove #(zero? (mod % 3)) (range 100))] | |
(if-let [x (first xs)] | |
(recur (conj s x) (next xs)) | |
s)))) | |
(assert (= s (set (remove #(zero? (mod % 3)) (range 100)))))))))) | |
;; PersistentTreeMap | |
(let [m1 (sorted-map) | |
c2 (comp - compare) | |
m2 (sorted-map-by c2)] | |
(assert (identical? cljs.core.PersistentTreeMap (type m1))) | |
(assert (identical? cljs.core.PersistentTreeMap (type m2))) | |
(assert (identical? compare (.-comp m1))) | |
(assert (zero? (count m1))) | |
(assert (zero? (count m2))) | |
(let [m1 (assoc m1 :foo 1 :bar 2 :quux 3) | |
m2 (assoc m2 :foo 1 :bar 2 :quux 3)] | |
(assert (= (count m1) 3)) | |
(assert (= (count m2) 3)) | |
(assert (= (seq m1) (list [:bar 2] [:foo 1] [:quux 3]))) | |
(assert (= (seq m2) (list [:quux 3] [:foo 1] [:bar 2]))) | |
(assert (= (seq m1) (rseq m2))) | |
(assert (= (seq m2) (rseq m1))) | |
(assert (= (conj m1 [:wibble 4]) {:foo 1 :bar 2 :quux 3 :wibble 4})) | |
(assert (= (count (conj m1 [:wibble 4])) 4)) | |
(assert (= (conj m2 [:wibble 4]) {:foo 1 :bar 2 :quux 3 :wibble 4})) | |
(assert (= (count (conj m2 [:wibble 4])) 4)) | |
(assert (= (map key (assoc m1 nil 4)) (list nil :bar :foo :quux))) | |
(assert (= (map key (assoc m2 nil 4)) (list :quux :foo :bar nil))))) | |
(let [m (->> [[0 10] [20 30] [10 20] [50 60] [30 40] [40 50]] | |
(mapcat (partial apply range)) | |
(mapcat #(list % %)) | |
(apply sorted-map)) | |
s1 (map #(vector % %) (range 60)) | |
s2 (map #(vector % %) (range 59 -1 -1))] | |
(assert (= (count m) 60)) | |
(assert (= (seq m) s1)) | |
(assert (= (rseq m) s2))) | |
(let [m (sorted-map :foo 1 :bar 2 :quux 3)] | |
(assert (= (dissoc m :foo) (hash-map :bar 2 :quux 3))) | |
(assert (= (count (dissoc m :foo)) 2)) | |
(assert (= (hash m) (hash (hash-map :foo 1 :bar 2 :quux 3)))) | |
(assert (= (subseq m < :foo) (list [:bar 2]))) | |
(assert (= (subseq m <= :foo) (list [:bar 2] [:foo 1]))) | |
(assert (= (subseq m > :foo) (list [:quux 3]))) | |
(assert (= (subseq m >= :foo) (list [:foo 1] [:quux 3]))) | |
(assert (= (map #(reduce (fn [_ x] x) %) m) (list 2 1 3))) | |
(assert (= (map #(reduce (fn [x _] x) 7 %) m) (list 7 7 7)))) | |
;; PersistentTreeSet | |
(let [s1 (sorted-set) | |
c2 (comp - compare) | |
s2 (sorted-set-by c2) | |
c3 #(compare (quot %1 2) (quot %2 2)) | |
s3 (sorted-set-by c3) | |
s4 (sorted-set-by <)] | |
(assert (identical? cljs.core.PersistentTreeSet (type s1))) | |
(assert (identical? cljs.core.PersistentTreeSet (type s2))) | |
(assert (identical? compare (-comparator s1))) | |
(assert (zero? (count s1))) | |
(assert (zero? (count s2))) | |
(let [s1 (conj s1 1 2 3) | |
s2 (conj s2 1 2 3) | |
s3 (conj s3 1 2 3 7 8 9) | |
s4 (conj s4 1 2 3)] | |
(assert (= (hash s1) (hash s2))) | |
(assert (= (hash s1) (hash #{1 2 3}))) | |
(assert (= (seq s1) (list 1 2 3))) | |
(assert (= (rseq s1) (list 3 2 1))) | |
(assert (= (seq s2) (list 3 2 1))) | |
(assert (= (rseq s2) (list 1 2 3))) | |
(assert (= (count s1) 3)) | |
(assert (= (count s2) 3)) | |
(assert (= (count s3) 4)) | |
(assert (= (get s3 0) 1)) | |
(assert (= (subseq s3 > 5) (list 7 8))) | |
(assert (= (subseq s3 > 6) (list 8))) | |
(assert (= (subseq s3 >= 6) (list 7 8))) | |
(assert (= (subseq s3 >= 12) nil)) | |
(assert (= (subseq s3 < 0) (list))) | |
(assert (= (subseq s3 < 5) (list 1 2))) | |
(assert (= (subseq s3 < 6) (list 1 2))) | |
(assert (= (subseq s3 <= 6) (list 1 2 7))) | |
(assert (= (subseq s3 >= 2 <= 6) (list 2 7))) | |
(assert (= (subseq s4 >= 2 < 3) (list 2))) | |
(let [s1 (disj s1 2) | |
s2 (disj s2 2)] | |
(assert (= (seq s1) (list 1 3))) | |
(assert (= (rseq s1) (list 3 1))) | |
(assert (= (seq s2) (list 3 1))) | |
(assert (= (rseq s2) (list 1 3))) | |
(assert (= (count s1) 2)) | |
(assert (= (count s2) 2))))) | |
(println "Completed 75% of tests") | |
;; defrecord | |
(defrecord Person [firstname lastname]) | |
(def fred (Person. "Fred" "Mertz")) | |
(assert (= (:firstname fred) "Fred")) | |
(def fred-too (Person. "Fred" "Mertz")) | |
(assert (= fred fred-too)) | |
(assert (false? (= fred nil))) | |
(assert (false? (= nil fred))) | |
(def ethel (Person. "Ethel" "Mertz" {:married true} {:husband :fred})) | |
(assert (= (meta ethel) {:married true})) | |
(def ethel-too (Person. "Ethel" "Mertz" {:married true} {:husband :fred})) | |
(assert (= ethel ethel-too)) | |
(assert (= (map->Person {:firstname "Fred" :lastname "Mertz"}) fred)) | |
(assert (= (->Person "Fred" "Mertz") fred)) | |
(assert (= (count fred) 2)) | |
(assert (= (count ethel) 3)) | |
(defrecord A []) | |
(assert (= {:foo 'bar} (meta (with-meta (A.) {:foo 'bar})))) | |
(assert (= 'bar (:foo (assoc (A.) :foo 'bar)))) | |
(defrecord C [a b c]) | |
(def letters (C. "a" "b" "c")) | |
(assert (= (set (keys letters)) #{:a :b :c})) | |
(def more-letters (assoc letters :d "d" :e "e" :f "f")) | |
(assert (= (set (keys more-letters)) #{:a :b :c :d :e :f})) | |
(assert (= (set (keys (dissoc more-letters :d))) #{:a :b :c :e :f})) | |
(assert (= (set (keys (dissoc more-letters :d :e))) #{:a :b :c :f})) | |
(assert (= (set (keys (dissoc more-letters :d :e :f))) #{:a :b :c})) | |
;; ObjMap | |
(let [ks (map (partial str "foo") (range 500)) | |
m (apply obj-map (interleave ks (range 500)))] | |
(assert (instance? cljs.core.ObjMap m)) | |
(assert (= 500 (count m))) | |
(assert (= 123 (m "foo123")))) | |
;; dot | |
(let [s "abc"] | |
(assert (= 3 (.-length s))) | |
(assert (= 3 (. s -length))) | |
(assert (= 3 (. (str 138) -length))) | |
(assert (= 3 (. "abc" -length))) | |
(assert (= "bc" (.substring s 1))) | |
(assert (= "bc" (.substring "abc" 1))) | |
(assert (= "bc" ((memfn substring start) s 1))) | |
(assert (= "bc" (. s substring 1))) | |
(assert (= "bc" (. s (substring 1)))) | |
(assert (= "bc" (. s (substring 1 3)))) | |
(assert (= "bc" (.substring s 1 3))) | |
(assert (= "ABC" (. s (toUpperCase)))) | |
(assert (= "ABC" (. "abc" (toUpperCase)))) | |
(assert (= "ABC" ((memfn toUpperCase) s))) | |
(assert (= "BC" (. (. s (toUpperCase)) substring 1))) | |
(assert (= 2 (.-length (. (. s (toUpperCase)) substring 1))))) | |
(assert (= (conj fred {:wife :ethel :friend :ricky}) | |
(map->Person {:firstname "Fred" :lastname "Mertz" :wife :ethel :friend :ricky}))) | |
(assert (= (conj fred {:lastname "Flintstone"}) | |
(map->Person {:firstname "Fred" :lastname "Flintstone"}))) | |
(assert (= (assoc fred :lastname "Flintstone") | |
(map->Person {:firstname "Fred" :lastname "Flintstone"}))) | |
(assert (= (assoc fred :wife :ethel) | |
(map->Person {:firstname "Fred" :lastname "Mertz" :wife :ethel}))) | |
(assert (= (dissoc ethel :husband) | |
(map->Person {:firstname "Ethel" :lastname "Mertz"}))) | |
(defrecord A [x]) | |
(defrecord B [x]) | |
(assert (not= (A. nil) (B. nil))) | |
;; protocols | |
(defprotocol IFoo (foo [this])) | |
(assert (= (meta (with-meta (reify IFoo (foo [this] :foo)) {:foo :bar})) | |
{:foo :bar})) | |
(defmulti foo2 identity) | |
(defmethod foo2 0 [x] x) | |
(assert (= foo2 (ffirst {foo2 1}))) | |
(defprotocol IMutate | |
(mutate [this])) | |
(deftype Mutate [^:mutable a] | |
IMutate | |
(mutate [_] | |
(set! a 'foo))) | |
;; IFn | |
(deftype FnLike [] | |
IFn | |
(-invoke [_] :a) | |
(-invoke [_ a] :b) | |
(-invoke [_ a b] :c)) | |
(assert (= :a ((FnLike.)))) | |
(assert (= :b ((FnLike.) 1))) | |
(assert (= :c ((FnLike.) 1 2))) | |
(assert (= [:b :b :b] (map (FnLike.) [0 0 0]))) | |
(deftype FnLikeB [a] | |
IFn | |
(-invoke [_] a)) | |
(assert (= 1 ((FnLikeB. 1)))) | |
;; hashing bug in many JS runtimes CLJ-118 | |
(let [g #{(conj #{:2} :alt)} | |
h #{#{:2 :alt}}] | |
(assert (= g h))) | |
(assert (= (hash {:a 1 :b 2}) | |
(hash {:b 2 :a 1}))) | |
(assert (= (hash (hash-map :a 1 :b 2)) | |
(hash (hash-map :b 2 :a 1)))) | |
(assert (= (hash {:start 133 :end 134}) | |
(hash (apply hash-map [:start 133 :end 134])))) | |
(defprotocol IHasFirst | |
(-get-first [this])) | |
(defprotocol IFindsFirst | |
(-find-first [this other])) | |
(deftype First [xs] | |
ISeqable | |
(-seq [this] (seq xs)) | |
IIndexed | |
(-nth [this i] (nth xs i)) | |
(-nth [this i not-found] (nth xs i not-found)) | |
IFn | |
(-invoke [[x]] x) | |
(-invoke [this x] this) | |
Object | |
(toString [[x]] (str x)) | |
IHasFirst | |
(-get-first [[x]] x) | |
IFindsFirst | |
(-find-first [_ [x]] x)) | |
(let [fv (First. [1 2 3]) | |
fs (First. "asdf")] | |
(assert (= (fv) 1)) | |
(assert (= (fs) \a)) | |
(assert (= (str fs) \a)) | |
(assert (= (-get-first fv) 1)) | |
(assert (= (-get-first fs) \a)) | |
(assert (= (-find-first fv [1]) 1)) | |
(assert (identical? (fv 1) fv))) | |
(deftype DestructuringWithLocals [a] | |
IFindsFirst | |
(-find-first [_ [x y]] | |
[x y a])) | |
(let [t (DestructuringWithLocals. 1)] | |
(assert (= [2 3 1] (-find-first t [2 3])))) | |
(let [x 1] | |
(assert (= (case x 1 :one) :one))) | |
(let [x 1] | |
(assert (= (case x 2 :two :default) :default))) | |
(let [x 1] | |
(assert (= (try | |
(case x 3 :three) | |
(catch js/Error e | |
:fail)) | |
:fail))) | |
(let [x 1] | |
(assert (= (case x | |
(1 2 3) :ok | |
:fail) | |
:ok))) | |
(let [x [:a :b]] | |
(assert (= (case x | |
[:a :b] :ok) | |
:ok))) | |
(let [a 'a] | |
(assert (= (case a | |
nil nil | |
& :amp | |
:none) | |
:none))) | |
(let [a '&] | |
(assert (= (case a | |
nil nil | |
& :amp | |
:none) | |
:amp))) | |
(let [foo 'a] | |
(assert (= (case foo | |
(a b c) :sym | |
:none) | |
:sym)) | |
(assert (= (case foo | |
(b c d) :sym | |
:none) | |
:none))) | |
;; IComparable | |
(assert (= 0 (compare false false))) | |
(assert (= -1 (compare false true))) | |
(assert (= 1 (compare true false))) | |
(assert (= -1 (compare 0 1))) | |
(assert (= -1 (compare -1 1))) | |
(assert (= 0 (compare 1 1))) | |
(assert (= 1 (compare 1 0))) | |
(assert (= 1 (compare 1 -1))) | |
(assert (= 0 (compare "cljs" "cljs"))) | |
(assert (= 0 (compare :cljs :cljs))) | |
(assert (= 0 (compare 'cljs 'cljs))) | |
(assert (= -1 (compare "a" "b"))) | |
(assert (= -1 (compare :a :b))) | |
(assert (= -1 (compare 'a 'b))) | |
;; cases involving ns | |
(assert (= -1 (compare :b/a :c/a))) | |
#_(assert (= -1 (compare :c :a/b))) | |
#_(assert (= 1 (compare :a/b :c))) | |
(assert (= -1 (compare 'b/a 'c/a))) | |
#_(assert (= -1 (compare 'c 'a/b))) | |
#_(assert (= 1 (compare 'a/b 'c))) | |
;; This is different from clj. clj gives -2 next 3 tests | |
(assert (= -1 (compare "a" "c"))) | |
(assert (= -1 (compare :a :c))) | |
(assert (= -1 (compare 'a 'c))) | |
(assert (= -1 (compare [1 2] [1 1 1]))) | |
(assert (= -1 (compare [1 2] [1 2 1]))) | |
(assert (= -1 (compare [1 1] [1 2]))) | |
(assert (= 0 (compare [1 2] [1 2]))) | |
(assert (= 1 (compare [1 2] [1 1]))) | |
(assert (= 1 (compare [1 1 1] [1 2]))) | |
(assert (= 1 (compare [1 1 2] [1 1 1]))) | |
(assert (= -1 (compare (subvec [1 2 3] 1) (subvec [1 2 4] 1)))) | |
(assert (= 0 (compare (subvec [1 2 3] 1) (subvec [1 2 3] 1)))) | |
(assert (= 1 (compare (subvec [1 2 4] 1) (subvec [1 2 3] 1)))) | |
;; RSeq | |
(assert (= '(3 2 1) (reverse (seq (array 1 2 3))))) | |
(assert (= '(3 2 1) (reverse [1 2 3]))) | |
(assert (= '(4 3 2 1) (cons 4 (reverse [1 2 3])))) | |
(assert (= 6 (reduce + (reverse [1 2 3])))) | |
(assert (= '(4 3 2) (map inc (reverse [1 2 3])))) | |
(assert (= '(4 2) (filter even? (reverse [1 2 3 4])))) | |
;; Chunked Sequences | |
(assert (= (hash (seq [1 2])) (hash (seq [1 2])))) | |
(assert (= 6 (reduce + (array-chunk (array 1 2 3))))) | |
(assert (instance? ChunkedSeq (seq [1 2 3]))) | |
(assert (= '(1 2 3) (seq [1 2 3]))) | |
(assert (= '(2 3 4) (map inc [1 2 3]))) | |
(assert (= '(2) (filter even? [1 2 3]))) | |
(assert (= '(1 3) (filter odd? [1 2 3]))) | |
(assert (= '(1 2 3) (concat [1] [2] [3]))) | |
;; INext | |
(assert (= nil (next nil))) | |
(assert (= nil (next (seq (array 1))))) | |
(assert (= '(2 3) (next (seq (array 1 2 3))))) | |
(assert (= nil (next (reverse (seq (array 1)))))) | |
(assert (= '(2 1) (next (reverse (seq (array 1 2 3)))))) | |
(assert (= nil (next (cons 1 nil)))) | |
(assert (= '(2 3) (next (cons 1 (cons 2 (cons 3 nil)))))) | |
(assert (= nil (next (lazy-seq (cons 1 nil))))) | |
(assert (= '(2 3) (next (lazy-seq | |
(cons 1 | |
(lazy-seq | |
(cons 2 | |
(lazy-seq (cons 3 nil))))))))) | |
(assert (= nil (next (list 1)))) | |
(assert (= '(2 3) (next (list 1 2 3)))) | |
(assert (= nil (next [1]))) | |
(assert (= '(2 3) (next [1 2 3]))) | |
(assert (= nil (next (range 1 2)))) | |
(assert (= '(2 3) (next (range 1 4)))) | |
;; UUID | |
(assert (= (UUID. "550e8400-e29b-41d4-a716-446655440000") | |
(UUID. "550e8400-e29b-41d4-a716-446655440000"))) | |
(assert (not (identical? (UUID. "550e8400-e29b-41d4-a716-446655440000") | |
(UUID. "550e8400-e29b-41d4-a716-446655440000")))) | |
(assert (= 42 (get {(UUID. "550e8400-e29b-41d4-a716-446655440000") 42} | |
(UUID. "550e8400-e29b-41d4-a716-446655440000") | |
:not-at-all-found))) | |
(assert (= :not-at-all-found | |
(get {(UUID. "550e8400-e29b-41d4-a716-446655440000") 42} | |
(UUID. "666e8400-e29b-41d4-a716-446655440000") | |
:not-at-all-found))) | |
;; Reader literals | |
;; TODO: reader literals | |
;; (assert (= #queue [1] (into cljs.core.PersistentQueue/EMPTY [1]))) | |
;; (assert (not= #queue [1 2] (into cljs.core.PersistentQueue/EMPTY [1]))) | |
;; | |
;; (assert (= #inst "2010-11-12T18:14:15.666-00:00" | |
;; #inst "2010-11-12T13:14:15.666-05:00")) | |
;; | |
;; (assert (= #uuid "550e8400-e29b-41d4-a716-446655440000" | |
;; #uuid "550e8400-e29b-41d4-a716-446655440000")) | |
;; | |
;; (assert (= 42 | |
;; (get {#uuid "550e8400-e29b-41d4-a716-446655440000" 42} | |
;; #uuid "550e8400-e29b-41d4-a716-446655440000"))) | |
;; pr-str | |
(assert (= (pr-str 1) "1")) | |
(assert (= (pr-str -1) "-1")) | |
(assert (= (pr-str -1.5) "-1.5")) | |
(assert (= (pr-str [3 4]) "[3 4]")) | |
(assert (= (pr-str "foo") "\"foo\"")) | |
(assert (= (pr-str :hello) ":hello")) | |
(assert (= (pr-str 'goodbye) "goodbye")) | |
(assert (= (pr-str #{1 2 3}) "#{1 2 3}")) | |
(assert (= (pr-str '(7 8 9)) "(7 8 9)")) | |
(assert (= (pr-str '(deref foo)) "(deref foo)")) | |
(assert (= (pr-str '(quote bar)) "(quote bar)")) | |
(assert (= (pr-str 'foo/bar) "foo/bar")) | |
(assert (= (pr-str \a) "\"a\"")) | |
(assert (= (pr-str :foo/bar) ":foo/bar")) | |
(assert (= (pr-str nil) "nil")) | |
(assert (= (pr-str true) "true")) | |
(assert (= (pr-str false) "false")) | |
(assert (= (pr-str "string") "\"string\"")) | |
;; TODO: fix unicode symbols | |
;; (assert (= (pr-str ["üñîçó∂£" :ทดสอบ/你好 'こんにちは]) "[\"üñîçó∂£\" :ทดสอบ/你好 こんにちは]")) | |
(assert (= (pr-str "escape chars \t \r \n \\ \" \b \f") "\"escape chars \\t \\r \\n \\\\ \\\" \\b \\f\"")) | |
;;; pr-str records | |
(defrecord PrintMe [a b]) | |
(assert (= (pr-str (PrintMe. 1 2)) "#PrintMe{:a 1, :b 2}")) | |
;;; pr-str backwards compatibility | |
(deftype PrintMeBackwardsCompat [a b] | |
IPrintable | |
(-pr-seq [_ _] (list (str "<<<" a " " b ">>>")))) | |
(assert (= (pr-str (PrintMeBackwardsCompat. 1 2)) "<<<1 2>>>")) | |
;;; pr-str inst | |
(assert (= (pr-str (js/Date. "2010-11-12T13:14:15.666-05:00")) | |
"#inst \"2010-11-12T18:14:15.666-00:00\"")) | |
(doseq [month (range 1 13) day (range 1 29) hour (range 1 23)] | |
(let [pad (fn [n] | |
(if (< n 10) | |
(str "0" n) | |
n)) | |
inst (str "2010-" (pad month) "-" (pad day) "T" (pad hour) ":14:15.666-00:00")] | |
(assert (= (pr-str (js/Date. inst)) (str "#inst \"" inst "\""))))) | |
;;; pr-str uuid | |
(let [uuid-str "550e8400-e29b-41d4-a716-446655440000" | |
uuid (UUID. uuid-str)] | |
(assert (= (pr-str uuid) (str "#uuid \"" uuid-str "\"")))) | |
;; CLJS-405 | |
(defprotocol IBar (-bar [this x])) | |
(defn baz [f] | |
(reify | |
IBar | |
(-bar [_ x] | |
(f x)))) | |
(assert (= 2 (-bar (baz inc) 1))) | |
;; CLJS-401 / CLJS-411 | |
(let [x "original"] | |
(defn original-closure-stmt [] x)) | |
(let [x "overwritten"] | |
(assert (= "original" (original-closure-stmt)))) | |
(assert (= "original" (let [x "original" | |
oce (fn [] x) | |
x "overwritten"] | |
(oce)))) | |
(letfn [(x [] "original") | |
(y [] (x))] | |
(let [x (fn [] "overwritten")] | |
(assert (= "original" (y))))) | |
(println "Completed 100% of tests") | |
:ok | |
) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment