OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 library map_test; | |
6 | |
7 import "package:expect/expect.dart"; | |
8 import 'dart:collection'; | |
9 import 'dart:convert' show JSON; | |
10 | |
11 Map newJsonMap() => JSON.decode('{}'); | |
12 Map newJsonMapCustomReviver() => | |
13 JSON.decode('{}', reviver: (key, value) => value); | |
14 | |
15 void main() { | |
16 test(new HashMap()); | |
17 test(new LinkedHashMap()); | |
18 test(new SplayTreeMap()); | |
19 test(new SplayTreeMap(Comparable.compare)); | |
20 test(new MapView(new HashMap())); | |
21 test(new MapView(new SplayTreeMap())); | |
22 test(new MapBaseMap()); | |
23 test(new MapMixinMap()); | |
24 testLinkedHashMap(); | |
25 testMapLiteral(); | |
26 testNullValue(); | |
27 testTypes(); | |
28 | |
29 testWeirdStringKeys(new Map()); | |
30 testWeirdStringKeys(new Map<String, String>()); | |
31 testWeirdStringKeys(new HashMap()); | |
32 testWeirdStringKeys(new HashMap<String, String>()); | |
33 testWeirdStringKeys(new LinkedHashMap()); | |
34 testWeirdStringKeys(new LinkedHashMap<String, String>()); | |
35 testWeirdStringKeys(new SplayTreeMap()); | |
36 testWeirdStringKeys(new SplayTreeMap<String, String>()); | |
37 testWeirdStringKeys(new MapBaseMap<String, String>()); | |
38 testWeirdStringKeys(new MapMixinMap<String, String>()); | |
39 testWeirdStringKeys(newJsonMap()); | |
40 testWeirdStringKeys(newJsonMapCustomReviver()); | |
41 | |
42 testNumericKeys(new Map()); | |
43 testNumericKeys(new Map<num, String>()); | |
44 testNumericKeys(new HashMap()); | |
45 testNumericKeys(new HashMap<num, String>()); | |
46 testNumericKeys(new HashMap.identity()); | |
47 testNumericKeys(new HashMap<num, String>.identity()); | |
48 testNumericKeys(new LinkedHashMap()); | |
49 testNumericKeys(new LinkedHashMap<num, String>()); | |
50 testNumericKeys(new LinkedHashMap.identity()); | |
51 testNumericKeys(new LinkedHashMap<num, String>.identity()); | |
52 testNumericKeys(new MapBaseMap<num, String>()); | |
53 testNumericKeys(new MapMixinMap<num, String>()); | |
54 | |
55 testNaNKeys(new Map()); | |
56 testNaNKeys(new Map<num, String>()); | |
57 testNaNKeys(new HashMap()); | |
58 testNaNKeys(new HashMap<num, String>()); | |
59 testNaNKeys(new LinkedHashMap()); | |
60 testNaNKeys(new LinkedHashMap<num, String>()); | |
61 testNaNKeys(new MapBaseMap<num, String>()); | |
62 testNaNKeys(new MapMixinMap<num, String>()); | |
63 // Identity maps fail the NaN-keys tests because the test assumes that | |
64 // NaN is not equal to NaN. | |
65 | |
66 testIdentityMap(new Map.identity()); | |
67 testIdentityMap(new HashMap.identity()); | |
68 testIdentityMap(new LinkedHashMap.identity()); | |
69 testIdentityMap(new HashMap(equals: identical, hashCode: identityHashCode)); | |
70 testIdentityMap( | |
71 new LinkedHashMap(equals: identical, hashCode: identityHashCode)); | |
72 testIdentityMap(new HashMap( | |
73 equals: (x, y) => identical(x, y), hashCode: (x) => identityHashCode(x))); | |
74 testIdentityMap(new LinkedHashMap( | |
75 equals: (x, y) => identical(x, y), hashCode: (x) => identityHashCode(x))); | |
76 | |
77 testCustomMap(new HashMap( | |
78 equals: myEquals, | |
79 hashCode: myHashCode, | |
80 isValidKey: (v) => v is Customer)); | |
81 testCustomMap(new LinkedHashMap( | |
82 equals: myEquals, | |
83 hashCode: myHashCode, | |
84 isValidKey: (v) => v is Customer)); | |
85 testCustomMap( | |
86 new HashMap<Customer, dynamic>(equals: myEquals, hashCode: myHashCode)); | |
87 | |
88 testCustomMap(new LinkedHashMap<Customer, dynamic>( | |
89 equals: myEquals, hashCode: myHashCode)); | |
90 | |
91 testIterationOrder(new LinkedHashMap()); | |
92 testIterationOrder(new LinkedHashMap.identity()); | |
93 | |
94 testOtherKeys(new SplayTreeMap<int, int>()); | |
95 testOtherKeys( | |
96 new SplayTreeMap<int, int>((int a, int b) => a - b, (v) => v is int)); | |
97 testOtherKeys(new SplayTreeMap((int a, int b) => a - b, (v) => v is int)); | |
98 testOtherKeys(new HashMap<int, int>()); | |
99 testOtherKeys(new HashMap<int, int>.identity()); | |
100 testOtherKeys(new HashMap<int, int>( | |
101 hashCode: (v) => v.hashCode, isValidKey: (v) => v is int)); | |
102 testOtherKeys(new HashMap( | |
103 equals: (int x, int y) => x == y, | |
104 hashCode: (int v) => v.hashCode, | |
105 isValidKey: (v) => v is int)); | |
106 testOtherKeys(new LinkedHashMap<int, int>()); | |
107 testOtherKeys(new LinkedHashMap<int, int>.identity()); | |
108 testOtherKeys(new LinkedHashMap<int, int>( | |
109 hashCode: (v) => v.hashCode, isValidKey: (v) => v is int)); | |
110 testOtherKeys(new LinkedHashMap( | |
111 equals: (int x, int y) => x == y, | |
112 hashCode: (int v) => v.hashCode, | |
113 isValidKey: (v) => v is int)); | |
114 testOtherKeys(new MapBaseMap<int, int>()); | |
115 testOtherKeys(new MapMixinMap<int, int>()); | |
116 | |
117 testUnmodifiableMap(const {1: 37}); | |
118 testUnmodifiableMap(new UnmodifiableMapView({1: 37})); | |
119 testUnmodifiableMap(new UnmodifiableMapBaseMap([1, 37])); | |
120 | |
121 testFrom(); | |
122 } | |
123 | |
124 void test(Map map) { | |
125 testDeletedElement(map); | |
126 testMap(map, 1, 2, 3, 4, 5, 6, 7, 8); | |
127 map.clear(); | |
128 testMap(map, "value1", "value2", "value3", "value4", "value5", "value6", | |
129 "value7", "value8"); | |
130 } | |
131 | |
132 void testLinkedHashMap() { | |
133 LinkedHashMap map = new LinkedHashMap(); | |
134 Expect.equals(false, map.containsKey(1)); | |
135 map[1] = 1; | |
136 map[1] = 2; | |
137 testLength(1, map); | |
138 } | |
139 | |
140 void testMap(Map map, key1, key2, key3, key4, key5, key6, key7, key8) { | |
141 int value1 = 10; | |
142 int value2 = 20; | |
143 int value3 = 30; | |
144 int value4 = 40; | |
145 int value5 = 50; | |
146 int value6 = 60; | |
147 int value7 = 70; | |
148 int value8 = 80; | |
149 | |
150 testLength(0, map); | |
151 | |
152 map[key1] = value1; | |
153 Expect.equals(value1, map[key1]); | |
154 map[key1] = value2; | |
155 Expect.equals(false, map.containsKey(key2)); | |
156 testLength(1, map); | |
157 | |
158 map[key1] = value1; | |
159 Expect.equals(value1, map[key1]); | |
160 // Add enough entries to make sure the table grows. | |
161 map[key2] = value2; | |
162 Expect.equals(value2, map[key2]); | |
163 testLength(2, map); | |
164 map[key3] = value3; | |
165 Expect.equals(value2, map[key2]); | |
166 Expect.equals(value3, map[key3]); | |
167 map[key4] = value4; | |
168 Expect.equals(value3, map[key3]); | |
169 Expect.equals(value4, map[key4]); | |
170 map[key5] = value5; | |
171 Expect.equals(value4, map[key4]); | |
172 Expect.equals(value5, map[key5]); | |
173 map[key6] = value6; | |
174 Expect.equals(value5, map[key5]); | |
175 Expect.equals(value6, map[key6]); | |
176 map[key7] = value7; | |
177 Expect.equals(value6, map[key6]); | |
178 Expect.equals(value7, map[key7]); | |
179 map[key8] = value8; | |
180 Expect.equals(value1, map[key1]); | |
181 Expect.equals(value2, map[key2]); | |
182 Expect.equals(value3, map[key3]); | |
183 Expect.equals(value4, map[key4]); | |
184 Expect.equals(value5, map[key5]); | |
185 Expect.equals(value6, map[key6]); | |
186 Expect.equals(value7, map[key7]); | |
187 Expect.equals(value8, map[key8]); | |
188 testLength(8, map); | |
189 | |
190 map.remove(key4); | |
191 Expect.equals(false, map.containsKey(key4)); | |
192 testLength(7, map); | |
193 | |
194 // Test clearing the table. | |
195 map.clear(); | |
196 testLength(0, map); | |
197 Expect.equals(false, map.containsKey(key1)); | |
198 Expect.equals(false, map.containsKey(key2)); | |
199 Expect.equals(false, map.containsKey(key3)); | |
200 Expect.equals(false, map.containsKey(key4)); | |
201 Expect.equals(false, map.containsKey(key5)); | |
202 Expect.equals(false, map.containsKey(key6)); | |
203 Expect.equals(false, map.containsKey(key7)); | |
204 Expect.equals(false, map.containsKey(key8)); | |
205 | |
206 // Test adding and removing again. | |
207 map[key1] = value1; | |
208 Expect.equals(value1, map[key1]); | |
209 testLength(1, map); | |
210 map[key2] = value2; | |
211 Expect.equals(value2, map[key2]); | |
212 testLength(2, map); | |
213 map[key3] = value3; | |
214 Expect.equals(value3, map[key3]); | |
215 map.remove(key3); | |
216 testLength(2, map); | |
217 map[key4] = value4; | |
218 Expect.equals(value4, map[key4]); | |
219 map.remove(key4); | |
220 testLength(2, map); | |
221 map[key5] = value5; | |
222 Expect.equals(value5, map[key5]); | |
223 map.remove(key5); | |
224 testLength(2, map); | |
225 map[key6] = value6; | |
226 Expect.equals(value6, map[key6]); | |
227 map.remove(key6); | |
228 testLength(2, map); | |
229 map[key7] = value7; | |
230 Expect.equals(value7, map[key7]); | |
231 map.remove(key7); | |
232 testLength(2, map); | |
233 map[key8] = value8; | |
234 Expect.equals(value8, map[key8]); | |
235 map.remove(key8); | |
236 testLength(2, map); | |
237 | |
238 Expect.equals(true, map.containsKey(key1)); | |
239 Expect.equals(true, map.containsValue(value1)); | |
240 | |
241 // Test Map.forEach. | |
242 Map otherMap = new Map(); | |
243 void testForEachMap(key, value) { | |
244 otherMap[key] = value; | |
245 } | |
246 | |
247 map.forEach(testForEachMap); | |
248 Expect.equals(true, otherMap.containsKey(key1)); | |
249 Expect.equals(true, otherMap.containsKey(key2)); | |
250 Expect.equals(true, otherMap.containsValue(value1)); | |
251 Expect.equals(true, otherMap.containsValue(value2)); | |
252 Expect.equals(2, otherMap.length); | |
253 | |
254 otherMap.clear(); | |
255 Expect.equals(0, otherMap.length); | |
256 | |
257 // Test Collection.keys. | |
258 void testForEachCollection(value) { | |
259 otherMap[value] = value; | |
260 } | |
261 | |
262 Iterable keys = map.keys; | |
263 keys.forEach(testForEachCollection); | |
264 Expect.equals(true, otherMap.containsKey(key1)); | |
265 Expect.equals(true, otherMap.containsKey(key2)); | |
266 Expect.equals(true, otherMap.containsValue(key1)); | |
267 Expect.equals(true, otherMap.containsValue(key2)); | |
268 Expect.equals(true, !otherMap.containsKey(value1)); | |
269 Expect.equals(true, !otherMap.containsKey(value2)); | |
270 Expect.equals(true, !otherMap.containsValue(value1)); | |
271 Expect.equals(true, !otherMap.containsValue(value2)); | |
272 Expect.equals(2, otherMap.length); | |
273 otherMap.clear(); | |
274 Expect.equals(0, otherMap.length); | |
275 | |
276 // Test Collection.values. | |
277 Iterable values = map.values; | |
278 values.forEach(testForEachCollection); | |
279 Expect.equals(true, !otherMap.containsKey(key1)); | |
280 Expect.equals(true, !otherMap.containsKey(key2)); | |
281 Expect.equals(true, !otherMap.containsValue(key1)); | |
282 Expect.equals(true, !otherMap.containsValue(key2)); | |
283 Expect.equals(true, otherMap.containsKey(value1)); | |
284 Expect.equals(true, otherMap.containsKey(value2)); | |
285 Expect.equals(true, otherMap.containsValue(value1)); | |
286 Expect.equals(true, otherMap.containsValue(value2)); | |
287 Expect.equals(2, otherMap.length); | |
288 otherMap.clear(); | |
289 Expect.equals(0, otherMap.length); | |
290 | |
291 // Test Map.putIfAbsent. | |
292 map.clear(); | |
293 Expect.equals(false, map.containsKey(key1)); | |
294 map.putIfAbsent(key1, () => 10); | |
295 Expect.equals(true, map.containsKey(key1)); | |
296 Expect.equals(10, map[key1]); | |
297 Expect.equals(10, map.putIfAbsent(key1, () => 11)); | |
298 | |
299 // Test Map.addAll. | |
300 map.clear(); | |
301 otherMap.clear(); | |
302 otherMap[99] = 1; | |
303 otherMap[50] = 50; | |
304 otherMap[1] = 99; | |
305 map.addAll(otherMap); | |
306 Expect.equals(3, map.length); | |
307 Expect.equals(1, map[99]); | |
308 Expect.equals(50, map[50]); | |
309 Expect.equals(99, map[1]); | |
310 otherMap[50] = 42; | |
311 map.addAll(new HashMap.from(otherMap)); | |
312 Expect.equals(3, map.length); | |
313 Expect.equals(1, map[99]); | |
314 Expect.equals(42, map[50]); | |
315 Expect.equals(99, map[1]); | |
316 otherMap[99] = 7; | |
317 map.addAll(new SplayTreeMap.from(otherMap)); | |
318 Expect.equals(3, map.length); | |
319 Expect.equals(7, map[99]); | |
320 Expect.equals(42, map[50]); | |
321 Expect.equals(99, map[1]); | |
322 otherMap.remove(99); | |
323 map[99] = 0; | |
324 map.addAll(otherMap); | |
325 Expect.equals(3, map.length); | |
326 Expect.equals(0, map[99]); | |
327 Expect.equals(42, map[50]); | |
328 Expect.equals(99, map[1]); | |
329 map.clear(); | |
330 otherMap.clear(); | |
331 map.addAll(otherMap); | |
332 Expect.equals(0, map.length); | |
333 } | |
334 | |
335 void testDeletedElement(Map map) { | |
336 map.clear(); | |
337 for (int i = 0; i < 100; i++) { | |
338 map[1] = 2; | |
339 testLength(1, map); | |
340 map.remove(1); | |
341 testLength(0, map); | |
342 } | |
343 testLength(0, map); | |
344 } | |
345 | |
346 void testMapLiteral() { | |
347 Map m = {"a": 1, "b": 2, "c": 3}; | |
348 Expect.equals(3, m.length); | |
349 int sum = 0; | |
350 m.forEach((a, b) { | |
351 sum += b; | |
352 }); | |
353 Expect.equals(6, sum); | |
354 | |
355 List values = m.keys.toList(); | |
356 Expect.equals(3, values.length); | |
357 String first = values[0]; | |
358 String second = values[1]; | |
359 String third = values[2]; | |
360 String all = "${first}${second}${third}"; | |
361 Expect.equals(3, all.length); | |
362 Expect.equals(true, all.contains("a", 0)); | |
363 Expect.equals(true, all.contains("b", 0)); | |
364 Expect.equals(true, all.contains("c", 0)); | |
365 } | |
366 | |
367 void testNullValue() { | |
368 Map m = {"a": 1, "b": null, "c": 3}; | |
369 | |
370 Expect.equals(null, m["b"]); | |
371 Expect.equals(true, m.containsKey("b")); | |
372 Expect.equals(3, m.length); | |
373 | |
374 m["a"] = null; | |
375 m["c"] = null; | |
376 Expect.equals(null, m["a"]); | |
377 Expect.equals(true, m.containsKey("a")); | |
378 Expect.equals(null, m["c"]); | |
379 Expect.equals(true, m.containsKey("c")); | |
380 Expect.equals(3, m.length); | |
381 | |
382 m.remove("a"); | |
383 Expect.equals(2, m.length); | |
384 Expect.equals(null, m["a"]); | |
385 Expect.equals(false, m.containsKey("a")); | |
386 } | |
387 | |
388 void testTypes() { | |
389 testMap(Map<num, String> map) { | |
390 Expect.isTrue(map is Map<num, String>); | |
391 Expect.isTrue(map is! Map<String, dynamic>); | |
392 Expect.isTrue(map is! Map<dynamic, int>); | |
393 | |
394 // Use with properly typed keys and values. | |
395 map[42] = "text1"; | |
396 map[43] = "text2"; | |
397 map[42] = "text3"; | |
398 Expect.equals("text3", map.remove(42)); | |
399 Expect.equals(null, map[42]); | |
400 map[42] = "text4"; | |
401 | |
402 // Ensure that "containsKey", "containsValue" and "remove" | |
403 // accepts any object. | |
404 for (var object in [true, null, new Object()]) { | |
405 Expect.isFalse(map.containsKey(object)); | |
406 Expect.isFalse(map.containsValue(object)); | |
407 Expect.isNull(map.remove(object)); | |
408 Expect.isNull(map[object]); | |
409 } | |
410 } | |
411 | |
412 testMap(new HashMap<int, String>()); | |
413 testMap(new LinkedHashMap<int, String>()); | |
414 testMap(new SplayTreeMap<int, String>()); | |
415 testMap(new SplayTreeMap<int, String>(Comparable.compare)); | |
416 testMap(new SplayTreeMap<int, String>((int a, int b) => a.compareTo(b))); | |
417 testMap(new HashMap<num, String>()); | |
418 testMap(new LinkedHashMap<num, String>()); | |
419 testMap(new SplayTreeMap<num, String>()); | |
420 testMap(new SplayTreeMap<num, String>(Comparable.compare)); | |
421 testMap(new SplayTreeMap<num, String>((num a, num b) => a.compareTo(b))); | |
422 } | |
423 | |
424 void testWeirdStringKeys(Map map) { | |
425 // Test weird keys. | |
426 var weirdKeys = const [ | |
427 'hasOwnProperty', | |
428 'constructor', | |
429 'toLocaleString', | |
430 'propertyIsEnumerable', | |
431 '__defineGetter__', | |
432 '__defineSetter__', | |
433 '__lookupGetter__', | |
434 '__lookupSetter__', | |
435 'isPrototypeOf', | |
436 'toString', | |
437 'valueOf', | |
438 '__proto__', | |
439 '__count__', | |
440 '__parent__', | |
441 '' | |
442 ]; | |
443 Expect.isTrue(map.isEmpty); | |
444 for (var key in weirdKeys) { | |
445 Expect.isFalse(map.containsKey(key)); | |
446 Expect.equals(null, map[key]); | |
447 var value = 'value:$key'; | |
448 map[key] = value; | |
449 Expect.isTrue(map.containsKey(key)); | |
450 Expect.equals(value, map[key]); | |
451 Expect.equals(value, map.remove(key)); | |
452 Expect.isFalse(map.containsKey(key)); | |
453 Expect.equals(null, map[key]); | |
454 } | |
455 Expect.isTrue(map.isEmpty); | |
456 } | |
457 | |
458 void testNumericKeys(Map map) { | |
459 var numericKeys = const [ | |
460 double.INFINITY, | |
461 double.NEGATIVE_INFINITY, | |
462 0, | |
463 0.0, | |
464 -0.0 | |
465 ]; | |
466 | |
467 Expect.isTrue(map.isEmpty); | |
468 for (var key in numericKeys) { | |
469 Expect.isFalse(map.containsKey(key)); | |
470 Expect.equals(null, map[key]); | |
471 var value = 'value:$key'; | |
472 map[key] = value; | |
473 Expect.isTrue(map.containsKey(key)); | |
474 Expect.equals(value, map[key]); | |
475 Expect.equals(value, map.remove(key)); | |
476 Expect.isFalse(map.containsKey(key)); | |
477 Expect.equals(null, map[key]); | |
478 } | |
479 Expect.isTrue(map.isEmpty); | |
480 } | |
481 | |
482 void testNaNKeys(Map map) { | |
483 Expect.isTrue(map.isEmpty); | |
484 // Test NaN. | |
485 var nan = double.NAN; | |
486 Expect.isFalse(map.containsKey(nan)); | |
487 Expect.equals(null, map[nan]); | |
488 | |
489 map[nan] = 'value:0'; | |
490 Expect.isFalse(map.containsKey(nan)); | |
491 Expect.equals(null, map[nan]); | |
492 testLength(1, map); | |
493 | |
494 map[nan] = 'value:1'; | |
495 Expect.isFalse(map.containsKey(nan)); | |
496 Expect.equals(null, map[nan]); | |
497 testLength(2, map); | |
498 | |
499 Expect.equals(null, map.remove(nan)); | |
500 testLength(2, map); | |
501 | |
502 var count = 0; | |
503 map.forEach((key, value) { | |
504 if (key.isNaN) count++; | |
505 }); | |
506 Expect.equals(2, count); | |
507 | |
508 map.clear(); | |
509 Expect.isTrue(map.isEmpty); | |
510 } | |
511 | |
512 void testLength(int length, Map map) { | |
513 Expect.equals(length, map.length); | |
514 Expect.equals(length, map.keys.length); | |
515 Expect.equals(length, map.values.length); | |
516 // Check being-empty. | |
517 var ifEmpty = (length == 0) ? Expect.isTrue : Expect.isFalse; | |
518 var ifNotEmpty = (length != 0) ? Expect.isTrue : Expect.isFalse; | |
519 ifEmpty(map.isEmpty); | |
520 ifNotEmpty(map.isNotEmpty); | |
521 ifEmpty(map.keys.isEmpty); | |
522 ifNotEmpty(map.keys.isNotEmpty); | |
523 ifEmpty(map.values.isEmpty); | |
524 ifNotEmpty(map.values.isNotEmpty); | |
525 // Test key/value iterators match their isEmpty/isNotEmpty. | |
526 ifNotEmpty(map.keys.iterator.moveNext()); | |
527 ifNotEmpty(map.values.iterator.moveNext()); | |
528 if (length == 0) { | |
529 for (var k in map.keys) Expect.fail("contains key when iterating: $k"); | |
530 for (var v in map.values) Expect.fail("contains values when iterating: $v"); | |
531 } | |
532 } | |
533 | |
534 testIdentityMap(Map map) { | |
535 Expect.isTrue(map.isEmpty); | |
536 | |
537 var nan = double.NAN; | |
538 // TODO(11551): Remove guard when dart2js makes identical(NaN, NaN) true. | |
539 if (identical(nan, nan)) { | |
540 map[nan] = 42; | |
541 testLength(1, map); | |
542 Expect.isTrue(map.containsKey(nan)); | |
543 Expect.equals(42, map[nan]); | |
544 map[nan] = 37; | |
545 testLength(1, map); | |
546 Expect.equals(37, map[nan]); | |
547 Expect.equals(37, map.remove(nan)); | |
548 testLength(0, map); | |
549 } | |
550 | |
551 Vampire v1 = const Vampire(1); | |
552 Vampire v2 = const Vampire(2); | |
553 Expect.isFalse(v1 == v1); | |
554 Expect.isFalse(v2 == v2); | |
555 Expect.isTrue(v2 == v1); // Snob! | |
556 | |
557 map[v1] = 1; | |
558 map[v2] = 2; | |
559 testLength(2, map); | |
560 | |
561 Expect.isTrue(map.containsKey(v1)); | |
562 Expect.isTrue(map.containsKey(v2)); | |
563 | |
564 Expect.equals(1, map[v1]); | |
565 Expect.equals(2, map[v2]); | |
566 | |
567 Expect.equals(1, map.remove(v1)); | |
568 testLength(1, map); | |
569 Expect.isFalse(map.containsKey(v1)); | |
570 Expect.isTrue(map.containsKey(v2)); | |
571 | |
572 Expect.isNull(map.remove(v1)); | |
573 Expect.equals(2, map.remove(v2)); | |
574 testLength(0, map); | |
575 | |
576 var eq01 = new Equalizer(0); | |
577 var eq02 = new Equalizer(0); | |
578 var eq11 = new Equalizer(1); | |
579 var eq12 = new Equalizer(1); | |
580 // Sanity. | |
581 Expect.equals(eq01, eq02); | |
582 Expect.equals(eq02, eq01); | |
583 Expect.equals(eq11, eq12); | |
584 Expect.equals(eq12, eq11); | |
585 Expect.notEquals(eq01, eq11); | |
586 Expect.notEquals(eq01, eq12); | |
587 Expect.notEquals(eq02, eq11); | |
588 Expect.notEquals(eq02, eq12); | |
589 Expect.notEquals(eq11, eq01); | |
590 Expect.notEquals(eq11, eq02); | |
591 Expect.notEquals(eq12, eq01); | |
592 Expect.notEquals(eq12, eq02); | |
593 | |
594 map[eq01] = 0; | |
595 map[eq02] = 1; | |
596 map[eq11] = 2; | |
597 map[eq12] = 3; | |
598 testLength(4, map); | |
599 | |
600 Expect.equals(0, map[eq01]); | |
601 Expect.equals(1, map[eq02]); | |
602 Expect.equals(2, map[eq11]); | |
603 Expect.equals(3, map[eq12]); | |
604 | |
605 Expect.isTrue(map.containsKey(eq01)); | |
606 Expect.isTrue(map.containsKey(eq02)); | |
607 Expect.isTrue(map.containsKey(eq11)); | |
608 Expect.isTrue(map.containsKey(eq12)); | |
609 | |
610 Expect.equals(1, map.remove(eq02)); | |
611 Expect.equals(3, map.remove(eq12)); | |
612 testLength(2, map); | |
613 Expect.isTrue(map.containsKey(eq01)); | |
614 Expect.isFalse(map.containsKey(eq02)); | |
615 Expect.isTrue(map.containsKey(eq11)); | |
616 Expect.isFalse(map.containsKey(eq12)); | |
617 | |
618 Expect.equals(0, map[eq01]); | |
619 Expect.equals(null, map[eq02]); | |
620 Expect.equals(2, map[eq11]); | |
621 Expect.equals(null, map[eq12]); | |
622 | |
623 Expect.equals(0, map.remove(eq01)); | |
624 Expect.equals(2, map.remove(eq11)); | |
625 testLength(0, map); | |
626 | |
627 map[eq01] = 0; | |
628 map[eq02] = 1; | |
629 map[eq11] = 2; | |
630 map[eq12] = 3; | |
631 testLength(4, map); | |
632 | |
633 // Transfer to equality-based map will collapse elements. | |
634 Map eqMap = new HashMap(); | |
635 eqMap.addAll(map); | |
636 testLength(2, eqMap); | |
637 Expect.isTrue(eqMap.containsKey(eq01)); | |
638 Expect.isTrue(eqMap.containsKey(eq02)); | |
639 Expect.isTrue(eqMap.containsKey(eq11)); | |
640 Expect.isTrue(eqMap.containsKey(eq12)); | |
641 | |
642 // Changing objects will not affect identity map. | |
643 map.clear(); | |
644 var m1 = new Mutable(1); | |
645 var m2 = new Mutable(2); | |
646 var m3 = new Mutable(3); | |
647 map[m1] = 1; | |
648 map[m2] = 2; | |
649 map[m3] = 3; | |
650 Expect.equals(3, map.length); | |
651 Expect.isTrue(map.containsKey(m1)); | |
652 Expect.isTrue(map.containsKey(m2)); | |
653 Expect.isTrue(map.containsKey(m3)); | |
654 Expect.notEquals(m1, m3); | |
655 m3.id = 1; | |
656 Expect.equals(m1, m3); | |
657 // Even if keys are equal, they are still not identical. | |
658 // Even if hashcode of m3 changed, it can still be found. | |
659 Expect.equals(1, map[m1]); | |
660 Expect.equals(3, map[m3]); | |
661 } | |
662 | |
663 /** Class of objects that are equal if they hold the same id. */ | |
664 class Equalizer { | |
665 int id; | |
666 Equalizer(this.id); | |
667 int get hashCode => id; | |
668 bool operator ==(Object other) => | |
669 other is Equalizer && id == (other as Equalizer).id; | |
670 } | |
671 | |
672 /** | |
673 * Objects that are not reflexive. | |
674 * | |
675 * They think they are better than their equals. | |
676 */ | |
677 class Vampire { | |
678 final int generation; | |
679 const Vampire(this.generation); | |
680 | |
681 int get hashCode => generation; | |
682 | |
683 // The double-fang operator falsely claims that a vampire is equal to | |
684 // any of its sire's generation. | |
685 bool operator ==(Object other) => | |
686 other is Vampire && generation - 1 == (other as Vampire).generation; | |
687 } | |
688 | |
689 void testCustomMap(Map map) { | |
690 testLength(0, map); | |
691 var c11 = const Customer(1, 1); | |
692 var c12 = const Customer(1, 2); | |
693 var c21 = const Customer(2, 1); | |
694 var c22 = const Customer(2, 2); | |
695 // Sanity. | |
696 Expect.equals(c11, c12); | |
697 Expect.notEquals(c11, c21); | |
698 Expect.notEquals(c11, c22); | |
699 Expect.equals(c21, c22); | |
700 Expect.notEquals(c21, c11); | |
701 Expect.notEquals(c21, c12); | |
702 | |
703 Expect.isTrue(myEquals(c11, c21)); | |
704 Expect.isFalse(myEquals(c11, c12)); | |
705 Expect.isFalse(myEquals(c11, c22)); | |
706 Expect.isTrue(myEquals(c12, c22)); | |
707 Expect.isFalse(myEquals(c12, c11)); | |
708 Expect.isFalse(myEquals(c12, c21)); | |
709 | |
710 map[c11] = 42; | |
711 testLength(1, map); | |
712 Expect.isTrue(map.containsKey(c11)); | |
713 Expect.isTrue(map.containsKey(c21)); | |
714 Expect.isFalse(map.containsKey(c12)); | |
715 Expect.isFalse(map.containsKey(c22)); | |
716 Expect.equals(42, map[c11]); | |
717 Expect.equals(42, map[c21]); | |
718 | |
719 map[c21] = 37; | |
720 testLength(1, map); | |
721 Expect.isTrue(map.containsKey(c11)); | |
722 Expect.isTrue(map.containsKey(c21)); | |
723 Expect.isFalse(map.containsKey(c12)); | |
724 Expect.isFalse(map.containsKey(c22)); | |
725 Expect.equals(37, map[c11]); | |
726 Expect.equals(37, map[c21]); | |
727 | |
728 map[c22] = 42; | |
729 testLength(2, map); | |
730 Expect.isTrue(map.containsKey(c11)); | |
731 Expect.isTrue(map.containsKey(c21)); | |
732 Expect.isTrue(map.containsKey(c12)); | |
733 Expect.isTrue(map.containsKey(c22)); | |
734 Expect.equals(37, map[c11]); | |
735 Expect.equals(37, map[c21]); | |
736 Expect.equals(42, map[c12]); | |
737 Expect.equals(42, map[c22]); | |
738 | |
739 Expect.equals(42, map.remove(c12)); | |
740 testLength(1, map); | |
741 Expect.isTrue(map.containsKey(c11)); | |
742 Expect.isTrue(map.containsKey(c21)); | |
743 Expect.isFalse(map.containsKey(c12)); | |
744 Expect.isFalse(map.containsKey(c22)); | |
745 Expect.equals(37, map[c11]); | |
746 Expect.equals(37, map[c21]); | |
747 | |
748 Expect.equals(37, map.remove(c11)); | |
749 testLength(0, map); | |
750 } | |
751 | |
752 void testUnmodifiableMap(Map map) { | |
753 Expect.isTrue(map.containsKey(1)); | |
754 testLength(1, map); | |
755 Expect.equals(1, map.keys.first); | |
756 Expect.equals(37, map.values.first); | |
757 | |
758 Expect.throws(map.clear); | |
759 Expect.throws(() { | |
760 map.remove(1); | |
761 }); | |
762 Expect.throws(() { | |
763 map[2] = 42; | |
764 }); | |
765 Expect.throws(() { | |
766 map.addAll({2: 42}); | |
767 }); | |
768 } | |
769 | |
770 class Customer { | |
771 final int id; | |
772 final int secondId; | |
773 const Customer(this.id, this.secondId); | |
774 int get hashCode => id; | |
775 bool operator ==(Object other) { | |
776 if (other is! Customer) return false; | |
777 Customer otherCustomer = other; | |
778 return id == otherCustomer.id; | |
779 } | |
780 } | |
781 | |
782 int myHashCode(Customer c) => c.secondId; | |
783 bool myEquals(Customer a, Customer b) => a.secondId == b.secondId; | |
784 | |
785 void testIterationOrder(Map map) { | |
786 var order = [0, 6, 4, 2, 7, 9, 7, 1, 2, 5, 3]; | |
787 for (int i = 0; i < order.length; i++) map[order[i]] = i; | |
788 Expect.listEquals(map.keys.toList(), [0, 6, 4, 2, 7, 9, 1, 5, 3]); | |
789 Expect.listEquals(map.values.toList(), [0, 1, 2, 8, 6, 5, 7, 9, 10]); | |
790 } | |
791 | |
792 void testOtherKeys(Map<int, int> map) { | |
793 // Test that non-int keys are allowed in containsKey/remove/lookup. | |
794 // Custom hash sets and tree sets must be constructed so they don't | |
795 // use the equality/comparator on incompatible objects. | |
796 | |
797 // This should not throw in either checked or unchecked mode. | |
798 map[0] = 0; | |
799 map[1] = 1; | |
800 map[2] = 2; | |
801 Expect.isFalse(map.containsKey("not an int")); | |
802 Expect.isFalse(map.containsKey(1.5)); | |
803 Expect.isNull(map.remove("not an int")); | |
804 Expect.isNull(map.remove(1.5)); | |
805 Expect.isNull(map["not an int"]); | |
806 Expect.isNull(map[1.5]); | |
807 } | |
808 | |
809 class Mutable { | |
810 int id; | |
811 Mutable(this.id); | |
812 int get hashCode => id; | |
813 bool operator ==(other) => other is Mutable && other.id == id; | |
814 } | |
815 | |
816 // Slow implementation of Map based on MapBase. | |
817 abstract class MapBaseOperations<K, V> { | |
818 final List _keys = <K>[]; | |
819 final List _values = <V>[]; | |
820 int _modCount = 0; | |
821 | |
822 V operator [](Object key) { | |
823 int index = _keys.indexOf(key); | |
824 if (index < 0) return null; | |
825 return _values[index]; | |
826 } | |
827 | |
828 Iterable<K> get keys => new TestKeyIterable<K>(this); | |
829 | |
830 void operator []=(K key, V value) { | |
831 int index = _keys.indexOf(key); | |
832 if (index >= 0) { | |
833 _values[index] = value; | |
834 } else { | |
835 _modCount++; | |
836 _keys.add(key); | |
837 _values.add(value); | |
838 } | |
839 } | |
840 | |
841 V remove(Object key) { | |
842 int index = _keys.indexOf(key); | |
843 if (index >= 0) { | |
844 var result = _values[index]; | |
845 key = _keys.removeLast(); | |
846 var value = _values.removeLast(); | |
847 if (index != _keys.length) { | |
848 _keys[index] = key; | |
849 _values[index] = value; | |
850 } | |
851 _modCount++; | |
852 return result; | |
853 } | |
854 return null; | |
855 } | |
856 | |
857 void clear() { | |
858 // Clear cannot be based on remove, since remove won't remove keys that | |
859 // are not equal to themselves. It will fail the testNaNKeys test. | |
860 _keys.clear(); | |
861 _values.clear(); | |
862 _modCount++; | |
863 } | |
864 } | |
865 | |
866 class MapBaseMap<K, V> = MapBase<K, V> with MapBaseOperations<K, V>; | |
867 class MapMixinMap<K, V> = MapBaseOperations<K, V> with MapMixin<K, V>; | |
868 | |
869 class TestKeyIterable<K> extends IterableBase<K> { | |
870 final _map; | |
871 TestKeyIterable(this._map); | |
872 int get length => _map._keys.length; | |
873 Iterator<K> get iterator => new TestKeyIterator<K>(_map); | |
874 } | |
875 | |
876 class TestKeyIterator<K> implements Iterator<K> { | |
877 final _map; | |
878 final int _modCount; | |
879 int _index = 0; | |
880 var _current; | |
881 TestKeyIterator(map) | |
882 : _map = map, | |
883 _modCount = map._modCount; | |
884 bool moveNext() { | |
885 if (_modCount != _map._modCount) { | |
886 throw new ConcurrentModificationError(_map); | |
887 } | |
888 if (_index == _map._keys.length) { | |
889 _current = null; | |
890 return false; | |
891 } | |
892 _current = _map._keys[_index++]; | |
893 return true; | |
894 } | |
895 | |
896 K get current => _current; | |
897 } | |
898 | |
899 // Slow implementation of Map based on MapBase. | |
900 class UnmodifiableMapBaseMap<K, V> extends UnmodifiableMapBase<K, V> { | |
901 final List _keys = <K>[]; | |
902 final List _values = <V>[]; | |
903 UnmodifiableMapBaseMap(List pairs) { | |
904 for (int i = 0; i < pairs.length; i += 2) { | |
905 _keys.add(pairs[i]); | |
906 _values.add(pairs[i + 1]); | |
907 } | |
908 } | |
909 | |
910 int get _modCount => 0; | |
911 | |
912 V operator [](K key) { | |
913 int index = _keys.indexOf(key); | |
914 if (index < 0) return null; | |
915 return _values[index]; | |
916 } | |
917 | |
918 Iterable<K> get keys => _keys.skip(0); | |
919 } | |
920 | |
921 abstract class Super implements Comparable {} | |
922 | |
923 abstract class Interface implements Comparable {} | |
924 | |
925 class Sub extends Super implements Interface, Comparable { | |
926 int compareTo(Sub other) => 0; | |
927 int get hashCode => 0; | |
928 bool operator ==(other) => other is Sub; | |
929 } | |
930 | |
931 expectMap(Map expect, Map actual) { | |
932 Expect.equals(expect.length, actual.length, "length"); | |
933 for (var key in expect.keys) { | |
934 Expect.isTrue(actual.containsKey(key), "containsKey $key"); | |
935 Expect.equals(expect[key], actual[key]); | |
936 } | |
937 } | |
938 | |
939 void testFrom() { | |
940 // Check contents. | |
941 for (var map in [ | |
942 {}, | |
943 {1: 1}, | |
944 {1: 2, 3: 4, 5: 6, 7: 8} | |
945 ]) { | |
946 expectMap(map, new Map.from(map)); | |
947 expectMap(map, new HashMap.from(map)); | |
948 expectMap(map, new LinkedHashMap.from(map)); | |
949 expectMap(map, new SplayTreeMap.from(map)); | |
950 } | |
951 // Test type combinations allowed. | |
952 Map<int, int> intMap = <int, int>{1: 2, 3: 4}; | |
953 Map<num, num> numMap = <num, num>{1: 2, 3: 4}; | |
954 expectMap(intMap, new Map<int, int>.from(numMap)); | |
955 expectMap(intMap, new Map<num, num>.from(intMap)); | |
956 expectMap(intMap, new HashMap<int, int>.from(numMap)); | |
957 expectMap(intMap, new HashMap<num, num>.from(intMap)); | |
958 expectMap(intMap, new LinkedHashMap<int, int>.from(numMap)); | |
959 expectMap(intMap, new LinkedHashMap<num, num>.from(intMap)); | |
960 expectMap(intMap, new SplayTreeMap<int, int>.from(numMap)); | |
961 expectMap(intMap, new SplayTreeMap<num, num>.from(intMap)); | |
962 | |
963 var sub = new Sub(); | |
964 Map<Super, Super> superMap = <Super, Super>{sub: sub}; | |
965 Map<Interface, Interface> interfaceMap = <Interface, Interface>{sub: sub}; | |
966 expectMap(superMap, new Map<Super, Super>.from(interfaceMap)); | |
967 expectMap(superMap, new Map<Interface, Interface>.from(superMap)); | |
968 expectMap(superMap, new HashMap<Super, Super>.from(interfaceMap)); | |
969 expectMap(superMap, new HashMap<Interface, Interface>.from(superMap)); | |
970 expectMap(superMap, new LinkedHashMap<Super, Super>.from(interfaceMap)); | |
971 expectMap(superMap, new LinkedHashMap<Interface, Interface>.from(superMap)); | |
972 expectMap(superMap, new SplayTreeMap<Super, Super>.from(interfaceMap)); | |
973 expectMap(superMap, new SplayTreeMap<Interface, Interface>.from(superMap)); | |
974 } | |
OLD | NEW |