--- jsr166/src/test/tck/ConcurrentLinkedQueueTest.java 2018/06/22 00:04:58 1.49 +++ jsr166/src/test/tck/ConcurrentLinkedQueueTest.java 2021/01/26 13:33:05 1.50 @@ -25,7 +25,7 @@ public class ConcurrentLinkedQueueTest e class Implementation implements CollectionImplementation { public Class klazz() { return ConcurrentLinkedQueue.class; } public Collection emptyCollection() { return new ConcurrentLinkedQueue(); } - 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; } } @@ -35,16 +35,16 @@ public class ConcurrentLinkedQueueTest e /** * Returns a new queue of given size containing consecutive - * Integers 0 ... n - 1. + * Items 0 ... n - 1. */ - private static ConcurrentLinkedQueue populatedQueue(int n) { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue<>(); + private static ConcurrentLinkedQueue populatedQueue(int n) { + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue<>(); 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.peek()); + mustEqual(n, q.size()); + mustEqual(0, q.peek()); return q; } @@ -52,7 +52,7 @@ public class ConcurrentLinkedQueueTest e * new queue is empty */ public void testConstructor1() { - assertEquals(0, new ConcurrentLinkedQueue().size()); + mustEqual(0, new ConcurrentLinkedQueue().size()); } /** @@ -60,7 +60,7 @@ public class ConcurrentLinkedQueueTest e */ public void testConstructor3() { try { - new ConcurrentLinkedQueue((Collection)null); + new ConcurrentLinkedQueue((Collection)null); shouldThrow(); } catch (NullPointerException success) {} } @@ -70,7 +70,7 @@ public class ConcurrentLinkedQueueTest e */ public void testConstructor4() { try { - new ConcurrentLinkedQueue(Arrays.asList(new Integer[SIZE])); + new ConcurrentLinkedQueue(Arrays.asList(new Item[SIZE])); shouldThrow(); } catch (NullPointerException success) {} } @@ -79,11 +79,10 @@ public class ConcurrentLinkedQueueTest 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 ConcurrentLinkedQueue(Arrays.asList(ints)); + new ConcurrentLinkedQueue(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -92,19 +91,17 @@ public class ConcurrentLinkedQueueTest e * Queue contains all elements of collection used to initialize */ public void testConstructor6() { - Integer[] ints = new Integer[SIZE]; + Item[] items = defaultItems; + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(items)); for (int i = 0; i < SIZE; ++i) - ints[i] = new Integer(i); - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(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() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); assertTrue(q.isEmpty()); q.add(one); assertFalse(q.isEmpty()); @@ -118,14 +115,14 @@ public class ConcurrentLinkedQueueTest e * size changes when elements added and removed */ public void testSize() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(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); } } @@ -133,7 +130,7 @@ public class ConcurrentLinkedQueueTest e * offer(null) throws NPE */ public void testOfferNull() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); try { q.offer(null); shouldThrow(); @@ -144,7 +141,7 @@ public class ConcurrentLinkedQueueTest e * add(null) throws NPE */ public void testAddNull() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); try { q.add(null); shouldThrow(); @@ -155,7 +152,7 @@ public class ConcurrentLinkedQueueTest e * Offer returns true */ public void testOffer() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); assertTrue(q.offer(zero)); assertTrue(q.offer(one)); } @@ -164,10 +161,10 @@ public class ConcurrentLinkedQueueTest e * add returns true */ public void testAdd() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.size()); - assertTrue(q.add(new Integer(i))); + mustEqual(i, q.size()); + mustAdd(q, i); } } @@ -175,7 +172,7 @@ public class ConcurrentLinkedQueueTest e * addAll(null) throws NullPointerException */ public void testAddAll1() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); try { q.addAll(null); shouldThrow(); @@ -186,7 +183,7 @@ public class ConcurrentLinkedQueueTest e * addAll(this) throws IllegalArgumentException */ public void testAddAllSelf() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); try { q.addAll(q); shouldThrow(); @@ -197,9 +194,9 @@ public class ConcurrentLinkedQueueTest e * addAll of a collection with null elements throws NullPointerException */ public void testAddAll2() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); try { - q.addAll(Arrays.asList(new Integer[SIZE])); + q.addAll(Arrays.asList(new Item[SIZE])); shouldThrow(); } catch (NullPointerException success) {} } @@ -209,12 +206,11 @@ public class ConcurrentLinkedQueueTest e * possibly adding some elements */ public void testAddAll3() { - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); - Integer[] ints = new Integer[SIZE]; - for (int i = 0; i < SIZE - 1; ++i) - ints[i] = new Integer(i); + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + Item[] items = new Item[2]; + items[0] = zero; try { - q.addAll(Arrays.asList(ints)); + q.addAll(Arrays.asList(items)); shouldThrow(); } catch (NullPointerException success) {} } @@ -223,24 +219,22 @@ public class ConcurrentLinkedQueueTest e * Queue 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); - ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + Item[] empty = new Item[0]; + Item[] items = defaultItems; + ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); 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()); } /** * poll succeeds unless empty */ public void testPoll() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.poll()); + mustEqual(i, q.poll()); } assertNull(q.poll()); } @@ -249,10 +243,10 @@ public class ConcurrentLinkedQueueTest e * peek returns next element, or null if empty */ public void testPeek() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(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)); } @@ -263,10 +257,10 @@ public class ConcurrentLinkedQueueTest e * element returns next element, or throws NSEE if empty */ public void testElement() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(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(); @@ -278,9 +272,9 @@ public class ConcurrentLinkedQueueTest e * remove removes next element, or throws NSEE if empty */ public void testRemove() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { - assertEquals(i, q.remove()); + mustEqual(i, q.remove()); } try { q.remove(); @@ -292,19 +286,19 @@ public class ConcurrentLinkedQueueTest e * remove(x) removes x and returns true if present */ public void testRemoveElement() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(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()); } @@ -313,11 +307,11 @@ public class ConcurrentLinkedQueueTest e * contains(x) reports true when elements added but not yet removed */ public void testContains() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(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); } } @@ -325,10 +319,10 @@ public class ConcurrentLinkedQueueTest e * clear removes all elements */ public void testClear() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); q.clear(); assertTrue(q.isEmpty()); - assertEquals(0, q.size()); + mustEqual(0, q.size()); q.add(one); assertFalse(q.isEmpty()); q.clear(); @@ -339,12 +333,12 @@ public class ConcurrentLinkedQueueTest e * containsAll(c) is true when c contains a subset of elements */ public void testContainsAll() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - ConcurrentLinkedQueue p = new ConcurrentLinkedQueue(); + ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue p = new ConcurrentLinkedQueue(); 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)); } @@ -353,8 +347,8 @@ public class ConcurrentLinkedQueueTest e * retainAll(c) retains only those elements of c and reports true if change */ public void testRetainAll() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - ConcurrentLinkedQueue p = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue p = populatedQueue(SIZE); for (int i = 0; i < SIZE; ++i) { boolean changed = q.retainAll(p); if (i == 0) @@ -363,7 +357,7 @@ public class ConcurrentLinkedQueueTest e assertTrue(changed); assertTrue(q.containsAll(p)); - assertEquals(SIZE - i, q.size()); + mustEqual(SIZE - i, q.size()); p.remove(); } } @@ -373,12 +367,12 @@ public class ConcurrentLinkedQueueTest e */ public void testRemoveAll() { for (int i = 1; i < SIZE; ++i) { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - ConcurrentLinkedQueue p = populatedQueue(i); + ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue p = populatedQueue(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()); + Item x = p.remove(); assertFalse(q.contains(x)); } } @@ -388,7 +382,7 @@ public class ConcurrentLinkedQueueTest e * toArray contains all elements in FIFO order */ public void testToArray() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); Object[] a = q.toArray(); assertSame(Object[].class, a.getClass()); for (Object o : a) @@ -400,11 +394,11 @@ public class ConcurrentLinkedQueueTest e * toArray(a) contains all elements in FIFO order */ public void testToArray2() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - Integer[] ints = new Integer[SIZE]; - Integer[] array = q.toArray(ints); - assertSame(ints, array); - for (Integer o : ints) + ConcurrentLinkedQueue q = populatedQueue(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()); } @@ -413,7 +407,7 @@ public class ConcurrentLinkedQueueTest e * toArray(null) throws NullPointerException */ public void testToArray_NullArg() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); try { q.toArray((Object[])null); shouldThrow(); @@ -424,7 +418,7 @@ public class ConcurrentLinkedQueueTest e * toArray(incompatible array type) throws ArrayStoreException */ public void testToArray1_BadArg() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); try { q.toArray(new String[10]); shouldThrow(); @@ -435,12 +429,12 @@ public class ConcurrentLinkedQueueTest e * iterator iterates through all elements */ public void testIterator() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); - Iterator it = q.iterator(); + ConcurrentLinkedQueue q = populatedQueue(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); } @@ -448,52 +442,52 @@ public class ConcurrentLinkedQueueTest e * iterator of empty collection has no elements */ public void testEmptyIterator() { - assertIteratorExhausted(new ConcurrentLinkedQueue().iterator()); + assertIteratorExhausted(new ConcurrentLinkedQueue().iterator()); } /** * iterator ordering is FIFO */ public void testIteratorOrdering() { - final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); 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 ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); 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("queue should be empty again", 0, q.size()); + mustEqual(0, q.size()); } /** * iterator.remove removes current element */ public void testIteratorRemove() { - final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); + final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(); q.add(one); q.add(two); q.add(three); - Iterator it = q.iterator(); + Iterator it = q.iterator(); it.next(); it.remove(); it = q.iterator(); @@ -506,7 +500,7 @@ public class ConcurrentLinkedQueueTest e * toString contains toStrings of elements */ public void testToString() { - ConcurrentLinkedQueue q = populatedQueue(SIZE); + ConcurrentLinkedQueue q = populatedQueue(SIZE); String s = q.toString(); for (int i = 0; i < SIZE; ++i) { assertTrue(s.contains(String.valueOf(i))); @@ -517,16 +511,16 @@ public class ConcurrentLinkedQueueTest e * A deserialized/reserialized queue has same elements in same order */ public void testSerialization() throws Exception { - Queue x = populatedQueue(SIZE); - Queue y = serialClone(x); + Queue x = populatedQueue(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()); }