Debian Codegraph @

closure-library/closure/goog/structs/map_test.js

raw
1 // Copyright 2006 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.structs.MapTest');
16 goog.setTestOnly('goog.structs.MapTest');
17
18 goog.require('goog.iter');
19 goog.require('goog.structs');
20 goog.require('goog.structs.Map');
21 goog.require('goog.testing.jsunit');
22
23 function stringifyMap(m) {
24 var keys = goog.structs.getKeys(m);
25 var s = '';
26 for (var i = 0; i < keys.length; i++) {
27 s += keys[i] + m[keys[i]];
28 }
29 return s;
30 }
31
32 function getMap() {
33 var m = new goog.structs.Map;
34 m.set('a', 0);
35 m.set('b', 1);
36 m.set('c', 2);
37 m.set('d', 3);
38 return m;
39 }
40
41 function testGetCount() {
42 var m = getMap();
43 assertEquals('count, should be 4', m.getCount(), 4);
44 m.remove('d');
45 assertEquals('count, should be 3', m.getCount(), 3);
46 }
47
48 function testKeys() {
49 var m = getMap();
50 assertEquals(
51 'getKeys, The keys should be a,b,c', m.getKeys().join(','), 'a,b,c,d');
52 }
53
54 function testValues() {
55 var m = getMap();
56 assertEquals(
57 'getValues, The values should be 0,1,2', m.getValues().join(','),
58 '0,1,2,3');
59 }
60
61 function testContainsKey() {
62 var m = getMap();
63 assertTrue("containsKey, Should contain the 'a' key", m.containsKey('a'));
64 assertFalse(
65 "containsKey, Should not contain the 'e' key", m.containsKey('e'));
66 }
67
68 function testClear() {
69 var m = getMap();
70 m.clear();
71 assertTrue('cleared so it should be empty', m.isEmpty());
72 assertTrue("cleared so it should not contain 'a' key", !m.containsKey('a'));
73 }
74
75 function testAddAll() {
76 var m = new goog.structs.Map;
77 m.addAll({a: 0, b: 1, c: 2, d: 3});
78 assertTrue('addAll so it should not be empty', !m.isEmpty());
79 assertTrue("addAll so it should contain 'c' key", m.containsKey('c'));
80
81 var m2 = new goog.structs.Map;
82 m2.addAll(m);
83 assertTrue('addAll so it should not be empty', !m2.isEmpty());
84 assertTrue("addAll so it should contain 'c' key", m2.containsKey('c'));
85 }
86
87 function testConstructor() {
88 var m = getMap();
89 var m2 = new goog.structs.Map(m);
90 assertTrue('constr with Map so it should not be empty', !m2.isEmpty());
91 assertTrue(
92 "constr with Map so it should contain 'c' key", m2.containsKey('c'));
93 }
94
95
96 function testConstructorWithVarArgs() {
97 var m = new goog.structs.Map('a', 1);
98 assertTrue('constr with var_args so it should not be empty', !m.isEmpty());
99 assertEquals('constr with var_args', 1, m.get('a'));
100
101 m = new goog.structs.Map('a', 1, 'b', 2);
102 assertTrue('constr with var_args so it should not be empty', !m.isEmpty());
103 assertEquals('constr with var_args', 1, m.get('a'));
104 assertEquals('constr with var_args', 2, m.get('b'));
105
106 assertThrows('Odd number of arguments is not allowed', function() {
107 var m = new goog.structs.Map('a', 1, 'b');
108 });
109 }
110
111 function testClone() {
112 var m = getMap();
113 var m2 = m.clone();
114 assertTrue('clone so it should not be empty', !m2.isEmpty());
115 assertTrue("clone so it should contain 'c' key", m2.containsKey('c'));
116 }
117
118
119 function testRemove() {
120 var m = new goog.structs.Map();
121 for (var i = 0; i < 1000; i++) {
122 m.set(i, 'foo');
123 }
124
125 for (var i = 0; i < 1000; i++) {
126 assertTrue(m.keys_.length <= 2 * m.getCount());
127 m.remove(i);
128 }
129 assertTrue(m.isEmpty());
130 assertEquals('', m.getKeys().join(''));
131 }
132
133
134 function testForEach() {
135 var m = getMap();
136 var s = '';
137 goog.structs.forEach(m, function(val, key, m2) {
138 assertNotUndefined(key);
139 assertEquals(m, m2);
140 s += key + val;
141 });
142 assertEquals(s, 'a0b1c2d3');
143 }
144
145 function testFilter() {
146 var m = getMap();
147
148 var m2 = goog.structs.filter(m, function(val, key, m3) {
149 assertNotUndefined(key);
150 assertEquals(m, m3);
151 return val > 1;
152 });
153 assertEquals(stringifyMap(m2), 'c2d3');
154 }
155
156
157 function testMap() {
158 var m = getMap();
159 var m2 = goog.structs.map(m, function(val, key, m3) {
160 assertNotUndefined(key);
161 assertEquals(m, m3);
162 return val * val;
163 });
164 assertEquals(stringifyMap(m2), 'a0b1c4d9');
165 }
166
167 function testSome() {
168 var m = getMap();
169 var b = goog.structs.some(m, function(val, key, m2) {
170 assertNotUndefined(key);
171 assertEquals(m, m2);
172 return val > 1;
173 });
174 assertTrue(b);
175 var b = goog.structs.some(m, function(val, key, m2) {
176 assertNotUndefined(key);
177 assertEquals(m, m2);
178 return val > 100;
179 });
180 assertFalse(b);
181 }
182
183 function testEvery() {
184 var m = getMap();
185 var b = goog.structs.every(m, function(val, key, m2) {
186 assertNotUndefined(key);
187 assertEquals(m, m2);
188 return val >= 0;
189 });
190 assertTrue(b);
191 b = goog.structs.every(m, function(val, key, m2) {
192 assertNotUndefined(key);
193 assertEquals(m, m2);
194 return val > 1;
195 });
196 assertFalse(b);
197 }
198
199 function testContainsValue() {
200 var m = getMap();
201 assertTrue(m.containsValue(3));
202 assertFalse(m.containsValue(4));
203 }
204
205 function testObjectProperties() {
206 var m = new goog.structs.Map;
207
208 assertEquals(m.get('toString'), undefined);
209 assertEquals(m.get('valueOf'), undefined);
210 assertEquals(m.get('eval'), undefined);
211 assertEquals(m.get('toSource'), undefined);
212 assertEquals(m.get('prototype'), undefined);
213 assertEquals(m.get(':foo'), undefined);
214
215 m.set('toString', 'once');
216 m.set('valueOf', 'upon');
217 m.set('eval', 'a');
218 m.set('toSource', 'midnight');
219 m.set('prototype', 'dreary');
220 m.set('hasOwnProperty', 'dark');
221 m.set(':foo', 'happy');
222
223 assertEquals(m.get('toString'), 'once');
224 assertEquals(m.get('valueOf'), 'upon');
225 assertEquals(m.get('eval'), 'a');
226 assertEquals(m.get('toSource'), 'midnight');
227 assertEquals(m.get('prototype'), 'dreary');
228 assertEquals(m.get('hasOwnProperty'), 'dark');
229 assertEquals(m.get(':foo'), 'happy');
230
231 var keys = m.getKeys().join(',');
232 assertEquals(
233 keys, 'toString,valueOf,eval,toSource,prototype,hasOwnProperty,:foo');
234
235 var values = m.getValues().join(',');
236 assertEquals(values, 'once,upon,a,midnight,dreary,dark,happy');
237 }
238
239 function testDuplicateKeys() {
240 var m = new goog.structs.Map;
241
242 m.set('a', 1);
243 m.set('b', 2);
244 m.set('c', 3);
245 m.set('d', 4);
246 m.set('e', 5);
247 m.set('f', 6);
248 assertEquals(6, m.getKeys().length);
249 m.set('foo', 1);
250 assertEquals(7, m.getKeys().length);
251 m.remove('foo');
252 assertEquals(6, m.getKeys().length);
253 m.set('foo', 2);
254 assertEquals(7, m.getKeys().length);
255 m.remove('foo');
256 m.set('foo', 3);
257 m.remove('foo');
258 m.set('foo', 4);
259 assertEquals(7, m.getKeys().length);
260 }
261
262 function testGetKeyIterator() {
263 var m = new goog.structs.Map;
264 m.set('a', 1);
265 m.set('b', 2);
266 m.set('c', 3);
267 m.set('d', 4);
268 m.set('e', 5);
269
270 var iter = m.getKeyIterator();
271 assertEquals('Should contain the keys', 'abcde', goog.iter.join(iter, ''));
272
273 m.remove('b');
274 m.remove('d');
275 iter = m.getKeyIterator();
276 assertEquals(
277 'Should not contain the removed keys', 'ace', goog.iter.join(iter, ''));
278 }
279
280 function testGetValueIterator() {
281 var m = new goog.structs.Map;
282 m.set('a', 1);
283 m.set('b', 2);
284 m.set('c', 3);
285 m.set('d', 4);
286 m.set('e', 5);
287
288 var iter = m.getValueIterator();
289 assertEquals('Should contain the values', '12345', goog.iter.join(iter, ''));
290
291 m.remove('b');
292 m.remove('d');
293 iter = m.getValueIterator();
294 assertEquals(
295 'Should not contain the removed keys', '135', goog.iter.join(iter, ''));
296 }
297
298 function testDefaultIterator() {
299 // The default iterator should behave like the value iterator
300
301 var m = new goog.structs.Map;
302 m.set('a', 1);
303 m.set('b', 2);
304 m.set('c', 3);
305 m.set('d', 4);
306 m.set('e', 5);
307
308 assertEquals('Should contain the values', '12345', goog.iter.join(m, ''));
309
310 m.remove('b');
311 m.remove('d');
312 assertEquals(
313 'Should not contain the removed keys', '135', goog.iter.join(m, ''));
314 }
315
316 function testMutatedIterator() {
317 var message = 'The map has changed since the iterator was created';
318
319 var m = new goog.structs.Map;
320 m.set('a', 1);
321 m.set('b', 2);
322 m.set('c', 3);
323 m.set('d', 4);
324
325 var iter = m.getValueIterator();
326 m.set('e', 5);
327 var ex = assertThrows(
328 'Expected an exception since the map has changed',
329 function() { iter.next(); });
330 assertEquals(message, ex.message);
331
332 m = new goog.structs.Map;
333 m.set('a', 1);
334 m.set('b', 2);
335 m.set('c', 3);
336 m.set('d', 4);
337
338 iter = m.getValueIterator();
339 m.remove('d');
340 var ex = assertThrows(
341 'Expected an exception since the map has changed',
342 function() { iter.next(); });
343 assertEquals(message, ex.message);
344
345 m = new goog.structs.Map;
346 m.set('a', 1);
347 m.set('b', 2);
348 m.set('c', 3);
349 m.set('d', 4);
350
351 iter = m.getValueIterator();
352 m.set('d', 5);
353 iter.next();
354 // Changing an existing value is OK.
355 iter.next();
356 }
357
358 function testTranspose() {
359 var m = new goog.structs.Map;
360 m.set('a', 1);
361 m.set('b', 2);
362 m.set('c', 3);
363 m.set('d', 4);
364 m.set('e', 5);
365
366 var transposed = m.transpose();
367 assertEquals(
368 'Should contain the keys', 'abcde', goog.iter.join(transposed, ''));
369 }
370
371 function testToObject() {
372 Object.prototype.b = 0;
373 try {
374 var map = new goog.structs.Map();
375 map.set('a', 0);
376 var obj = map.toObject();
377 assertTrue('object representation has key "a"', obj.hasOwnProperty('a'));
378 assertFalse(
379 'object representation does not have key "b"', obj.hasOwnProperty('b'));
380 assertEquals('value for key "a"', 0, obj['a']);
381 } finally {
382 delete Object.prototype.b;
383 }
384 }
385
386 function testEqualsWithSameObject() {
387 var map1 = getMap();
388 assertTrue('maps are the same object', map1.equals(map1));
389 }
390
391 function testEqualsWithDifferentSizeMaps() {
392 var map1 = getMap();
393 var map2 = new goog.structs.Map();
394
395 assertFalse('maps are different sizes', map1.equals(map2));
396 }
397
398 function testEqualsWithDefaultEqualityFn() {
399 var map1 = new goog.structs.Map();
400 var map2 = new goog.structs.Map();
401
402 assertTrue('maps are both empty', map1.equals(map2));
403
404 map1 = getMap();
405 map2 = getMap();
406 assertTrue('maps are the same', map1.equals(map2));
407
408 map2.set('d', '3');
409 assertFalse('maps have 3 and \'3\'', map1.equals(map2));
410 }
411
412 function testEqualsWithCustomEqualityFn() {
413 var map1 = new goog.structs.Map();
414 var map2 = new goog.structs.Map();
415
416 map1.set('a', 0);
417 map1.set('b', 1);
418
419 map2.set('a', '0');
420 map2.set('b', '1');
421
422 var equalsFn = function(a, b) { return a == b };
423
424 assertTrue('maps are equal with ==', map1.equals(map2, equalsFn));
425 }