|
rlm@10
|
1 ; Copyright (c) Rich Hickey. All rights reserved.
|
|
rlm@10
|
2 ; The use and distribution terms for this software are covered by the
|
|
rlm@10
|
3 ; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
|
|
rlm@10
|
4 ; which can be found in the file epl-v10.html at the root of this distribution.
|
|
rlm@10
|
5 ; By using this software in any fashion, you are agreeing to be bound by
|
|
rlm@10
|
6 ; the terms of this license.
|
|
rlm@10
|
7 ; You must not remove this notice, or any other, from this software.
|
|
rlm@10
|
8
|
|
rlm@10
|
9 ; Author: Stuart Halloway, Daniel Solano Gómez
|
|
rlm@10
|
10
|
|
rlm@10
|
11 (ns clojure.test-clojure.vectors
|
|
rlm@10
|
12 (:use clojure.test))
|
|
rlm@10
|
13
|
|
rlm@10
|
14 (deftest test-reversed-vec
|
|
rlm@10
|
15 (let [r (range 6)
|
|
rlm@10
|
16 v (into (vector-of :int) r)
|
|
rlm@10
|
17 reversed (.rseq v)]
|
|
rlm@10
|
18 (testing "returns the right impl"
|
|
rlm@10
|
19 (is (= clojure.lang.APersistentVector$RSeq (class reversed))))
|
|
rlm@10
|
20 (testing "RSeq methods"
|
|
rlm@10
|
21 (is (= [5 4 3 2 1 0] reversed))
|
|
rlm@10
|
22 (is (= 5 (.index reversed)))
|
|
rlm@10
|
23 (is (= 5 (.first reversed)))
|
|
rlm@10
|
24 (is (= [4 3 2 1 0] (.next reversed)))
|
|
rlm@10
|
25 (is (= [3 2 1 0] (.. reversed next next)))
|
|
rlm@10
|
26 (is (= 6 (.count reversed))))
|
|
rlm@10
|
27 (testing "clojure calling through"
|
|
rlm@10
|
28 (is (= 5 (first reversed)))
|
|
rlm@10
|
29 (is (= 5 (nth reversed 0))))
|
|
rlm@10
|
30 (testing "empty reverses to nil"
|
|
rlm@10
|
31 (is (nil? (.. v empty rseq))))))
|
|
rlm@10
|
32
|
|
rlm@10
|
33 (deftest test-vecseq
|
|
rlm@10
|
34 (let [r (range 100)
|
|
rlm@10
|
35 vs (into (vector-of :int) r)
|
|
rlm@10
|
36 vs-1 (next vs)
|
|
rlm@10
|
37 vs-32 (.chunkedNext (seq vs))]
|
|
rlm@10
|
38 (testing "="
|
|
rlm@10
|
39 (are [a b] (= a b)
|
|
rlm@10
|
40 vs vs
|
|
rlm@10
|
41 vs-1 vs-1
|
|
rlm@10
|
42 vs-32 vs-32)
|
|
rlm@10
|
43 (are [a b] (not= a b)
|
|
rlm@10
|
44 vs vs-1
|
|
rlm@10
|
45 vs-1 vs
|
|
rlm@10
|
46 vs vs-32
|
|
rlm@10
|
47 vs-32 vs))
|
|
rlm@10
|
48 (testing "IPersistentCollection.empty"
|
|
rlm@10
|
49 (are [a] (identical? clojure.lang.PersistentList/EMPTY (.empty (seq a)))
|
|
rlm@10
|
50 vs vs-1 vs-32))
|
|
rlm@10
|
51 (testing "IPersistentCollection.cons"
|
|
rlm@10
|
52 (are [result input] (= result (.cons input :foo))
|
|
rlm@10
|
53 [:foo 1] (seq (into (vector-of :int) [1]))))
|
|
rlm@10
|
54 (testing "IPersistentCollection.count"
|
|
rlm@10
|
55 (are [ct s] (= ct (.count (seq s)))
|
|
rlm@10
|
56 100 vs
|
|
rlm@10
|
57 99 vs-1
|
|
rlm@10
|
58 68 vs-32)
|
|
rlm@10
|
59 ;; can't manufacture this scenario: ASeq defers to Counted, but
|
|
rlm@10
|
60 ;; LazySeq doesn't, so Counted never gets checked on reified seq below
|
|
rlm@10
|
61 #_(testing "hops to counted when available"
|
|
rlm@10
|
62 (is (= 200
|
|
rlm@10
|
63 (.count (concat
|
|
rlm@10
|
64 (seq vs)
|
|
rlm@10
|
65 (reify clojure.lang.ISeq
|
|
rlm@10
|
66 (seq [this] this)
|
|
rlm@10
|
67 clojure.lang.Counted
|
|
rlm@10
|
68 (count [_] 100))))))))
|
|
rlm@10
|
69 (testing "IPersistentCollection.equiv"
|
|
rlm@10
|
70 (are [a b] (true? (.equiv a b))
|
|
rlm@10
|
71 vs vs
|
|
rlm@10
|
72 vs-1 vs-1
|
|
rlm@10
|
73 vs-32 vs-32
|
|
rlm@10
|
74 vs r)
|
|
rlm@10
|
75 (are [a b] (false? (.equiv a b))
|
|
rlm@10
|
76 vs vs-1
|
|
rlm@10
|
77 vs-1 vs
|
|
rlm@10
|
78 vs vs-32
|
|
rlm@10
|
79 vs-32 vs
|
|
rlm@10
|
80 vs nil))))
|
|
rlm@10
|
81
|
|
rlm@10
|
82 (deftest test-vec-compare
|
|
rlm@10
|
83 (let [nums (range 1 100)
|
|
rlm@10
|
84 ; randomly replaces a single item with the given value
|
|
rlm@10
|
85 rand-replace (fn[val]
|
|
rlm@10
|
86 (let [r (rand-int 99)]
|
|
rlm@10
|
87 (concat (take r nums) [val] (drop (inc r) nums))))
|
|
rlm@10
|
88 ; all num sequences in map
|
|
rlm@10
|
89 num-seqs {:standard nums
|
|
rlm@10
|
90 :empty '()
|
|
rlm@10
|
91 ; different lengths
|
|
rlm@10
|
92 :longer (concat nums [100])
|
|
rlm@10
|
93 :shorter (drop-last nums)
|
|
rlm@10
|
94 ; greater by value
|
|
rlm@10
|
95 :first-greater (concat [100] (next nums))
|
|
rlm@10
|
96 :last-greater (concat (drop-last nums) [100])
|
|
rlm@10
|
97 :rand-greater-1 (rand-replace 100)
|
|
rlm@10
|
98 :rand-greater-2 (rand-replace 100)
|
|
rlm@10
|
99 :rand-greater-3 (rand-replace 100)
|
|
rlm@10
|
100 ; lesser by value
|
|
rlm@10
|
101 :first-lesser (concat [0] (next nums))
|
|
rlm@10
|
102 :last-lesser (concat (drop-last nums) [0])
|
|
rlm@10
|
103 :rand-lesser-1 (rand-replace 0)
|
|
rlm@10
|
104 :rand-lesser-2 (rand-replace 0)
|
|
rlm@10
|
105 :rand-lesser-3 (rand-replace 0)}
|
|
rlm@10
|
106 ; a way to create compare values based on num-seqs
|
|
rlm@10
|
107 create-vals (fn[base-val]
|
|
rlm@10
|
108 (zipmap (keys num-seqs)
|
|
rlm@10
|
109 (map #(into base-val %1) (vals num-seqs))))
|
|
rlm@10
|
110 ; Vecs made of int primitives
|
|
rlm@10
|
111 int-vecs (create-vals (vector-of :int))
|
|
rlm@10
|
112 ; Vecs made of long primitives
|
|
rlm@10
|
113 long-vecs (create-vals (vector-of :long))
|
|
rlm@10
|
114 ; standard boxing vectors
|
|
rlm@10
|
115 regular-vecs (create-vals [])
|
|
rlm@10
|
116 ; the standard int Vec for comparisons
|
|
rlm@10
|
117 int-vec (:standard int-vecs)]
|
|
rlm@10
|
118 (testing "compare"
|
|
rlm@10
|
119 (testing "identical"
|
|
rlm@10
|
120 (is (= 0 (compare int-vec int-vec))))
|
|
rlm@10
|
121 (testing "equivalent"
|
|
rlm@10
|
122 (are [x y] (= 0 (compare x y))
|
|
rlm@10
|
123 ; standard
|
|
rlm@10
|
124 int-vec (:standard long-vecs)
|
|
rlm@10
|
125 (:standard long-vecs) int-vec
|
|
rlm@10
|
126 int-vec (:standard regular-vecs)
|
|
rlm@10
|
127 (:standard regular-vecs) int-vec
|
|
rlm@10
|
128 ; empty
|
|
rlm@10
|
129 (:empty int-vecs) (:empty long-vecs)
|
|
rlm@10
|
130 (:empty long-vecs) (:empty int-vecs)))
|
|
rlm@10
|
131 (testing "lesser"
|
|
rlm@10
|
132 (are [x] (= -1 (compare int-vec x))
|
|
rlm@10
|
133 (:longer int-vecs)
|
|
rlm@10
|
134 (:longer long-vecs)
|
|
rlm@10
|
135 (:longer regular-vecs)
|
|
rlm@10
|
136 (:first-greater int-vecs)
|
|
rlm@10
|
137 (:first-greater long-vecs)
|
|
rlm@10
|
138 (:first-greater regular-vecs)
|
|
rlm@10
|
139 (:last-greater int-vecs)
|
|
rlm@10
|
140 (:last-greater long-vecs)
|
|
rlm@10
|
141 (:last-greater regular-vecs)
|
|
rlm@10
|
142 (:rand-greater-1 int-vecs)
|
|
rlm@10
|
143 (:rand-greater-1 long-vecs)
|
|
rlm@10
|
144 (:rand-greater-1 regular-vecs)
|
|
rlm@10
|
145 (:rand-greater-2 int-vecs)
|
|
rlm@10
|
146 (:rand-greater-2 long-vecs)
|
|
rlm@10
|
147 (:rand-greater-2 regular-vecs)
|
|
rlm@10
|
148 (:rand-greater-3 int-vecs)
|
|
rlm@10
|
149 (:rand-greater-3 long-vecs)
|
|
rlm@10
|
150 (:rand-greater-3 regular-vecs))
|
|
rlm@10
|
151 (are [x] (= -1 (compare x int-vec))
|
|
rlm@10
|
152 nil
|
|
rlm@10
|
153 (:empty int-vecs)
|
|
rlm@10
|
154 (:empty long-vecs)
|
|
rlm@10
|
155 (:empty regular-vecs)
|
|
rlm@10
|
156 (:shorter int-vecs)
|
|
rlm@10
|
157 (:shorter long-vecs)
|
|
rlm@10
|
158 (:shorter regular-vecs)
|
|
rlm@10
|
159 (:first-lesser int-vecs)
|
|
rlm@10
|
160 (:first-lesser long-vecs)
|
|
rlm@10
|
161 (:first-lesser regular-vecs)
|
|
rlm@10
|
162 (:last-lesser int-vecs)
|
|
rlm@10
|
163 (:last-lesser long-vecs)
|
|
rlm@10
|
164 (:last-lesser regular-vecs)
|
|
rlm@10
|
165 (:rand-lesser-1 int-vecs)
|
|
rlm@10
|
166 (:rand-lesser-1 long-vecs)
|
|
rlm@10
|
167 (:rand-lesser-1 regular-vecs)
|
|
rlm@10
|
168 (:rand-lesser-2 int-vecs)
|
|
rlm@10
|
169 (:rand-lesser-2 long-vecs)
|
|
rlm@10
|
170 (:rand-lesser-2 regular-vecs)
|
|
rlm@10
|
171 (:rand-lesser-3 int-vecs)
|
|
rlm@10
|
172 (:rand-lesser-3 long-vecs)
|
|
rlm@10
|
173 (:rand-lesser-3 regular-vecs)))
|
|
rlm@10
|
174 (testing "greater"
|
|
rlm@10
|
175 (are [x] (= 1 (compare int-vec x))
|
|
rlm@10
|
176 nil
|
|
rlm@10
|
177 (:empty int-vecs)
|
|
rlm@10
|
178 (:empty long-vecs)
|
|
rlm@10
|
179 (:empty regular-vecs)
|
|
rlm@10
|
180 (:shorter int-vecs)
|
|
rlm@10
|
181 (:shorter long-vecs)
|
|
rlm@10
|
182 (:shorter regular-vecs)
|
|
rlm@10
|
183 (:first-lesser int-vecs)
|
|
rlm@10
|
184 (:first-lesser long-vecs)
|
|
rlm@10
|
185 (:first-lesser regular-vecs)
|
|
rlm@10
|
186 (:last-lesser int-vecs)
|
|
rlm@10
|
187 (:last-lesser long-vecs)
|
|
rlm@10
|
188 (:last-lesser regular-vecs)
|
|
rlm@10
|
189 (:rand-lesser-1 int-vecs)
|
|
rlm@10
|
190 (:rand-lesser-1 long-vecs)
|
|
rlm@10
|
191 (:rand-lesser-1 regular-vecs)
|
|
rlm@10
|
192 (:rand-lesser-2 int-vecs)
|
|
rlm@10
|
193 (:rand-lesser-2 long-vecs)
|
|
rlm@10
|
194 (:rand-lesser-2 regular-vecs)
|
|
rlm@10
|
195 (:rand-lesser-3 int-vecs)
|
|
rlm@10
|
196 (:rand-lesser-3 long-vecs)
|
|
rlm@10
|
197 (:rand-lesser-3 regular-vecs))
|
|
rlm@10
|
198 (are [x] (= 1 (compare x int-vec))
|
|
rlm@10
|
199 (:longer int-vecs)
|
|
rlm@10
|
200 (:longer long-vecs)
|
|
rlm@10
|
201 (:longer regular-vecs)
|
|
rlm@10
|
202 (:first-greater int-vecs)
|
|
rlm@10
|
203 (:first-greater long-vecs)
|
|
rlm@10
|
204 (:first-greater regular-vecs)
|
|
rlm@10
|
205 (:last-greater int-vecs)
|
|
rlm@10
|
206 (:last-greater long-vecs)
|
|
rlm@10
|
207 (:last-greater regular-vecs)
|
|
rlm@10
|
208 (:rand-greater-1 int-vecs)
|
|
rlm@10
|
209 (:rand-greater-1 long-vecs)
|
|
rlm@10
|
210 (:rand-greater-1 regular-vecs)
|
|
rlm@10
|
211 (:rand-greater-2 int-vecs)
|
|
rlm@10
|
212 (:rand-greater-2 long-vecs)
|
|
rlm@10
|
213 (:rand-greater-2 regular-vecs)
|
|
rlm@10
|
214 (:rand-greater-3 int-vecs)
|
|
rlm@10
|
215 (:rand-greater-3 long-vecs)
|
|
rlm@10
|
216 (:rand-greater-3 regular-vecs))))
|
|
rlm@10
|
217 (testing "Comparable.compareTo"
|
|
rlm@10
|
218 (testing "incompatible"
|
|
rlm@10
|
219 (is (thrown? NullPointerException (.compareTo int-vec nil)))
|
|
rlm@10
|
220 (are [x] (thrown? ClassCastException (.compareTo int-vec x))
|
|
rlm@10
|
221 '()
|
|
rlm@10
|
222 {}
|
|
rlm@10
|
223 #{}
|
|
rlm@10
|
224 (sorted-set)
|
|
rlm@10
|
225 (sorted-map)
|
|
rlm@10
|
226 nums
|
|
rlm@10
|
227 1))
|
|
rlm@10
|
228 (testing "identical"
|
|
rlm@10
|
229 (is (= 0 (.compareTo int-vec int-vec))))
|
|
rlm@10
|
230 (testing "equivalent"
|
|
rlm@10
|
231 (are [x] (= 0 (.compareTo int-vec x))
|
|
rlm@10
|
232 (:standard long-vecs)
|
|
rlm@10
|
233 (:standard regular-vecs)))
|
|
rlm@10
|
234 (testing "lesser"
|
|
rlm@10
|
235 (are [x] (= -1 (.compareTo int-vec x))
|
|
rlm@10
|
236 (:longer int-vecs)
|
|
rlm@10
|
237 (:longer long-vecs)
|
|
rlm@10
|
238 (:longer regular-vecs)
|
|
rlm@10
|
239 (:first-greater int-vecs)
|
|
rlm@10
|
240 (:first-greater long-vecs)
|
|
rlm@10
|
241 (:first-greater regular-vecs)
|
|
rlm@10
|
242 (:last-greater int-vecs)
|
|
rlm@10
|
243 (:last-greater long-vecs)
|
|
rlm@10
|
244 (:last-greater regular-vecs)
|
|
rlm@10
|
245 (:rand-greater-1 int-vecs)
|
|
rlm@10
|
246 (:rand-greater-1 long-vecs)
|
|
rlm@10
|
247 (:rand-greater-1 regular-vecs)
|
|
rlm@10
|
248 (:rand-greater-2 int-vecs)
|
|
rlm@10
|
249 (:rand-greater-2 long-vecs)
|
|
rlm@10
|
250 (:rand-greater-2 regular-vecs)
|
|
rlm@10
|
251 (:rand-greater-3 int-vecs)
|
|
rlm@10
|
252 (:rand-greater-3 long-vecs)
|
|
rlm@10
|
253 (:rand-greater-3 regular-vecs)))
|
|
rlm@10
|
254 (testing "greater"
|
|
rlm@10
|
255 (are [x] (= 1 (.compareTo int-vec x))
|
|
rlm@10
|
256 (:empty int-vecs)
|
|
rlm@10
|
257 (:empty long-vecs)
|
|
rlm@10
|
258 (:empty regular-vecs)
|
|
rlm@10
|
259 (:shorter int-vecs)
|
|
rlm@10
|
260 (:shorter long-vecs)
|
|
rlm@10
|
261 (:shorter regular-vecs)
|
|
rlm@10
|
262 (:first-lesser int-vecs)
|
|
rlm@10
|
263 (:first-lesser long-vecs)
|
|
rlm@10
|
264 (:first-lesser regular-vecs)
|
|
rlm@10
|
265 (:last-lesser int-vecs)
|
|
rlm@10
|
266 (:last-lesser long-vecs)
|
|
rlm@10
|
267 (:last-lesser regular-vecs)
|
|
rlm@10
|
268 (:rand-lesser-1 int-vecs)
|
|
rlm@10
|
269 (:rand-lesser-1 long-vecs)
|
|
rlm@10
|
270 (:rand-lesser-1 regular-vecs)
|
|
rlm@10
|
271 (:rand-lesser-2 int-vecs)
|
|
rlm@10
|
272 (:rand-lesser-2 long-vecs)
|
|
rlm@10
|
273 (:rand-lesser-2 regular-vecs)
|
|
rlm@10
|
274 (:rand-lesser-3 int-vecs)
|
|
rlm@10
|
275 (:rand-lesser-3 long-vecs)
|
|
rlm@10
|
276 (:rand-lesser-3 regular-vecs))))))
|
|
rlm@10
|
277
|
|
rlm@10
|
278 (deftest test-vec-associative
|
|
rlm@10
|
279 (let [empty-v (vector-of :long)
|
|
rlm@10
|
280 v (into empty-v (range 1 6))]
|
|
rlm@10
|
281 (testing "Associative.containsKey"
|
|
rlm@10
|
282 (are [x] (.containsKey v x)
|
|
rlm@10
|
283 0 1 2 3 4)
|
|
rlm@10
|
284 (are [x] (not (.containsKey v x))
|
|
rlm@10
|
285 -1 -100 nil [] "" #"" #{} 5 100)
|
|
rlm@10
|
286 (are [x] (not (.containsKey empty-v x))
|
|
rlm@10
|
287 0 1))
|
|
rlm@10
|
288 (testing "contains?"
|
|
rlm@10
|
289 (are [x] (contains? v x)
|
|
rlm@10
|
290 0 2 4)
|
|
rlm@10
|
291 (are [x] (not (contains? v x))
|
|
rlm@10
|
292 -1 -100 nil "" 5 100)
|
|
rlm@10
|
293 (are [x] (not (contains? empty-v x))
|
|
rlm@10
|
294 0 1))
|
|
rlm@10
|
295 (testing "Associative.entryAt"
|
|
rlm@10
|
296 (are [idx val] (= (clojure.lang.MapEntry. idx val)
|
|
rlm@10
|
297 (.entryAt v idx))
|
|
rlm@10
|
298 0 1
|
|
rlm@10
|
299 2 3
|
|
rlm@10
|
300 4 5)
|
|
rlm@10
|
301 (are [idx] (nil? (.entryAt v idx))
|
|
rlm@10
|
302 -5 -1 5 10 nil "")
|
|
rlm@10
|
303 (are [idx] (nil? (.entryAt empty-v idx))
|
|
rlm@10
|
304 0 1))))
|
