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