Lines Matching refs:map
34 AtomicLongMap<Object> map = AtomicLongMap.create();
35 tester.testAllPublicInstanceMethods(map);
40 AtomicLongMap<String> map = AtomicLongMap.create(in);
41 assertFalse(map.isEmpty());
42 assertSame(3, map.size());
43 assertTrue(map.containsKey("1"));
44 assertTrue(map.containsKey("2"));
45 assertTrue(map.containsKey("3"));
46 assertEquals(1L, map.get("1"));
47 assertEquals(2L, map.get("2"));
48 assertEquals(3L, map.get("3"));
52 AtomicLongMap<String> map = AtomicLongMap.create();
55 long before = map.get(key);
56 long result = map.incrementAndGet(key);
57 long after = map.get(key);
61 assertEquals(1, map.size());
62 assertTrue(!map.isEmpty());
63 assertTrue(map.containsKey(key));
64 assertEquals(ITERATIONS, (int) map.get(key));
68 AtomicLongMap<String> map = AtomicLongMap.create();
70 assertEquals(0L, map.get(key));
71 assertFalse(map.containsKey(key));
73 assertEquals(1L, map.incrementAndGet(key));
74 assertEquals(1L, map.get(key));
76 assertEquals(0L, map.decrementAndGet(key));
77 assertEquals(0L, map.get(key));
78 assertTrue(map.containsKey(key));
80 assertEquals(1L, map.incrementAndGet(key));
81 assertEquals(1L, map.get(key));
85 AtomicLongMap<String> map = AtomicLongMap.create();
88 long before = map.get(key);
89 long result = map.getAndIncrement(key);
90 long after = map.get(key);
94 assertEquals(1, map.size());
95 assertTrue(!map.isEmpty());
96 assertTrue(map.containsKey(key));
97 assertEquals(ITERATIONS, (int) map.get(key));
101 AtomicLongMap<String> map = AtomicLongMap.create();
103 assertEquals(0L, map.get(key));
104 assertFalse(map.containsKey(key));
106 assertEquals(0L, map.getAndIncrement(key));
107 assertEquals(1L, map.get(key));
109 assertEquals(1L, map.getAndDecrement(key));
110 assertEquals(0L, map.get(key));
111 assertTrue(map.containsKey(key));
113 assertEquals(0L, map.getAndIncrement(key));
114 assertEquals(1L, map.get(key));
118 AtomicLongMap<String> map = AtomicLongMap.create();
121 long before = map.get(key);
122 long result = map.decrementAndGet(key);
123 long after = map.get(key);
127 assertEquals(1, map.size());
128 assertTrue(!map.isEmpty());
129 assertTrue(map.containsKey(key));
130 assertEquals(-1 * ITERATIONS, (int) map.get(key));
134 AtomicLongMap<String> map = AtomicLongMap.create();
136 assertEquals(0L, map.get(key));
137 assertFalse(map.containsKey(key));
139 assertEquals(-1L, map.decrementAndGet(key));
140 assertEquals(-1L, map.get(key));
142 assertEquals(0L, map.incrementAndGet(key));
143 assertEquals(0L, map.get(key));
144 assertTrue(map.containsKey(key));
146 assertEquals(-1L, map.decrementAndGet(key));
147 assertEquals(-1L, map.get(key));
151 AtomicLongMap<String> map = AtomicLongMap.create();
154 long before = map.get(key);
155 long result = map.getAndDecrement(key);
156 long after = map.get(key);
160 assertEquals(1, map.size());
161 assertTrue(!map.isEmpty());
162 assertTrue(map.containsKey(key));
163 assertEquals(-1 * ITERATIONS, (int) map.get(key));
167 AtomicLongMap<String> map = AtomicLongMap.create();
169 assertEquals(0L, map.get(key));
170 assertFalse(map.containsKey(key));
172 assertEquals(0L, map.getAndDecrement(key));
173 assertEquals(-1L, map.get(key));
175 assertEquals(-1L, map.getAndIncrement(key));
176 assertEquals(0L, map.get(key));
177 assertTrue(map.containsKey(key));
179 assertEquals(0L, map.getAndDecrement(key));
180 assertEquals(-1L, map.get(key));
184 AtomicLongMap<String> map = AtomicLongMap.create();
188 long before = map.get(key);
189 long result = map.addAndGet(key, addend);
190 long after = map.get(key);
195 assertEquals(1, map.size());
196 assertTrue(!map.isEmpty());
197 assertTrue(map.containsKey(key));
201 AtomicLongMap<String> map = AtomicLongMap.create();
204 assertEquals(0L, map.get(key));
205 assertFalse(map.containsKey(key));
207 assertEquals(value, map.addAndGet(key, value));
208 assertEquals(value, map.get(key));
210 assertEquals(0L, map.addAndGet(key, -1 * value));
211 assertEquals(0L, map.get(key));
212 assertTrue(map.containsKey(key));
214 assertEquals(value, map.addAndGet(key, value));
215 assertEquals(value, map.get(key));
219 AtomicLongMap<String> map = AtomicLongMap.create();
223 long before = map.get(key);
224 long result = map.getAndAdd(key, addend);
225 long after = map.get(key);
230 assertEquals(1, map.size());
231 assertTrue(!map.isEmpty());
232 assertTrue(map.containsKey(key));
236 AtomicLongMap<String> map = AtomicLongMap.create();
239 assertEquals(0L, map.get(key));
240 assertFalse(map.containsKey(key));
242 assertEquals(0L, map.getAndAdd(key, value));
243 assertEquals(value, map.get(key));
245 assertEquals(value, map.getAndAdd(key, -1 * value));
246 assertEquals(0L, map.get(key));
247 assertTrue(map.containsKey(key));
249 assertEquals(0L, map.getAndAdd(key, value));
250 assertEquals(value, map.get(key));
254 AtomicLongMap<String> map = AtomicLongMap.create();
258 long before = map.get(key);
259 long result = map.put(key, newValue);
260 long after = map.get(key);
265 assertEquals(1, map.size());
266 assertTrue(!map.isEmpty());
267 assertTrue(map.containsKey(key));
271 AtomicLongMap<String> map = AtomicLongMap.create();
274 assertEquals(0L, map.get(key));
275 assertFalse(map.containsKey(key));
277 assertEquals(0L, map.put(key, value));
278 assertEquals(value, map.get(key));
280 assertEquals(value, map.put(key, 0L));
281 assertEquals(0L, map.get(key));
282 assertTrue(map.containsKey(key));
284 assertEquals(0L, map.put(key, value));
285 assertEquals(value, map.get(key));
290 AtomicLongMap<String> map = AtomicLongMap.create();
291 assertTrue(map.isEmpty());
292 assertSame(0, map.size());
293 assertFalse(map.containsKey("1"));
294 assertFalse(map.containsKey("2"));
295 assertFalse(map.containsKey("3"));
296 assertEquals(0L, map.get("1"));
297 assertEquals(0L, map.get("2"));
298 assertEquals(0L, map.get("3"));
300 map.putAll(in);
301 assertFalse(map.isEmpty());
302 assertSame(3, map.size());
303 assertTrue(map.containsKey("1"));
304 assertTrue(map.containsKey("2"));
305 assertTrue(map.containsKey("3"));
306 assertEquals(1L, map.get("1"));
307 assertEquals(2L, map.get("2"));
308 assertEquals(3L, map.get("3"));
312 AtomicLongMap<String> map = AtomicLongMap.create();
316 long before = map.get(key);
317 long result = map.putIfAbsent(key, newValue);
318 long after = map.get(key);
322 map.remove(key);
323 before = map.get(key);
324 result = map.putIfAbsent(key, newValue);
325 after = map.get(key);
330 map.put(key, 0L);
331 before = map.get(key);
332 result = map.putIfAbsent(key, newValue);
333 after = map.get(key);
340 assertEquals(1, map.size());
341 assertTrue(!map.isEmpty());
342 assertTrue(map.containsKey(key));
346 AtomicLongMap<String> map = AtomicLongMap.create();
349 assertEquals(0L, map.get(key));
350 assertFalse(map.containsKey(key));
352 assertEquals(0L, map.putIfAbsent(key, value));
353 assertEquals(value, map.get(key));
355 assertEquals(value, map.put(key, 0L));
356 assertEquals(0L, map.get(key));
357 assertTrue(map.containsKey(key));
359 assertEquals(0L, map.putIfAbsent(key, value));
360 assertEquals(value, map.get(key));
364 AtomicLongMap<String> map = AtomicLongMap.create();
368 long before = map.get(key);
369 assertFalse(map.replace(key, before + 1, newValue + 1));
370 assertFalse(map.replace(key, before - 1, newValue - 1));
371 assertTrue(map.replace(key, before, newValue));
372 long after = map.get(key);
376 assertEquals(1, map.size());
377 assertTrue(!map.isEmpty());
378 assertTrue(map.containsKey(key));
382 AtomicLongMap<String> map = AtomicLongMap.create();
385 assertEquals(0L, map.get(key));
386 assertFalse(map.containsKey(key));
388 assertTrue(map.replace(key, 0L, value));
389 assertEquals(value, map.get(key));
391 assertTrue(map.replace(key, value, 0L));
392 assertEquals(0L, map.get(key));
393 assertTrue(map.containsKey(key));
395 assertTrue(map.replace(key, 0L, value));
396 assertEquals(value, map.get(key));
400 AtomicLongMap<String> map = AtomicLongMap.create();
402 assertEquals(0, map.size());
403 assertTrue(map.isEmpty());
404 assertEquals(0L, map.remove(key));
408 map.put(key, newValue);
409 assertTrue(map.containsKey(key));
411 long before = map.get(key);
412 long result = map.remove(key);
413 long after = map.get(key);
414 assertFalse(map.containsKey(key));
419 assertEquals(0, map.size());
420 assertTrue(map.isEmpty());
424 AtomicLongMap<String> map = AtomicLongMap.create();
426 assertEquals(0L, map.get(key));
427 assertFalse(map.containsKey(key));
429 assertEquals(0L, map.remove(key));
430 assertEquals(0L, map.get(key));
431 assertFalse(map.containsKey(key));
433 assertEquals(0L, map.put(key, 0L));
434 assertEquals(0L, map.get(key));
435 assertTrue(map.containsKey(key));
437 assertEquals(0L, map.remove(key));
438 assertEquals(0L, map.get(key));
439 assertFalse(map.containsKey(key));
443 AtomicLongMap<String> map = AtomicLongMap.create();
445 assertEquals(0, map.size());
446 assertTrue(map.isEmpty());
447 assertFalse(map.remove(key, 0L));
451 map.put(key, newValue);
452 assertTrue(map.containsKey(key));
454 long before = map.get(key);
455 assertFalse(map.remove(key, newValue + 1));
456 assertFalse(map.remove(key, newValue - 1));
457 assertTrue(map.remove(key, newValue));
458 long after = map.get(key);
459 assertFalse(map.containsKey(key));
463 assertEquals(0, map.size());
464 assertTrue(map.isEmpty());
468 AtomicLongMap<String> map = AtomicLongMap.create();
470 assertEquals(0L, map.get(key));
471 assertFalse(map.containsKey(key));
473 assertFalse(map.remove(key, 0L));
474 assertEquals(0L, map.get(key));
475 assertFalse(map.containsKey(key));
477 assertEquals(0L, map.put(key, 0L));
478 assertEquals(0L, map.get(key));
479 assertTrue(map.containsKey(key));
481 assertTrue(map.remove(key, 0L));
482 assertEquals(0L, map.get(key));
483 assertFalse(map.containsKey(key));
487 AtomicLongMap<Object> map = AtomicLongMap.create();
492 map.put(key, value);
497 assertEquals(ITERATIONS, map.size());
498 assertTrue(map.asMap().containsValue(0L));
500 map.removeAllZeros();
501 assertFalse(map.asMap().containsValue(0L));
502 assertEquals(ITERATIONS / 2, map.size());
503 assertEquals(nonZeroKeys, map.asMap().keySet());
507 AtomicLongMap<Object> map = AtomicLongMap.create();
509 map.put(new Object(), i);
511 assertEquals(ITERATIONS, map.size());
513 map.clear();
514 assertEquals(0, map.size());
515 assertTrue(map.isEmpty());
519 AtomicLongMap<Object> map = AtomicLongMap.create();
522 map.put(new Object(), i);
525 assertEquals(ITERATIONS, map.size());
526 assertEquals(sum, map.sum());
530 AtomicLongMap<String> map = AtomicLongMap.create();
531 assertEquals(0L, map.get("a"));
532 assertEquals(0, map.size());
533 assertTrue(map.isEmpty());
534 assertFalse(map.remove("a", 1L));
535 assertFalse(map.remove("a", 0L));
536 assertFalse(map.replace("a", 1L, 0L));
547 final AtomicLongMap<String> map = AtomicLongMap.create();
559 map.incrementAndGet(key);
563 map.decrementAndGet(key);
567 map.addAndGet(key, delta);
571 map.getAndIncrement(key);
575 map.getAndDecrement(key);
579 map.getAndAdd(key, delta);
583 long oldValue = map.put(key, delta);
587 oldValue = map.get(key);
588 if (map.replace(key, oldValue, delta)) {
593 oldValue = map.remove(key);
597 oldValue = map.get(key);
598 if (map.remove(key, oldValue)) {
614 assertEquals(sum.get(), map.get(key));