--- jsr166/src/test/tck/ConcurrentLinkedDequeTest.java 2019/12/16 21:13:07 1.36 +++ jsr166/src/test/tck/ConcurrentLinkedDequeTest.java 2021/01/26 13:33:05 1.37 @@ -30,7 +30,7 @@ public class ConcurrentLinkedDequeTest e class Implementation implements CollectionImplementation { public Class klazz() { return ConcurrentLinkedDeque.class; } public Collection emptyCollection() { return new ConcurrentLinkedDeque(); } - public Object makeElement(int i) { return i; } + public Object makeElement(int i) { return JSR166TestCase.itemFor(i); } public boolean isConcurrent() { return true; } public boolean permitsNulls() { return false; } } @@ -40,17 +40,17 @@ public class ConcurrentLinkedDequeTest e /** * Returns a new deque of given size containing consecutive - * Integers 0 ... n - 1. + * Items 0 ... n - 1. */ - private static ConcurrentLinkedDeque populatedDeque(int n) { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque<>(); + private static ConcurrentLinkedDeque populatedDeque(int n) { + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque<>(); assertTrue(q.isEmpty()); for (int i = 0; i < n; ++i) - assertTrue(q.offer(new Integer(i))); + mustOffer(q, i); assertFalse(q.isEmpty()); - assertEquals(n, q.size()); - assertEquals((Integer) 0, q.peekFirst()); - assertEquals((Integer) (n - 1), q.peekLast()); + mustEqual(n, q.size()); + mustEqual(0, q.peekFirst()); + mustEqual((n - 1), q.peekLast()); return q; } @@ -58,8 +58,8 @@ public class ConcurrentLinkedDequeTest e * new deque is empty */ public void testConstructor1() { - assertTrue(new ConcurrentLinkedDeque().isEmpty()); - assertEquals(0, new ConcurrentLinkedDeque().size()); + assertTrue(new ConcurrentLinkedDeque().isEmpty()); + mustEqual(0, new ConcurrentLinkedDeque().size()); } /** @@ -67,7 +67,7 @@ public class ConcurrentLinkedDequeTest e */ public void testConstructor3() { try { - new ConcurrentLinkedDeque((Collection)null); + new ConcurrentLinkedDeque((Collection)null); shouldThrow(); } catch (NullPointerException success) {} } @@ -77,7 +77,7 @@ public class ConcurrentLinkedDequeTest e */ public void testConstructor4() { try { - new ConcurrentLinkedDeque(Arrays.asList(new Integer[SIZE])); + new ConcurrentLinkedDeque(Arrays.asList(new Item[SIZE])); shouldThrow(); } catch (NullPointerException success) {} } @@ -86,11 +86,9 @@ public class ConcurrentLinkedDequeTest e * Initializing from Collection with some null elements throws NPE */ public void testConstructor5() { - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); + Item[] items = new Item[2]; items[0] = zero; try { - new ConcurrentLinkedDeque(Arrays.asList(ints)); + new ConcurrentLinkedDeque(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -99,19 +97,17 @@ public class ConcurrentLinkedDequeTest e * Deque contains all elements of collection used to initialize */ public void testConstructor6() { - Integer[] ints = new Integer[SIZE]; + Item[] items = defaultItems; + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(items)); for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints)); - for (int i = 0; i < SIZE; ++i) - assertEquals(ints[i], q.poll()); + mustEqual(items[i], q.poll()); } /** * isEmpty is true before add, false after */ public void testEmpty() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); assertTrue(q.isEmpty()); q.add(one); assertFalse(q.isEmpty()); @@ -125,14 +121,14 @@ public class ConcurrentLinkedDequeTest e * size() changes when elements added and removed */ public void testSize() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); q.remove(); } for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.size()); - q.add(new Integer(i)); + mustEqual(i, q.size()); + mustAdd(q, i); } } @@ -140,7 +136,7 @@ public class ConcurrentLinkedDequeTest e * push(null) throws NPE */ public void testPushNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.push(null); shouldThrow(); @@ -151,7 +147,7 @@ public class ConcurrentLinkedDequeTest e * peekFirst() returns element inserted with push */ public void testPush() { - ConcurrentLinkedDeque q = populatedDeque(3); + ConcurrentLinkedDeque q = populatedDeque(3); q.pollLast(); q.push(four); assertSame(four, q.peekFirst()); @@ -161,9 +157,9 @@ public class ConcurrentLinkedDequeTest e * pop() removes first element, or throws NSEE if empty */ public void testPop() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pop()); + mustEqual(i, q.pop()); } try { q.pop(); @@ -175,7 +171,7 @@ public class ConcurrentLinkedDequeTest e * offer(null) throws NPE */ public void testOfferNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.offer(null); shouldThrow(); @@ -186,7 +182,7 @@ public class ConcurrentLinkedDequeTest e * offerFirst(null) throws NPE */ public void testOfferFirstNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.offerFirst(null); shouldThrow(); @@ -197,7 +193,7 @@ public class ConcurrentLinkedDequeTest e * offerLast(null) throws NPE */ public void testOfferLastNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.offerLast(null); shouldThrow(); @@ -208,7 +204,7 @@ public class ConcurrentLinkedDequeTest e * offer(x) succeeds */ public void testOffer() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); assertTrue(q.offer(zero)); assertTrue(q.offer(one)); assertSame(zero, q.peekFirst()); @@ -219,7 +215,7 @@ public class ConcurrentLinkedDequeTest e * offerFirst(x) succeeds */ public void testOfferFirst() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); assertTrue(q.offerFirst(zero)); assertTrue(q.offerFirst(one)); assertSame(one, q.peekFirst()); @@ -230,7 +226,7 @@ public class ConcurrentLinkedDequeTest e * offerLast(x) succeeds */ public void testOfferLast() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); assertTrue(q.offerLast(zero)); assertTrue(q.offerLast(one)); assertSame(zero, q.peekFirst()); @@ -241,7 +237,7 @@ public class ConcurrentLinkedDequeTest e * add(null) throws NPE */ public void testAddNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.add(null); shouldThrow(); @@ -252,7 +248,7 @@ public class ConcurrentLinkedDequeTest e * addFirst(null) throws NPE */ public void testAddFirstNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.addFirst(null); shouldThrow(); @@ -263,7 +259,7 @@ public class ConcurrentLinkedDequeTest e * addLast(null) throws NPE */ public void testAddLastNull() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.addLast(null); shouldThrow(); @@ -274,7 +270,7 @@ public class ConcurrentLinkedDequeTest e * add(x) succeeds */ public void testAdd() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); assertTrue(q.add(zero)); assertTrue(q.add(one)); assertSame(zero, q.peekFirst()); @@ -285,7 +281,7 @@ public class ConcurrentLinkedDequeTest e * addFirst(x) succeeds */ public void testAddFirst() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); q.addFirst(zero); q.addFirst(one); assertSame(one, q.peekFirst()); @@ -296,7 +292,7 @@ public class ConcurrentLinkedDequeTest e * addLast(x) succeeds */ public void testAddLast() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); q.addLast(zero); q.addLast(one); assertSame(zero, q.peekFirst()); @@ -307,7 +303,7 @@ public class ConcurrentLinkedDequeTest e * addAll(null) throws NPE */ public void testAddAll1() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { q.addAll(null); shouldThrow(); @@ -318,7 +314,7 @@ public class ConcurrentLinkedDequeTest e * addAll(this) throws IllegalArgumentException */ public void testAddAllSelf() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); try { q.addAll(q); shouldThrow(); @@ -329,9 +325,9 @@ public class ConcurrentLinkedDequeTest e * addAll of a collection with null elements throws NPE */ public void testAddAll2() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); try { - q.addAll(Arrays.asList(new Integer[SIZE])); + q.addAll(Arrays.asList(new Item[SIZE])); shouldThrow(); } catch (NullPointerException success) {} } @@ -341,12 +337,10 @@ public class ConcurrentLinkedDequeTest e * possibly adding some elements */ public void testAddAll3() { - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + Item[] items = new Item[2]; items[0] = zero; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -355,24 +349,22 @@ public class ConcurrentLinkedDequeTest e * Deque contains all elements, in traversal order, of successful addAll */ public void testAddAll5() { - Integer[] empty = new Integer[0]; - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + Item[] empty = new Item[0]; + Item[] items = defaultItems; + ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); 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(ints[i], q.poll()); + mustEqual(items[i], q.poll()); } /** * pollFirst() succeeds unless empty */ public void testPollFirst() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.pollFirst()); + mustEqual(i, q.pollFirst()); } assertNull(q.pollFirst()); } @@ -381,9 +373,9 @@ public class ConcurrentLinkedDequeTest e * pollLast() succeeds unless empty */ public void testPollLast() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.pollLast()); + mustEqual(i, q.pollLast()); } assertNull(q.pollLast()); } @@ -392,9 +384,9 @@ public class ConcurrentLinkedDequeTest e * poll() succeeds unless empty */ public void testPoll() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.poll()); + mustEqual(i, q.poll()); } assertNull(q.poll()); } @@ -403,10 +395,10 @@ public class ConcurrentLinkedDequeTest e * peek() returns next element, or null if empty */ public void testPeek() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.peek()); - assertEquals(i, q.poll()); + mustEqual(i, q.peek()); + mustEqual(i, q.poll()); assertTrue(q.peek() == null || !q.peek().equals(i)); } @@ -417,10 +409,10 @@ public class ConcurrentLinkedDequeTest e * element() returns first element, or throws NSEE if empty */ public void testElement() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.element()); - assertEquals(i, q.poll()); + mustEqual(i, q.element()); + mustEqual(i, q.poll()); } try { q.element(); @@ -432,9 +424,9 @@ public class ConcurrentLinkedDequeTest e * remove() removes next element, or throws NSEE if empty */ public void testRemove() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.remove()); + mustEqual(i, q.remove()); } try { q.remove(); @@ -446,19 +438,19 @@ public class ConcurrentLinkedDequeTest e * remove(x) removes x and returns true if present */ public void testRemoveElement() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(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()); } @@ -467,10 +459,10 @@ public class ConcurrentLinkedDequeTest e * peekFirst() returns next element, or null if empty */ public void testPeekFirst() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.peekFirst()); - assertEquals(i, q.pollFirst()); + mustEqual(i, q.peekFirst()); + mustEqual(i, q.pollFirst()); assertTrue(q.peekFirst() == null || !q.peekFirst().equals(i)); } @@ -481,10 +473,10 @@ public class ConcurrentLinkedDequeTest e * peekLast() returns next element, or null if empty */ public void testPeekLast() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.peekLast()); - assertEquals(i, q.pollLast()); + mustEqual(i, q.peekLast()); + mustEqual(i, q.pollLast()); assertTrue(q.peekLast() == null || !q.peekLast().equals(i)); } @@ -495,10 +487,10 @@ public class ConcurrentLinkedDequeTest e * getFirst() returns first element, or throws NSEE if empty */ public void testFirstElement() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.getFirst()); - assertEquals(i, q.pollFirst()); + mustEqual(i, q.getFirst()); + mustEqual(i, q.pollFirst()); } try { q.getFirst(); @@ -510,10 +502,10 @@ public class ConcurrentLinkedDequeTest e * getLast() returns last element, or throws NSEE if empty */ public void testLastElement() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.getLast()); - assertEquals(i, q.pollLast()); + mustEqual(i, q.getLast()); + mustEqual(i, q.pollLast()); } try { q.getLast(); @@ -526,9 +518,9 @@ public class ConcurrentLinkedDequeTest e * removeFirst() removes first element, or throws NSEE if empty */ public void testRemoveFirst() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.removeFirst()); + mustEqual(i, q.removeFirst()); } try { q.removeFirst(); @@ -541,9 +533,9 @@ public class ConcurrentLinkedDequeTest e * removeLast() removes last element, or throws NSEE if empty */ public void testRemoveLast() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = SIZE - 1; i >= 0; --i) { - assertEquals(i, q.removeLast()); + mustEqual(i, q.removeLast()); } try { q.removeLast(); @@ -556,13 +548,13 @@ public class ConcurrentLinkedDequeTest e * removeFirstOccurrence(x) removes x and returns true if present */ public void testRemoveFirstOccurrence() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.removeFirstOccurrence(new Integer(i))); + assertTrue(q.removeFirstOccurrence(itemFor(i))); } for (int i = 0; i < SIZE; i += 2) { - assertTrue(q.removeFirstOccurrence(new Integer(i))); - assertFalse(q.removeFirstOccurrence(new Integer(i + 1))); + assertTrue(q.removeFirstOccurrence(itemFor(i))); + assertFalse(q.removeFirstOccurrence(itemFor(i + 1))); } assertTrue(q.isEmpty()); } @@ -571,13 +563,13 @@ public class ConcurrentLinkedDequeTest e * removeLastOccurrence(x) removes x and returns true if present */ public void testRemoveLastOccurrence() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 1; i < SIZE; i += 2) { - assertTrue(q.removeLastOccurrence(new Integer(i))); + assertTrue(q.removeLastOccurrence(itemFor(i))); } for (int i = 0; i < SIZE; i += 2) { - assertTrue(q.removeLastOccurrence(new Integer(i))); - assertFalse(q.removeLastOccurrence(new Integer(i + 1))); + assertTrue(q.removeLastOccurrence(itemFor(i))); + assertFalse(q.removeLastOccurrence(itemFor(i + 1))); } assertTrue(q.isEmpty()); } @@ -586,11 +578,11 @@ public class ConcurrentLinkedDequeTest e * contains(x) reports true when elements added but not yet removed */ public void testContains() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { - assertTrue(q.contains(new Integer(i))); + mustContain(q, i); q.poll(); - assertFalse(q.contains(new Integer(i))); + mustNotContain(q, i); } } @@ -598,10 +590,10 @@ public class ConcurrentLinkedDequeTest e * clear() removes all elements */ public void testClear() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); q.clear(); assertTrue(q.isEmpty()); - assertEquals(0, q.size()); + mustEqual(0, q.size()); q.add(one); assertFalse(q.isEmpty()); q.clear(); @@ -612,12 +604,12 @@ public class ConcurrentLinkedDequeTest e * containsAll(c) is true when c contains a subset of elements */ public void testContainsAll() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); - ConcurrentLinkedDeque p = new ConcurrentLinkedDeque(); + ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque p = new ConcurrentLinkedDeque(); 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)); } @@ -626,8 +618,8 @@ public class ConcurrentLinkedDequeTest e * retainAll(c) retains only those elements of c and reports true if change */ public void testRetainAll() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); - ConcurrentLinkedDeque p = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque p = populatedDeque(SIZE); for (int i = 0; i < SIZE; ++i) { boolean changed = q.retainAll(p); if (i == 0) @@ -636,7 +628,7 @@ public class ConcurrentLinkedDequeTest e assertTrue(changed); assertTrue(q.containsAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); p.remove(); } } @@ -646,13 +638,12 @@ public class ConcurrentLinkedDequeTest e */ public void testRemoveAll() { for (int i = 1; i < SIZE; ++i) { - ConcurrentLinkedDeque q = populatedDeque(SIZE); - ConcurrentLinkedDeque p = populatedDeque(i); + ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque p = populatedDeque(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.remove()); - assertFalse(q.contains(x)); + mustNotContain(q, p.remove()); } } } @@ -661,7 +652,7 @@ public class ConcurrentLinkedDequeTest e * toArray() contains all elements in FIFO order */ public void testToArray() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); Object[] a = q.toArray(); assertSame(Object[].class, a.getClass()); for (Object o : a) @@ -673,11 +664,11 @@ public class ConcurrentLinkedDequeTest e * toArray(a) contains all elements in FIFO order */ public void testToArray2() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); - Integer[] ints = new Integer[SIZE]; - Integer[] array = q.toArray(ints); - assertSame(ints, array); - for (Integer o : ints) + ConcurrentLinkedDeque q = populatedDeque(SIZE); + Item[] items = new Item[SIZE]; + Item[] array = q.toArray(items); + assertSame(items, array); + for (Item o : items) assertSame(o, q.poll()); assertTrue(q.isEmpty()); } @@ -686,7 +677,7 @@ public class ConcurrentLinkedDequeTest e * toArray(null) throws NullPointerException */ public void testToArray_NullArg() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); try { q.toArray((Object[])null); shouldThrow(); @@ -697,7 +688,7 @@ public class ConcurrentLinkedDequeTest e * toArray(incompatible array type) throws ArrayStoreException */ public void testToArray1_BadArg() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); try { q.toArray(new String[10]); shouldThrow(); @@ -708,12 +699,12 @@ public class ConcurrentLinkedDequeTest e * Iterator iterates through all elements */ public void testIterator() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); - Iterator it = q.iterator(); + ConcurrentLinkedDeque q = populatedDeque(SIZE); + Iterator it = q.iterator(); int i; for (i = 0; it.hasNext(); i++) - assertTrue(q.contains(it.next())); - assertEquals(i, SIZE); + mustContain(q, it.next()); + mustEqual(i, SIZE); assertIteratorExhausted(it); } @@ -721,7 +712,7 @@ public class ConcurrentLinkedDequeTest e * iterator of empty collection has no elements */ public void testEmptyIterator() { - Deque c = new ConcurrentLinkedDeque(); + Deque c = new ConcurrentLinkedDeque(); assertIteratorExhausted(c.iterator()); assertIteratorExhausted(c.descendingIterator()); } @@ -730,57 +721,57 @@ public class ConcurrentLinkedDequeTest e * Iterator ordering is FIFO */ public void testIteratorOrdering() { - final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); q.add(one); q.add(two); q.add(three); int k = 0; - for (Iterator it = q.iterator(); it.hasNext();) { - assertEquals(++k, it.next()); + for (Iterator it = q.iterator(); it.hasNext();) { + mustEqual(++k, it.next()); } - assertEquals(3, k); + mustEqual(3, k); } /** * Modifications do not cause iterators to fail */ public void testWeaklyConsistentIteration() { - final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); q.add(one); q.add(two); q.add(three); - for (Iterator it = q.iterator(); it.hasNext();) { + for (Iterator it = q.iterator(); it.hasNext();) { q.remove(); it.next(); } - assertEquals("deque should be empty again", 0, q.size()); + mustEqual(0, q.size()); } /** * iterator.remove() removes current element */ public void testIteratorRemove() { - final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); final Random rng = new Random(); for (int iters = 0; iters < 100; ++iters) { int max = rng.nextInt(5) + 2; int split = rng.nextInt(max - 1) + 1; for (int j = 1; j <= max; ++j) - q.add(new Integer(j)); - Iterator it = q.iterator(); + mustAdd(q, j); + Iterator it = q.iterator(); for (int j = 1; j <= split; ++j) - assertEquals(it.next(), new Integer(j)); + mustEqual(it.next(), j); it.remove(); - assertEquals(it.next(), new Integer(split + 1)); + mustEqual(it.next(), itemFor(split + 1)); for (int j = 1; j <= split; ++j) - q.remove(new Integer(j)); + q.remove(itemFor(j)); it = q.iterator(); for (int j = split + 1; j <= max; ++j) { - assertEquals(it.next(), new Integer(j)); + mustEqual(it.next(), j); it.remove(); } assertFalse(it.hasNext()); @@ -792,14 +783,14 @@ public class ConcurrentLinkedDequeTest e * Descending iterator iterates through all elements */ public void testDescendingIterator() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); int i = 0; - Iterator it = q.descendingIterator(); + Iterator it = q.descendingIterator(); while (it.hasNext()) { - assertTrue(q.contains(it.next())); + mustContain(q, it.next()); ++i; } - assertEquals(i, SIZE); + mustEqual(i, SIZE); assertFalse(it.hasNext()); try { it.next(); @@ -811,17 +802,17 @@ public class ConcurrentLinkedDequeTest e * Descending iterator ordering is reverse FIFO */ public void testDescendingIteratorOrdering() { - final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); for (int iters = 0; iters < 100; ++iters) { - q.add(new Integer(3)); - q.add(new Integer(2)); - q.add(new Integer(1)); + mustAdd(q, three); + mustAdd(q, two); + mustAdd(q, one); int k = 0; - for (Iterator it = q.descendingIterator(); it.hasNext();) { - assertEquals(++k, it.next()); + for (Iterator it = q.descendingIterator(); it.hasNext();) { + mustEqual(++k, it.next()); } - assertEquals(3, k); + mustEqual(3, k); q.remove(); q.remove(); q.remove(); @@ -832,23 +823,23 @@ public class ConcurrentLinkedDequeTest e * descendingIterator.remove() removes current element */ public void testDescendingIteratorRemove() { - final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); + final ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(); final Random rng = new Random(); for (int iters = 0; iters < 100; ++iters) { int max = rng.nextInt(5) + 2; int split = rng.nextInt(max - 1) + 1; for (int j = max; j >= 1; --j) - q.add(new Integer(j)); - Iterator it = q.descendingIterator(); + mustAdd(q, j); + Iterator it = q.descendingIterator(); for (int j = 1; j <= split; ++j) - assertEquals(it.next(), new Integer(j)); + mustEqual(it.next(), j); it.remove(); - assertEquals(it.next(), new Integer(split + 1)); + mustEqual(it.next(), itemFor(split + 1)); for (int j = 1; j <= split; ++j) - q.remove(new Integer(j)); + q.remove(itemFor(j)); it = q.descendingIterator(); for (int j = split + 1; j <= max; ++j) { - assertEquals(it.next(), new Integer(j)); + mustEqual(it.next(), j); it.remove(); } assertFalse(it.hasNext()); @@ -860,7 +851,7 @@ public class ConcurrentLinkedDequeTest e * toString() contains toStrings of elements */ public void testToString() { - ConcurrentLinkedDeque q = populatedDeque(SIZE); + ConcurrentLinkedDeque q = populatedDeque(SIZE); String s = q.toString(); for (int i = 0; i < SIZE; ++i) { assertTrue(s.contains(String.valueOf(i))); @@ -871,16 +862,16 @@ public class ConcurrentLinkedDequeTest e * A deserialized/reserialized deque has same elements in same order */ public void testSerialization() throws Exception { - Queue x = populatedDeque(SIZE); - Queue y = serialClone(x); + Queue x = populatedDeque(SIZE); + Queue y = serialClone(x); assertNotSame(x, y); - assertEquals(x.size(), y.size()); - assertEquals(x.toString(), y.toString()); + mustEqual(x.size(), y.size()); + mustEqual(x.toString(), y.toString()); assertTrue(Arrays.equals(x.toArray(), y.toArray())); while (!x.isEmpty()) { assertFalse(y.isEmpty()); - assertEquals(x.remove(), y.remove()); + mustEqual(x.remove(), y.remove()); } assertTrue(y.isEmpty()); } @@ -929,13 +920,13 @@ public class ConcurrentLinkedDequeTest e final ThreadLocalRandom rnd = ThreadLocalRandom.current(); final LongAdder nulls = new LongAdder(), zeros = new LongAdder(); for (int n = expensiveTests ? 100_000 : 10; n--> 0; ) { - ConcurrentLinkedDeque d = new ConcurrentLinkedDeque<>(); + ConcurrentLinkedDeque d = new ConcurrentLinkedDeque<>(); boolean peek = rnd.nextBoolean(); Runnable getter = () -> { - Integer x = peek ? d.peekFirst() : d.pollFirst(); + Item x = peek ? d.peekFirst() : d.pollFirst(); if (x == null) nulls.increment(); - else if (x == 0) zeros.increment(); + else if (x.value == 0) zeros.increment(); else throw new AssertionError( String.format( @@ -943,7 +934,7 @@ public class ConcurrentLinkedDequeTest e x, nulls.sum(), zeros.sum())); }; - Runnable adder = () -> { d.addFirst(0); d.addLast(42); }; + Runnable adder = () -> { d.addFirst(zero); d.addLast(fortytwo); }; runAsync(getter, adder); } @@ -956,13 +947,13 @@ public class ConcurrentLinkedDequeTest e final ThreadLocalRandom rnd = ThreadLocalRandom.current(); final LongAdder nulls = new LongAdder(), zeros = new LongAdder(); for (int n = expensiveTests ? 100_000 : 10; n--> 0; ) { - ConcurrentLinkedDeque d = new ConcurrentLinkedDeque<>(); + ConcurrentLinkedDeque d = new ConcurrentLinkedDeque<>(); boolean peek = rnd.nextBoolean(); Runnable getter = () -> { - Integer x = peek ? d.peekLast() : d.pollLast(); + Item x = peek ? d.peekLast() : d.pollLast(); if (x == null) nulls.increment(); - else if (x == 0) zeros.increment(); + else if (x.value == 0) zeros.increment(); else throw new AssertionError( String.format( @@ -970,7 +961,7 @@ public class ConcurrentLinkedDequeTest e x, nulls.sum(), zeros.sum())); }; - Runnable adder = () -> { d.addLast(0); d.addFirst(42); }; + Runnable adder = () -> { d.addLast(zero); d.addFirst(fortytwo); }; runAsync(getter, adder); }