ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/jtreg/util/NavigableMap/LockStep.java

Comparing jsr166/src/test/jtreg/util/NavigableMap/LockStep.java (file contents):
Revision 1.9 by jsr166, Thu Mar 29 23:35:00 2018 UTC vs.
Revision 1.10 by jsr166, Tue Aug 11 19:32:56 2020 UTC

#	Line 46 | Line 46 | import java.util.Collections;
46		import java.util.Comparator;
47		import java.util.HashSet;
48		import java.util.Iterator;
49	–	import java.util.List;
49		import java.util.Map;
50		import java.util.NavigableMap;
51		import java.util.NavigableSet;
52		import java.util.NoSuchElementException;
53	+	import java.util.Objects;
54		import java.util.Random;
55		import java.util.Set;
56		import java.util.TreeMap;
#	Line 79 | Line 79 | public class LockStep {
79		static void realMain(String[] args) {
80		size = intArg(args, 0, DEFAULT_SIZE);
81
82	<	lockSteps(new TreeMap(),
83	<	new ConcurrentSkipListMap());
84	<	lockSteps(new TreeMap(),
85	<	Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class));
86	<	lockSteps(new TreeMap(),
87	<	Collections.synchronizedNavigableMap(new TreeMap()));
88	<	lockSteps(new TreeMap(reverseOrder()),
89	<	new ConcurrentSkipListMap(reverseOrder()));
90	<
91	<	lockSteps(new TreeSet(),
92	<	new ConcurrentSkipListSet());
93	<	lockSteps(new TreeSet(),
94	<	Collections.checkedNavigableSet(new TreeSet(), Integer.class));
95	<	lockSteps(new TreeSet(),
96	<	Collections.synchronizedNavigableSet(new TreeSet()));
97	<	lockSteps(new TreeSet(reverseOrder()),
98	<	new ConcurrentSkipListSet(reverseOrder()));
82	>	lockSteps(new TreeMap<>(),
83	>	new ConcurrentSkipListMap<>());
84	>	lockSteps(new TreeMap<>(),
85	>	Collections.checkedNavigableMap(new TreeMap<>(), Integer.class, Integer.class));
86	>	lockSteps(new TreeMap<>(),
87	>	Collections.synchronizedNavigableMap(new TreeMap<>()));
88	>	lockSteps(new TreeMap<>(reverseOrder()),
89	>	new ConcurrentSkipListMap<>(reverseOrder()));
90	>
91	>	lockSteps(new TreeSet<>(),
92	>	new ConcurrentSkipListSet<>());
93	>	lockSteps(new TreeSet<>(),
94	>	Collections.checkedNavigableSet(new TreeSet<>(), Integer.class));
95	>	lockSteps(new TreeSet<>(),
96	>	Collections.synchronizedNavigableSet(new TreeSet<>()));
97	>	lockSteps(new TreeSet<>(reverseOrder()),
98	>	new ConcurrentSkipListSet<>(reverseOrder()));
99		}
100
101	<	static void lockSteps(NavigableMap m1, NavigableMap m2) {
101	>	static void lockSteps(NavigableMap<Integer, Integer> m1, NavigableMap<Integer, Integer> m2) {
102		if (maybe(4)) m1 = serialClone(m1);
103		if (maybe(4)) m2 = serialClone(m2);
104		lockStep(m1,
#	Line 119 | Line 119 | public class LockStep {
119		fullTailMap(m2.descendingMap()));
120		}
121
122	<	static void lockSteps(NavigableSet s1, NavigableSet s2) {
122	>	static void lockSteps(NavigableSet<Integer> s1, NavigableSet<Integer> s2) {
123		if (maybe(4)) s1 = serialClone(s1);
124		if (maybe(4)) s2 = serialClone(s2);
125		lockStep(s1,
#	Line 140 | Line 140 | public class LockStep {
140		fullTailSet(s2.descendingSet()));
141		}
142
143	<	static boolean isAscending(NavigableMap m) {
144	<	Comparator cmp = m.comparator();
143	>	static boolean isAscending(NavigableMap<Integer, Integer> m) {
144	>	var cmp = m.comparator();
145		return (cmp == null || cmp.compare(1, 2) < 0);
146		}
147
148	<	static NavigableMap fullSubMap(NavigableMap m) {
148	>	static NavigableMap<Integer, Integer> fullSubMap(NavigableMap<Integer, Integer> m) {
149		return isAscending(m)
150		? m.subMap(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
151		: m.subMap(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
152		}
153
154	<	static NavigableMap fullHeadMap(NavigableMap m) {
154	>	static NavigableMap<Integer, Integer> fullHeadMap(NavigableMap<Integer, Integer> m) {
155		return isAscending(m)
156		? m.headMap(Integer.MAX_VALUE, true)
157		: m.headMap(Integer.MIN_VALUE, true);
158		}
159
160	<	static NavigableMap fullTailMap(NavigableMap m) {
160	>	static NavigableMap<Integer, Integer> fullTailMap(NavigableMap<Integer, Integer> m) {
161		return isAscending(m)
162		? m.tailMap(Integer.MIN_VALUE, true)
163		: m.tailMap(Integer.MAX_VALUE, true);
164		}
165
166	<	static boolean isAscending(NavigableSet s) {
167	<	Comparator cmp = s.comparator();
166	>	static boolean isAscending(NavigableSet<Integer> s) {
167	>	var cmp = s.comparator();
168		return (cmp == null || cmp.compare(1, 2) < 0);
169		}
170
171	<	static NavigableSet fullSubSet(NavigableSet s) {
171	>	static NavigableSet<Integer> fullSubSet(NavigableSet<Integer> s) {
172		return isAscending(s)
173		? s.subSet(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
174		: s.subSet(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
175		}
176
177	<	static NavigableSet fullHeadSet(NavigableSet s) {
177	>	static NavigableSet<Integer> fullHeadSet(NavigableSet<Integer> s) {
178		return isAscending(s)
179		? s.headSet(Integer.MAX_VALUE, true)
180		: s.headSet(Integer.MIN_VALUE, true);
181		}
182
183	<	static NavigableSet fullTailSet(NavigableSet s) {
183	>	static NavigableSet<Integer> fullTailSet(NavigableSet<Integer> s) {
184		return isAscending(s)
185		? s.tailSet(Integer.MIN_VALUE, true)
186		: s.tailSet(Integer.MAX_VALUE, true);
#	Line 231 | Line 231 | public class LockStep {
231		equal(it.next(), expected);
232		}
233
234	<	static Comparator comparator(NavigableSet s) {
235	<	Comparator cmp = s.comparator();
236	<	return cmp != null ? cmp : new Comparator() {
237	<	public int compare(Object o1, Object o2) {
238	<	return ((Comparable) o1).compareTo(o2); }};
234	>	static Comparator<? super Integer> comparator(NavigableSet<Integer> s) {
235	>	var cmp = s.comparator();
236	>	return cmp != null ? cmp : Comparator.naturalOrder();
237		}
238
239	<	static Comparator comparator(NavigableMap m) {
240	<	Comparator cmp = m.comparator();
241	<	return cmp != null ? cmp : new Comparator() {
244	<	public int compare(Object o1, Object o2) {
245	<	return ((Comparable) o1).compareTo(o2); }};
239	>	static Comparator<? super Integer> comparator(NavigableMap<Integer, Integer> m) {
240	>	var cmp = m.comparator();
241	>	return cmp != null ? cmp : Comparator.naturalOrder();
242		}
243
244	<	static void checkNavigableSet(final NavigableSet s) {
244	>	static void checkNavigableSet(final NavigableSet<Integer> s) {
245		if (s.comparator() == null)
246		check(s.descendingSet().descendingSet().comparator() == null);
247		equal(s.isEmpty(), s.size() == 0);
#	Line 259 | Line 255 | public class LockStep {
255		}
256		}
257		}
258	<	Comparator cmp = comparator(s);
258	>	var cmp = comparator(s);
259		if (s.isEmpty()) {
260		THROWS(NoSuchElementException.class,
261		() -> s.first(),
#	Line 269 | Line 265 | public class LockStep {
265		equal(null, s.ceiling(1));
266		equal(null, s.higher(1));
267		} else {
268	<	Object a = s.first();
269	<	Object z = s.last();
268	>	Integer a = s.first();
269	>	Integer z = s.last();
270		equal(s.lower(a), null);
271		equal(s.higher(z), null);
272		equal2(s, s.tailSet(a));
#	Line 285 | Line 281 | public class LockStep {
281		equal2(s.headSet(a, true), singleton(a));
282		equal2(s.tailSet(z, true), singleton(z));
283		}
284	<	Iterator[] its = new Iterator[] {
284	>	Iterator<?>[] its = new Iterator[] {
285		s.iterator(),
286		s.descendingSet().descendingSet().iterator(),
287		};
288	<	for (final Iterator it : its)
288	>	for (final Iterator<?> it : its)
289		if (maybe(4))
290		THROWS(IllegalStateException.class, () -> it.remove());
291	<	Object prev = null;
292	<	for (Object e : s) {
291	>	Integer prev = null;
292	>	for (final Integer e : s) {
293		check(s.contains(e));
294	<	for (Iterator it : its) equalNext(it, e);
294	>	for (Iterator<?> it : its) equalNext(it, e);
295		equal(e, s.ceiling(e));
296		equal(e, s.floor(e));
297		check(s.higher(e) == null || cmp.compare(e, s.higher(e)) < 0);
298		equal(s.lower(e), prev);
299	<	if (prev == null) {
304	<	} else {
299	>	if (prev != null) {
300		check(cmp.compare(prev, e) < 0);
301		}
302		prev = e;
303		}
304	<	for (final Iterator it : its) {
304	>	for (final Iterator<?> it : its) {
305		if (maybe(2))
306		check(! it.hasNext());
307		Fun fun = () -> it.next();
#	Line 324 | Line 319 | public class LockStep {
319		check(! it2.hasNext());
320		}
321
322	<	static void equalSetsLeaf(final Set s1, final Set s2) {
322	>	static void equalSetsLeaf(final Set<?> s1, final Set<?> s2) {
323		equal2(s1,            s2);
324		equal( s1.size(),     s2.size());
325		equal( s1.isEmpty(),  s2.isEmpty());
#	Line 333 | Line 328 | public class LockStep {
328		equal( s1.containsAll(s2), s2.containsAll(s1));
329		}
330
331	<	static void equalNavigableSetsLeaf(final NavigableSet s1,
332	<	final NavigableSet s2) {
331	>	static void equalNavigableSetsLeaf(final NavigableSet<Integer> s1,
332	>	final NavigableSet<Integer> s2) {
333		equal2(s1,            s2);
334		equal( s1.size(),     s2.size());
335		equal( s1.isEmpty(),  s2.isEmpty());
#	Line 350 | Line 345 | public class LockStep {
345		checkNavigableSet(s2);
346		}
347
348	<	static void equalNavigableSets(final NavigableSet s1,
349	<	final NavigableSet s2) {
348	>	static void equalNavigableSets(final NavigableSet<Integer> s1,
349	>	final NavigableSet<Integer> s2) {
350		equalNavigableSetsLeaf(s1, s2);
351		equalNavigableSetsLeaf(s1.descendingSet(), s2.descendingSet());
352		equalNavigableSetsLeaf(s1.descendingSet().descendingSet(), s2);
353	<	Object min = s1.isEmpty() ? Integer.MIN_VALUE : s1.first();
354	<	Object max = s2.isEmpty() ? Integer.MAX_VALUE : s2.last();
353	>	Integer min = s1.isEmpty() ? Integer.MIN_VALUE : s1.first();
354	>	Integer max = s2.isEmpty() ? Integer.MAX_VALUE : s2.last();
355		if (s1.comparator() != null &&
356		s1.comparator().compare(min, max) > 0) {
357	<	Object tmp = min; min = max; max = tmp;
357	>	Integer tmp = min; min = max; max = tmp;
358		}
359
360		equalNavigableSetsLeaf(s1.subSet(min, true, max, true),
#	Line 368 | Line 363 | public class LockStep {
363		s2.tailSet(min, true));
364		equalNavigableSetsLeaf(s1.headSet(max, true),
365		s2.headSet(max, true));
366	<	equalNavigableSetsLeaf((NavigableSet) s1.subSet(min, max),
367	<	(NavigableSet) s2.subSet(min, max));
368	<	equalNavigableSetsLeaf((NavigableSet) s1.tailSet(min),
369	<	(NavigableSet) s2.tailSet(min));
370	<	equalNavigableSetsLeaf((NavigableSet) s1.headSet(max),
371	<	(NavigableSet) s2.headSet(max));
366	>	equalNavigableSetsLeaf((NavigableSet<Integer>) s1.subSet(min, max),
367	>	(NavigableSet<Integer>) s2.subSet(min, max));
368	>	equalNavigableSetsLeaf((NavigableSet<Integer>) s1.tailSet(min),
369	>	(NavigableSet<Integer>) s2.tailSet(min));
370	>	equalNavigableSetsLeaf((NavigableSet<Integer>) s1.headSet(max),
371	>	(NavigableSet<Integer>) s2.headSet(max));
372		}
373
374		// Destined for a Collections.java near you?
375		static <T> T[] concat(T[]... arrays) {
376		int len = 0;
377	<	for (int i = 0; i < arrays.length; i++)
383	<	len += arrays[i].length;
377	>	for (T[] arr : arrays) len += arr.length;
378		T[] a = (T[])java.lang.reflect.Array
379		.newInstance(arrays[0].getClass().getComponentType(), len);
380		int k = 0;
381	<	for (int i = 0; i < arrays.length; i++) {
382	<	T[] array = arrays[i];
383	<	System.arraycopy(array, 0, a, k, array.length);
390	<	k += array.length;
381	>	for (T[] arr : arrays) {
382	>	System.arraycopy(arr, 0, a, k, arr.length);
383	>	k += arr.length;
384		}
385		return a;
386		}
387
388	<	static void checkNavigableMap(final NavigableMap m) {
388	>	static void checkNavigableMap(final NavigableMap<Integer, Integer> m) {
389		if (m.comparator() == null) {
390		check(m.descendingMap().descendingMap().comparator() == null);
391		check(m.descendingKeySet().descendingSet().comparator() == null);
#	Line 402 | Line 395 | public class LockStep {
395		if (maybe(4))
396		equal2(m, serialClone(m));
397		equal2(m.keySet(), m.descendingKeySet());
398	<	Comparator cmp = comparator(m);
398	>	var cmp = comparator(m);
399		if (m.isEmpty()) {
400		THROWS(NoSuchElementException.class,
401		() -> m.firstKey(),
#	Line 420 | Line 413 | public class LockStep {
413		equal(null, m.ceilingEntry(1));
414		equal(null, m.higherEntry(1));
415		} else {
416	<	Object a = m.firstKey();
417	<	Object z = m.lastKey();
416	>	Integer a = m.firstKey();
417	>	Integer z = m.lastKey();
418		equal(m.lowerKey(a), null);
419		equal(m.higherKey(z), null);
420		equal(a, m.firstEntry().getKey());
#	Line 439 | Line 432 | public class LockStep {
432		equal2(m.tailMap(z, true), singletonMap(z, m.get(z)));
433		}
434
435	<	Iterator[] kits = new Iterator[] {
435	>	Iterator<?>[] kits = new Iterator[] {
436		m.keySet().iterator(),
437		m.descendingMap().descendingKeySet().iterator(),
438		m.descendingKeySet().descendingSet().iterator(),
439		};
440	<	Iterator[] vits = new Iterator[] {
440	>	Iterator<?>[] vits = new Iterator[] {
441		m.values().iterator(),
442		m.descendingMap().descendingMap().values().iterator(),
443		};
444	<	Iterator[] eits = new Iterator[] {
444	>	Iterator<?>[] eits = new Iterator[] {
445		m.entrySet().iterator(),
446		m.descendingMap().descendingMap().entrySet().iterator(),
447		};
448	<	Iterator[] its = concat(kits, vits, eits);
449	<	for (final Iterator it : its)
448	>	Iterator<?>[] its = concat(kits, vits, eits);
449	>	for (final Iterator<?> it : its)
450		if (maybe(4))
451		THROWS(IllegalStateException.class, () -> it.remove());
452	<	Map.Entry prev = null;
453	<	for (Map.Entry e : (Set<Map.Entry>) m.entrySet()) {
454	<	Object k = e.getKey();
455	<	Object v = e.getValue();
452	>	Map.Entry<Integer, Integer> prev = null;
453	>	for (var e : m.entrySet()) {
454	>	Integer k = e.getKey();
455	>	Integer v = e.getValue();
456		check(m.containsKey(k));
457		check(m.containsValue(v));
458	<	for (Iterator kit : kits) equalNext(kit, k);
459	<	for (Iterator vit : vits) equalNext(vit, v);
460	<	for (Iterator eit : eits) equalNext(eit, e);
458	>	for (var kit : kits) equalNext(kit, k);
459	>	for (var vit : vits) equalNext(vit, v);
460	>	for (var eit : eits) equalNext(eit, e);
461		equal(k, m.ceilingKey(k));
462		equal(k, m.ceilingEntry(k).getKey());
463		equal(k, m.floorKey(k));
#	Line 480 | Line 473 | public class LockStep {
473		}
474		prev = e;
475		}
476	<	for (final Iterator it : its) {
476	>	for (final var it : its) {
477		if (maybe(2))
478		check(! it.hasNext());
479		Fun fun = () -> it.next();
#	Line 488 | Line 481 | public class LockStep {
481		}
482		}
483
484	<	static void equalNavigableMapsLeaf(final NavigableMap m1,
485	<	final NavigableMap m2) {
484	>	static void equalNavigableMapsLeaf(final NavigableMap<Integer, Integer> m1,
485	>	final NavigableMap<Integer, Integer> m2) {
486		equal2(m1,              m2);
487		equal( m1.size(),       m2.size());
488		equal( m1.isEmpty(),    m2.isEmpty());
#	Line 501 | Line 494 | public class LockStep {
494		checkNavigableMap(m2);
495		}
496
497	<	static void equalNavigableMaps(NavigableMap m1,
498	<	NavigableMap m2) {
497	>	static void equalNavigableMaps(NavigableMap<Integer, Integer> m1,
498	>	NavigableMap<Integer, Integer> m2) {
499		equalNavigableMapsLeaf(m1, m2);
500		equalSetsLeaf(m1.keySet(), m2.keySet());
501		equalNavigableSets(m1.navigableKeySet(),
#	Line 515 | Line 508 | public class LockStep {
508		m2.descendingMap());
509		equalNavigableMapsLeaf(m1.descendingMap().descendingMap(),
510		m2);
511	<	equalNavigableSetsLeaf((NavigableSet) m1.descendingMap().keySet(),
512	<	(NavigableSet) m2.descendingMap().keySet());
511	>	equalNavigableSetsLeaf((NavigableSet<Integer>) m1.descendingMap().keySet(),
512	>	(NavigableSet<Integer>) m2.descendingMap().keySet());
513		equalNavigableSetsLeaf(m1.descendingMap().descendingKeySet(),
514		m2.descendingMap().descendingKeySet());
515		equal2(m1.descendingMap().entrySet(),
#	Line 525 | Line 518 | public class LockStep {
518		//----------------------------------------------------------------
519		// submaps
520		//----------------------------------------------------------------
521	<	Object min = Integer.MIN_VALUE;
522	<	Object max = Integer.MAX_VALUE;
521	>	Integer min = Integer.MIN_VALUE;
522	>	Integer max = Integer.MAX_VALUE;
523		if (m1.comparator() != null
524		&& m1.comparator().compare(min, max) > 0) {
525	<	Object tmp = min; min = max; max = tmp;
525	>	Integer tmp = min; min = max; max = tmp;
526		}
527		switch (rnd.nextInt(6)) {
528		case 0:
#	Line 545 | Line 538 | public class LockStep {
538		m2.headMap(max, true));
539		break;
540		case 3:
541	<	equalNavigableMapsLeaf((NavigableMap) m1.subMap(min, max),
542	<	(NavigableMap) m2.subMap(min, max));
541	>	equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.subMap(min, max),
542	>	(NavigableMap<Integer, Integer>) m2.subMap(min, max));
543		break;
544		case 4:
545	<	equalNavigableMapsLeaf((NavigableMap) m1.tailMap(min),
546	<	(NavigableMap) m2.tailMap(min));
545	>	equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.tailMap(min),
546	>	(NavigableMap<Integer, Integer>) m2.tailMap(min));
547		break;
548		case 5:
549	<	equalNavigableMapsLeaf((NavigableMap) m1.headMap(max),
550	<	(NavigableMap) m2.headMap(max));
549	>	equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.headMap(max),
550	>	(NavigableMap<Integer, Integer>) m2.headMap(max));
551		break;
552		}
553		}
554
555	<	abstract static class MapFrobber { abstract void frob(NavigableMap m); }
556	<	abstract static class SetFrobber { abstract void frob(NavigableSet m); }
555	>	interface MapFrobber { void frob(NavigableMap<Integer, Integer> m); }
556	>	interface SetFrobber { void frob(NavigableSet<Integer> m); }
557
558	<	static MapFrobber randomAdder(NavigableMap m) {
558	>	static MapFrobber randomAdder(NavigableMap<Integer, Integer> m) {
559		final Integer k = unusedKey(m);
560		final MapFrobber[] randomAdders = {
561	<	new MapFrobber() {void frob(NavigableMap m) {
562	<	equal(m.put(k, k+1), null);
563	<	equal(m.get(k), k+1);
561	>	map -> {
562	>	equal(map.put(k, k + 1), null);
563	>	equal(map.get(k), k + 1);
564		if (maybe(4)) {
565	<	equal(m.put(k, k+1), k+1);
566	<	equal(m.get(k), k+1);}}},
567	<	new MapFrobber() {void frob(NavigableMap m) {
568	<	m.descendingMap().put(k, k+1);
569	<	equal(m.get(k), k+1);}},
570	<	new MapFrobber() {void frob(NavigableMap m) {
571	<	m.tailMap(k,true).headMap(k,true).put(k,k+1);}},
572	<	new MapFrobber() {void frob(NavigableMap m) {
573	<	m.tailMap(k,true).headMap(k,true).descendingMap().put(k,k+1);}}
565	>	equal(map.put(k, k + 1), k + 1);
566	>	equal(map.get(k), k + 1);}},
567	>	map -> {
568	>	map.descendingMap().put(k, k + 1);
569	>	equal(map.get(k), k + 1);},
570	>	map -> map.tailMap(k,true).headMap(k,true).put(k, k + 1),
571	>	map -> {
572	>	equal(map.tailMap(k,true).headMap(k,true).putIfAbsent(k, k + 1), null);
573	>	equal(map.tailMap(k,true).headMap(k,true).putIfAbsent(k, k + 1), k + 1);},
574	>	map -> {
575	>	equal(map.tailMap(k,true).headMap(k,true).merge(k,k,Integer::sum), k);
576	>	equal(map.tailMap(k,true).headMap(k,true).merge(k,1,Integer::sum), k+1);},
577	>	map -> equal(map.subMap(k,true, k, true).computeIfAbsent(k, key -> key + 1), k + 1),
578	>	map -> {
579	>	equal(map.subMap(k,true, k, true).computeIfPresent(k, (key, val) -> 1), null);
580	>	equal(map.tailMap(k,true).compute(k, (key, val) -> {
581	>	equal(val, null);
582	>	return 1;
583	>	}), 1);
584	>	equal(map.headMap(k, true).computeIfPresent(k, (key, val) -> val + key), k + 1);
585	>	equal(map.tailMap(k, false).computeIfPresent(k, (key, val) -> 1), null);
586	>	equal(map.headMap(k, false).compute(k, (key, val) -> null), null);
587	>	equal(map.tailMap(k, false).computeIfAbsent(k, key -> null), null);
588	>	},
589	>	map -> map.tailMap(k,true).headMap(k,true).descendingMap().put(k, k + 1)
590		};
591	<	return new MapFrobber() {void frob(NavigableMap m) {
592	<	randomAdders[rnd.nextInt(randomAdders.length)].frob(m);
593	<	if (maybe(2)) equal(m.get(k), k+1);
591	>	return map -> {
592	>	randomAdders[rnd.nextInt(randomAdders.length)].frob(map);
593	>	if (maybe(2)) equal(map.get(k), k + 1);
594		if (maybe(4)) {
595	<	equal(m.put(k, k+1), k+1);
596	<	equal(m.get(k), k+1);}}};
595	>	equal(map.put(k, k + 1), k + 1);
596	>	equal(map.get(k), k + 1);}};
597		}
598
599	<	static SetFrobber randomAdder(NavigableSet s) {
599	>	static SetFrobber randomAdder(NavigableSet<Integer> s) {
600		final Integer e = unusedElt(s);
601		final SetFrobber[] randomAdders = {
602	<	new SetFrobber() {void frob(NavigableSet s) {
603	<	check(s.add(e));}},
604	<	new SetFrobber() {void frob(NavigableSet s) {
605	<	s.descendingSet().add(e);}},
597	<	new SetFrobber() {void frob(NavigableSet s) {
598	<	s.tailSet(e,true).headSet(e,true).add(e);}},
599	<	new SetFrobber() {void frob(NavigableSet s) {
600	<	s.descendingSet().tailSet(e,true).headSet(e,true).add(e);}}
602	>	set -> check(set.add(e)),
603	>	set -> set.descendingSet().add(e),
604	>	set -> set.tailSet(e,true).headSet(e,true).add(e),
605	>	set -> set.descendingSet().tailSet(e,true).headSet(e,true).add(e)
606		};
607	<	return new SetFrobber() {void frob(NavigableSet s) {
608	<	if (maybe(2)) check(! s.contains(e));
609	<	randomAdders[rnd.nextInt(randomAdders.length)].frob(s);
610	<	if (maybe(2)) check(! s.add(e));
611	<	if (maybe(2)) check(s.contains(e));}};
607	>	return set -> {
608	>	if (maybe(2)) check(! set.contains(e));
609	>	randomAdders[rnd.nextInt(randomAdders.length)].frob(set);
610	>	if (maybe(2)) check(! set.add(e));
611	>	if (maybe(2)) check(set.contains(e));};
612		}
613
614	<	static Integer unusedElt(NavigableSet s) {
614	>	static Integer unusedElt(NavigableSet<Integer> s) {
615		Integer e;
616		do { e = rnd.nextInt(1024); }
617		while (s.contains(e));
618		return e;
619		}
620
621	<	static Integer unusedKey(NavigableMap m) {
621	>	static Integer unusedKey(NavigableMap<Integer, Integer> m) {
622		Integer k;
623		do { k = rnd.nextInt(1024); }
624		while (m.containsKey(k));
625		return k;
626		}
627
628	<	static Integer usedKey(NavigableMap m) {
628	>	static Integer usedKey(NavigableMap<Integer, Integer> m) {
629		Integer x = rnd.nextInt(1024);
630	<	Integer floor   = (Integer) m.floorKey(x);
631	<	Integer ceiling = (Integer) m.ceilingKey(x);
630	>	Integer floor   = m.floorKey(x);
631	>	Integer ceiling = m.ceilingKey(x);
632		if (floor != null) return floor;
633		check(ceiling != null);
634		return ceiling;
635		}
636
637	<	static Integer usedElt(NavigableSet s) {
637	>	static Integer usedElt(NavigableSet<Integer> s) {
638		Integer x = rnd.nextInt(1024);
639	<	Integer floor   = (Integer) s.floor(x);
640	<	Integer ceiling = (Integer) s.ceiling(x);
639	>	Integer floor   = s.floor(x);
640	>	Integer ceiling = s.ceiling(x);
641		if (floor != null) return floor;
642		check(ceiling != null);
643		return ceiling;
644		}
645
646	<	static void checkUnusedKey(NavigableMap m, Object k) {
646	>	static void checkUnusedKey(NavigableMap<Integer, Integer> m, Integer k) {
647		check(! m.containsKey(k));
648		equal(m.get(k), null);
649		if (maybe(2))
650		equal(m.remove(k), null);
651		}
652
653	<	static void checkUnusedElt(NavigableSet s, Object e) {
653	>	static void checkUnusedElt(NavigableSet<Integer> s, Integer e) {
654		if (maybe(2))
655		check(! s.contains(e));
656		if (maybe(2)) {
#	Line 656 | Line 661 | public class LockStep {
661		check(! s.remove(e));
662		}
663
664	<	static Fun remover(final Iterator it) {
664	>	static Fun remover(final Iterator<?> it) {
665		return () -> it.remove();
666		}
667
668	<	static MapFrobber randomRemover(NavigableMap m) {
668	>	static MapFrobber randomRemover(NavigableMap<Integer, Integer> m) {
669		final Integer k = usedKey(m);
670		final MapFrobber[] randomRemovers = {
671	<	new MapFrobber() {void frob(NavigableMap m) {
672	<	Map.Entry e = m.firstEntry();
673	<	equal(m.pollFirstEntry(), e);
674	<	checkUnusedKey(m, e.getKey());}},
675	<	new MapFrobber() {void frob(NavigableMap m) {
676	<	Map.Entry e = m.lastEntry();
677	<	equal(m.pollLastEntry(), e);
678	<	checkUnusedKey(m, e.getKey());}},
679	<	new MapFrobber() {void frob(NavigableMap m) {
680	<	check(m.remove(k) != null);
681	<	checkUnusedKey(m, k);}},
682	<	new MapFrobber() {void frob(NavigableMap m) {
683	<	m.subMap(k, true, k, true).clear();
684	<	checkUnusedKey(m, k);}},
685	<	new MapFrobber() {void frob(NavigableMap m) {
686	<	m.descendingMap().subMap(k, true, k, true).clear();
687	<	checkUnusedKey(m, k);}},
688	<	new MapFrobber() {void frob(NavigableMap m) {
689	<	final Iterator it = m.keySet().iterator();
671	>	map -> {
672	>	var e = map.firstEntry();
673	>	equal(map.pollFirstEntry(), e);
674	>	checkUnusedKey(map, e.getKey());},
675	>	map -> {
676	>	var e = map.lastEntry();
677	>	equal(map.pollLastEntry(), e);
678	>	checkUnusedKey(map, e.getKey());},
679	>	map -> {
680	>	check(map.remove(k) != null);
681	>	checkUnusedKey(map, k);},
682	>	map -> {
683	>	map.subMap(k, true, k, true).clear();
684	>	checkUnusedKey(map, k);},
685	>	map -> {
686	>	map.descendingMap().subMap(k, true, k, true).clear();
687	>	checkUnusedKey(map, k);},
688	>	map -> {
689	>	final var it = map.keySet().iterator();
690		while (it.hasNext())
691		if (it.next().equals(k)) {
692		it.remove();
#	Line 689 | Line 694 | public class LockStep {
694		THROWS(IllegalStateException.class,
695		() -> it.remove());
696		}
697	<	checkUnusedKey(m, k);}},
698	<	new MapFrobber() {void frob(NavigableMap m) {
699	<	final Iterator it = m.navigableKeySet().descendingIterator();
697	>	checkUnusedKey(map, k);},
698	>	map -> {
699	>	final var it = map.navigableKeySet().descendingIterator();
700		while (it.hasNext())
701		if (it.next().equals(k)) {
702		it.remove();
#	Line 699 | Line 704 | public class LockStep {
704		THROWS(IllegalStateException.class,
705		() -> it.remove());
706		}
707	<	checkUnusedKey(m, k);}},
708	<	new MapFrobber() {void frob(NavigableMap m) {
709	<	final Iterator<Map.Entry> it = m.entrySet().iterator();
707	>	checkUnusedKey(map, k);},
708	>	map -> {
709	>	final var it = map.entrySet().iterator();
710		while (it.hasNext())
711		if (it.next().getKey().equals(k)) {
712		it.remove();
713		if (maybe(2))
714		THROWS(IllegalStateException.class, remover(it));
715		}
716	<	checkUnusedKey(m, k);}},
716	>	checkUnusedKey(map, k);},
717		};
718
719		return randomRemovers[rnd.nextInt(randomRemovers.length)];
720		}
721
722	<	static SetFrobber randomRemover(NavigableSet s) {
722	>	static SetFrobber randomRemover(NavigableSet<Integer> s) {
723		final Integer e = usedElt(s);
724
725		final SetFrobber[] randomRemovers = {
726	<	new SetFrobber() {void frob(NavigableSet s) {
727	<	Object e = s.first();
728	<	equal(s.pollFirst(), e);
729	<	checkUnusedElt(s, e);}},
730	<	new SetFrobber() {void frob(NavigableSet s) {
731	<	Object e = s.last();
732	<	equal(s.pollLast(), e);
733	<	checkUnusedElt(s, e);}},
734	<	new SetFrobber() {void frob(NavigableSet s) {
735	<	check(s.remove(e));
736	<	checkUnusedElt(s, e);}},
737	<	new SetFrobber() {void frob(NavigableSet s) {
738	<	s.subSet(e, true, e, true).clear();
739	<	checkUnusedElt(s, e);}},
740	<	new SetFrobber() {void frob(NavigableSet s) {
741	<	s.descendingSet().subSet(e, true, e, true).clear();
742	<	checkUnusedElt(s, e);}},
743	<	new SetFrobber() {void frob(NavigableSet s) {
744	<	final Iterator it = s.iterator();
726	>	set -> {
727	>	var fst = set.first();
728	>	equal(set.pollFirst(), fst);
729	>	checkUnusedElt(set, fst);},
730	>	set -> {
731	>	var lst = set.last();
732	>	equal(set.pollLast(), lst);
733	>	checkUnusedElt(set, lst);},
734	>	set -> {
735	>	check(set.remove(e));
736	>	checkUnusedElt(set, e);},
737	>	set -> {
738	>	set.subSet(e, true, e, true).clear();
739	>	checkUnusedElt(set, e);},
740	>	set -> {
741	>	set.descendingSet().subSet(e, true, e, true).clear();
742	>	checkUnusedElt(set, e);},
743	>	set -> {
744	>	final var it = set.iterator();
745		while (it.hasNext())
746		if (it.next().equals(e)) {
747		it.remove();
#	Line 744 | Line 749 | public class LockStep {
749		THROWS(IllegalStateException.class,
750		() -> it.remove());
751		}
752	<	checkUnusedElt(s, e);}},
753	<	new SetFrobber() {void frob(NavigableSet s) {
754	<	final Iterator it = s.descendingSet().iterator();
752	>	checkUnusedElt(set, e);},
753	>	set -> {
754	>	final var it = set.descendingSet().iterator();
755		while (it.hasNext())
756		if (it.next().equals(e)) {
757		it.remove();
#	Line 754 | Line 759 | public class LockStep {
759		THROWS(IllegalStateException.class,
760		() -> it.remove());
761		}
762	<	checkUnusedElt(s, e);}},
763	<	new SetFrobber() {void frob(NavigableSet s) {
764	<	final Iterator it = s.descendingIterator();
762	>	checkUnusedElt(set, e);},
763	>	set -> {
764	>	final var it = set.descendingIterator();
765		while (it.hasNext())
766		if (it.next().equals(e)) {
767		it.remove();
#	Line 764 | Line 769 | public class LockStep {
769		THROWS(IllegalStateException.class,
770		() -> it.remove());
771		}
772	<	checkUnusedElt(s, e);}}
772	>	checkUnusedElt(set, e);}
773		};
774
775		return randomRemovers[rnd.nextInt(randomRemovers.length)];
776		}
777
778	<	static void lockStep(NavigableMap m1,
779	<	NavigableMap m2) {
778	>	static void lockStep(NavigableMap<Integer, Integer> m1,
779	>	NavigableMap<Integer, Integer> m2) {
780		if (! (thorough || maybe(3))) return;
781		if (maybe(4)) m1 = serialClone(m1);
782		if (maybe(4)) m2 = serialClone(m2);
783
784	<	List<NavigableMap> maps = Arrays.asList(m1, m2);
785	<	for (NavigableMap m : maps) testEmptyMap(m);
784	>	var maps = Arrays.asList(m1, m2);
785	>	for (var m : maps) testEmptyMap(m);
786		final Set<Integer> ints = new HashSet<>();
787		while (ints.size() < size)
788		ints.add(rnd.nextInt(1024));
789		final Integer[] elts = ints.toArray(new Integer[size]);
790	+	equal(elts.length, size);
791		for (int i = 0; i < size; i++) {
792		MapFrobber adder = randomAdder(m1);
793	<	for (final NavigableMap m : maps) {
793	>	for (var m : maps) {
794		adder.frob(m);
795		equal(m.size(), i+1);
796		}
797		equalNavigableMaps(m1, m2);
798		}
799	<	for (final NavigableMap m : maps) {
800	<	final Object e = usedKey(m);
799	>	for (var m : maps) {
800	>	final var e = usedKey(m);
801		THROWS(IllegalArgumentException.class,
802	<	() -> {m.subMap(e,true,e,false)
803	<	.subMap(e,true,e,true);},
798	<	() -> {m.subMap(e,false,e,true)
799	<	.subMap(e,true,e,true);},
802	>	() -> m.subMap(e,true,e,false).subMap(e,true,e,true),
803	>	() -> m.subMap(e,false,e,true).subMap(e,true,e,true),
804		() -> m.tailMap(e,false).tailMap(e,true),
805	<	() -> m.headMap(e,false).headMap(e,true));
805	>	() -> m.headMap(e,false).headMap(e,true),
806	>	() -> m.headMap(e, false).put(e, 0),
807	>	() -> m.tailMap(e, false).putIfAbsent(e, 0),
808	>	() -> m.headMap(e, false).computeIfAbsent(e, k -> 1),
809	>	() -> m.tailMap(e, false).compute(e, (k, v) -> 0));
810		}
811		//System.out.printf("%s%n", m1);
812		for (int i = size; i > 0; i--) {
813		MapFrobber remover = randomRemover(m1);
814	<	for (final NavigableMap m : maps) {
814	>	for (var m : maps) {
815		remover.frob(m);
816		equal(m.size(), i-1);
817		}
818		equalNavigableMaps(m1, m2);
819		}
820	<	for (NavigableMap m : maps) testEmptyMap(m);
820	>	for (var m : maps) testEmptyMap(m);
821		}
822
823	<	static void lockStep(NavigableSet s1,
824	<	NavigableSet s2) {
823	>	static void lockStep(NavigableSet<Integer> s1,
824	>	NavigableSet<Integer> s2) {
825		if (! (thorough || maybe(3))) return;
826		if (maybe(4)) s1 = serialClone(s1);
827		if (maybe(4)) s2 = serialClone(s2);
828
829	<	List<NavigableSet> sets = Arrays.asList(s1, s2);
830	<	for (NavigableSet s : sets) testEmptySet(s);
829	>	var sets = Arrays.asList(s1, s2);
830	>	for (var s : sets) testEmptySet(s);
831		final Set<Integer> ints = new HashSet<>();
832		while (ints.size() < size)
833		ints.add(rnd.nextInt(1024));
834		final Integer[] elts = ints.toArray(new Integer[size]);
835	+	equal(elts.length, size);
836		for (int i = 0; i < size; i++) {
837		SetFrobber adder = randomAdder(s1);
838	<	for (final NavigableSet s : sets) {
838	>	for (var s : sets) {
839		adder.frob(s);
840		equal(s.size(), i+1);
841		}
842		equalNavigableSets(s1, s2);
843		}
844	<	for (final NavigableSet s : sets) {
845	<	final Object e = usedElt(s);
844	>	for (var s : sets) {
845	>	final Integer e = usedElt(s);
846		THROWS(IllegalArgumentException.class,
847	<	() -> {s.subSet(e,true,e,false)
848	<	.subSet(e,true,e,true);},
840	<	() -> {s.subSet(e,false,e,true)
841	<	.subSet(e,true,e,true);},
847	>	() -> s.subSet(e,true,e,false).subSet(e,true,e,true),
848	>	() -> s.subSet(e,false,e,true).subSet(e,true,e,true),
849		() -> s.tailSet(e,false).tailSet(e,true),
850		() -> s.headSet(e,false).headSet(e,true));
851		}
852		//System.out.printf("%s%n", s1);
853		for (int i = size; i > 0; i--) {
854		SetFrobber remover = randomRemover(s1);
855	<	for (final NavigableSet s : sets) {
855	>	for (var s : sets) {
856		remover.frob(s);
857		equal(s.size(), i-1);
858		}
859		equalNavigableSets(s1, s2);
860		}
861	<	for (NavigableSet s : sets) testEmptySet(s);
861	>	for (var s : sets) testEmptySet(s);
862		}
863
864		//--------------------- Infrastructure ---------------------------
#	Line 862 | Line 869 | public class LockStep {
869		static void unexpected(Throwable t) { failed++; t.printStackTrace(); }
870		static void check(boolean cond) { if (cond) pass(); else fail(); }
871		static void equal(Object x, Object y) {
872	<	if (x == null ? y == null : x.equals(y)) pass();
872	>	if (Objects.equals(x, y)) pass();
873		else {System.out.println(x + " not equal to " + y); fail();}}
874		static void equal2(Object x, Object y) {equal(x, y); equal(y, x);}
875		public static void main(String[] args) throws Throwable {

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines