--- jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java 2018/05/28 21:19:50 1.39 +++ jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java 2021/01/26 13:33:05 1.40 @@ -23,6 +23,7 @@ public class ConcurrentSkipListSubSetTes } static class MyReverseComparator implements Comparator { + @SuppressWarnings("unchecked") public int compare(Object x, Object y) { return ((Comparable)y).compareTo(x); } @@ -30,29 +31,29 @@ public class ConcurrentSkipListSubSetTes /** * Returns a new set of given size containing consecutive - * Integers 0 ... n - 1. + * Items 0 ... n - 1. */ - private static NavigableSet populatedSet(int n) { - ConcurrentSkipListSet q = new ConcurrentSkipListSet<>(); + private static NavigableSet populatedSet(int n) { + ConcurrentSkipListSet q = new ConcurrentSkipListSet<>(); assertTrue(q.isEmpty()); for (int i = n - 1; i >= 0; i -= 2) - assertTrue(q.add(new Integer(i))); + mustAdd(q, i); for (int i = (n & 1); i < n; i += 2) - assertTrue(q.add(new Integer(i))); - assertTrue(q.add(new Integer(-n))); - assertTrue(q.add(new Integer(n))); - NavigableSet s = q.subSet(new Integer(0), true, new Integer(n), false); + mustAdd(q, i); + mustAdd(q, -n); + mustAdd(q, n); + NavigableSet s = q.subSet(itemFor(0), true, itemFor(n), false); assertFalse(s.isEmpty()); - assertEquals(n, s.size()); + mustEqual(n, s.size()); return s; } /** * Returns a new set of first 5 ints. */ - private static NavigableSet set5() { - ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + private static NavigableSet set5() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); assertTrue(q.isEmpty()); q.add(one); q.add(two); @@ -61,35 +62,35 @@ public class ConcurrentSkipListSubSetTes q.add(five); q.add(zero); q.add(seven); - NavigableSet s = q.subSet(one, true, seven, false); - assertEquals(5, s.size()); + NavigableSet s = q.subSet(one, true, seven, false); + mustEqual(5, s.size()); return s; } /** * Returns a new set of first 5 negative ints. */ - private static NavigableSet dset5() { - ConcurrentSkipListSet q = new ConcurrentSkipListSet(); + private static NavigableSet dset5() { + ConcurrentSkipListSet q = new ConcurrentSkipListSet(); assertTrue(q.isEmpty()); - q.add(m1); - q.add(m2); - q.add(m3); - q.add(m4); - q.add(m5); - NavigableSet s = q.descendingSet(); - assertEquals(5, s.size()); + q.add(minusOne); + q.add(minusTwo); + q.add(minusThree); + q.add(minusFour); + q.add(minusFive); + NavigableSet s = q.descendingSet(); + mustEqual(5, s.size()); return s; } - private static NavigableSet set0() { - ConcurrentSkipListSet set = new ConcurrentSkipListSet(); + private static NavigableSet set0() { + ConcurrentSkipListSet set = new ConcurrentSkipListSet(); assertTrue(set.isEmpty()); - return set.tailSet(m1, true); + return set.tailSet(minusOne, true); } - private static NavigableSet dset0() { - ConcurrentSkipListSet set = new ConcurrentSkipListSet(); + private static NavigableSet dset0() { + ConcurrentSkipListSet set = new ConcurrentSkipListSet(); assertTrue(set.isEmpty()); return set; } @@ -98,18 +99,18 @@ public class ConcurrentSkipListSubSetTes * A new set has unbounded capacity */ public void testConstructor1() { - assertEquals(0, set0().size()); + mustEqual(0, set0().size()); } /** * isEmpty is true before add, false after */ public void testEmpty() { - NavigableSet q = set0(); + NavigableSet q = set0(); assertTrue(q.isEmpty()); - q.add(new Integer(1)); + mustAdd(q, one); assertFalse(q.isEmpty()); - q.add(new Integer(2)); + mustAdd(q, two); q.pollFirst(); q.pollFirst(); assertTrue(q.isEmpty()); @@ -119,14 +120,14 @@ public class ConcurrentSkipListSubSetTes * size changes when elements added and removed */ public void testSize() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); q.pollFirst(); } for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.size()); - q.add(new Integer(i)); + mustEqual(i, q.size()); + mustAdd(q, i); } } @@ -134,7 +135,7 @@ public class ConcurrentSkipListSubSetTes * add(null) throws NPE */ public void testAddNull() { - NavigableSet q = set0(); + NavigableSet q = set0(); try { q.add(null); shouldThrow(); @@ -145,7 +146,7 @@ public class ConcurrentSkipListSubSetTes * Add of comparable element succeeds */ public void testAdd() { - NavigableSet q = set0(); + NavigableSet q = set0(); assertTrue(q.add(six)); } @@ -153,7 +154,7 @@ public class ConcurrentSkipListSubSetTes * Add of duplicate element fails */ public void testAddDup() { - NavigableSet q = set0(); + NavigableSet q = set0(); assertTrue(q.add(six)); assertFalse(q.add(six)); } @@ -162,7 +163,8 @@ public class ConcurrentSkipListSubSetTes * Add of non-Comparable throws CCE */ public void testAddNonComparable() { - NavigableSet q = set0(); + ConcurrentSkipListSet src = new ConcurrentSkipListSet(); + NavigableSet q = src.tailSet(minusOne, true); try { q.add(new Object()); q.add(new Object()); @@ -174,7 +176,7 @@ public class ConcurrentSkipListSubSetTes * addAll(null) throws NPE */ public void testAddAll1() { - NavigableSet q = set0(); + NavigableSet q = set0(); try { q.addAll(null); shouldThrow(); @@ -185,10 +187,10 @@ public class ConcurrentSkipListSubSetTes * addAll of a collection with null elements throws NPE */ public void testAddAll2() { - NavigableSet q = set0(); - Integer[] ints = new Integer[SIZE]; + NavigableSet q = set0(); + Item[] items = new Item[SIZE]; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -198,12 +200,10 @@ public class ConcurrentSkipListSubSetTes * possibly adding some elements */ public void testAddAll3() { - NavigableSet q = set0(); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i + SIZE); + NavigableSet q = set0(); + Item[] items = new Item[2]; items[0] = zero; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -212,24 +212,24 @@ public class ConcurrentSkipListSubSetTes * Set contains all elements of successful addAll */ public void testAddAll5() { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; + Item[] empty = new Item[0]; + Item[] items = new Item[SIZE]; for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(SIZE - 1 - i); - NavigableSet q = set0(); + items[i] = itemFor(SIZE - 1 - i); + NavigableSet q = set0(); assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); + assertTrue(q.addAll(Arrays.asList(items))); for (int i = 0; i < SIZE; ++i) - assertEquals(new Integer(i), q.pollFirst()); + mustEqual(i, q.pollFirst()); } /** * poll succeeds unless empty */ public void testPoll() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst()); + mustEqual(i, q.pollFirst()); } assertNull(q.pollFirst()); } @@ -238,19 +238,19 @@ public class ConcurrentSkipListSubSetTes * remove(x) removes x and returns true if present */ public void testRemoveElement() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.contains(i)); - assertTrue(q.remove(i)); - assertFalse(q.contains(i)); - assertTrue(q.contains(i - 1)); + mustContain(q, i); + mustRemove(q, i); + mustNotContain(q, i); + mustContain(q, i - 1); } for (int i = 0; i < SIZE; i += 2) { - assertTrue(q.contains(i)); - assertTrue(q.remove(i)); - assertFalse(q.contains(i)); - assertFalse(q.remove(i + 1)); - assertFalse(q.contains(i + 1)); + mustContain(q, i); + mustRemove(q, i); + mustNotContain(q, i); + mustNotRemove(q, i + 1); + mustNotContain(q, i + 1); } assertTrue(q.isEmpty()); } @@ -259,11 +259,11 @@ public class ConcurrentSkipListSubSetTes * contains(x) reports true when elements added but not yet removed */ public void testContains() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertTrue(q.contains(new Integer(i))); + mustContain(q, i); q.pollFirst(); - assertFalse(q.contains(new Integer(i))); + mustNotContain(q, i); } } @@ -271,11 +271,11 @@ public class ConcurrentSkipListSubSetTes * clear removes all elements */ public void testClear() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); q.clear(); assertTrue(q.isEmpty()); - assertEquals(0, q.size()); - q.add(new Integer(1)); + mustEqual(0, q.size()); + mustAdd(q, one); assertFalse(q.isEmpty()); q.clear(); assertTrue(q.isEmpty()); @@ -285,12 +285,12 @@ public class ConcurrentSkipListSubSetTes * containsAll(c) is true when c contains a subset of elements */ public void testContainsAll() { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = set0(); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = set0(); for (int i = 0; i < SIZE; ++i) { assertTrue(q.containsAll(p)); assertFalse(p.containsAll(q)); - p.add(new Integer(i)); + mustAdd(p, i); } assertTrue(p.containsAll(q)); } @@ -299,8 +299,8 @@ public class ConcurrentSkipListSubSetTes * retainAll(c) retains only those elements of c and reports true if changed */ public void testRetainAll() { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { boolean changed = q.retainAll(p); if (i == 0) @@ -309,7 +309,7 @@ public class ConcurrentSkipListSubSetTes assertTrue(changed); assertTrue(q.containsAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); p.pollFirst(); } } @@ -319,13 +319,12 @@ public class ConcurrentSkipListSubSetTes */ public void testRemoveAll() { for (int i = 1; i < SIZE; ++i) { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = populatedSet(i); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(i); assertTrue(q.removeAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); for (int j = 0; j < i; ++j) { - Integer x = (Integer)(p.pollFirst()); - assertFalse(q.contains(x)); + mustNotContain(q, p.pollFirst()); } } } @@ -334,12 +333,12 @@ public class ConcurrentSkipListSubSetTes * lower returns preceding element */ public void testLower() { - NavigableSet q = set5(); + NavigableSet q = set5(); Object e1 = q.lower(three); - assertEquals(two, e1); + mustEqual(two, e1); Object e2 = q.lower(six); - assertEquals(five, e2); + mustEqual(five, e2); Object e3 = q.lower(one); assertNull(e3); @@ -352,12 +351,12 @@ public class ConcurrentSkipListSubSetTes * higher returns next element */ public void testHigher() { - NavigableSet q = set5(); + NavigableSet q = set5(); Object e1 = q.higher(three); - assertEquals(four, e1); + mustEqual(four, e1); Object e2 = q.higher(zero); - assertEquals(one, e2); + mustEqual(one, e2); Object e3 = q.higher(five); assertNull(e3); @@ -370,15 +369,15 @@ public class ConcurrentSkipListSubSetTes * floor returns preceding element */ public void testFloor() { - NavigableSet q = set5(); + NavigableSet q = set5(); Object e1 = q.floor(three); - assertEquals(three, e1); + mustEqual(three, e1); Object e2 = q.floor(six); - assertEquals(five, e2); + mustEqual(five, e2); Object e3 = q.floor(one); - assertEquals(one, e3); + mustEqual(one, e3); Object e4 = q.floor(zero); assertNull(e4); @@ -388,15 +387,15 @@ public class ConcurrentSkipListSubSetTes * ceiling returns next element */ public void testCeiling() { - NavigableSet q = set5(); + NavigableSet q = set5(); Object e1 = q.ceiling(three); - assertEquals(three, e1); + mustEqual(three, e1); Object e2 = q.ceiling(zero); - assertEquals(one, e2); + mustEqual(one, e2); Object e3 = q.ceiling(five); - assertEquals(five, e3); + mustEqual(five, e3); Object e4 = q.ceiling(six); assertNull(e4); @@ -406,7 +405,7 @@ public class ConcurrentSkipListSubSetTes * toArray contains all elements in sorted order */ public void testToArray() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); Object[] a = q.toArray(); assertSame(Object[].class, a.getClass()); for (Object o : a) @@ -418,11 +417,11 @@ public class ConcurrentSkipListSubSetTes * toArray(a) contains all elements in sorted order */ public void testToArray2() { - NavigableSet q = populatedSet(SIZE); - Integer[] ints = new Integer[SIZE]; - Integer[] array = q.toArray(ints); - assertSame(ints, array); - for (Integer o : ints) + NavigableSet q = populatedSet(SIZE); + Item[] items = new Item[SIZE]; + Item[] array = q.toArray(items); + assertSame(items, array); + for (Item o : items) assertSame(o, q.pollFirst()); assertTrue(q.isEmpty()); } @@ -431,12 +430,12 @@ public class ConcurrentSkipListSubSetTes * iterator iterates through all elements */ public void testIterator() { - NavigableSet q = populatedSet(SIZE); - Iterator it = q.iterator(); + NavigableSet q = populatedSet(SIZE); + Iterator it = q.iterator(); int i; for (i = 0; it.hasNext(); i++) assertTrue(q.contains(it.next())); - assertEquals(i, SIZE); + mustEqual(i, SIZE); assertIteratorExhausted(it); } @@ -451,18 +450,17 @@ public class ConcurrentSkipListSubSetTes * iterator.remove removes current element */ public void testIteratorRemove() { - final NavigableSet q = set0(); - q.add(new Integer(2)); - q.add(new Integer(1)); - q.add(new Integer(3)); - - Iterator it = q.iterator(); + final NavigableSet q = set0(); + mustAdd(q, two); + mustAdd(q, one); + mustAdd(q, three); + Iterator it = q.iterator(); it.next(); it.remove(); it = q.iterator(); - assertEquals(it.next(), new Integer(2)); - assertEquals(it.next(), new Integer(3)); + mustEqual(it.next(), two); + mustEqual(it.next(), three); assertFalse(it.hasNext()); } @@ -470,7 +468,7 @@ public class ConcurrentSkipListSubSetTes * toString contains toStrings of elements */ public void testToString() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); String s = q.toString(); for (int i = 0; i < SIZE; ++i) { assertTrue(s.contains(String.valueOf(i))); @@ -481,16 +479,16 @@ public class ConcurrentSkipListSubSetTes * A deserialized/reserialized set equals original */ public void testSerialization() throws Exception { - NavigableSet x = populatedSet(SIZE); - NavigableSet y = serialClone(x); + NavigableSet x = populatedSet(SIZE); + NavigableSet y = serialClone(x); assertNotSame(y, x); - assertEquals(x.size(), y.size()); - assertEquals(x, y); - assertEquals(y, x); + mustEqual(x.size(), y.size()); + mustEqual(x, y); + mustEqual(y, x); while (!x.isEmpty()) { assertFalse(y.isEmpty()); - assertEquals(x.pollFirst(), y.pollFirst()); + mustEqual(x.pollFirst(), y.pollFirst()); } assertTrue(y.isEmpty()); } @@ -499,133 +497,134 @@ public class ConcurrentSkipListSubSetTes * subSet returns set with keys in requested range */ public void testSubSetContents() { - NavigableSet set = set5(); - SortedSet sm = set.subSet(two, four); - assertEquals(two, sm.first()); - assertEquals(three, sm.last()); - assertEquals(2, sm.size()); - assertFalse(sm.contains(one)); - assertTrue(sm.contains(two)); - assertTrue(sm.contains(three)); - assertFalse(sm.contains(four)); - assertFalse(sm.contains(five)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(two, k); - k = (Integer)(i.next()); - assertEquals(three, k); + NavigableSet set = set5(); + SortedSet sm = set.subSet(two, four); + mustEqual(two, sm.first()); + mustEqual(three, sm.last()); + mustEqual(2, sm.size()); + mustNotContain(sm, one); + mustContain(sm, two); + mustContain(sm, three); + mustNotContain(sm, four); + mustNotContain(sm, five); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(two, k); + k = i.next(); + mustEqual(three, k); assertFalse(i.hasNext()); - Iterator j = sm.iterator(); + Iterator j = sm.iterator(); j.next(); j.remove(); - assertFalse(set.contains(two)); - assertEquals(4, set.size()); - assertEquals(1, sm.size()); - assertEquals(three, sm.first()); - assertEquals(three, sm.last()); - assertTrue(sm.remove(three)); + mustNotContain(set, two); + mustEqual(4, set.size()); + mustEqual(1, sm.size()); + mustEqual(three, sm.first()); + mustEqual(three, sm.last()); + mustRemove(sm, three); assertTrue(sm.isEmpty()); - assertEquals(3, set.size()); + mustEqual(3, set.size()); } public void testSubSetContents2() { - NavigableSet set = set5(); - SortedSet sm = set.subSet(two, three); - assertEquals(1, sm.size()); - assertEquals(two, sm.first()); - assertEquals(two, sm.last()); - assertFalse(sm.contains(one)); - assertTrue(sm.contains(two)); - assertFalse(sm.contains(three)); - assertFalse(sm.contains(four)); - assertFalse(sm.contains(five)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(two, k); + NavigableSet set = set5(); + SortedSet sm = set.subSet(two, three); + mustEqual(1, sm.size()); + mustEqual(two, sm.first()); + mustEqual(two, sm.last()); + mustNotContain(sm, one); + mustContain(sm, two); + mustNotContain(sm, three); + mustNotContain(sm, four); + mustNotContain(sm, five); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(two, k); assertFalse(i.hasNext()); - Iterator j = sm.iterator(); + Iterator j = sm.iterator(); j.next(); j.remove(); - assertFalse(set.contains(two)); - assertEquals(4, set.size()); - assertEquals(0, sm.size()); + mustNotContain(set, two); + mustEqual(4, set.size()); + mustEqual(0, sm.size()); assertTrue(sm.isEmpty()); assertFalse(sm.remove(three)); - assertEquals(4, set.size()); + mustEqual(4, set.size()); } /** * headSet returns set with keys in requested range */ public void testHeadSetContents() { - NavigableSet set = set5(); - SortedSet sm = set.headSet(four); - assertTrue(sm.contains(one)); - assertTrue(sm.contains(two)); - assertTrue(sm.contains(three)); - assertFalse(sm.contains(four)); - assertFalse(sm.contains(five)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(one, k); - k = (Integer)(i.next()); - assertEquals(two, k); - k = (Integer)(i.next()); - assertEquals(three, k); + NavigableSet set = set5(); + SortedSet sm = set.headSet(four); + mustContain(sm, one); + mustContain(sm, two); + mustContain(sm, three); + mustNotContain(sm, four); + mustNotContain(sm, five); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(one, k); + k = i.next(); + mustEqual(two, k); + k = i.next(); + mustEqual(three, k); assertFalse(i.hasNext()); sm.clear(); assertTrue(sm.isEmpty()); - assertEquals(2, set.size()); - assertEquals(four, set.first()); + mustEqual(2, set.size()); + mustEqual(four, set.first()); } /** * tailSet returns set with keys in requested range */ public void testTailSetContents() { - NavigableSet set = set5(); - SortedSet sm = set.tailSet(two); + NavigableSet set = set5(); + SortedSet sm = set.tailSet(two); + mustNotContain(sm, one); + mustContain(sm, two); + mustContain(sm, three); + mustContain(sm, four); + mustContain(sm, five); assertFalse(sm.contains(one)); assertTrue(sm.contains(two)); assertTrue(sm.contains(three)); assertTrue(sm.contains(four)); assertTrue(sm.contains(five)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(two, k); - k = (Integer)(i.next()); - assertEquals(three, k); - k = (Integer)(i.next()); - assertEquals(four, k); - k = (Integer)(i.next()); - assertEquals(five, k); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(two, k); + k = i.next(); + mustEqual(three, k); + k = i.next(); + mustEqual(four, k); + k = i.next(); + mustEqual(five, k); assertFalse(i.hasNext()); - SortedSet ssm = sm.tailSet(four); - assertEquals(four, ssm.first()); - assertEquals(five, ssm.last()); - assertTrue(ssm.remove(four)); - assertEquals(1, ssm.size()); - assertEquals(3, sm.size()); - assertEquals(4, set.size()); + SortedSet ssm = sm.tailSet(four); + mustEqual(four, ssm.first()); + mustEqual(five, ssm.last()); + mustRemove(ssm, four); + mustEqual(1, ssm.size()); + mustEqual(3, sm.size()); + mustEqual(4, set.size()); } /** * size changes when elements added and removed */ public void testDescendingSize() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); q.pollFirst(); } for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.size()); - q.add(new Integer(i)); + mustEqual(i, q.size()); + mustAdd(q, i); } } @@ -633,7 +632,7 @@ public class ConcurrentSkipListSubSetTes * add(null) throws NPE */ public void testDescendingAddNull() { - NavigableSet q = dset0(); + NavigableSet q = dset0(); try { q.add(null); shouldThrow(); @@ -644,24 +643,24 @@ public class ConcurrentSkipListSubSetTes * Add of comparable element succeeds */ public void testDescendingAdd() { - NavigableSet q = dset0(); - assertTrue(q.add(m6)); + NavigableSet q = dset0(); + assertTrue(q.add(minusSix)); } /** * Add of duplicate element fails */ public void testDescendingAddDup() { - NavigableSet q = dset0(); - assertTrue(q.add(m6)); - assertFalse(q.add(m6)); + NavigableSet q = dset0(); + assertTrue(q.add(minusSix)); + assertFalse(q.add(minusSix)); } /** * Add of non-Comparable throws CCE */ public void testDescendingAddNonComparable() { - NavigableSet q = dset0(); + NavigableSet q = new ConcurrentSkipListSet(); try { q.add(new Object()); q.add(new Object()); @@ -673,7 +672,7 @@ public class ConcurrentSkipListSubSetTes * addAll(null) throws NPE */ public void testDescendingAddAll1() { - NavigableSet q = dset0(); + NavigableSet q = dset0(); try { q.addAll(null); shouldThrow(); @@ -684,10 +683,10 @@ public class ConcurrentSkipListSubSetTes * addAll of a collection with null elements throws NPE */ public void testDescendingAddAll2() { - NavigableSet q = dset0(); - Integer[] ints = new Integer[SIZE]; + NavigableSet q = dset0(); + Item[] items = new Item[1]; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -697,12 +696,10 @@ public class ConcurrentSkipListSubSetTes * possibly adding some elements */ public void testDescendingAddAll3() { - NavigableSet q = dset0(); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i + SIZE); + NavigableSet q = dset0(); + Item[] items = new Item[2]; items[0] = zero; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -711,24 +708,24 @@ public class ConcurrentSkipListSubSetTes * Set contains all elements of successful addAll */ public void testDescendingAddAll5() { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; + Item[] empty = new Item[0]; + Item[] items = new Item[SIZE]; for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(SIZE - 1 - i); - NavigableSet q = dset0(); + items[i] = itemFor(SIZE - 1 - i); + NavigableSet q = dset0(); assertFalse(q.addAll(Arrays.asList(empty))); - assertTrue(q.addAll(Arrays.asList(ints))); + assertTrue(q.addAll(Arrays.asList(items))); for (int i = 0; i < SIZE; ++i) - assertEquals(new Integer(i), q.pollFirst()); + mustEqual(i, q.pollFirst()); } /** * poll succeeds unless empty */ public void testDescendingPoll() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst()); + mustEqual(i, q.pollFirst()); } assertNull(q.pollFirst()); } @@ -737,13 +734,13 @@ public class ConcurrentSkipListSubSetTes * remove(x) removes x and returns true if present */ public void testDescendingRemoveElement() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.remove(new Integer(i))); + mustRemove(q, i); } for (int i = 0; i < SIZE; i += 2 ) { - assertTrue(q.remove(new Integer(i))); - assertFalse(q.remove(new Integer(i + 1))); + mustRemove(q, i); + mustNotRemove(q, i + 1); } assertTrue(q.isEmpty()); } @@ -752,11 +749,11 @@ public class ConcurrentSkipListSubSetTes * contains(x) reports true when elements added but not yet removed */ public void testDescendingContains() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { - assertTrue(q.contains(new Integer(i))); + mustContain(q, i); q.pollFirst(); - assertFalse(q.contains(new Integer(i))); + mustNotContain(q, i); } } @@ -764,11 +761,11 @@ public class ConcurrentSkipListSubSetTes * clear removes all elements */ public void testDescendingClear() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); q.clear(); assertTrue(q.isEmpty()); - assertEquals(0, q.size()); - q.add(new Integer(1)); + mustEqual(0, q.size()); + mustAdd(q, one); assertFalse(q.isEmpty()); q.clear(); assertTrue(q.isEmpty()); @@ -778,12 +775,12 @@ public class ConcurrentSkipListSubSetTes * containsAll(c) is true when c contains a subset of elements */ public void testDescendingContainsAll() { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = dset0(); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = dset0(); for (int i = 0; i < SIZE; ++i) { assertTrue(q.containsAll(p)); assertFalse(p.containsAll(q)); - p.add(new Integer(i)); + mustAdd(p, i); } assertTrue(p.containsAll(q)); } @@ -792,8 +789,8 @@ public class ConcurrentSkipListSubSetTes * retainAll(c) retains only those elements of c and reports true if changed */ public void testDescendingRetainAll() { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(SIZE); for (int i = 0; i < SIZE; ++i) { boolean changed = q.retainAll(p); if (i == 0) @@ -802,7 +799,7 @@ public class ConcurrentSkipListSubSetTes assertTrue(changed); assertTrue(q.containsAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); p.pollFirst(); } } @@ -812,13 +809,12 @@ public class ConcurrentSkipListSubSetTes */ public void testDescendingRemoveAll() { for (int i = 1; i < SIZE; ++i) { - NavigableSet q = populatedSet(SIZE); - NavigableSet p = populatedSet(i); + NavigableSet q = populatedSet(SIZE); + NavigableSet p = populatedSet(i); assertTrue(q.removeAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); for (int j = 0; j < i; ++j) { - Integer x = (Integer)(p.pollFirst()); - assertFalse(q.contains(x)); + mustNotContain(q, p.pollFirst()); } } } @@ -827,14 +823,14 @@ public class ConcurrentSkipListSubSetTes * lower returns preceding element */ public void testDescendingLower() { - NavigableSet q = dset5(); - Object e1 = q.lower(m3); - assertEquals(m2, e1); + NavigableSet q = dset5(); + Object e1 = q.lower(minusThree); + mustEqual(minusTwo, e1); - Object e2 = q.lower(m6); - assertEquals(m5, e2); + Object e2 = q.lower(minusSix); + mustEqual(minusFive, e2); - Object e3 = q.lower(m1); + Object e3 = q.lower(minusOne); assertNull(e3); Object e4 = q.lower(zero); @@ -845,17 +841,17 @@ public class ConcurrentSkipListSubSetTes * higher returns next element */ public void testDescendingHigher() { - NavigableSet q = dset5(); - Object e1 = q.higher(m3); - assertEquals(m4, e1); + NavigableSet q = dset5(); + Object e1 = q.higher(minusThree); + mustEqual(minusFour, e1); Object e2 = q.higher(zero); - assertEquals(m1, e2); + mustEqual(minusOne, e2); - Object e3 = q.higher(m5); + Object e3 = q.higher(minusFive); assertNull(e3); - Object e4 = q.higher(m6); + Object e4 = q.higher(minusSix); assertNull(e4); } @@ -863,15 +859,15 @@ public class ConcurrentSkipListSubSetTes * floor returns preceding element */ public void testDescendingFloor() { - NavigableSet q = dset5(); - Object e1 = q.floor(m3); - assertEquals(m3, e1); + NavigableSet q = dset5(); + Object e1 = q.floor(minusThree); + mustEqual(minusThree, e1); - Object e2 = q.floor(m6); - assertEquals(m5, e2); + Object e2 = q.floor(minusSix); + mustEqual(minusFive, e2); - Object e3 = q.floor(m1); - assertEquals(m1, e3); + Object e3 = q.floor(minusOne); + mustEqual(minusOne, e3); Object e4 = q.floor(zero); assertNull(e4); @@ -881,17 +877,17 @@ public class ConcurrentSkipListSubSetTes * ceiling returns next element */ public void testDescendingCeiling() { - NavigableSet q = dset5(); - Object e1 = q.ceiling(m3); - assertEquals(m3, e1); + NavigableSet q = dset5(); + Object e1 = q.ceiling(minusThree); + mustEqual(minusThree, e1); Object e2 = q.ceiling(zero); - assertEquals(m1, e2); + mustEqual(minusOne, e2); - Object e3 = q.ceiling(m5); - assertEquals(m5, e3); + Object e3 = q.ceiling(minusFive); + mustEqual(minusFive, e3); - Object e4 = q.ceiling(m6); + Object e4 = q.ceiling(minusSix); assertNull(e4); } @@ -899,69 +895,69 @@ public class ConcurrentSkipListSubSetTes * toArray contains all elements */ public void testDescendingToArray() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); Object[] o = q.toArray(); Arrays.sort(o); for (int i = 0; i < o.length; i++) - assertEquals(o[i], q.pollFirst()); + mustEqual(o[i], q.pollFirst()); } /** * toArray(a) contains all elements */ public void testDescendingToArray2() { - NavigableSet q = populatedSet(SIZE); - Integer[] ints = new Integer[SIZE]; - assertSame(ints, q.toArray(ints)); - Arrays.sort(ints); - for (int i = 0; i < ints.length; i++) - assertEquals(ints[i], q.pollFirst()); + NavigableSet q = populatedSet(SIZE); + Item[] items = new Item[SIZE]; + assertSame(items, q.toArray(items)); + Arrays.sort(items); + for (int i = 0; i < items.length; i++) + mustEqual(items[i], q.pollFirst()); } /** * iterator iterates through all elements */ public void testDescendingIterator() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); int i = 0; - Iterator it = q.iterator(); + Iterator it = q.iterator(); while (it.hasNext()) { - assertTrue(q.contains(it.next())); + mustContain(q, it.next()); ++i; } - assertEquals(i, SIZE); + mustEqual(i, SIZE); } /** * iterator of empty set has no elements */ public void testDescendingEmptyIterator() { - NavigableSet q = dset0(); + NavigableSet q = dset0(); int i = 0; - Iterator it = q.iterator(); + Iterator it = q.iterator(); while (it.hasNext()) { - assertTrue(q.contains(it.next())); + mustContain(q, it.next()); ++i; } - assertEquals(0, i); + mustEqual(0, i); } /** * iterator.remove removes current element */ public void testDescendingIteratorRemove() { - final NavigableSet q = dset0(); - q.add(new Integer(2)); - q.add(new Integer(1)); - q.add(new Integer(3)); + final NavigableSet q = dset0(); + q.add(two); + q.add(one); + q.add(three); - Iterator it = q.iterator(); + Iterator it = q.iterator(); it.next(); it.remove(); it = q.iterator(); - assertEquals(it.next(), new Integer(2)); - assertEquals(it.next(), new Integer(3)); + mustEqual(it.next(), two); + mustEqual(it.next(), three); assertFalse(it.hasNext()); } @@ -969,7 +965,7 @@ public class ConcurrentSkipListSubSetTes * toString contains toStrings of elements */ public void testDescendingToString() { - NavigableSet q = populatedSet(SIZE); + NavigableSet q = populatedSet(SIZE); String s = q.toString(); for (int i = 0; i < SIZE; ++i) { assertTrue(s.contains(String.valueOf(i))); @@ -980,16 +976,16 @@ public class ConcurrentSkipListSubSetTes * A deserialized/reserialized set equals original */ public void testDescendingSerialization() throws Exception { - NavigableSet x = dset5(); - NavigableSet y = serialClone(x); + NavigableSet x = dset5(); + NavigableSet y = serialClone(x); assertNotSame(y, x); - assertEquals(x.size(), y.size()); - assertEquals(x, y); - assertEquals(y, x); + mustEqual(x.size(), y.size()); + mustEqual(x, y); + mustEqual(y, x); while (!x.isEmpty()) { assertFalse(y.isEmpty()); - assertEquals(x.pollFirst(), y.pollFirst()); + mustEqual(x.pollFirst(), y.pollFirst()); } assertTrue(y.isEmpty()); } @@ -998,119 +994,115 @@ public class ConcurrentSkipListSubSetTes * subSet returns set with keys in requested range */ public void testDescendingSubSetContents() { - NavigableSet set = dset5(); - SortedSet sm = set.subSet(m2, m4); - assertEquals(m2, sm.first()); - assertEquals(m3, sm.last()); - assertEquals(2, sm.size()); - assertFalse(sm.contains(m1)); - assertTrue(sm.contains(m2)); - assertTrue(sm.contains(m3)); - assertFalse(sm.contains(m4)); - assertFalse(sm.contains(m5)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(m2, k); - k = (Integer)(i.next()); - assertEquals(m3, k); + NavigableSet set = dset5(); + SortedSet sm = set.subSet(minusTwo, minusFour); + mustEqual(minusTwo, sm.first()); + mustEqual(minusThree, sm.last()); + mustEqual(2, sm.size()); + mustNotContain(sm, minusOne); + mustContain(sm, minusTwo); + mustContain(sm, minusThree); + mustNotContain(sm, minusFour); + mustNotContain(sm, minusFive); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(minusTwo, k); + k = i.next(); + mustEqual(minusThree, k); assertFalse(i.hasNext()); - Iterator j = sm.iterator(); + Iterator j = sm.iterator(); j.next(); j.remove(); - assertFalse(set.contains(m2)); - assertEquals(4, set.size()); - assertEquals(1, sm.size()); - assertEquals(m3, sm.first()); - assertEquals(m3, sm.last()); - assertTrue(sm.remove(m3)); + mustNotContain(set, minusTwo); + mustEqual(4, set.size()); + mustEqual(1, sm.size()); + mustEqual(minusThree, sm.first()); + mustEqual(minusThree, sm.last()); + mustRemove(sm, minusThree); assertTrue(sm.isEmpty()); - assertEquals(3, set.size()); + mustEqual(3, set.size()); } public void testDescendingSubSetContents2() { - NavigableSet set = dset5(); - SortedSet sm = set.subSet(m2, m3); - assertEquals(1, sm.size()); - assertEquals(m2, sm.first()); - assertEquals(m2, sm.last()); - assertFalse(sm.contains(m1)); - assertTrue(sm.contains(m2)); - assertFalse(sm.contains(m3)); - assertFalse(sm.contains(m4)); - assertFalse(sm.contains(m5)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(m2, k); + NavigableSet set = dset5(); + SortedSet sm = set.subSet(minusTwo, minusThree); + mustEqual(1, sm.size()); + mustEqual(minusTwo, sm.first()); + mustEqual(minusTwo, sm.last()); + mustNotContain(sm, minusOne); + mustContain(sm, minusTwo); + mustNotContain(sm, minusThree); + mustNotContain(sm, minusFour); + mustNotContain(sm, minusFive); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(minusTwo, k); assertFalse(i.hasNext()); - Iterator j = sm.iterator(); + Iterator j = sm.iterator(); j.next(); j.remove(); - assertFalse(set.contains(m2)); - assertEquals(4, set.size()); - assertEquals(0, sm.size()); + mustNotContain(set, minusTwo); + mustEqual(4, set.size()); + mustEqual(0, sm.size()); assertTrue(sm.isEmpty()); - assertFalse(sm.remove(m3)); - assertEquals(4, set.size()); + mustNotRemove(sm, minusThree); + mustEqual(4, set.size()); } /** * headSet returns set with keys in requested range */ public void testDescendingHeadSetContents() { - NavigableSet set = dset5(); - SortedSet sm = set.headSet(m4); - assertTrue(sm.contains(m1)); - assertTrue(sm.contains(m2)); - assertTrue(sm.contains(m3)); - assertFalse(sm.contains(m4)); - assertFalse(sm.contains(m5)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(m1, k); - k = (Integer)(i.next()); - assertEquals(m2, k); - k = (Integer)(i.next()); - assertEquals(m3, k); + NavigableSet set = dset5(); + SortedSet sm = set.headSet(minusFour); + mustContain(sm, minusOne); + mustContain(sm, minusTwo); + mustContain(sm, minusThree); + mustNotContain(sm, minusFour); + mustNotContain(sm, minusFive); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(minusOne, k); + k = i.next(); + mustEqual(minusTwo, k); + k = i.next(); + mustEqual(minusThree, k); assertFalse(i.hasNext()); sm.clear(); assertTrue(sm.isEmpty()); - assertEquals(2, set.size()); - assertEquals(m4, set.first()); + mustEqual(2, set.size()); + mustEqual(minusFour, set.first()); } /** * tailSet returns set with keys in requested range */ public void testDescendingTailSetContents() { - NavigableSet set = dset5(); - SortedSet sm = set.tailSet(m2); - assertFalse(sm.contains(m1)); - assertTrue(sm.contains(m2)); - assertTrue(sm.contains(m3)); - assertTrue(sm.contains(m4)); - assertTrue(sm.contains(m5)); - Iterator i = sm.iterator(); - Object k; - k = (Integer)(i.next()); - assertEquals(m2, k); - k = (Integer)(i.next()); - assertEquals(m3, k); - k = (Integer)(i.next()); - assertEquals(m4, k); - k = (Integer)(i.next()); - assertEquals(m5, k); + NavigableSet set = dset5(); + SortedSet sm = set.tailSet(minusTwo); + mustNotContain(sm, minusOne); + mustContain(sm, minusTwo); + mustContain(sm, minusThree); + mustContain(sm, minusFour); + mustContain(sm, minusFive); + Iterator i = sm.iterator(); + Item k = i.next(); + mustEqual(minusTwo, k); + k = i.next(); + mustEqual(minusThree, k); + k = i.next(); + mustEqual(minusFour, k); + k = i.next(); + mustEqual(minusFive, k); assertFalse(i.hasNext()); - SortedSet ssm = sm.tailSet(m4); - assertEquals(m4, ssm.first()); - assertEquals(m5, ssm.last()); - assertTrue(ssm.remove(m4)); - assertEquals(1, ssm.size()); - assertEquals(3, sm.size()); - assertEquals(4, set.size()); + SortedSet ssm = sm.tailSet(minusFour); + mustEqual(minusFour, ssm.first()); + mustEqual(minusFive, ssm.last()); + mustRemove(ssm, minusFour); + mustEqual(1, ssm.size()); + mustEqual(3, sm.size()); + mustEqual(4, set.size()); } }