Cross Reference: /external/guava/guava-testlib/src/com/google/common/collect/testing/ConcurrentMapInterfaceTest.java

Lines Matching refs:map
51    * that will not be found in the map
71     final ConcurrentMap<K, V> map;
75       map = makeEitherMap();
82       int initialSize = map.size();
83       V oldValue = map.putIfAbsent(keyToPut, valueToPut);
84       assertEquals(valueToPut, map.get(keyToPut));
85       assertTrue(map.containsKey(keyToPut));
86       assertTrue(map.containsValue(valueToPut));
87       assertEquals(initialSize + 1, map.size());
91         map.putIfAbsent(keyToPut, valueToPut);
97     assertInvariants(map);
101     final ConcurrentMap<K, V> map;
105       map = makePopulatedMap();
110     keyToPut = map.keySet().iterator().next();
112       V oldValue = map.get(keyToPut);
113       int initialSize = map.size();
114       assertEquals(oldValue, map.putIfAbsent(keyToPut, valueToPut));
115       assertEquals(oldValue, map.get(keyToPut));
116       assertTrue(map.containsKey(keyToPut));
117       assertTrue(map.containsValue(oldValue));
118       assertFalse(map.containsValue(valueToPut));
119       assertEquals(initialSize, map.size());
122         map.putIfAbsent(keyToPut, valueToPut);
128     assertInvariants(map);
135     final ConcurrentMap<K, V> map;
138       map = makeEitherMap();
143     int initialSize = map.size();
146         map.putIfAbsent(null, valueToPut);
153         map.putIfAbsent(null, valueToPut);
161     assertEquals(initialSize, map.size());
162     assertInvariants(map);
169     final ConcurrentMap<K, V> map;
172       map = makeEitherMap();
177     int initialSize = map.size();
180         map.putIfAbsent(keyToPut, null);
187         map.putIfAbsent(keyToPut, null);
195     assertEquals(initialSize, map.size());
196     assertInvariants(map);
203     final ConcurrentMap<K, V> map;
206       map = makePopulatedMap();
210     keyToPut = map.keySet().iterator().next();
211     int initialSize = map.size();
214         assertNull(map.putIfAbsent(keyToPut, null));
220         map.putIfAbsent(keyToPut, null);
228     assertEquals(initialSize, map.size());
229     assertInvariants(map);
233     final ConcurrentMap<K, V> map;
236       map = makePopulatedMap();
240     keyToRemove = map.keySet().iterator().next();
241     V oldValue = map.get(keyToRemove);
243       int initialSize = map.size();
244       assertTrue(map.remove(keyToRemove, oldValue));
245       assertFalse(map.containsKey(keyToRemove));
246       assertEquals(initialSize - 1, map.size());
249         map.remove(keyToRemove, oldValue);
255     assertInvariants(map);
259     final ConcurrentMap<K, V> map;
263       map = makePopulatedMap();
270       int initialSize = map.size();
271       assertFalse(map.remove(keyToRemove, valueToRemove));
272       assertEquals(initialSize, map.size());
275         map.remove(keyToRemove, valueToRemove);
281     assertInvariants(map);
285     final ConcurrentMap<K, V> map;
289       map = makePopulatedMap();
294     keyToRemove = map.keySet().iterator().next();
296       int initialSize = map.size();
297       V oldValue = map.get(keyToRemove);
298       assertFalse(map.remove(keyToRemove, valueToRemove));
299       assertEquals(oldValue, map.get(keyToRemove));
300       assertTrue(map.containsKey(keyToRemove));
301       assertEquals(initialSize, map.size());
304         map.remove(keyToRemove, valueToRemove);
310     assertInvariants(map);
317     final ConcurrentMap<K, V> map;
320       map = makeEitherMap();
325     int initialSize = map.size();
328         assertFalse(map.remove(null, valueToRemove));
334         assertFalse(map.remove(null, valueToRemove));
341     assertEquals(initialSize, map.size());
342     assertInvariants(map);
349     final ConcurrentMap<K, V> map;
352       map = makePopulatedMap();
356     keyToRemove = map.keySet().iterator().next();
357     int initialSize = map.size();
360         assertFalse(map.remove(keyToRemove, null));
366         assertFalse(map.remove(keyToRemove, null));
373     assertEquals(initialSize, map.size());
374     assertInvariants(map);
381     final ConcurrentMap<K, V> map;
384       map = makeEitherMap();
389     int initialSize = map.size();
392         assertFalse(map.remove(keyToRemove, null));
398         assertFalse(map.remove(keyToRemove, null));
405     assertEquals(initialSize, map.size());
406     assertInvariants(map);
412     final ConcurrentMap<K, V> map;
416       map = makePopulatedMap();
421     keyToReplace = map.keySet().iterator().next();
423       V oldValue = map.get(keyToReplace);
424       int initialSize = map.size();
425       assertEquals(oldValue, map.replace(keyToReplace, newValue));
426       assertEquals(newValue, map.get(keyToReplace));
427       assertTrue(map.containsKey(keyToReplace));
428       assertTrue(map.containsValue(newValue));
429       assertEquals(initialSize, map.size());
432         map.replace(keyToReplace, newValue);
438     assertInvariants(map);
442     final ConcurrentMap<K, V> map;
446       map = makeEitherMap();
453       int initialSize = map.size();
454       assertNull(map.replace(keyToReplace, newValue));
455       assertNull(map.get(keyToReplace));
456       assertFalse(map.containsKey(keyToReplace));
457       assertFalse(map.containsValue(newValue));
458       assertEquals(initialSize, map.size());
461         map.replace(keyToReplace, newValue);
467     assertInvariants(map);
474     final ConcurrentMap<K, V> map;
477       map = makeEitherMap();
482     int initialSize = map.size();
485         assertNull(map.replace(null, valueToReplace));
491         assertNull(map.replace(null, valueToReplace));
498     assertEquals(initialSize, map.size());
499     assertInvariants(map);
506     final ConcurrentMap<K, V> map;
509       map = makePopulatedMap();
513     keyToReplace = map.keySet().iterator().next();
514     int initialSize = map.size();
517         map.replace(keyToReplace, null);
524         map.replace(keyToReplace, null);
532     assertEquals(initialSize, map.size());
533     assertInvariants(map);
540     final ConcurrentMap<K, V> map;
543       map = makeEitherMap();
548     int initialSize = map.size();
551         assertNull(map.replace(keyToReplace, null));
557         assertNull(map.replace(keyToReplace, null));
564     assertEquals(initialSize, map.size());
565     assertInvariants(map);
573     final ConcurrentMap<K, V> map;
578       map = makePopulatedMap();
583     keyToReplace = map.keySet().iterator().next();
584     oldValue = map.get(keyToReplace);
586       int initialSize = map.size();
587       assertTrue(map.replace(keyToReplace, oldValue, newValue));
588       assertEquals(newValue, map.get(keyToReplace));
589       assertTrue(map.containsKey(keyToReplace));
590       assertTrue(map.containsValue(newValue));
591       assertFalse(map.containsValue(oldValue));
592       assertEquals(initialSize, map.size());
595         map.replace(keyToReplace, oldValue, newValue);
601     assertInvariants(map);
605     final ConcurrentMap<K, V> map;
610       map = makePopulatedMap();
616     keyToReplace = map.keySet().iterator().next();
617     final V originalValue = map.get(keyToReplace);
618     int initialSize = map.size();
620       assertFalse(map.replace(keyToReplace, oldValue, newValue));
623         map.replace(keyToReplace, oldValue, newValue);
629     assertTrue(map.containsKey(keyToReplace));
630     assertFalse(map.containsValue(newValue));
631     assertFalse(map.containsValue(oldValue));
632     assertEquals(originalValue, map.get(keyToReplace));
633     assertEquals(initialSize, map.size());
634     assertInvariants(map);
638     final ConcurrentMap<K, V> map;
643       map = makeEitherMap();
650     int initialSize = map.size();
652       assertFalse(map.replace(keyToReplace, oldValue, newValue));
655         map.replace(keyToReplace, oldValue, newValue);
661     assertFalse(map.containsKey(keyToReplace));
662     assertFalse(map.containsValue(newValue));
663     assertFalse(map.containsValue(oldValue));
664     assertEquals(initialSize, map.size());
665     assertInvariants(map);
672     final ConcurrentMap<K, V> map;
676       map = makeEitherMap();
682     int initialSize = map.size();
685         assertFalse(map.replace(null, oldValue, newValue));
691         assertFalse(map.replace(null, oldValue, newValue));
698     assertEquals(initialSize, map.size());
699     assertInvariants(map);
706     final ConcurrentMap<K, V> map;
710       map = makePopulatedMap();
715     keyToReplace = map.keySet().iterator().next();
716     final V originalValue = map.get(keyToReplace);
717     int initialSize = map.size();
720         assertFalse(map.replace(keyToReplace, null, newValue));
726         assertFalse(map.replace(keyToReplace, null, newValue));
733     assertEquals(initialSize, map.size());
734     assertEquals(originalValue, map.get(keyToReplace));
735     assertInvariants(map);
742     final ConcurrentMap<K, V> map;
746       map = makeEitherMap();
752     int initialSize = map.size();
755         assertFalse(map.replace(keyToReplace, null, newValue));
761         assertFalse(map.replace(keyToReplace, null, newValue));
768     assertEquals(initialSize, map.size());
769     assertInvariants(map);
776     final ConcurrentMap<K, V> map;
780       map = makeEitherMap();
786     int initialSize = map.size();
789         map.replace(keyToReplace, oldValue, null);
795         map.replace(keyToReplace, oldValue, null);
802     assertEquals(initialSize, map.size());
803     assertInvariants(map);
810     final ConcurrentMap<K, V> map;
814       map = makePopulatedMap();
818     keyToReplace = map.keySet().iterator().next();
819     oldValue = map.get(keyToReplace);
820     int initialSize = map.size();
823         map.replace(keyToReplace, oldValue, null);
830         map.replace(keyToReplace, oldValue, null);
838     assertEquals(initialSize, map.size());
839     assertEquals(oldValue, map.get(keyToReplace));
840     assertInvariants(map);