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);
|