< prev index next >
test/jdk/java/util/NavigableMap/LockStep.java
Print this page
*** 44,58 ****
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
- import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListMap;
--- 44,58 ----
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
+ import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.ConcurrentSkipListMap;
*** 77,106 ****
static boolean maybe(int n) { return rnd.nextInt(n) == 0; }
static void realMain(String[] args) {
size = intArg(args, 0, DEFAULT_SIZE);
! lockSteps(new TreeMap(),
! new ConcurrentSkipListMap());
! lockSteps(new TreeMap(),
! Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class));
! lockSteps(new TreeMap(),
! Collections.synchronizedNavigableMap(new TreeMap()));
! lockSteps(new TreeMap(reverseOrder()),
! new ConcurrentSkipListMap(reverseOrder()));
!
! lockSteps(new TreeSet(),
! new ConcurrentSkipListSet());
! lockSteps(new TreeSet(),
! Collections.checkedNavigableSet(new TreeSet(), Integer.class));
! lockSteps(new TreeSet(),
! Collections.synchronizedNavigableSet(new TreeSet()));
! lockSteps(new TreeSet(reverseOrder()),
! new ConcurrentSkipListSet(reverseOrder()));
}
! static void lockSteps(NavigableMap m1, NavigableMap m2) {
if (maybe(4)) m1 = serialClone(m1);
if (maybe(4)) m2 = serialClone(m2);
lockStep(m1,
m2);
lockStep(m1.descendingMap(),
--- 77,106 ----
static boolean maybe(int n) { return rnd.nextInt(n) == 0; }
static void realMain(String[] args) {
size = intArg(args, 0, DEFAULT_SIZE);
! lockSteps(new TreeMap<>(),
! new ConcurrentSkipListMap<>());
! lockSteps(new TreeMap<>(),
! Collections.checkedNavigableMap(new TreeMap<>(), Integer.class, Integer.class));
! lockSteps(new TreeMap<>(),
! Collections.synchronizedNavigableMap(new TreeMap<>()));
! lockSteps(new TreeMap<>(reverseOrder()),
! new ConcurrentSkipListMap<>(reverseOrder()));
!
! lockSteps(new TreeSet<>(),
! new ConcurrentSkipListSet<>());
! lockSteps(new TreeSet<>(),
! Collections.checkedNavigableSet(new TreeSet<>(), Integer.class));
! lockSteps(new TreeSet<>(),
! Collections.synchronizedNavigableSet(new TreeSet<>()));
! lockSteps(new TreeSet<>(reverseOrder()),
! new ConcurrentSkipListSet<>(reverseOrder()));
}
! static void lockSteps(NavigableMap<Integer, Integer> m1, NavigableMap<Integer, Integer> m2) {
if (maybe(4)) m1 = serialClone(m1);
if (maybe(4)) m2 = serialClone(m2);
lockStep(m1,
m2);
lockStep(m1.descendingMap(),
*** 117,127 ****
fullTailMap(m2));
lockStep(fullTailMap(m1.descendingMap()),
fullTailMap(m2.descendingMap()));
}
! static void lockSteps(NavigableSet s1, NavigableSet s2) {
if (maybe(4)) s1 = serialClone(s1);
if (maybe(4)) s2 = serialClone(s2);
lockStep(s1,
s2);
lockStep(s1.descendingSet(),
--- 117,127 ----
fullTailMap(m2));
lockStep(fullTailMap(m1.descendingMap()),
fullTailMap(m2.descendingMap()));
}
! static void lockSteps(NavigableSet<Integer> s1, NavigableSet<Integer> s2) {
if (maybe(4)) s1 = serialClone(s1);
if (maybe(4)) s2 = serialClone(s2);
lockStep(s1,
s2);
lockStep(s1.descendingSet(),
*** 138,188 ****
fullTailSet(s2));
lockStep(fullTailSet(s1.descendingSet()),
fullTailSet(s2.descendingSet()));
}
! static boolean isAscending(NavigableMap m) {
! Comparator cmp = m.comparator();
return (cmp == null || cmp.compare(1, 2) < 0);
}
! static NavigableMap fullSubMap(NavigableMap m) {
return isAscending(m)
? m.subMap(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
: m.subMap(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
}
! static NavigableMap fullHeadMap(NavigableMap m) {
return isAscending(m)
? m.headMap(Integer.MAX_VALUE, true)
: m.headMap(Integer.MIN_VALUE, true);
}
! static NavigableMap fullTailMap(NavigableMap m) {
return isAscending(m)
? m.tailMap(Integer.MIN_VALUE, true)
: m.tailMap(Integer.MAX_VALUE, true);
}
! static boolean isAscending(NavigableSet s) {
! Comparator cmp = s.comparator();
return (cmp == null || cmp.compare(1, 2) < 0);
}
! static NavigableSet fullSubSet(NavigableSet s) {
return isAscending(s)
? s.subSet(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
: s.subSet(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
}
! static NavigableSet fullHeadSet(NavigableSet s) {
return isAscending(s)
? s.headSet(Integer.MAX_VALUE, true)
: s.headSet(Integer.MIN_VALUE, true);
}
! static NavigableSet fullTailSet(NavigableSet s) {
return isAscending(s)
? s.tailSet(Integer.MIN_VALUE, true)
: s.tailSet(Integer.MAX_VALUE, true);
}
--- 138,188 ----
fullTailSet(s2));
lockStep(fullTailSet(s1.descendingSet()),
fullTailSet(s2.descendingSet()));
}
! static boolean isAscending(NavigableMap<Integer, Integer> m) {
! var cmp = m.comparator();
return (cmp == null || cmp.compare(1, 2) < 0);
}
! static NavigableMap<Integer, Integer> fullSubMap(NavigableMap<Integer, Integer> m) {
return isAscending(m)
? m.subMap(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
: m.subMap(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
}
! static NavigableMap<Integer, Integer> fullHeadMap(NavigableMap<Integer, Integer> m) {
return isAscending(m)
? m.headMap(Integer.MAX_VALUE, true)
: m.headMap(Integer.MIN_VALUE, true);
}
! static NavigableMap<Integer, Integer> fullTailMap(NavigableMap<Integer, Integer> m) {
return isAscending(m)
? m.tailMap(Integer.MIN_VALUE, true)
: m.tailMap(Integer.MAX_VALUE, true);
}
! static boolean isAscending(NavigableSet<Integer> s) {
! var cmp = s.comparator();
return (cmp == null || cmp.compare(1, 2) < 0);
}
! static NavigableSet<Integer> fullSubSet(NavigableSet<Integer> s) {
return isAscending(s)
? s.subSet(Integer.MIN_VALUE, true, Integer.MAX_VALUE, true)
: s.subSet(Integer.MAX_VALUE, true, Integer.MIN_VALUE, true);
}
! static NavigableSet<Integer> fullHeadSet(NavigableSet<Integer> s) {
return isAscending(s)
? s.headSet(Integer.MAX_VALUE, true)
: s.headSet(Integer.MIN_VALUE, true);
}
! static NavigableSet<Integer> fullTailSet(NavigableSet<Integer> s) {
return isAscending(s)
? s.tailSet(Integer.MIN_VALUE, true)
: s.tailSet(Integer.MAX_VALUE, true);
}
*** 229,253 ****
if (maybe(2))
check(it.hasNext());
equal(it.next(), expected);
}
! static Comparator comparator(NavigableSet s) {
! Comparator cmp = s.comparator();
! return cmp != null ? cmp : new Comparator() {
! public int compare(Object o1, Object o2) {
! return ((Comparable) o1).compareTo(o2); }};
}
! static Comparator comparator(NavigableMap m) {
! Comparator cmp = m.comparator();
! return cmp != null ? cmp : new Comparator() {
! public int compare(Object o1, Object o2) {
! return ((Comparable) o1).compareTo(o2); }};
}
! static void checkNavigableSet(final NavigableSet s) {
if (s.comparator() == null)
check(s.descendingSet().descendingSet().comparator() == null);
equal(s.isEmpty(), s.size() == 0);
equal2(s, s.descendingSet());
if (maybe(4) && s instanceof Serializable) {
--- 229,249 ----
if (maybe(2))
check(it.hasNext());
equal(it.next(), expected);
}
! static Comparator<? super Integer> comparator(NavigableSet<Integer> s) {
! var cmp = s.comparator();
! return cmp != null ? cmp : Comparator.naturalOrder();
}
! static Comparator<? super Integer> comparator(NavigableMap<Integer, Integer> m) {
! var cmp = m.comparator();
! return cmp != null ? cmp : Comparator.naturalOrder();
}
! static void checkNavigableSet(final NavigableSet<Integer> s) {
if (s.comparator() == null)
check(s.descendingSet().descendingSet().comparator() == null);
equal(s.isEmpty(), s.size() == 0);
equal2(s, s.descendingSet());
if (maybe(4) && s instanceof Serializable) {
*** 257,278 ****
if (!(uhoh.getCause() instanceof NotSerializableException)) {
throw uhoh;
}
}
}
! Comparator cmp = comparator(s);
if (s.isEmpty()) {
THROWS(NoSuchElementException.class,
() -> s.first(),
() -> s.last());
equal(null, s.lower(1));
equal(null, s.floor(1));
equal(null, s.ceiling(1));
equal(null, s.higher(1));
} else {
! Object a = s.first();
! Object z = s.last();
equal(s.lower(a), null);
equal(s.higher(z), null);
equal2(s, s.tailSet(a));
equal2(s, s.headSet(z, true));
equal2(s, s.subSet(a, true, z, true));
--- 253,274 ----
if (!(uhoh.getCause() instanceof NotSerializableException)) {
throw uhoh;
}
}
}
! var cmp = comparator(s);
if (s.isEmpty()) {
THROWS(NoSuchElementException.class,
() -> s.first(),
() -> s.last());
equal(null, s.lower(1));
equal(null, s.floor(1));
equal(null, s.ceiling(1));
equal(null, s.higher(1));
} else {
! Integer a = s.first();
! Integer z = s.last();
equal(s.lower(a), null);
equal(s.higher(z), null);
equal2(s, s.tailSet(a));
equal2(s, s.headSet(z, true));
equal2(s, s.subSet(a, true, z, true));
*** 283,314 ****
testEmptySet(s.tailSet(z, false));
equal2(s.headSet(a, true), singleton(a));
equal2(s.tailSet(z, true), singleton(z));
}
! Iterator[] its = new Iterator[] {
s.iterator(),
s.descendingSet().descendingSet().iterator(),
};
! for (final Iterator it : its)
if (maybe(4))
THROWS(IllegalStateException.class, () -> it.remove());
! Object prev = null;
! for (Object e : s) {
check(s.contains(e));
! for (Iterator it : its) equalNext(it, e);
equal(e, s.ceiling(e));
equal(e, s.floor(e));
check(s.higher(e) == null || cmp.compare(e, s.higher(e)) < 0);
equal(s.lower(e), prev);
! if (prev == null) {
! } else {
check(cmp.compare(prev, e) < 0);
}
prev = e;
}
! for (final Iterator it : its) {
if (maybe(2))
check(! it.hasNext());
Fun fun = () -> it.next();
THROWS(NoSuchElementException.class, fun, fun, fun);
}
--- 279,309 ----
testEmptySet(s.tailSet(z, false));
equal2(s.headSet(a, true), singleton(a));
equal2(s.tailSet(z, true), singleton(z));
}
! Iterator<?>[] its = new Iterator[] {
s.iterator(),
s.descendingSet().descendingSet().iterator(),
};
! for (final Iterator<?> it : its)
if (maybe(4))
THROWS(IllegalStateException.class, () -> it.remove());
! Integer prev = null;
! for (final Integer e : s) {
check(s.contains(e));
! for (Iterator<?> it : its) equalNext(it, e);
equal(e, s.ceiling(e));
equal(e, s.floor(e));
check(s.higher(e) == null || cmp.compare(e, s.higher(e)) < 0);
equal(s.lower(e), prev);
! if (prev != null) {
check(cmp.compare(prev, e) < 0);
}
prev = e;
}
! for (final Iterator<?> it : its) {
if (maybe(2))
check(! it.hasNext());
Fun fun = () -> it.next();
THROWS(NoSuchElementException.class, fun, fun, fun);
}
*** 322,342 ****
equal(it1.next(), it2.next());
}
check(! it2.hasNext());
}
! static void equalSetsLeaf(final Set s1, final Set s2) {
equal2(s1, s2);
equal( s1.size(), s2.size());
equal( s1.isEmpty(), s2.isEmpty());
equal( s1.hashCode(), s2.hashCode());
equal( s1.toString(), s2.toString());
equal( s1.containsAll(s2), s2.containsAll(s1));
}
! static void equalNavigableSetsLeaf(final NavigableSet s1,
! final NavigableSet s2) {
equal2(s1, s2);
equal( s1.size(), s2.size());
equal( s1.isEmpty(), s2.isEmpty());
equal( s1.hashCode(), s2.hashCode());
equal( s1.toString(), s2.toString());
--- 317,337 ----
equal(it1.next(), it2.next());
}
check(! it2.hasNext());
}
! static void equalSetsLeaf(final Set<?> s1, final Set<?> s2) {
equal2(s1, s2);
equal( s1.size(), s2.size());
equal( s1.isEmpty(), s2.isEmpty());
equal( s1.hashCode(), s2.hashCode());
equal( s1.toString(), s2.toString());
equal( s1.containsAll(s2), s2.containsAll(s1));
}
! static void equalNavigableSetsLeaf(final NavigableSet<Integer> s1,
! final NavigableSet<Integer> s2) {
equal2(s1, s2);
equal( s1.size(), s2.size());
equal( s1.isEmpty(), s2.isEmpty());
equal( s1.hashCode(), s2.hashCode());
equal( s1.toString(), s2.toString());
*** 348,410 ****
equalIterators(s1.descendingIterator(), s2.descendingIterator());
checkNavigableSet(s1);
checkNavigableSet(s2);
}
! static void equalNavigableSets(final NavigableSet s1,
! final NavigableSet s2) {
equalNavigableSetsLeaf(s1, s2);
equalNavigableSetsLeaf(s1.descendingSet(), s2.descendingSet());
equalNavigableSetsLeaf(s1.descendingSet().descendingSet(), s2);
! Object min = s1.isEmpty() ? Integer.MIN_VALUE : s1.first();
! Object max = s2.isEmpty() ? Integer.MAX_VALUE : s2.last();
if (s1.comparator() != null &&
s1.comparator().compare(min, max) > 0) {
! Object tmp = min; min = max; max = tmp;
}
equalNavigableSetsLeaf(s1.subSet(min, true, max, true),
s2.subSet(min, true, max, true));
equalNavigableSetsLeaf(s1.tailSet(min, true),
s2.tailSet(min, true));
equalNavigableSetsLeaf(s1.headSet(max, true),
s2.headSet(max, true));
! equalNavigableSetsLeaf((NavigableSet) s1.subSet(min, max),
! (NavigableSet) s2.subSet(min, max));
! equalNavigableSetsLeaf((NavigableSet) s1.tailSet(min),
! (NavigableSet) s2.tailSet(min));
! equalNavigableSetsLeaf((NavigableSet) s1.headSet(max),
! (NavigableSet) s2.headSet(max));
}
// Destined for a Collections.java near you?
static <T> T[] concat(T[]... arrays) {
int len = 0;
! for (int i = 0; i < arrays.length; i++)
! len += arrays[i].length;
T[] a = (T[])java.lang.reflect.Array
.newInstance(arrays[0].getClass().getComponentType(), len);
int k = 0;
! for (int i = 0; i < arrays.length; i++) {
! T[] array = arrays[i];
! System.arraycopy(array, 0, a, k, array.length);
! k += array.length;
}
return a;
}
! static void checkNavigableMap(final NavigableMap m) {
if (m.comparator() == null) {
check(m.descendingMap().descendingMap().comparator() == null);
check(m.descendingKeySet().descendingSet().comparator() == null);
}
equal(m.isEmpty(), m.size() == 0);
equal2(m, m.descendingMap());
if (maybe(4))
equal2(m, serialClone(m));
equal2(m.keySet(), m.descendingKeySet());
! Comparator cmp = comparator(m);
if (m.isEmpty()) {
THROWS(NoSuchElementException.class,
() -> m.firstKey(),
() -> m.lastKey());
equal(null, m.firstEntry());
--- 343,403 ----
equalIterators(s1.descendingIterator(), s2.descendingIterator());
checkNavigableSet(s1);
checkNavigableSet(s2);
}
! static void equalNavigableSets(final NavigableSet<Integer> s1,
! final NavigableSet<Integer> s2) {
equalNavigableSetsLeaf(s1, s2);
equalNavigableSetsLeaf(s1.descendingSet(), s2.descendingSet());
equalNavigableSetsLeaf(s1.descendingSet().descendingSet(), s2);
! Integer min = s1.isEmpty() ? Integer.MIN_VALUE : s1.first();
! Integer max = s2.isEmpty() ? Integer.MAX_VALUE : s2.last();
if (s1.comparator() != null &&
s1.comparator().compare(min, max) > 0) {
! Integer tmp = min; min = max; max = tmp;
}
equalNavigableSetsLeaf(s1.subSet(min, true, max, true),
s2.subSet(min, true, max, true));
equalNavigableSetsLeaf(s1.tailSet(min, true),
s2.tailSet(min, true));
equalNavigableSetsLeaf(s1.headSet(max, true),
s2.headSet(max, true));
! equalNavigableSetsLeaf((NavigableSet<Integer>) s1.subSet(min, max),
! (NavigableSet<Integer>) s2.subSet(min, max));
! equalNavigableSetsLeaf((NavigableSet<Integer>) s1.tailSet(min),
! (NavigableSet<Integer>) s2.tailSet(min));
! equalNavigableSetsLeaf((NavigableSet<Integer>) s1.headSet(max),
! (NavigableSet<Integer>) s2.headSet(max));
}
// Destined for a Collections.java near you?
static <T> T[] concat(T[]... arrays) {
int len = 0;
! for (T[] arr : arrays) len += arr.length;
T[] a = (T[])java.lang.reflect.Array
.newInstance(arrays[0].getClass().getComponentType(), len);
int k = 0;
! for (T[] arr : arrays) {
! System.arraycopy(arr, 0, a, k, arr.length);
! k += arr.length;
}
return a;
}
! static void checkNavigableMap(final NavigableMap<Integer, Integer> m) {
if (m.comparator() == null) {
check(m.descendingMap().descendingMap().comparator() == null);
check(m.descendingKeySet().descendingSet().comparator() == null);
}
equal(m.isEmpty(), m.size() == 0);
equal2(m, m.descendingMap());
if (maybe(4))
equal2(m, serialClone(m));
equal2(m.keySet(), m.descendingKeySet());
! var cmp = comparator(m);
if (m.isEmpty()) {
THROWS(NoSuchElementException.class,
() -> m.firstKey(),
() -> m.lastKey());
equal(null, m.firstEntry());
*** 418,429 ****
equal(null, m.lowerEntry(1));
equal(null, m.floorEntry(1));
equal(null, m.ceilingEntry(1));
equal(null, m.higherEntry(1));
} else {
! Object a = m.firstKey();
! Object z = m.lastKey();
equal(m.lowerKey(a), null);
equal(m.higherKey(z), null);
equal(a, m.firstEntry().getKey());
equal(z, m.lastEntry().getKey());
equal2(m, m.tailMap(a));
--- 411,422 ----
equal(null, m.lowerEntry(1));
equal(null, m.floorEntry(1));
equal(null, m.ceilingEntry(1));
equal(null, m.higherEntry(1));
} else {
! Integer a = m.firstKey();
! Integer z = m.lastKey();
equal(m.lowerKey(a), null);
equal(m.higherKey(z), null);
equal(a, m.firstEntry().getKey());
equal(z, m.lastEntry().getKey());
equal2(m, m.tailMap(a));
*** 437,472 ****
equal2(m.headMap(a, true), singletonMap(a, m.get(a)));
equal2(m.tailMap(z, true), singletonMap(z, m.get(z)));
}
! Iterator[] kits = new Iterator[] {
m.keySet().iterator(),
m.descendingMap().descendingKeySet().iterator(),
m.descendingKeySet().descendingSet().iterator(),
};
! Iterator[] vits = new Iterator[] {
m.values().iterator(),
m.descendingMap().descendingMap().values().iterator(),
};
! Iterator[] eits = new Iterator[] {
m.entrySet().iterator(),
m.descendingMap().descendingMap().entrySet().iterator(),
};
! Iterator[] its = concat(kits, vits, eits);
! for (final Iterator it : its)
if (maybe(4))
THROWS(IllegalStateException.class, () -> it.remove());
! Map.Entry prev = null;
! for (Map.Entry e : (Set<Map.Entry>) m.entrySet()) {
! Object k = e.getKey();
! Object v = e.getValue();
check(m.containsKey(k));
check(m.containsValue(v));
! for (Iterator kit : kits) equalNext(kit, k);
! for (Iterator vit : vits) equalNext(vit, v);
! for (Iterator eit : eits) equalNext(eit, e);
equal(k, m.ceilingKey(k));
equal(k, m.ceilingEntry(k).getKey());
equal(k, m.floorKey(k));
equal(k, m.floorEntry(k).getKey());
check(m.higherKey(k) == null || cmp.compare(k, m.higherKey(k)) < 0);
--- 430,465 ----
equal2(m.headMap(a, true), singletonMap(a, m.get(a)));
equal2(m.tailMap(z, true), singletonMap(z, m.get(z)));
}
! Iterator<?>[] kits = new Iterator[] {
m.keySet().iterator(),
m.descendingMap().descendingKeySet().iterator(),
m.descendingKeySet().descendingSet().iterator(),
};
! Iterator<?>[] vits = new Iterator[] {
m.values().iterator(),
m.descendingMap().descendingMap().values().iterator(),
};
! Iterator<?>[] eits = new Iterator[] {
m.entrySet().iterator(),
m.descendingMap().descendingMap().entrySet().iterator(),
};
! Iterator<?>[] its = concat(kits, vits, eits);
! for (final Iterator<?> it : its)
if (maybe(4))
THROWS(IllegalStateException.class, () -> it.remove());
! Map.Entry<Integer, Integer> prev = null;
! for (var e : m.entrySet()) {
! Integer k = e.getKey();
! Integer v = e.getValue();
check(m.containsKey(k));
check(m.containsValue(v));
! for (var kit : kits) equalNext(kit, k);
! for (var vit : vits) equalNext(vit, v);
! for (var eit : eits) equalNext(eit, e);
equal(k, m.ceilingKey(k));
equal(k, m.ceilingEntry(k).getKey());
equal(k, m.floorKey(k));
equal(k, m.floorEntry(k).getKey());
check(m.higherKey(k) == null || cmp.compare(k, m.higherKey(k)) < 0);
*** 478,497 ****
equal(m.lowerKey(k), prev.getKey());
check(cmp.compare(prev.getKey(), e.getKey()) < 0);
}
prev = e;
}
! for (final Iterator it : its) {
if (maybe(2))
check(! it.hasNext());
Fun fun = () -> it.next();
THROWS(NoSuchElementException.class, fun, fun, fun);
}
}
! static void equalNavigableMapsLeaf(final NavigableMap m1,
! final NavigableMap m2) {
equal2(m1, m2);
equal( m1.size(), m2.size());
equal( m1.isEmpty(), m2.isEmpty());
equal( m1.hashCode(), m2.hashCode());
equal( m1.toString(), m2.toString());
--- 471,490 ----
equal(m.lowerKey(k), prev.getKey());
check(cmp.compare(prev.getKey(), e.getKey()) < 0);
}
prev = e;
}
! for (final var it : its) {
if (maybe(2))
check(! it.hasNext());
Fun fun = () -> it.next();
THROWS(NoSuchElementException.class, fun, fun, fun);
}
}
! static void equalNavigableMapsLeaf(final NavigableMap<Integer, Integer> m1,
! final NavigableMap<Integer, Integer> m2) {
equal2(m1, m2);
equal( m1.size(), m2.size());
equal( m1.isEmpty(), m2.isEmpty());
equal( m1.hashCode(), m2.hashCode());
equal( m1.toString(), m2.toString());
*** 499,510 ****
equal2(m1.lastEntry(), m2.lastEntry());
checkNavigableMap(m1);
checkNavigableMap(m2);
}
! static void equalNavigableMaps(NavigableMap m1,
! NavigableMap m2) {
equalNavigableMapsLeaf(m1, m2);
equalSetsLeaf(m1.keySet(), m2.keySet());
equalNavigableSets(m1.navigableKeySet(),
m2.navigableKeySet());
equalNavigableSets(m1.descendingKeySet(),
--- 492,503 ----
equal2(m1.lastEntry(), m2.lastEntry());
checkNavigableMap(m1);
checkNavigableMap(m2);
}
! static void equalNavigableMaps(NavigableMap<Integer, Integer> m1,
! NavigableMap<Integer, Integer> m2) {
equalNavigableMapsLeaf(m1, m2);
equalSetsLeaf(m1.keySet(), m2.keySet());
equalNavigableSets(m1.navigableKeySet(),
m2.navigableKeySet());
equalNavigableSets(m1.descendingKeySet(),
*** 513,537 ****
m2.entrySet());
equalNavigableMapsLeaf(m1.descendingMap(),
m2.descendingMap());
equalNavigableMapsLeaf(m1.descendingMap().descendingMap(),
m2);
! equalNavigableSetsLeaf((NavigableSet) m1.descendingMap().keySet(),
! (NavigableSet) m2.descendingMap().keySet());
equalNavigableSetsLeaf(m1.descendingMap().descendingKeySet(),
m2.descendingMap().descendingKeySet());
equal2(m1.descendingMap().entrySet(),
m2.descendingMap().entrySet());
//----------------------------------------------------------------
// submaps
//----------------------------------------------------------------
! Object min = Integer.MIN_VALUE;
! Object max = Integer.MAX_VALUE;
if (m1.comparator() != null
&& m1.comparator().compare(min, max) > 0) {
! Object tmp = min; min = max; max = tmp;
}
switch (rnd.nextInt(6)) {
case 0:
equalNavigableMapsLeaf(m1.subMap(min, true, max, true),
m2.subMap(min, true, max, true));
--- 506,530 ----
m2.entrySet());
equalNavigableMapsLeaf(m1.descendingMap(),
m2.descendingMap());
equalNavigableMapsLeaf(m1.descendingMap().descendingMap(),
m2);
! equalNavigableSetsLeaf((NavigableSet<Integer>) m1.descendingMap().keySet(),
! (NavigableSet<Integer>) m2.descendingMap().keySet());
equalNavigableSetsLeaf(m1.descendingMap().descendingKeySet(),
m2.descendingMap().descendingKeySet());
equal2(m1.descendingMap().entrySet(),
m2.descendingMap().entrySet());
//----------------------------------------------------------------
// submaps
//----------------------------------------------------------------
! Integer min = Integer.MIN_VALUE;
! Integer max = Integer.MAX_VALUE;
if (m1.comparator() != null
&& m1.comparator().compare(min, max) > 0) {
! Integer tmp = min; min = max; max = tmp;
}
switch (rnd.nextInt(6)) {
case 0:
equalNavigableMapsLeaf(m1.subMap(min, true, max, true),
m2.subMap(min, true, max, true));
*** 543,870 ****
case 2:
equalNavigableMapsLeaf(m1.headMap(max, true),
m2.headMap(max, true));
break;
case 3:
! equalNavigableMapsLeaf((NavigableMap) m1.subMap(min, max),
! (NavigableMap) m2.subMap(min, max));
break;
case 4:
! equalNavigableMapsLeaf((NavigableMap) m1.tailMap(min),
! (NavigableMap) m2.tailMap(min));
break;
case 5:
! equalNavigableMapsLeaf((NavigableMap) m1.headMap(max),
! (NavigableMap) m2.headMap(max));
break;
}
}
! abstract static class MapFrobber { abstract void frob(NavigableMap m); }
! abstract static class SetFrobber { abstract void frob(NavigableSet m); }
! static MapFrobber randomAdder(NavigableMap m) {
final Integer k = unusedKey(m);
final MapFrobber[] randomAdders = {
! new MapFrobber() {void frob(NavigableMap m) {
! equal(m.put(k, k+1), null);
! equal(m.get(k), k+1);
if (maybe(4)) {
! equal(m.put(k, k+1), k+1);
! equal(m.get(k), k+1);}}},
! new MapFrobber() {void frob(NavigableMap m) {
! m.descendingMap().put(k, k+1);
! equal(m.get(k), k+1);}},
! new MapFrobber() {void frob(NavigableMap m) {
! m.tailMap(k,true).headMap(k,true).put(k,k+1);}},
! new MapFrobber() {void frob(NavigableMap m) {
! m.tailMap(k,true).headMap(k,true).descendingMap().put(k,k+1);}}
};
! return new MapFrobber() {void frob(NavigableMap m) {
! randomAdders[rnd.nextInt(randomAdders.length)].frob(m);
! if (maybe(2)) equal(m.get(k), k+1);
if (maybe(4)) {
! equal(m.put(k, k+1), k+1);
! equal(m.get(k), k+1);}}};
}
! static SetFrobber randomAdder(NavigableSet s) {
final Integer e = unusedElt(s);
final SetFrobber[] randomAdders = {
! new SetFrobber() {void frob(NavigableSet s) {
! check(s.add(e));}},
! new SetFrobber() {void frob(NavigableSet s) {
! s.descendingSet().add(e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! s.tailSet(e,true).headSet(e,true).add(e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! s.descendingSet().tailSet(e,true).headSet(e,true).add(e);}}
};
! return new SetFrobber() {void frob(NavigableSet s) {
! if (maybe(2)) check(! s.contains(e));
! randomAdders[rnd.nextInt(randomAdders.length)].frob(s);
! if (maybe(2)) check(! s.add(e));
! if (maybe(2)) check(s.contains(e));}};
}
! static Integer unusedElt(NavigableSet s) {
Integer e;
do { e = rnd.nextInt(1024); }
while (s.contains(e));
return e;
}
! static Integer unusedKey(NavigableMap m) {
Integer k;
do { k = rnd.nextInt(1024); }
while (m.containsKey(k));
return k;
}
! static Integer usedKey(NavigableMap m) {
Integer x = rnd.nextInt(1024);
! Integer floor = (Integer) m.floorKey(x);
! Integer ceiling = (Integer) m.ceilingKey(x);
if (floor != null) return floor;
check(ceiling != null);
return ceiling;
}
! static Integer usedElt(NavigableSet s) {
Integer x = rnd.nextInt(1024);
! Integer floor = (Integer) s.floor(x);
! Integer ceiling = (Integer) s.ceiling(x);
if (floor != null) return floor;
check(ceiling != null);
return ceiling;
}
! static void checkUnusedKey(NavigableMap m, Object k) {
check(! m.containsKey(k));
equal(m.get(k), null);
if (maybe(2))
equal(m.remove(k), null);
}
! static void checkUnusedElt(NavigableSet s, Object e) {
if (maybe(2))
check(! s.contains(e));
if (maybe(2)) {
check(s.ceiling(e) != e);
check(s.floor(e) != e);
}
if (maybe(2))
check(! s.remove(e));
}
! static Fun remover(final Iterator it) {
return () -> it.remove();
}
! static MapFrobber randomRemover(NavigableMap m) {
final Integer k = usedKey(m);
final MapFrobber[] randomRemovers = {
! new MapFrobber() {void frob(NavigableMap m) {
! Map.Entry e = m.firstEntry();
! equal(m.pollFirstEntry(), e);
! checkUnusedKey(m, e.getKey());}},
! new MapFrobber() {void frob(NavigableMap m) {
! Map.Entry e = m.lastEntry();
! equal(m.pollLastEntry(), e);
! checkUnusedKey(m, e.getKey());}},
! new MapFrobber() {void frob(NavigableMap m) {
! check(m.remove(k) != null);
! checkUnusedKey(m, k);}},
! new MapFrobber() {void frob(NavigableMap m) {
! m.subMap(k, true, k, true).clear();
! checkUnusedKey(m, k);}},
! new MapFrobber() {void frob(NavigableMap m) {
! m.descendingMap().subMap(k, true, k, true).clear();
! checkUnusedKey(m, k);}},
! new MapFrobber() {void frob(NavigableMap m) {
! final Iterator it = m.keySet().iterator();
while (it.hasNext())
if (it.next().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedKey(m, k);}},
! new MapFrobber() {void frob(NavigableMap m) {
! final Iterator it = m.navigableKeySet().descendingIterator();
while (it.hasNext())
if (it.next().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedKey(m, k);}},
! new MapFrobber() {void frob(NavigableMap m) {
! final Iterator<Map.Entry> it = m.entrySet().iterator();
while (it.hasNext())
if (it.next().getKey().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class, remover(it));
}
! checkUnusedKey(m, k);}},
};
return randomRemovers[rnd.nextInt(randomRemovers.length)];
}
! static SetFrobber randomRemover(NavigableSet s) {
final Integer e = usedElt(s);
final SetFrobber[] randomRemovers = {
! new SetFrobber() {void frob(NavigableSet s) {
! Object e = s.first();
! equal(s.pollFirst(), e);
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! Object e = s.last();
! equal(s.pollLast(), e);
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! check(s.remove(e));
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! s.subSet(e, true, e, true).clear();
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! s.descendingSet().subSet(e, true, e, true).clear();
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! final Iterator it = s.iterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! final Iterator it = s.descendingSet().iterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(s, e);}},
! new SetFrobber() {void frob(NavigableSet s) {
! final Iterator it = s.descendingIterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(s, e);}}
};
return randomRemovers[rnd.nextInt(randomRemovers.length)];
}
! static void lockStep(NavigableMap m1,
! NavigableMap m2) {
if (! (thorough || maybe(3))) return;
if (maybe(4)) m1 = serialClone(m1);
if (maybe(4)) m2 = serialClone(m2);
! List<NavigableMap> maps = Arrays.asList(m1, m2);
! for (NavigableMap m : maps) testEmptyMap(m);
final Set<Integer> ints = new HashSet<>();
while (ints.size() < size)
ints.add(rnd.nextInt(1024));
final Integer[] elts = ints.toArray(new Integer[size]);
for (int i = 0; i < size; i++) {
MapFrobber adder = randomAdder(m1);
! for (final NavigableMap m : maps) {
adder.frob(m);
equal(m.size(), i+1);
}
equalNavigableMaps(m1, m2);
}
! for (final NavigableMap m : maps) {
! final Object e = usedKey(m);
THROWS(IllegalArgumentException.class,
! () -> {m.subMap(e,true,e,false)
! .subMap(e,true,e,true);},
! () -> {m.subMap(e,false,e,true)
! .subMap(e,true,e,true);},
() -> m.tailMap(e,false).tailMap(e,true),
! () -> m.headMap(e,false).headMap(e,true));
}
//System.out.printf("%s%n", m1);
for (int i = size; i > 0; i--) {
MapFrobber remover = randomRemover(m1);
! for (final NavigableMap m : maps) {
remover.frob(m);
equal(m.size(), i-1);
}
equalNavigableMaps(m1, m2);
}
! for (NavigableMap m : maps) testEmptyMap(m);
}
! static void lockStep(NavigableSet s1,
! NavigableSet s2) {
if (! (thorough || maybe(3))) return;
if (maybe(4)) s1 = serialClone(s1);
if (maybe(4)) s2 = serialClone(s2);
! List<NavigableSet> sets = Arrays.asList(s1, s2);
! for (NavigableSet s : sets) testEmptySet(s);
final Set<Integer> ints = new HashSet<>();
while (ints.size() < size)
ints.add(rnd.nextInt(1024));
final Integer[] elts = ints.toArray(new Integer[size]);
for (int i = 0; i < size; i++) {
SetFrobber adder = randomAdder(s1);
! for (final NavigableSet s : sets) {
adder.frob(s);
equal(s.size(), i+1);
}
equalNavigableSets(s1, s2);
}
! for (final NavigableSet s : sets) {
! final Object e = usedElt(s);
THROWS(IllegalArgumentException.class,
! () -> {s.subSet(e,true,e,false)
! .subSet(e,true,e,true);},
! () -> {s.subSet(e,false,e,true)
! .subSet(e,true,e,true);},
() -> s.tailSet(e,false).tailSet(e,true),
() -> s.headSet(e,false).headSet(e,true));
}
//System.out.printf("%s%n", s1);
for (int i = size; i > 0; i--) {
SetFrobber remover = randomRemover(s1);
! for (final NavigableSet s : sets) {
remover.frob(s);
equal(s.size(), i-1);
}
equalNavigableSets(s1, s2);
}
! for (NavigableSet s : sets) testEmptySet(s);
}
//--------------------- Infrastructure ---------------------------
static volatile int passed = 0, failed = 0;
static void pass() { passed++; }
static void fail() { failed++; Thread.dumpStack(); }
static void fail(String msg) { System.out.println(msg); fail(); }
static void unexpected(Throwable t) { failed++; t.printStackTrace(); }
static void check(boolean cond) { if (cond) pass(); else fail(); }
static void equal(Object x, Object y) {
! if (x == null ? y == null : x.equals(y)) pass();
else {System.out.println(x + " not equal to " + y); fail();}}
static void equal2(Object x, Object y) {equal(x, y); equal(y, x);}
public static void main(String[] args) throws Throwable {
try { realMain(args); } catch (Throwable t) { unexpected(t); }
--- 536,877 ----
case 2:
equalNavigableMapsLeaf(m1.headMap(max, true),
m2.headMap(max, true));
break;
case 3:
! equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.subMap(min, max),
! (NavigableMap<Integer, Integer>) m2.subMap(min, max));
break;
case 4:
! equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.tailMap(min),
! (NavigableMap<Integer, Integer>) m2.tailMap(min));
break;
case 5:
! equalNavigableMapsLeaf((NavigableMap<Integer, Integer>) m1.headMap(max),
! (NavigableMap<Integer, Integer>) m2.headMap(max));
break;
}
}
! interface MapFrobber { void frob(NavigableMap<Integer, Integer> m); }
! interface SetFrobber { void frob(NavigableSet<Integer> m); }
! static MapFrobber randomAdder(NavigableMap<Integer, Integer> m) {
final Integer k = unusedKey(m);
final MapFrobber[] randomAdders = {
! map -> {
! equal(map.put(k, k + 1), null);
! equal(map.get(k), k + 1);
if (maybe(4)) {
! equal(map.put(k, k + 1), k + 1);
! equal(map.get(k), k + 1);}},
! map -> {
! map.descendingMap().put(k, k + 1);
! equal(map.get(k), k + 1);},
! map -> map.tailMap(k,true).headMap(k,true).put(k, k + 1),
! map -> {
! equal(map.tailMap(k,true).headMap(k,true).putIfAbsent(k, k + 1), null);
! equal(map.tailMap(k,true).headMap(k,true).putIfAbsent(k, k + 1), k + 1);},
! map -> {
! equal(map.tailMap(k,true).headMap(k,true).merge(k,k,Integer::sum), k);
! equal(map.tailMap(k,true).headMap(k,true).merge(k,1,Integer::sum), k+1);},
! map -> equal(map.subMap(k,true, k, true).computeIfAbsent(k, key -> key + 1), k + 1),
! map -> {
! equal(map.subMap(k,true, k, true).computeIfPresent(k, (key, val) -> 1), null);
! equal(map.tailMap(k,true).compute(k, (key, val) -> {
! equal(val, null);
! return 1;
! }), 1);
! equal(map.headMap(k, true).computeIfPresent(k, (key, val) -> val + key), k + 1);
! equal(map.tailMap(k, false).computeIfPresent(k, (key, val) -> 1), null);
! equal(map.headMap(k, false).compute(k, (key, val) -> null), null);
! equal(map.tailMap(k, false).computeIfAbsent(k, key -> null), null);
! },
! map -> map.tailMap(k,true).headMap(k,true).descendingMap().put(k, k + 1)
};
! return map -> {
! randomAdders[rnd.nextInt(randomAdders.length)].frob(map);
! if (maybe(2)) equal(map.get(k), k + 1);
if (maybe(4)) {
! equal(map.put(k, k + 1), k + 1);
! equal(map.get(k), k + 1);}};
}
! static SetFrobber randomAdder(NavigableSet<Integer> s) {
final Integer e = unusedElt(s);
final SetFrobber[] randomAdders = {
! set -> check(set.add(e)),
! set -> set.descendingSet().add(e),
! set -> set.tailSet(e,true).headSet(e,true).add(e),
! set -> set.descendingSet().tailSet(e,true).headSet(e,true).add(e)
};
! return set -> {
! if (maybe(2)) check(! set.contains(e));
! randomAdders[rnd.nextInt(randomAdders.length)].frob(set);
! if (maybe(2)) check(! set.add(e));
! if (maybe(2)) check(set.contains(e));};
}
! static Integer unusedElt(NavigableSet<Integer> s) {
Integer e;
do { e = rnd.nextInt(1024); }
while (s.contains(e));
return e;
}
! static Integer unusedKey(NavigableMap<Integer, Integer> m) {
Integer k;
do { k = rnd.nextInt(1024); }
while (m.containsKey(k));
return k;
}
! static Integer usedKey(NavigableMap<Integer, Integer> m) {
Integer x = rnd.nextInt(1024);
! Integer floor = m.floorKey(x);
! Integer ceiling = m.ceilingKey(x);
if (floor != null) return floor;
check(ceiling != null);
return ceiling;
}
! static Integer usedElt(NavigableSet<Integer> s) {
Integer x = rnd.nextInt(1024);
! Integer floor = s.floor(x);
! Integer ceiling = s.ceiling(x);
if (floor != null) return floor;
check(ceiling != null);
return ceiling;
}
! static void checkUnusedKey(NavigableMap<Integer, Integer> m, Integer k) {
check(! m.containsKey(k));
equal(m.get(k), null);
if (maybe(2))
equal(m.remove(k), null);
}
! static void checkUnusedElt(NavigableSet<Integer> s, Integer e) {
if (maybe(2))
check(! s.contains(e));
if (maybe(2)) {
check(s.ceiling(e) != e);
check(s.floor(e) != e);
}
if (maybe(2))
check(! s.remove(e));
}
! static Fun remover(final Iterator<?> it) {
return () -> it.remove();
}
! static MapFrobber randomRemover(NavigableMap<Integer, Integer> m) {
final Integer k = usedKey(m);
final MapFrobber[] randomRemovers = {
! map -> {
! var e = map.firstEntry();
! equal(map.pollFirstEntry(), e);
! checkUnusedKey(map, e.getKey());},
! map -> {
! var e = map.lastEntry();
! equal(map.pollLastEntry(), e);
! checkUnusedKey(map, e.getKey());},
! map -> {
! check(map.remove(k) != null);
! checkUnusedKey(map, k);},
! map -> {
! map.subMap(k, true, k, true).clear();
! checkUnusedKey(map, k);},
! map -> {
! map.descendingMap().subMap(k, true, k, true).clear();
! checkUnusedKey(map, k);},
! map -> {
! final var it = map.keySet().iterator();
while (it.hasNext())
if (it.next().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedKey(map, k);},
! map -> {
! final var it = map.navigableKeySet().descendingIterator();
while (it.hasNext())
if (it.next().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedKey(map, k);},
! map -> {
! final var it = map.entrySet().iterator();
while (it.hasNext())
if (it.next().getKey().equals(k)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class, remover(it));
}
! checkUnusedKey(map, k);},
};
return randomRemovers[rnd.nextInt(randomRemovers.length)];
}
! static SetFrobber randomRemover(NavigableSet<Integer> s) {
final Integer e = usedElt(s);
final SetFrobber[] randomRemovers = {
! set -> {
! var fst = set.first();
! equal(set.pollFirst(), fst);
! checkUnusedElt(set, fst);},
! set -> {
! var lst = set.last();
! equal(set.pollLast(), lst);
! checkUnusedElt(set, lst);},
! set -> {
! check(set.remove(e));
! checkUnusedElt(set, e);},
! set -> {
! set.subSet(e, true, e, true).clear();
! checkUnusedElt(set, e);},
! set -> {
! set.descendingSet().subSet(e, true, e, true).clear();
! checkUnusedElt(set, e);},
! set -> {
! final var it = set.iterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(set, e);},
! set -> {
! final var it = set.descendingSet().iterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(set, e);},
! set -> {
! final var it = set.descendingIterator();
while (it.hasNext())
if (it.next().equals(e)) {
it.remove();
if (maybe(2))
THROWS(IllegalStateException.class,
() -> it.remove());
}
! checkUnusedElt(set, e);}
};
return randomRemovers[rnd.nextInt(randomRemovers.length)];
}
! static void lockStep(NavigableMap<Integer, Integer> m1,
! NavigableMap<Integer, Integer> m2) {
if (! (thorough || maybe(3))) return;
if (maybe(4)) m1 = serialClone(m1);
if (maybe(4)) m2 = serialClone(m2);
! var maps = Arrays.asList(m1, m2);
! for (var m : maps) testEmptyMap(m);
final Set<Integer> ints = new HashSet<>();
while (ints.size() < size)
ints.add(rnd.nextInt(1024));
final Integer[] elts = ints.toArray(new Integer[size]);
+ equal(elts.length, size);
for (int i = 0; i < size; i++) {
MapFrobber adder = randomAdder(m1);
! for (var m : maps) {
adder.frob(m);
equal(m.size(), i+1);
}
equalNavigableMaps(m1, m2);
}
! for (var m : maps) {
! final var e = usedKey(m);
THROWS(IllegalArgumentException.class,
! () -> m.subMap(e,true,e,false).subMap(e,true,e,true),
! () -> m.subMap(e,false,e,true).subMap(e,true,e,true),
() -> m.tailMap(e,false).tailMap(e,true),
! () -> m.headMap(e,false).headMap(e,true),
! () -> m.headMap(e, false).put(e, 0),
! () -> m.tailMap(e, false).putIfAbsent(e, 0),
! () -> m.headMap(e, false).computeIfAbsent(e, k -> 1),
! () -> m.tailMap(e, false).compute(e, (k, v) -> 0));
}
//System.out.printf("%s%n", m1);
for (int i = size; i > 0; i--) {
MapFrobber remover = randomRemover(m1);
! for (var m : maps) {
remover.frob(m);
equal(m.size(), i-1);
}
equalNavigableMaps(m1, m2);
}
! for (var m : maps) testEmptyMap(m);
}
! static void lockStep(NavigableSet<Integer> s1,
! NavigableSet<Integer> s2) {
if (! (thorough || maybe(3))) return;
if (maybe(4)) s1 = serialClone(s1);
if (maybe(4)) s2 = serialClone(s2);
! var sets = Arrays.asList(s1, s2);
! for (var s : sets) testEmptySet(s);
final Set<Integer> ints = new HashSet<>();
while (ints.size() < size)
ints.add(rnd.nextInt(1024));
final Integer[] elts = ints.toArray(new Integer[size]);
+ equal(elts.length, size);
for (int i = 0; i < size; i++) {
SetFrobber adder = randomAdder(s1);
! for (var s : sets) {
adder.frob(s);
equal(s.size(), i+1);
}
equalNavigableSets(s1, s2);
}
! for (var s : sets) {
! final Integer e = usedElt(s);
THROWS(IllegalArgumentException.class,
! () -> s.subSet(e,true,e,false).subSet(e,true,e,true),
! () -> s.subSet(e,false,e,true).subSet(e,true,e,true),
() -> s.tailSet(e,false).tailSet(e,true),
() -> s.headSet(e,false).headSet(e,true));
}
//System.out.printf("%s%n", s1);
for (int i = size; i > 0; i--) {
SetFrobber remover = randomRemover(s1);
! for (var s : sets) {
remover.frob(s);
equal(s.size(), i-1);
}
equalNavigableSets(s1, s2);
}
! for (var s : sets) testEmptySet(s);
}
//--------------------- Infrastructure ---------------------------
static volatile int passed = 0, failed = 0;
static void pass() { passed++; }
static void fail() { failed++; Thread.dumpStack(); }
static void fail(String msg) { System.out.println(msg); fail(); }
static void unexpected(Throwable t) { failed++; t.printStackTrace(); }
static void check(boolean cond) { if (cond) pass(); else fail(); }
static void equal(Object x, Object y) {
! if (Objects.equals(x, y)) pass();
else {System.out.println(x + " not equal to " + y); fail();}}
static void equal2(Object x, Object y) {equal(x, y); equal(y, x);}
public static void main(String[] args) throws Throwable {
try { realMain(args); } catch (Throwable t) { unexpected(t); }
< prev index next >