Debian Codegraph @

closure-library/closure/goog/structs/linkedmap_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.LinkedMapTest');
16 goog.setTestOnly('goog.structs.LinkedMapTest');
17
18 goog.require('goog.structs.LinkedMap');
19 goog.require('goog.testing.jsunit');
20 goog.require('goog.testing.recordFunction');
21
22 function fillLinkedMap(m) {
23 m.set('a', 0);
24 m.set('b', 1);
25 m.set('c', 2);
26 m.set('d', 3);
27 }
28
29 var someObj = {};
30
31 function testLinkedMap() {
32 var m = new goog.structs.LinkedMap();
33 fillLinkedMap(m);
34
35 assertArrayEquals(['a', 'b', 'c', 'd'], m.getKeys());
36 assertArrayEquals([0, 1, 2, 3], m.getValues());
37 }
38
39 function testMaxSizeLinkedMap() {
40 var m = new goog.structs.LinkedMap(3);
41 fillLinkedMap(m);
42
43 assertArrayEquals(['b', 'c', 'd'], m.getKeys());
44 assertArrayEquals([1, 2, 3], m.getValues());
45 }
46
47 function testLruLinkedMap() {
48 var m = new goog.structs.LinkedMap(undefined, true);
49 fillLinkedMap(m);
50
51 assertArrayEquals(['d', 'c', 'b', 'a'], m.getKeys());
52 assertArrayEquals([3, 2, 1, 0], m.getValues());
53
54 m.get('a');
55 assertArrayEquals(['a', 'd', 'c', 'b'], m.getKeys());
56 assertArrayEquals([0, 3, 2, 1], m.getValues());
57
58 m.set('b', 4);
59 assertArrayEquals(['b', 'a', 'd', 'c'], m.getKeys());
60 assertArrayEquals([4, 0, 3, 2], m.getValues());
61 }
62
63 function testMaxSizeLruLinkedMap() {
64 var m = new goog.structs.LinkedMap(3, true);
65 fillLinkedMap(m);
66
67 assertArrayEquals(['d', 'c', 'b'], m.getKeys());
68 assertArrayEquals([3, 2, 1], m.getValues());
69
70 m.get('c');
71 assertArrayEquals(['c', 'd', 'b'], m.getKeys());
72 assertArrayEquals([2, 3, 1], m.getValues());
73
74 m.set('d', 4);
75 assertArrayEquals(['d', 'c', 'b'], m.getKeys());
76 assertArrayEquals([4, 2, 1], m.getValues());
77 }
78
79 function testMaxSizeLruLinkedMapWithEvictionCallback() {
80 var cb = goog.testing.recordFunction();
81 var m = new goog.structs.LinkedMap(4, true, cb);
82 fillLinkedMap(m);
83 assertEquals(0, cb.getCallCount()); // But cache is full.
84 assertArrayEquals(['d', 'c', 'b', 'a'], m.getKeys());
85 m.set('d', 'exists');
86 assertEquals(0, cb.getCallCount());
87 m.set('extra1', 'val1');
88 assertEquals(1, cb.getCallCount());
89 assertArrayEquals(['a', 0], cb.getLastCall().getArguments());
90 m.set('extra2', 'val2');
91 assertEquals(2, cb.getCallCount());
92 assertArrayEquals(['b', 1], cb.getLastCall().getArguments());
93 m.set('extra2', 'val2_2');
94 assertEquals(2, cb.getCallCount());
95 }
96
97 function testGetCount() {
98 var m = new goog.structs.LinkedMap();
99 assertEquals(0, m.getCount());
100 m.set('a', 0);
101 assertEquals(1, m.getCount());
102 m.set('a', 1);
103 assertEquals(1, m.getCount());
104 m.set('b', 2);
105 assertEquals(2, m.getCount());
106 m.remove('a');
107 assertEquals(1, m.getCount());
108 }
109
110 function testIsEmpty() {
111 var m = new goog.structs.LinkedMap();
112 assertTrue(m.isEmpty());
113 m.set('a', 0);
114 assertFalse(m.isEmpty());
115 m.remove('a');
116 assertTrue(m.isEmpty());
117 }
118
119 function testSetMaxCount() {
120 var m = new goog.structs.LinkedMap(3);
121 fillLinkedMap(m);
122 assertEquals(3, m.getCount());
123
124 m.setMaxCount(5);
125 m.set('e', 5);
126 m.set('f', 6);
127 m.set('g', 7);
128 assertEquals(5, m.getCount());
129
130 m.setMaxCount(4);
131 assertEquals(4, m.getCount());
132
133 m.setMaxCount(0);
134 m.set('h', 8);
135 m.set('i', 9);
136 m.set('j', 10);
137 assertEquals(7, m.getCount());
138 }
139
140 function testClear() {
141 var m = new goog.structs.LinkedMap();
142 fillLinkedMap(m);
143 m.clear();
144 assertTrue(m.isEmpty());
145 }
146
147 function testForEach() {
148 var m = new goog.structs.LinkedMap();
149 fillLinkedMap(m);
150
151 m.forEach(function(val, key, linkedMap) {
152 linkedMap.set(key, val * 2);
153 assertEquals('forEach should run in provided context.', someObj, this);
154 }, someObj);
155
156 assertArrayEquals(['a', 'b', 'c', 'd'], m.getKeys());
157 assertArrayEquals([0, 2, 4, 6], m.getValues());
158 }
159
160 function testMap() {
161 var m = new goog.structs.LinkedMap();
162 fillLinkedMap(m);
163
164 var result = m.map(function(val, key, linkedMap) {
165 assertEquals('The LinkedMap object should get passed in', m, linkedMap);
166 assertEquals('map should run in provided context', someObj, this);
167 return key + val;
168 }, someObj);
169
170 assertArrayEquals(['a0', 'b1', 'c2', 'd3'], result);
171 }
172
173 function testSome() {
174 var m = new goog.structs.LinkedMap();
175 fillLinkedMap(m);
176
177 var result = m.some(function(val, key, linkedMap) {
178 assertEquals('The LinkedMap object should get passed in', m, linkedMap);
179 assertEquals('map should run in provided context', someObj, this);
180 return val > 2;
181 }, someObj);
182
183 assertTrue(result);
184 assertFalse(m.some(function(val) { return val > 3 }));
185
186 assertTrue(m.some(function(val, key) { return key == 'c'; }));
187 assertFalse(m.some(function(val, key) { return key == 'e'; }));
188 }
189
190 function testEvery() {
191 var m = new goog.structs.LinkedMap();
192 fillLinkedMap(m);
193
194 var result = m.every(function(val, key, linkedMap) {
195 assertEquals('The LinkedMap object should get passed in', m, linkedMap);
196 assertEquals('map should run in provided context', someObj, this);
197 return val < 5;
198 }, someObj);
199
200 assertTrue(result);
201 assertFalse(m.every(function(val) { return val < 2 }));
202
203 assertTrue(m.every(function(val, key) { return key.length == 1; }));
204 assertFalse(m.every(function(val, key) { return key == 'b'; }));
205 }
206
207 function testPeek() {
208 var m = new goog.structs.LinkedMap();
209 assertEquals(undefined, m.peek());
210 assertEquals(undefined, m.peekLast());
211
212 fillLinkedMap(m);
213 assertEquals(0, m.peek());
214
215 m.remove('a');
216 assertEquals(1, m.peek());
217
218 assertEquals(3, m.peekLast());
219
220 assertEquals(3, m.peekValue('d'));
221 assertEquals(1, m.peek());
222
223 m.remove('d');
224 assertEquals(2, m.peekLast());
225 }
226
227 function testPop() {
228 var m = new goog.structs.LinkedMap();
229 assertEquals(undefined, m.shift());
230 assertEquals(undefined, m.pop());
231
232 fillLinkedMap(m);
233 assertEquals(4, m.getCount());
234
235 assertEquals(0, m.shift());
236 assertEquals(1, m.peek());
237
238 assertEquals(3, m.pop());
239 assertEquals(2, m.peekLast());
240
241 assertEquals(2, m.getCount());
242 }
243
244 function testContains() {
245 var m = new goog.structs.LinkedMap();
246 fillLinkedMap(m);
247
248 assertTrue(m.contains(2));
249 assertFalse(m.contains(4));
250 }
251
252 function testContainsKey() {
253 var m = new goog.structs.LinkedMap();
254 fillLinkedMap(m);
255
256 assertTrue(m.containsKey('b'));
257 assertFalse(m.containsKey('elephant'));
258 assertFalse(m.containsKey('undefined'));
259 }
260
261 function testRemoveNodeCalls() {
262 var m = new goog.structs.LinkedMap(1);
263 m.removeNode = goog.testing.recordFunction(m.removeNode);
264
265 m.set('1', 1);
266 assertEquals(
267 'removeNode not called after adding an element', 0,
268 m.removeNode.getCallCount());
269 m.set('1', 2);
270 assertEquals(
271 'removeNode not called after updating an element', 0,
272 m.removeNode.getCallCount());
273 m.set('2', 2);
274 assertEquals(
275 'removeNode called after adding an overflowing element', 1,
276 m.removeNode.getCallCount());
277
278 m.remove('3');
279 assertEquals(
280 'removeNode not called after removing a non-existing element', 1,
281 m.removeNode.getCallCount());
282 m.remove('2');
283 assertEquals(
284 'removeNode called after removing an existing element', 2,
285 m.removeNode.getCallCount());
286
287 m.set('1', 1);
288 m.clear();
289 assertEquals(
290 'removeNode called after clearing the map', 3,
291 m.removeNode.getCallCount());
292 m.clear();
293 assertEquals(
294 'removeNode not called after clearing an empty map', 3,
295 m.removeNode.getCallCount());
296
297 m.set('1', 1);
298 m.pop();
299 assertEquals(
300 'removeNode called after calling pop', 4, m.removeNode.getCallCount());
301 m.pop();
302 assertEquals(
303 'removeNode not called after calling pop on an empty map', 4,
304 m.removeNode.getCallCount());
305
306 m.set('1', 1);
307 m.shift();
308 assertEquals(
309 'removeNode called after calling shift', 5, m.removeNode.getCallCount());
310 m.shift();
311 assertEquals(
312 'removeNode not called after calling shift on an empty map', 5,
313 m.removeNode.getCallCount());
314
315 m.setMaxCount(2);
316 m.set('1', 1);
317 m.set('2', 2);
318 assertEquals(
319 'removeNode not called after increasing the maximum map size', 5,
320 m.removeNode.getCallCount());
321 m.setMaxCount(1);
322 assertEquals(
323 'removeNode called after decreasing the maximum map size', 6,
324 m.removeNode.getCallCount());
325 }