test/java/util/Map/Defaults.java

Print this page
rev 8947 : 8030016: HashMap.computeIfAbsent generates spurious access event
Reviewed-by: duke


  63 public class Defaults {
  64 
  65     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=withNull values=withNull")
  66     public void testGetOrDefaultNulls(String description, Map<IntegerEnum, String> map) {
  67         assertTrue(map.containsKey(null), description + ": null key absent");
  68         assertNull(map.get(null), description + ": value not null");
  69         assertSame(map.get(null), map.getOrDefault(null, EXTRA_VALUE), description + ": values should match");
  70     }
  71 
  72     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=all values=all")
  73     public void testGetOrDefault(String description, Map<IntegerEnum, String> map) {
  74         assertTrue(map.containsKey(KEYS[1]), "expected key missing");
  75         assertSame(map.get(KEYS[1]), map.getOrDefault(KEYS[1], EXTRA_VALUE), "values should match");
  76         assertFalse(map.containsKey(EXTRA_KEY), "expected absent key");
  77         assertSame(map.getOrDefault(EXTRA_KEY, EXTRA_VALUE), EXTRA_VALUE, "value not returned as default");
  78         assertNull(map.getOrDefault(EXTRA_KEY, null), "null not returned as default");
  79     }
  80 
  81     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
  82     public void testPutIfAbsentNulls(String description, Map<IntegerEnum, String> map) {

  83         assertTrue(map.containsKey(null), "null key absent");
  84         assertNull(map.get(null), "value not null");
  85         assertNull(map.putIfAbsent(null, EXTRA_VALUE), "previous not null");

  86         assertTrue(map.containsKey(null), "null key absent");
  87         assertSame(map.get(null), EXTRA_VALUE, "unexpected value");
  88         assertSame(map.putIfAbsent(null, null), EXTRA_VALUE, "previous not expected value");
  89         assertTrue(map.containsKey(null), "null key absent");
  90         assertSame(map.get(null), EXTRA_VALUE, "unexpected value");
  91         assertSame(map.remove(null), EXTRA_VALUE, "removed unexpected value");

  92 
  93         assertFalse(map.containsKey(null), description + ": key present after remove");
  94         assertNull(map.putIfAbsent(null, null), "previous not null");

  95         assertTrue(map.containsKey(null), "null key absent");
  96         assertNull(map.get(null), "value not null");
  97         assertNull(map.putIfAbsent(null, EXTRA_VALUE), "previous not null");
  98         assertSame(map.get(null), EXTRA_VALUE, "value not expected");
  99     }
 100 
 101     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 102     public void testPutIfAbsent(String description, Map<IntegerEnum, String> map) {

 103         assertTrue(map.containsKey(KEYS[1]));
 104         Object expected = map.get(KEYS[1]);
 105         assertTrue(null == expected || expected == VALUES[1]);
 106         assertSame(map.putIfAbsent(KEYS[1], EXTRA_VALUE), expected);
 107         assertSame(map.get(KEYS[1]), expected);
 108 

 109         assertFalse(map.containsKey(EXTRA_KEY));
 110         assertSame(map.putIfAbsent(EXTRA_KEY, EXTRA_VALUE), null);
 111         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);


 112     }
 113 
 114     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=all values=all")
 115     public void testForEach(String description, Map<IntegerEnum, String> map) {
 116         IntegerEnum[] EACH_KEY = new IntegerEnum[map.size()];
 117 
 118         map.forEach((k, v) -> {
 119             int idx = (null == k) ? 0 : k.ordinal(); // substitute for index.
 120             assertNull(EACH_KEY[idx]);
 121             EACH_KEY[idx] = (idx == 0) ? KEYS[0] : k; // substitute for comparison.
 122             assertSame(v, map.get(k));
 123         });
 124 
 125         assertEquals(KEYS, EACH_KEY, description);
 126     }
 127 
 128     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 129     public static void testReplaceAll(String description, Map<IntegerEnum, String> map) {
 130         IntegerEnum[] EACH_KEY = new IntegerEnum[map.size()];
 131         Set<String> EACH_REPLACE = new HashSet<>(map.size());


 251         assertFalse(map.replace(KEYS[1], EXTRA_VALUE, EXTRA_VALUE));
 252         assertSame(map.get(KEYS[1]), expected);
 253         assertTrue(map.replace(KEYS[1], (String)expected, EXTRA_VALUE));
 254         assertSame(map.get(KEYS[1]), EXTRA_VALUE);
 255         assertTrue(map.replace(KEYS[1], EXTRA_VALUE, EXTRA_VALUE));
 256         assertSame(map.get(KEYS[1]), EXTRA_VALUE);
 257 
 258         assertFalse(map.containsKey(EXTRA_KEY));
 259         assertFalse(map.replace(EXTRA_KEY, EXTRA_VALUE, EXTRA_VALUE));
 260         assertFalse(map.containsKey(EXTRA_KEY));
 261         assertNull(map.get(EXTRA_KEY));
 262         assertNull(map.put(EXTRA_KEY, EXTRA_VALUE));
 263         assertTrue(map.containsKey(EXTRA_KEY));
 264         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 265         assertTrue(map.replace(EXTRA_KEY, EXTRA_VALUE, EXTRA_VALUE));
 266         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 267     }
 268 
 269     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
 270     public void testComputeIfAbsentNulls(String description, Map<IntegerEnum, String> map) {




 271         assertTrue(map.containsKey(null), "null key absent");
 272         assertNull(map.get(null), "value not null");
 273         assertSame(map.computeIfAbsent(null, (k) -> EXTRA_VALUE), EXTRA_VALUE, description);
 274         assertSame(map.get(null), EXTRA_VALUE, description);









 275     }
 276 
 277     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 278     public void testComputeIfAbsent(String description, Map<IntegerEnum, String> map) {

 279         assertTrue(map.containsKey(KEYS[1]));
 280         Object expected = map.get(KEYS[1]);
 281         assertTrue(null == expected || expected == VALUES[1], description + String.valueOf(expected));
 282         expected = (null == expected) ? EXTRA_VALUE : expected;
 283         assertSame(map.computeIfAbsent(KEYS[1], (k) -> EXTRA_VALUE), expected, description);
 284         assertSame(map.get(KEYS[1]), expected, description);
 285 



 286         assertFalse(map.containsKey(EXTRA_KEY));
 287         assertSame(map.computeIfAbsent(EXTRA_KEY, (k) -> EXTRA_VALUE), EXTRA_VALUE);

 288         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 289     }
 290 
 291     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 292     public void testComputeIfAbsentNullFunction(String description, Map<IntegerEnum, String> map) {
 293         assertThrows( () -> { map.computeIfAbsent(KEYS[1], null);},
 294                 NullPointerException.class,
 295                 "Should throw NPE");
 296     }
 297 
 298     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
 299     public void testComputeIfPresentNulls(String description, Map<IntegerEnum, String> map) {
 300         assertTrue(map.containsKey(null), description + ": null key absent");
 301         assertNull(map.get(null), description + ": value not null");
 302         assertSame(map.computeIfPresent(null, (k, v) -> {
 303             fail(description + ": null value is not deemed present");
 304             return EXTRA_VALUE;
 305         }), null, description);
 306         assertTrue(map.containsKey(null));
 307         assertNull(map.get(null), description);




  63 public class Defaults {
  64 
  65     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=withNull values=withNull")
  66     public void testGetOrDefaultNulls(String description, Map<IntegerEnum, String> map) {
  67         assertTrue(map.containsKey(null), description + ": null key absent");
  68         assertNull(map.get(null), description + ": value not null");
  69         assertSame(map.get(null), map.getOrDefault(null, EXTRA_VALUE), description + ": values should match");
  70     }
  71 
  72     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=all values=all")
  73     public void testGetOrDefault(String description, Map<IntegerEnum, String> map) {
  74         assertTrue(map.containsKey(KEYS[1]), "expected key missing");
  75         assertSame(map.get(KEYS[1]), map.getOrDefault(KEYS[1], EXTRA_VALUE), "values should match");
  76         assertFalse(map.containsKey(EXTRA_KEY), "expected absent key");
  77         assertSame(map.getOrDefault(EXTRA_KEY, EXTRA_VALUE), EXTRA_VALUE, "value not returned as default");
  78         assertNull(map.getOrDefault(EXTRA_KEY, null), "null not returned as default");
  79     }
  80 
  81     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
  82     public void testPutIfAbsentNulls(String description, Map<IntegerEnum, String> map) {
  83         // null -> null
  84         assertTrue(map.containsKey(null), "null key absent");
  85         assertNull(map.get(null), "value not null");
  86         assertNull(map.putIfAbsent(null, EXTRA_VALUE), "previous not null");
  87         // null -> EXTRA_VALUE
  88         assertTrue(map.containsKey(null), "null key absent");
  89         assertSame(map.get(null), EXTRA_VALUE, "unexpected value");
  90         assertSame(map.putIfAbsent(null, null), EXTRA_VALUE, "previous not expected value");
  91         assertTrue(map.containsKey(null), "null key absent");
  92         assertSame(map.get(null), EXTRA_VALUE, "unexpected value");
  93         assertSame(map.remove(null), EXTRA_VALUE, "removed unexpected value");
  94         // null -> <absent>
  95 
  96         assertFalse(map.containsKey(null), description + ": key present after remove");
  97         assertNull(map.putIfAbsent(null, null), "previous not null");
  98         // null -> null
  99         assertTrue(map.containsKey(null), "null key absent");
 100         assertNull(map.get(null), "value not null");
 101         assertNull(map.putIfAbsent(null, EXTRA_VALUE), "previous not null");
 102         assertSame(map.get(null), EXTRA_VALUE, "value not expected");
 103     }
 104 
 105     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 106     public void testPutIfAbsent(String description, Map<IntegerEnum, String> map) {
 107         // 1 -> 1
 108         assertTrue(map.containsKey(KEYS[1]));
 109         Object expected = map.get(KEYS[1]);
 110         assertTrue(null == expected || expected == VALUES[1]);
 111         assertSame(map.putIfAbsent(KEYS[1], EXTRA_VALUE), expected);
 112         assertSame(map.get(KEYS[1]), expected);
 113 
 114         // EXTRA_KEY -> <absent>
 115         assertFalse(map.containsKey(EXTRA_KEY));
 116         assertSame(map.putIfAbsent(EXTRA_KEY, EXTRA_VALUE), null);
 117         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 118         assertSame(map.putIfAbsent(EXTRA_KEY, VALUES[2]), EXTRA_VALUE);
 119         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 120     }
 121 
 122     @Test(dataProvider = "Map<IntegerEnum,String> rw=all keys=all values=all")
 123     public void testForEach(String description, Map<IntegerEnum, String> map) {
 124         IntegerEnum[] EACH_KEY = new IntegerEnum[map.size()];
 125 
 126         map.forEach((k, v) -> {
 127             int idx = (null == k) ? 0 : k.ordinal(); // substitute for index.
 128             assertNull(EACH_KEY[idx]);
 129             EACH_KEY[idx] = (idx == 0) ? KEYS[0] : k; // substitute for comparison.
 130             assertSame(v, map.get(k));
 131         });
 132 
 133         assertEquals(KEYS, EACH_KEY, description);
 134     }
 135 
 136     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 137     public static void testReplaceAll(String description, Map<IntegerEnum, String> map) {
 138         IntegerEnum[] EACH_KEY = new IntegerEnum[map.size()];
 139         Set<String> EACH_REPLACE = new HashSet<>(map.size());


 259         assertFalse(map.replace(KEYS[1], EXTRA_VALUE, EXTRA_VALUE));
 260         assertSame(map.get(KEYS[1]), expected);
 261         assertTrue(map.replace(KEYS[1], (String)expected, EXTRA_VALUE));
 262         assertSame(map.get(KEYS[1]), EXTRA_VALUE);
 263         assertTrue(map.replace(KEYS[1], EXTRA_VALUE, EXTRA_VALUE));
 264         assertSame(map.get(KEYS[1]), EXTRA_VALUE);
 265 
 266         assertFalse(map.containsKey(EXTRA_KEY));
 267         assertFalse(map.replace(EXTRA_KEY, EXTRA_VALUE, EXTRA_VALUE));
 268         assertFalse(map.containsKey(EXTRA_KEY));
 269         assertNull(map.get(EXTRA_KEY));
 270         assertNull(map.put(EXTRA_KEY, EXTRA_VALUE));
 271         assertTrue(map.containsKey(EXTRA_KEY));
 272         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 273         assertTrue(map.replace(EXTRA_KEY, EXTRA_VALUE, EXTRA_VALUE));
 274         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 275     }
 276 
 277     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
 278     public void testComputeIfAbsentNulls(String description, Map<IntegerEnum, String> map) {
 279         // null -> null
 280         assertTrue(map.containsKey(null), "null key absent");
 281         assertNull(map.get(null), "value not null");
 282         assertSame(map.computeIfAbsent(null, (k) -> null), null,  "not expected result");
 283         assertTrue(map.containsKey(null), "null key absent");
 284         assertNull(map.get(null), "value not null");
 285         assertSame(map.computeIfAbsent(null, (k) -> EXTRA_VALUE), EXTRA_VALUE, "not mapped to result");
 286         // null -> EXTRA_VALUE
 287         assertTrue(map.containsKey(null), "null key absent");
 288         assertSame(map.get(null), EXTRA_VALUE,  "not expected value");
 289         assertSame(map.remove(null), EXTRA_VALUE, "removed unexpected value");
 290         // null -> <absent>
 291         assertFalse(map.containsKey(null), "null key present");
 292         assertSame(map.computeIfAbsent(null, (k) -> EXTRA_VALUE), EXTRA_VALUE, "not mapped to result");
 293         // null -> EXTRA_VALUE
 294         assertTrue(map.containsKey(null), "null key absent");
 295         assertSame(map.get(null), EXTRA_VALUE,  "not expected value");
 296     }
 297 
 298     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 299     public void testComputeIfAbsent(String description, Map<IntegerEnum, String> map) {
 300         // 1 -> 1
 301         assertTrue(map.containsKey(KEYS[1]));
 302         Object expected = map.get(KEYS[1]);
 303         assertTrue(null == expected || expected == VALUES[1], description + String.valueOf(expected));
 304         expected = (null == expected) ? EXTRA_VALUE : expected;
 305         assertSame(map.computeIfAbsent(KEYS[1], (k) -> EXTRA_VALUE), expected, description);
 306         assertSame(map.get(KEYS[1]), expected, description);
 307 
 308         // EXTRA_KEY -> <absent>
 309         assertFalse(map.containsKey(EXTRA_KEY));
 310         assertNull(map.computeIfAbsent(EXTRA_KEY, (k) -> null));
 311         assertFalse(map.containsKey(EXTRA_KEY));
 312         assertSame(map.computeIfAbsent(EXTRA_KEY, (k) -> EXTRA_VALUE), EXTRA_VALUE);
 313         // EXTRA_KEY -> EXTRA_VALUE
 314         assertSame(map.get(EXTRA_KEY), EXTRA_VALUE);
 315     }
 316 
 317     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=all values=all")
 318     public void testComputeIfAbsentNullFunction(String description, Map<IntegerEnum, String> map) {
 319         assertThrows( () -> { map.computeIfAbsent(KEYS[1], null);},
 320                 NullPointerException.class,
 321                 "Should throw NPE");
 322     }
 323 
 324     @Test(dataProvider = "Map<IntegerEnum,String> rw=true keys=withNull values=withNull")
 325     public void testComputeIfPresentNulls(String description, Map<IntegerEnum, String> map) {
 326         assertTrue(map.containsKey(null), description + ": null key absent");
 327         assertNull(map.get(null), description + ": value not null");
 328         assertSame(map.computeIfPresent(null, (k, v) -> {
 329             fail(description + ": null value is not deemed present");
 330             return EXTRA_VALUE;
 331         }), null, description);
 332         assertTrue(map.containsKey(null));
 333         assertNull(map.get(null), description);