Debian Codegraph @

closure-library/closure/goog/structs/structs_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.structsTest');
16 goog.setTestOnly('goog.structsTest');
17
18 goog.require('goog.array');
19 goog.require('goog.dom');
20 goog.require('goog.dom.TagName');
21 goog.require('goog.structs');
22 goog.require('goog.structs.Map');
23 goog.require('goog.structs.Set'); // needed for filter
24 goog.require('goog.testing.jsunit');
25
26 /*
27
28 This one does not test Map or Set
29 It tests Array, Object, String and a NodeList
30
31 */
32
33
34
35 function stringifyObject(obj) {
36 var sb = [];
37 for (var key in obj) {
38 sb.push(key + obj[key]);
39 }
40 return sb.join('');
41 }
42
43
44 function getTestElement() {
45 return document.getElementById('test');
46 }
47
48
49 function getAll() {
50 return getTestElement().getElementsByTagName('*');
51 }
52
53
54 var node;
55
56
57 function addNode() {
58 node = goog.dom.createElement(goog.dom.TagName.SPAN);
59 getTestElement().appendChild(node);
60 }
61
62
63 function removeNode() {
64 getTestElement().removeChild(node);
65 }
66
67
68 function nodeNames(nl) {
69 var sb = [];
70 for (var i = 0, n; n = nl[i]; i++) {
71 sb.push(n.nodeName);
72 }
73 return sb.join(',');
74 }
75
76
77 var allTagNames1 = 'HR,P,P,P,P,P,P,P,P,H1';
78 var allTagNames2 = allTagNames1 + ',SPAN';
79
80
81 function testGetCount() {
82 var arr = ['a', 'b', 'c'];
83 assertEquals('count, should be 3', 3, goog.structs.getCount(arr));
84 arr.push('d');
85 assertEquals('count, should be 4', 4, goog.structs.getCount(arr));
86 goog.array.remove(arr, 'd');
87 assertEquals('count, should be 3', 3, goog.structs.getCount(arr));
88
89 var obj = {a: 0, b: 1, c: 2};
90 assertEquals('count, should be 3', 3, goog.structs.getCount(obj));
91 obj.d = 3;
92 assertEquals('count, should be 4', 4, goog.structs.getCount(obj));
93 delete obj.d;
94 assertEquals('count, should be 3', 3, goog.structs.getCount(obj));
95
96 var s = 'abc';
97 assertEquals('count, should be 3', 3, goog.structs.getCount(s));
98 s += 'd';
99 assertEquals('count, should be 4', 4, goog.structs.getCount(s));
100
101 var all = getAll();
102 assertEquals('count, should be 10', 10, goog.structs.getCount(all));
103 addNode();
104 assertEquals('count, should be 11', 11, goog.structs.getCount(all));
105 removeNode();
106 assertEquals('count, should be 10', 10, goog.structs.getCount(all));
107
108 var aMap = new goog.structs.Map({a: 0, b: 1, c: 2});
109 assertEquals('count, should be 3', 3, goog.structs.getCount(aMap));
110 aMap.set('d', 3);
111 assertEquals('count, should be 4', 4, goog.structs.getCount(aMap));
112 aMap.remove('a');
113 assertEquals('count, should be 3', 3, goog.structs.getCount(aMap));
114
115 var aSet = new goog.structs.Set('abc');
116 assertEquals('count, should be 3', 3, goog.structs.getCount(aSet));
117 aSet.add('d');
118 assertEquals('count, should be 4', 4, goog.structs.getCount(aSet));
119 aSet.remove('a');
120 assertEquals('count, should be 3', 3, goog.structs.getCount(aSet));
121 }
122
123
124 function testGetValues() {
125 var arr = ['a', 'b', 'c', 'd'];
126 assertEquals('abcd', goog.structs.getValues(arr).join(''));
127
128 var obj = {a: 0, b: 1, c: 2, d: 3};
129 assertEquals('0123', goog.structs.getValues(obj).join(''));
130
131 var s = 'abc';
132 assertEquals('abc', goog.structs.getValues(s).join(''));
133 s += 'd';
134 assertEquals('abcd', goog.structs.getValues(s).join(''));
135
136 var all = getAll();
137 assertEquals(allTagNames1, nodeNames(goog.structs.getValues(all)));
138 addNode();
139 assertEquals(allTagNames2, nodeNames(goog.structs.getValues(all)));
140 removeNode();
141 assertEquals(allTagNames1, nodeNames(goog.structs.getValues(all)));
142
143 var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
144 assertEquals('123', goog.structs.getValues(aMap).join(''));
145
146 var aSet = new goog.structs.Set([1, 2, 3]);
147 assertEquals('123', goog.structs.getValues(aMap).join(''));
148 }
149
150
151 function testGetKeys() {
152 var arr = ['a', 'b', 'c', 'd'];
153 assertEquals('0123', goog.structs.getKeys(arr).join(''));
154
155 var obj = {a: 0, b: 1, c: 2, d: 3};
156 assertEquals('abcd', goog.structs.getKeys(obj).join(''));
157
158 var s = 'abc';
159 assertEquals('012', goog.structs.getKeys(s).join(''));
160 s += 'd';
161 assertEquals('0123', goog.structs.getKeys(s).join(''));
162
163 var all = getAll();
164 assertEquals('0123456789', goog.structs.getKeys(all).join(''));
165 addNode();
166 assertEquals('012345678910', goog.structs.getKeys(all).join(''));
167 removeNode();
168 assertEquals('0123456789', goog.structs.getKeys(all).join(''));
169
170 var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
171 assertEquals('abc', goog.structs.getKeys(aMap).join(''));
172
173 var aSet = new goog.structs.Set([1, 2, 3]);
174 assertUndefined(goog.structs.getKeys(aSet));
175 }
176
177 function testContains() {
178 var arr = ['a', 'b', 'c', 'd'];
179 assertTrue("contains, Should contain 'a'", goog.structs.contains(arr, 'a'));
180 assertFalse(
181 "contains, Should not contain 'e'", goog.structs.contains(arr, 'e'));
182
183 var obj = {a: 0, b: 1, c: 2, d: 3};
184 assertTrue("contains, Should contain '0'", goog.structs.contains(obj, 0));
185 assertFalse(
186 "contains, Should not contain '4'", goog.structs.contains(obj, 4));
187
188 var s = 'abc';
189 assertTrue("contains, Should contain 'a'", goog.structs.contains(s, 'a'));
190 assertFalse(
191 "contains, Should not contain 'd'", goog.structs.contains(s, 'd'));
192
193 var all = getAll();
194 assertTrue(
195 "contains, Should contain 'h1'",
196 goog.structs.contains(all, document.getElementById('h1')));
197 assertFalse(
198 "contains, Should not contain 'document.body'",
199 goog.structs.contains(all, document.body));
200
201 var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
202 assertTrue("contains, Should contain '1'", goog.structs.contains(aMap, 1));
203 assertFalse(
204 "contains, Should not contain '4'", goog.structs.contains(aMap, 4));
205
206 var aSet = new goog.structs.Set([1, 2, 3]);
207 assertTrue("contains, Should contain '1'", goog.structs.contains(aSet, 1));
208 assertFalse(
209 "contains, Should not contain '4'", goog.structs.contains(aSet, 4));
210 }
211
212
213 function testClear() {
214 var arr = ['a', 'b', 'c', 'd'];
215 goog.structs.clear(arr);
216 assertTrue('cleared so it should be empty', goog.structs.isEmpty(arr));
217 assertFalse(
218 "cleared so it should not contain 'a'", goog.structs.contains(arr, 'a'));
219
220 var obj = {a: 0, b: 1, c: 2, d: 3};
221 goog.structs.clear(obj);
222 assertTrue('cleared so it should be empty', goog.structs.isEmpty(obj));
223 assertFalse(
224 "cleared so it should not contain 'a' key",
225 goog.structs.contains(obj, 0));
226
227 var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
228 goog.structs.clear(aMap);
229 assertTrue('cleared map so it should be empty', goog.structs.isEmpty(aMap));
230 assertFalse(
231 "cleared map so it should not contain '1' value",
232 goog.structs.contains(aMap, 1));
233
234 var aSet = new goog.structs.Set([1, 2, 3]);
235 goog.structs.clear(aSet);
236 assertTrue('cleared set so it should be empty', goog.structs.isEmpty(aSet));
237 assertFalse(
238 "cleared set so it should not contain '1'",
239 goog.structs.contains(aSet, 1));
240
241 // cannot clear a string or a NodeList
242 }
243
244
245
246 // Map
247
248 function testMap() {
249 var RV = {};
250 var obj = {
251 map: function(g) {
252 assertEquals(f, g);
253 assertEquals(this, obj);
254 return RV;
255 }
256 };
257 function f() {}
258 assertEquals(RV, goog.structs.map(obj, f));
259 }
260
261 function testMap2() {
262 var THIS_OBJ = {};
263 var RV = {};
264 var obj = {
265 map: function(g, obj2) {
266 assertEquals(f, g);
267 assertEquals(this, obj);
268 assertEquals(THIS_OBJ, obj2);
269 return RV;
270 }
271 };
272 function f() {}
273 assertEquals(RV, goog.structs.map(obj, f, THIS_OBJ));
274 }
275
276 function testMapArrayLike() {
277 var col = [0, 1, 2];
278 function f(v, i, col2) {
279 assertEquals(col, col2);
280 assertEquals('number', typeof i);
281 return v * v;
282 }
283 assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
284 }
285
286 function testMapArrayLike2() {
287 var THIS_OBJ = {};
288 var col = [0, 1, 2];
289 function f(v, i, col2) {
290 assertEquals(col, col2);
291 assertEquals('number', typeof i);
292 assertEquals(THIS_OBJ, this);
293 return v * v;
294 }
295 assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
296 }
297
298 function testMapString() {
299 var col = '012';
300 function f(v, i, col2) {
301 // The SpiderMonkey Array.map for strings turns the string into a String
302 // so we cannot use assertEquals because it uses ===.
303 assertTrue(col == col2);
304 assertEquals('number', typeof i);
305 return Number(v) * Number(v);
306 }
307 assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
308 }
309
310 function testMapString2() {
311 var THIS_OBJ = {};
312 var col = '012';
313 function f(v, i, col2) {
314 // for some reason the strings are equal but identical???
315 assertEquals(String(col), String(col2));
316 assertEquals('number', typeof i);
317 assertEquals(THIS_OBJ, this);
318 return Number(v) * Number(v);
319 }
320 assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
321 }
322
323 function testMapMap() {
324 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
325 function f(v, key, col2) {
326 assertEquals(col, col2);
327 assertEquals('string', typeof key);
328 return v * v;
329 }
330 assertObjectEquals({a: 0, b: 1, c: 4}, goog.structs.map(col, f));
331 }
332
333 function testMapMap2() {
334 var THIS_OBJ = {};
335 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
336 function f(v, key, col2) {
337 assertEquals(col, col2);
338 assertEquals('string', typeof key);
339 assertEquals(THIS_OBJ, this);
340 return v * v;
341 }
342 assertObjectEquals({a: 0, b: 1, c: 4}, goog.structs.map(col, f, THIS_OBJ));
343 }
344
345 function testMapSet() {
346 var col = new goog.structs.Set([0, 1, 2]);
347 function f(v, key, col2) {
348 assertEquals(col, col2);
349 assertEquals('undefined', typeof key);
350 return v * v;
351 }
352 assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
353 }
354
355 function testMapSet2() {
356 var THIS_OBJ = {};
357 var col = new goog.structs.Set([0, 1, 2]);
358 function f(v, key, col2) {
359 assertEquals(col, col2);
360 assertEquals('undefined', typeof key);
361 assertEquals(THIS_OBJ, this);
362 return v * v;
363 }
364 assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
365 }
366
367 function testMapNodeList() {
368 var col = getAll();
369 function f(v, i, col2) {
370 assertEquals(col, col2);
371 assertEquals('number', typeof i);
372 return v.tagName;
373 }
374 assertEquals('HRPPPPPPPPH1', goog.structs.map(col, f).join(''));
375 }
376
377 function testMapNodeList2() {
378 var THIS_OBJ = {};
379 var col = getAll();
380 function f(v, i, col2) {
381 assertEquals(col, col2);
382 assertEquals('number', typeof i);
383 assertEquals(THIS_OBJ, this);
384 return v.tagName;
385 }
386 assertEquals('HRPPPPPPPPH1', goog.structs.map(col, f, THIS_OBJ).join(''));
387 }
388
389 // Filter
390
391 function testFilter() {
392 var RV = {};
393 var obj = {
394 filter: function(g) {
395 assertEquals(f, g);
396 assertEquals(this, obj);
397 return RV;
398 }
399 };
400 function f() {}
401 assertEquals(RV, goog.structs.filter(obj, f));
402 }
403
404 function testFilter2() {
405 var THIS_OBJ = {};
406 var RV = {};
407 var obj = {
408 filter: function(g, obj2) {
409 assertEquals(f, g);
410 assertEquals(this, obj);
411 assertEquals(THIS_OBJ, obj2);
412 return RV;
413 }
414 };
415 function f() {}
416 assertEquals(RV, goog.structs.filter(obj, f, THIS_OBJ));
417 }
418
419 function testFilterArrayLike() {
420 var col = [0, 1, 2];
421 function f(v, i, col2) {
422 assertEquals(col, col2);
423 assertEquals('number', typeof i);
424 return v > 0;
425 }
426 assertArrayEquals([1, 2], goog.structs.filter(col, f));
427 }
428
429 function testFilterArrayLike2() {
430 var THIS_OBJ = {};
431 var col = [0, 1, 2];
432 function f(v, i, col2) {
433 assertEquals(col, col2);
434 assertEquals('number', typeof i);
435 assertEquals(THIS_OBJ, this);
436 return v > 0;
437 }
438 assertArrayEquals([1, 2], goog.structs.filter(col, f, THIS_OBJ));
439 }
440
441 function testFilterString() {
442 var col = '012';
443 function f(v, i, col2) {
444 // for some reason the strings are equal but identical???
445 assertEquals(String(col), String(col2));
446 assertEquals('number', typeof i);
447 return Number(v) > 0;
448 }
449 assertArrayEquals(['1', '2'], goog.structs.filter(col, f));
450 }
451
452 function testFilterString2() {
453 var THIS_OBJ = {};
454 var col = '012';
455 function f(v, i, col2) {
456 // for some reason the strings are equal but identical???
457 assertEquals(String(col), String(col2));
458 assertEquals('number', typeof i);
459 assertEquals(THIS_OBJ, this);
460 return Number(v) > 0;
461 }
462 assertArrayEquals(['1', '2'], goog.structs.filter(col, f, THIS_OBJ));
463 }
464
465 function testFilterMap() {
466 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
467 function f(v, key, col2) {
468 assertEquals(col, col2);
469 assertEquals('string', typeof key);
470 return v > 0;
471 }
472 assertObjectEquals({b: 1, c: 2}, goog.structs.filter(col, f));
473 }
474
475 function testFilterMap2() {
476 var THIS_OBJ = {};
477 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
478 function f(v, key, col2) {
479 assertEquals(col, col2);
480 assertEquals('string', typeof key);
481 assertEquals(THIS_OBJ, this);
482 return v > 0;
483 }
484 assertObjectEquals({b: 1, c: 2}, goog.structs.filter(col, f, THIS_OBJ));
485 }
486
487 function testFilterSet() {
488 var col = new goog.structs.Set([0, 1, 2]);
489 function f(v, key, col2) {
490 assertEquals(col, col2);
491 assertEquals('undefined', typeof key);
492 return v > 0;
493 }
494 assertArrayEquals([1, 2], goog.structs.filter(col, f));
495 }
496
497 function testFilterSet2() {
498 var THIS_OBJ = {};
499 var col = new goog.structs.Set([0, 1, 2]);
500 function f(v, key, col2) {
501 assertEquals(col, col2);
502 assertEquals('undefined', typeof key);
503 assertEquals(THIS_OBJ, this);
504 return v > 0;
505 }
506 assertArrayEquals([1, 2], goog.structs.filter(col, f, THIS_OBJ));
507 }
508
509 function testFilterNodeList() {
510 var col = getAll();
511 function f(v, i, col2) {
512 assertEquals(col, col2);
513 assertEquals('number', typeof i);
514 return v.tagName == goog.dom.TagName.P;
515 }
516 assertEquals('P,P,P,P,P,P,P,P', nodeNames(goog.structs.filter(col, f)));
517 }
518
519 function testFilterNodeList2() {
520 var THIS_OBJ = {};
521 var col = getAll();
522 function f(v, i, col2) {
523 assertEquals(col, col2);
524 assertEquals('number', typeof i);
525 assertEquals(THIS_OBJ, this);
526 return v.tagName == goog.dom.TagName.P;
527 }
528 assertEquals(
529 'P,P,P,P,P,P,P,P', nodeNames(goog.structs.filter(col, f, THIS_OBJ)));
530 }
531
532 // Some
533
534 function testSome() {
535 var RV = {};
536 var obj = {
537 some: function(g) {
538 assertEquals(f, g);
539 assertEquals(this, obj);
540 return RV;
541 }
542 };
543 function f() {}
544 assertEquals(RV, goog.structs.some(obj, f));
545 }
546
547 function testSome2() {
548 var THIS_OBJ = {};
549 var RV = {};
550 var obj = {
551 some: function(g, obj2) {
552 assertEquals(f, g);
553 assertEquals(this, obj);
554 assertEquals(THIS_OBJ, obj2);
555 return RV;
556 }
557 };
558 function f() {}
559 assertEquals(RV, goog.structs.some(obj, f, THIS_OBJ));
560 }
561
562 function testSomeArrayLike() {
563 var limit = 0;
564 var col = [0, 1, 2];
565 function f(v, i, col2) {
566 assertEquals(col, col2);
567 assertEquals('number', typeof i);
568 return v > limit;
569 }
570 assertTrue(goog.structs.some(col, f));
571 limit = 2;
572 assertFalse(goog.structs.some(col, f));
573 }
574
575 function testSomeArrayLike2() {
576 var THIS_OBJ = {};
577 var limit = 0;
578 var col = [0, 1, 2];
579 function f(v, i, col2) {
580 assertEquals(col, col2);
581 assertEquals('number', typeof i);
582 assertEquals(THIS_OBJ, this);
583 return v > limit;
584 }
585 assertTrue(goog.structs.some(col, f, THIS_OBJ));
586 limit = 2;
587 assertFalse(goog.structs.some(col, f, THIS_OBJ));
588 }
589
590 function testSomeString() {
591 var limit = 0;
592 var col = '012';
593 function f(v, i, col2) {
594 // for some reason the strings are equal but identical???
595 assertEquals(String(col), String(col2));
596 assertEquals('number', typeof i);
597 return Number(v) > limit;
598 }
599 assertTrue(goog.structs.some(col, f));
600 limit = 2;
601 assertFalse(goog.structs.some(col, f));
602 }
603
604 function testSomeString2() {
605 var THIS_OBJ = {};
606 var limit = 0;
607 var col = '012';
608 function f(v, i, col2) {
609 // for some reason the strings are equal but identical???
610 assertEquals(String(col), String(col2));
611 assertEquals('number', typeof i);
612 assertEquals(THIS_OBJ, this);
613 return Number(v) > limit;
614 }
615 assertTrue(goog.structs.some(col, f, THIS_OBJ));
616 limit = 2;
617 assertFalse(goog.structs.some(col, f, THIS_OBJ));
618 }
619
620 function testSomeMap() {
621 var limit = 0;
622 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
623 function f(v, key, col2) {
624 assertEquals(col, col2);
625 assertEquals('string', typeof key);
626 return v > limit;
627 }
628 assertObjectEquals(true, goog.structs.some(col, f));
629 limit = 2;
630 assertFalse(goog.structs.some(col, f));
631 }
632
633 function testSomeMap2() {
634 var THIS_OBJ = {};
635 var limit = 0;
636 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
637 function f(v, key, col2) {
638 assertEquals(col, col2);
639 assertEquals('string', typeof key);
640 assertEquals(THIS_OBJ, this);
641 return v > limit;
642 }
643 assertObjectEquals(true, goog.structs.some(col, f, THIS_OBJ));
644 limit = 2;
645 assertFalse(goog.structs.some(col, f, THIS_OBJ));
646 }
647
648 function testSomeSet() {
649 var limit = 0;
650 var col = new goog.structs.Set([0, 1, 2]);
651 function f(v, key, col2) {
652 assertEquals(col, col2);
653 assertEquals('undefined', typeof key);
654 return v > limit;
655 }
656 assertTrue(goog.structs.some(col, f));
657 limit = 2;
658 assertFalse(goog.structs.some(col, f));
659 }
660
661 function testSomeSet2() {
662 var THIS_OBJ = {};
663 var limit = 0;
664 var col = new goog.structs.Set([0, 1, 2]);
665 function f(v, key, col2) {
666 assertEquals(col, col2);
667 assertEquals('undefined', typeof key);
668 assertEquals(THIS_OBJ, this);
669 return v > limit;
670 }
671 assertTrue(goog.structs.some(col, f, THIS_OBJ));
672 limit = 2;
673 assertFalse(goog.structs.some(col, f, THIS_OBJ));
674 }
675
676 function testSomeNodeList() {
677 var tagName = goog.dom.TagName.P;
678 var col = getAll();
679 function f(v, i, col2) {
680 assertEquals(col, col2);
681 assertEquals('number', typeof i);
682 return v.tagName == tagName;
683 }
684 assertTrue(goog.structs.some(col, f));
685 tagName = 'MARQUEE';
686 assertFalse(goog.structs.some(col, f));
687 }
688
689 function testSomeNodeList2() {
690 var THIS_OBJ = {};
691 var tagName = goog.dom.TagName.P;
692 var col = getAll();
693 function f(v, i, col2) {
694 assertEquals(col, col2);
695 assertEquals('number', typeof i);
696 assertEquals(THIS_OBJ, this);
697 return v.tagName == tagName;
698 }
699 assertTrue(goog.structs.some(col, f, THIS_OBJ));
700 tagName = 'MARQUEE';
701 assertFalse(goog.structs.some(col, f, THIS_OBJ));
702 }
703
704 // Every
705
706 function testEvery() {
707 var RV = {};
708 var obj = {
709 every: function(g) {
710 assertEquals(f, g);
711 assertEquals(this, obj);
712 return RV;
713 }
714 };
715 function f() {}
716 assertEquals(RV, goog.structs.every(obj, f));
717 }
718
719 function testEvery2() {
720 var THIS_OBJ = {};
721 var RV = {};
722 var obj = {
723 every: function(g, obj2) {
724 assertEquals(f, g);
725 assertEquals(this, obj);
726 assertEquals(THIS_OBJ, obj2);
727 return RV;
728 }
729 };
730 function f() {}
731 assertEquals(RV, goog.structs.every(obj, f, THIS_OBJ));
732 }
733
734 function testEveryArrayLike() {
735 var limit = -1;
736 var col = [0, 1, 2];
737 function f(v, i, col2) {
738 assertEquals(col, col2);
739 assertEquals('number', typeof i);
740 return v > limit;
741 }
742 assertTrue(goog.structs.every(col, f));
743 limit = 1;
744 assertFalse(goog.structs.every(col, f));
745 }
746
747 function testEveryArrayLike2() {
748 var THIS_OBJ = {};
749 var limit = -1;
750 var col = [0, 1, 2];
751 function f(v, i, col2) {
752 assertEquals(col, col2);
753 assertEquals('number', typeof i);
754 assertEquals(THIS_OBJ, this);
755 return v > limit;
756 }
757 assertTrue(goog.structs.every(col, f, THIS_OBJ));
758 limit = 1;
759 assertFalse(goog.structs.every(col, f, THIS_OBJ));
760 }
761
762 function testEveryString() {
763 var limit = -1;
764 var col = '012';
765 function f(v, i, col2) {
766 // for some reason the strings are equal but identical???
767 assertEquals(String(col), String(col2));
768 assertEquals('number', typeof i);
769 return Number(v) > limit;
770 }
771 assertTrue(goog.structs.every(col, f));
772 limit = 1;
773 assertFalse(goog.structs.every(col, f));
774 }
775
776 function testEveryString2() {
777 var THIS_OBJ = {};
778 var limit = -1;
779 var col = '012';
780 function f(v, i, col2) {
781 // for some reason the strings are equal but identical???
782 assertEquals(String(col), String(col2));
783 assertEquals('number', typeof i);
784 assertEquals(THIS_OBJ, this);
785 return Number(v) > limit;
786 }
787 assertTrue(goog.structs.every(col, f, THIS_OBJ));
788 limit = 1;
789 assertFalse(goog.structs.every(col, f, THIS_OBJ));
790 }
791
792 function testEveryMap() {
793 var limit = -1;
794 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
795 function f(v, key, col2) {
796 assertEquals(col, col2);
797 assertEquals('string', typeof key);
798 return v > limit;
799 }
800 assertObjectEquals(true, goog.structs.every(col, f));
801 limit = 1;
802 assertFalse(goog.structs.every(col, f));
803 }
804
805 function testEveryMap2() {
806 var THIS_OBJ = {};
807 var limit = -1;
808 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
809 function f(v, key, col2) {
810 assertEquals(col, col2);
811 assertEquals('string', typeof key);
812 assertEquals(THIS_OBJ, this);
813 return v > limit;
814 }
815 assertObjectEquals(true, goog.structs.every(col, f, THIS_OBJ));
816 limit = 1;
817 assertFalse(goog.structs.every(col, f, THIS_OBJ));
818 }
819
820 function testEverySet() {
821 var limit = -1;
822 var col = new goog.structs.Set([0, 1, 2]);
823 function f(v, key, col2) {
824 assertEquals(col, col2);
825 assertEquals('undefined', typeof key);
826 return v > limit;
827 }
828 assertTrue(goog.structs.every(col, f));
829 limit = 1;
830 assertFalse(goog.structs.every(col, f));
831 }
832
833 function testEverySet2() {
834 var THIS_OBJ = {};
835 var limit = -1;
836 var col = new goog.structs.Set([0, 1, 2]);
837 function f(v, key, col2) {
838 assertEquals(col, col2);
839 assertEquals('undefined', typeof key);
840 assertEquals(THIS_OBJ, this);
841 return v > limit;
842 }
843 assertTrue(goog.structs.every(col, f, THIS_OBJ));
844 limit = 1;
845 assertFalse(goog.structs.every(col, f, THIS_OBJ));
846 }
847
848 function testEveryNodeList() {
849 var nodeType = 1; // ELEMENT
850 var col = getAll();
851 function f(v, i, col2) {
852 assertEquals(col, col2);
853 assertEquals('number', typeof i);
854 return v.nodeType == nodeType;
855 }
856 assertTrue(goog.structs.every(col, f));
857 nodeType = 3; // TEXT
858 assertFalse(goog.structs.every(col, f));
859 }
860
861 function testEveryNodeList2() {
862 var THIS_OBJ = {};
863 var nodeType = 1; // ELEMENT
864 var col = getAll();
865 function f(v, i, col2) {
866 assertEquals(col, col2);
867 assertEquals('number', typeof i);
868 assertEquals(THIS_OBJ, this);
869 return v.nodeType == nodeType;
870 }
871 assertTrue(goog.structs.every(col, f, THIS_OBJ));
872 nodeType = 3; // TEXT
873 assertFalse(goog.structs.every(col, f, THIS_OBJ));
874 }
875
876 // For each
877
878 function testForEach() {
879 var called = false;
880 var obj = {
881 forEach: function(g) {
882 assertEquals(f, g);
883 assertEquals(this, obj);
884 called = true;
885 }
886 };
887 function f() {}
888 goog.structs.forEach(obj, f);
889 assertTrue(called);
890 }
891
892 function testForEach2() {
893 var called = false;
894 var THIS_OBJ = {};
895 var obj = {
896 forEach: function(g, obj2) {
897 assertEquals(f, g);
898 assertEquals(this, obj);
899 assertEquals(THIS_OBJ, obj2);
900 called = true;
901 }
902 };
903 function f() {}
904 goog.structs.forEach(obj, f, THIS_OBJ);
905 assertTrue(called);
906 }
907
908 function testForEachArrayLike() {
909 var col = [0, 1, 2];
910 var values = [];
911 function f(v, i, col2) {
912 assertEquals(col, col2);
913 assertEquals('number', typeof i);
914 values.push(v * v);
915 }
916 goog.structs.forEach(col, f);
917 assertArrayEquals([0, 1, 4], values);
918 }
919
920 function testForEachArrayLike2() {
921 var THIS_OBJ = {};
922 var col = [0, 1, 2];
923 var values = [];
924 function f(v, i, col2) {
925 assertEquals(col, col2);
926 assertEquals('number', typeof i);
927 assertEquals(THIS_OBJ, this);
928 values.push(v * v);
929 }
930 goog.structs.forEach(col, f, THIS_OBJ);
931 assertArrayEquals([0, 1, 4], values);
932 }
933
934 function testForEachString() {
935 var col = '012';
936 var values = [];
937 function f(v, i, col2) {
938 // for some reason the strings are equal but identical???
939 assertEquals(String(col), String(col2));
940 assertEquals('number', typeof i);
941 values.push(Number(v) * Number(v));
942 }
943 goog.structs.forEach(col, f);
944 assertArrayEquals([0, 1, 4], values);
945 }
946
947 function testForEachString2() {
948 var THIS_OBJ = {};
949 var col = '012';
950 var values = [];
951 function f(v, i, col2) {
952 // for some reason the strings are equal but identical???
953 assertEquals(String(col), String(col2));
954 assertEquals('number', typeof i);
955 assertEquals(THIS_OBJ, this);
956 values.push(Number(v) * Number(v));
957 }
958 goog.structs.forEach(col, f, THIS_OBJ);
959 assertArrayEquals([0, 1, 4], values);
960 }
961
962 function testForEachMap() {
963 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
964 var values = [];
965 var keys = [];
966 function f(v, key, col2) {
967 assertEquals(col, col2);
968 assertEquals('string', typeof key);
969 values.push(v * v);
970 keys.push(key);
971 }
972 goog.structs.forEach(col, f);
973 assertArrayEquals([0, 1, 4], values);
974 assertArrayEquals(['a', 'b', 'c'], keys);
975 }
976
977 function testForEachMap2() {
978 var THIS_OBJ = {};
979 var col = new goog.structs.Map({a: 0, b: 1, c: 2});
980 var values = [];
981 var keys = [];
982 function f(v, key, col2) {
983 assertEquals(col, col2);
984 assertEquals('string', typeof key);
985 assertEquals(THIS_OBJ, this);
986 values.push(v * v);
987 keys.push(key);
988 }
989 goog.structs.forEach(col, f, THIS_OBJ);
990 assertArrayEquals([0, 1, 4], values);
991 assertArrayEquals(['a', 'b', 'c'], keys);
992 }
993
994 function testForEachSet() {
995 var col = new goog.structs.Set([0, 1, 2]);
996 var values = [];
997 function f(v, key, col2) {
998 assertEquals(col, col2);
999 assertEquals('undefined', typeof key);
1000 values.push(v * v);
1001 }
1002 goog.structs.forEach(col, f);
1003 assertArrayEquals([0, 1, 4], values);
1004 }
1005
1006 function testForEachSet2() {
1007 var THIS_OBJ = {};
1008 var col = new goog.structs.Set([0, 1, 2]);
1009 var values = [];
1010 function f(v, key, col2) {
1011 assertEquals(col, col2);
1012 assertEquals('undefined', typeof key);
1013 assertEquals(THIS_OBJ, this);
1014 values.push(v * v);
1015 }
1016 goog.structs.forEach(col, f, THIS_OBJ);
1017 assertArrayEquals([0, 1, 4], values);
1018 }
1019
1020 function testForEachNodeList() {
1021 var values = [];
1022 var col = getAll();
1023 function f(v, i, col2) {
1024 assertEquals(col, col2);
1025 assertEquals('number', typeof i);
1026 values.push(v.tagName);
1027 }
1028 goog.structs.forEach(col, f);
1029 assertEquals('HRPPPPPPPPH1', values.join(''));
1030 }
1031
1032 function testForEachNodeList2() {
1033 var THIS_OBJ = {};
1034 var values = [];
1035 var col = getAll();
1036 function f(v, i, col2) {
1037 assertEquals(col, col2);
1038 assertEquals('number', typeof i);
1039 assertEquals(THIS_OBJ, this);
1040 values.push(v.tagName);
1041 }
1042 goog.structs.forEach(col, f, THIS_OBJ);
1043 assertEquals('HRPPPPPPPPH1', values.join(''));
1044 }