Debian Codegraph @

closure-library/closure/goog/labs/structs/multimap_test.js

raw
1 // Copyright 2012 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.labs.structs.MultimapTest');
16 goog.setTestOnly('goog.labs.structs.MultimapTest');
17
18 goog.require('goog.labs.structs.Map');
19 goog.require('goog.labs.structs.Multimap');
20 goog.require('goog.testing.jsunit');
21
22 var map;
23
24
25 function setUp() {
26 map = new goog.labs.structs.Multimap();
27 }
28
29
30 function testGetCountWithEmptyMultimap() {
31 assertEquals(0, map.getCount());
32 assertTrue(map.isEmpty());
33 }
34
35
36 function testClone() {
37 map.add('k', 'v');
38 map.addAllValues('k2', ['v', 'v1', 'v2']);
39
40 var map2 = map.clone();
41
42 assertSameElements(['v'], map.get('k'));
43 assertSameElements(['v', 'v1', 'v2'], map.get('k2'));
44 }
45
46
47 function testAdd() {
48 map.add('key', 'v');
49 assertEquals(1, map.getCount());
50 map.add('key', 'v2');
51 assertEquals(2, map.getCount());
52 map.add('key', 'v3');
53 assertEquals(3, map.getCount());
54
55 var values = map.get('key');
56 assertEquals(3, values.length);
57 assertContains('v', values);
58 assertContains('v2', values);
59 assertContains('v3', values);
60 }
61
62
63 function testAddValues() {
64 map.addAllValues('key', ['v', 'v2', 'v3']);
65 assertSameElements(['v', 'v2', 'v3'], map.get('key'));
66
67 map.add('key2', 'a');
68 map.addAllValues('key2', ['v', 'v2', 'v3']);
69 assertSameElements(['a', 'v', 'v2', 'v3'], map.get('key2'));
70 }
71
72
73 function testAddAllWithMultimap() {
74 map.add('k', 'v');
75 map.addAllValues('k2', ['v', 'v1', 'v2']);
76
77 var map2 = new goog.labs.structs.Multimap();
78 map2.add('k2', 'v');
79 map2.addAllValues('k3', ['a', 'a1', 'a2']);
80
81 map.addAllFromMultimap(map2);
82 assertSameElements(['v'], map.get('k'));
83 assertSameElements(['v', 'v1', 'v2', 'v'], map.get('k2'));
84 assertSameElements(['a', 'a1', 'a2'], map.get('k3'));
85 }
86
87
88 function testAddAllWithMap() {
89 map.add('k', 'v');
90 map.addAllValues('k2', ['v', 'v1', 'v2']);
91
92 var map2 = new goog.labs.structs.Map();
93 map2.set('k2', 'v');
94 map2.set('k3', 'a');
95
96 map.addAllFromMultimap(map2);
97 assertSameElements(['v'], map.get('k'));
98 assertSameElements(['v', 'v1', 'v2', 'v'], map.get('k2'));
99 assertSameElements(['a'], map.get('k3'));
100 }
101
102
103 function testReplaceValues() {
104 map.add('key', 'v');
105 map.add('key', 'v2');
106
107 map.replaceValues('key', [0, 1, 2]);
108 assertSameElements([0, 1, 2], map.get('key'));
109 assertEquals(3, map.getCount());
110
111 map.replaceValues('key', ['v']);
112 assertSameElements(['v'], map.get('key'));
113 assertEquals(1, map.getCount());
114
115 map.replaceValues('key', []);
116 assertSameElements([], map.get('key'));
117 assertEquals(0, map.getCount());
118 }
119
120
121 function testRemove() {
122 map.add('key', 'v');
123 map.add('key', 'v2');
124 map.add('key', 'v3');
125
126 assertTrue(map.remove('key', 'v'));
127 var values = map.get('key');
128 assertEquals(2, map.getCount());
129 assertEquals(2, values.length);
130 assertContains('v2', values);
131 assertContains('v3', values);
132 assertFalse(map.remove('key', 'v'));
133
134 assertTrue(map.remove('key', 'v2'));
135 values = map.get('key');
136 assertEquals(1, map.getCount());
137 assertEquals(1, values.length);
138 assertContains('v3', values);
139 assertFalse(map.remove('key', 'v2'));
140
141 assertTrue(map.remove('key', 'v3'));
142 map.remove('key', 'v3');
143 assertTrue(map.isEmpty());
144 assertEquals(0, map.get('key').length);
145 assertFalse(map.remove('key', 'v2'));
146 }
147
148
149 function testRemoveWithNaN() {
150 map.add('key', NaN);
151 map.add('key', NaN);
152
153 assertTrue(map.remove('key', NaN));
154 var values = map.get('key');
155 assertEquals(1, values.length);
156 assertTrue(isNaN(values[0]));
157
158 assertTrue(map.remove('key', NaN));
159 assertEquals(0, map.get('key').length);
160 assertFalse(map.remove('key', NaN));
161 }
162
163
164 function testRemoveWithNegativeZero() {
165 map.add('key', 0);
166 map.add('key', -0);
167
168 assertTrue(map.remove('key', -0));
169 var values = map.get('key');
170 assertEquals(1, values.length);
171 assertTrue(1 / values[0] === 1 / 0);
172 assertFalse(map.remove('key', -0));
173
174 map.add('key', -0);
175
176 assertTrue(map.remove('key', 0));
177 var values = map.get('key');
178 assertEquals(1, values.length);
179 assertTrue(1 / values[0] === 1 / -0);
180 assertFalse(map.remove('key', 0));
181
182 assertTrue(map.remove('key', -0));
183 assertEquals(0, map.get('key').length);
184 }
185
186
187 function testRemoveAll() {
188 map.add('key', 'v');
189 map.add('key', 'v2');
190 map.add('key', 'v3');
191 map.add('key', 'v4');
192 map.add('key2', 'v');
193
194 assertTrue(map.removeAll('key'));
195 assertSameElements([], map.get('key'));
196 assertSameElements(['v'], map.get('key2'));
197 assertFalse(map.removeAll('key'));
198 assertEquals(1, map.getCount());
199
200 assertTrue(map.removeAll('key2'));
201 assertSameElements([], map.get('key2'));
202 assertFalse(map.removeAll('key2'));
203 assertTrue(map.isEmpty());
204 }
205
206
207 function testAddWithDuplicateValue() {
208 map.add('key', 'v');
209 map.add('key', 'v');
210 map.add('key', 'v');
211 assertArrayEquals(['v', 'v', 'v'], map.get('key'));
212 }
213
214
215 function testContainsEntry() {
216 assertFalse(map.containsEntry('k', 'v'));
217 assertFalse(map.containsEntry('k', 'v2'));
218 assertFalse(map.containsEntry('k2', 'v'));
219
220 map.add('k', 'v');
221 assertTrue(map.containsEntry('k', 'v'));
222 assertFalse(map.containsEntry('k', 'v2'));
223 assertFalse(map.containsEntry('k2', 'v'));
224
225 map.add('k', 'v2');
226 assertTrue(map.containsEntry('k', 'v'));
227 assertTrue(map.containsEntry('k', 'v2'));
228 assertFalse(map.containsEntry('k2', 'v'));
229
230 map.add('k2', 'v');
231 assertTrue(map.containsEntry('k', 'v'));
232 assertTrue(map.containsEntry('k', 'v2'));
233 assertTrue(map.containsEntry('k2', 'v'));
234 }
235
236
237 function testContainsKey() {
238 assertFalse(map.containsKey('k'));
239 assertFalse(map.containsKey('k2'));
240
241 map.add('k', 'v');
242 assertTrue(map.containsKey('k'));
243 map.add('k2', 'v');
244 assertTrue(map.containsKey('k2'));
245
246 map.remove('k', 'v');
247 assertFalse(map.containsKey('k'));
248 map.remove('k2', 'v');
249 assertFalse(map.containsKey('k2'));
250 }
251
252
253 function testContainsValue() {
254 assertFalse(map.containsValue('v'));
255 assertFalse(map.containsValue('v2'));
256
257 map.add('key', 'v');
258 assertTrue(map.containsValue('v'));
259 map.add('key', 'v2');
260 assertTrue(map.containsValue('v2'));
261 }
262
263
264 function testGetEntries() {
265 map.add('key', 'v');
266 map.add('key', 'v2');
267 map.add('key2', 'v3');
268
269 var entries = map.getEntries();
270 assertEquals(3, entries.length);
271 assertContainsEntry(['key', 'v'], entries);
272 assertContainsEntry(['key', 'v2'], entries);
273 assertContainsEntry(['key2', 'v3'], entries);
274 }
275
276
277 function testGetKeys() {
278 map.add('key', 'v');
279 map.add('key', 'v2');
280 map.add('key2', 'v3');
281 map.add('key3', 'v4');
282 map.removeAll('key3');
283
284 assertSameElements(['key', 'key2'], map.getKeys());
285 }
286
287
288 function testGetKeys() {
289 map.add('key', 'v');
290 map.add('key', 'v2');
291 map.add('key2', 'v2');
292 map.add('key3', 'v4');
293 map.removeAll('key3');
294
295 assertSameElements(['v', 'v2', 'v2'], map.getValues());
296 }
297
298
299 function testGetReturnsDefensiveCopyOfUnderlyingData() {
300 map.add('key', 'v');
301 map.add('key', 'v2');
302 map.add('key', 'v3');
303
304 var values = map.get('key');
305 values.push('v4');
306 assertFalse(map.containsEntry('key', 'v4'));
307 }
308
309
310 function testClear() {
311 map.add('key', 'v');
312 map.add('key', 'v2');
313 map.add('key2', 'v3');
314
315 map.clear();
316 assertTrue(map.isEmpty());
317 assertSameElements([], map.getEntries());
318 }
319
320
321 function assertContainsEntry(entry, entryList) {
322 for (var i = 0; i < entryList.length; ++i) {
323 if (entry[0] == entryList[i][0] && entry[1] === entryList[i][1]) {
324 return;
325 }
326 }
327 fail('Did not find entry: ' + entry + ' in: ' + entryList);
328 }