ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentLinkedQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ConcurrentLinkedQueueTest.java (file contents):
Revision 1.28 by jsr166, Tue Feb 21 01:54:03 2012 UTC vs.
Revision 1.41 by jsr166, Sun Oct 16 20:16:36 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.Arrays;
10   import java.util.Collection;
11   import java.util.Iterator;
# Line 14 | Line 13 | import java.util.NoSuchElementException;
13   import java.util.Queue;
14   import java.util.concurrent.ConcurrentLinkedQueue;
15  
16 + import junit.framework.Test;
17 + import junit.framework.TestSuite;
18 +
19   public class ConcurrentLinkedQueueTest extends JSR166TestCase {
20  
21      public static void main(String[] args) {
22 <        junit.textui.TestRunner.run(suite());
22 >        main(suite(), args);
23      }
24  
25      public static Test suite() {
26 <        return new TestSuite(ConcurrentLinkedQueueTest.class);
26 >        class Implementation implements CollectionImplementation {
27 >            public Class<?> klazz() { return ConcurrentLinkedQueue.class; }
28 >            public Collection emptyCollection() { return new ConcurrentLinkedQueue(); }
29 >            public Object makeElement(int i) { return i; }
30 >            public boolean isConcurrent() { return true; }
31 >            public boolean permitsNulls() { return false; }
32 >        }
33 >        return newTestSuite(ConcurrentLinkedQueueTest.class,
34 >                            CollectionTest.testSuite(new Implementation()));
35      }
36  
37      /**
38 <     * Creates a queue of given size containing consecutive
38 >     * Returns a new queue of given size containing consecutive
39       * Integers 0 ... n.
40       */
41      private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
# Line 50 | Line 60 | public class ConcurrentLinkedQueueTest e
60       */
61      public void testConstructor3() {
62          try {
63 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
63 >            new ConcurrentLinkedQueue((Collection)null);
64              shouldThrow();
65          } catch (NullPointerException success) {}
66      }
# Line 60 | Line 70 | public class ConcurrentLinkedQueueTest e
70       */
71      public void testConstructor4() {
72          try {
73 <            Integer[] ints = new Integer[SIZE];
64 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
73 >            new ConcurrentLinkedQueue(Arrays.asList(new Integer[SIZE]));
74              shouldThrow();
75          } catch (NullPointerException success) {}
76      }
# Line 70 | Line 79 | public class ConcurrentLinkedQueueTest e
79       * Initializing from Collection with some null elements throws NPE
80       */
81      public void testConstructor5() {
82 +        Integer[] ints = new Integer[SIZE];
83 +        for (int i = 0; i < SIZE - 1; ++i)
84 +            ints[i] = new Integer(i);
85          try {
86 <            Integer[] ints = new Integer[SIZE];
75 <            for (int i = 0; i < SIZE-1; ++i)
76 <                ints[i] = new Integer(i);
77 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
86 >            new ConcurrentLinkedQueue(Arrays.asList(ints));
87              shouldThrow();
88          } catch (NullPointerException success) {}
89      }
# Line 111 | Line 120 | public class ConcurrentLinkedQueueTest e
120      public void testSize() {
121          ConcurrentLinkedQueue q = populatedQueue(SIZE);
122          for (int i = 0; i < SIZE; ++i) {
123 <            assertEquals(SIZE-i, q.size());
123 >            assertEquals(SIZE - i, q.size());
124              q.remove();
125          }
126          for (int i = 0; i < SIZE; ++i) {
# Line 124 | Line 133 | public class ConcurrentLinkedQueueTest e
133       * offer(null) throws NPE
134       */
135      public void testOfferNull() {
136 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
137          try {
128 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
138              q.offer(null);
139              shouldThrow();
140          } catch (NullPointerException success) {}
# Line 135 | Line 144 | public class ConcurrentLinkedQueueTest e
144       * add(null) throws NPE
145       */
146      public void testAddNull() {
147 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
148          try {
139 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
149              q.add(null);
150              shouldThrow();
151          } catch (NullPointerException success) {}
# Line 166 | Line 175 | public class ConcurrentLinkedQueueTest e
175       * addAll(null) throws NPE
176       */
177      public void testAddAll1() {
178 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
179          try {
170 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
180              q.addAll(null);
181              shouldThrow();
182          } catch (NullPointerException success) {}
# Line 177 | Line 186 | public class ConcurrentLinkedQueueTest e
186       * addAll(this) throws IAE
187       */
188      public void testAddAllSelf() {
189 +        ConcurrentLinkedQueue q = populatedQueue(SIZE);
190          try {
181 –            ConcurrentLinkedQueue q = populatedQueue(SIZE);
191              q.addAll(q);
192              shouldThrow();
193          } catch (IllegalArgumentException success) {}
# Line 188 | Line 197 | public class ConcurrentLinkedQueueTest e
197       * addAll of a collection with null elements throws NPE
198       */
199      public void testAddAll2() {
200 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
201          try {
202 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
193 <            Integer[] ints = new Integer[SIZE];
194 <            q.addAll(Arrays.asList(ints));
202 >            q.addAll(Arrays.asList(new Integer[SIZE]));
203              shouldThrow();
204          } catch (NullPointerException success) {}
205      }
# Line 201 | Line 209 | public class ConcurrentLinkedQueueTest e
209       * possibly adding some elements
210       */
211      public void testAddAll3() {
212 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
213 +        Integer[] ints = new Integer[SIZE];
214 +        for (int i = 0; i < SIZE - 1; ++i)
215 +            ints[i] = new Integer(i);
216          try {
205 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
206 –            Integer[] ints = new Integer[SIZE];
207 –            for (int i = 0; i < SIZE-1; ++i)
208 –                ints[i] = new Integer(i);
217              q.addAll(Arrays.asList(ints));
218              shouldThrow();
219          } catch (NullPointerException success) {}
# Line 285 | Line 293 | public class ConcurrentLinkedQueueTest e
293       */
294      public void testRemoveElement() {
295          ConcurrentLinkedQueue q = populatedQueue(SIZE);
296 <        for (int i = 1; i < SIZE; i+=2) {
296 >        for (int i = 1; i < SIZE; i += 2) {
297              assertTrue(q.contains(i));
298              assertTrue(q.remove(i));
299              assertFalse(q.contains(i));
300 <            assertTrue(q.contains(i-1));
300 >            assertTrue(q.contains(i - 1));
301          }
302 <        for (int i = 0; i < SIZE; i+=2) {
302 >        for (int i = 0; i < SIZE; i += 2) {
303              assertTrue(q.contains(i));
304              assertTrue(q.remove(i));
305              assertFalse(q.contains(i));
306 <            assertFalse(q.remove(i+1));
307 <            assertFalse(q.contains(i+1));
306 >            assertFalse(q.remove(i + 1));
307 >            assertFalse(q.contains(i + 1));
308          }
309          assertTrue(q.isEmpty());
310      }
# Line 355 | Line 363 | public class ConcurrentLinkedQueueTest e
363                  assertTrue(changed);
364  
365              assertTrue(q.containsAll(p));
366 <            assertEquals(SIZE-i, q.size());
366 >            assertEquals(SIZE - i, q.size());
367              p.remove();
368          }
369      }
# Line 368 | Line 376 | public class ConcurrentLinkedQueueTest e
376              ConcurrentLinkedQueue q = populatedQueue(SIZE);
377              ConcurrentLinkedQueue p = populatedQueue(i);
378              assertTrue(q.removeAll(p));
379 <            assertEquals(SIZE-i, q.size());
379 >            assertEquals(SIZE - i, q.size());
380              for (int j = 0; j < i; ++j) {
381 <                Integer I = (Integer)(p.remove());
382 <                assertFalse(q.contains(I));
381 >                Integer x = (Integer)(p.remove());
382 >                assertFalse(q.contains(x));
383              }
384          }
385      }
# Line 425 | Line 433 | public class ConcurrentLinkedQueueTest e
433       */
434      public void testIterator() {
435          ConcurrentLinkedQueue q = populatedQueue(SIZE);
428 –        int i = 0;
436          Iterator it = q.iterator();
437 <        while (it.hasNext()) {
437 >        int i;
438 >        for (i = 0; it.hasNext(); i++)
439              assertTrue(q.contains(it.next()));
432 –            ++i;
433 –        }
440          assertEquals(i, SIZE);
441 +        assertIteratorExhausted(it);
442 +    }
443 +
444 +    /**
445 +     * iterator of empty collection has no elements
446 +     */
447 +    public void testEmptyIterator() {
448 +        assertIteratorExhausted(new ConcurrentLinkedQueue().iterator());
449      }
450  
451      /**
# Line 503 | Line 517 | public class ConcurrentLinkedQueueTest e
517          Queue x = populatedQueue(SIZE);
518          Queue y = serialClone(x);
519  
520 <        assertTrue(x != y);
520 >        assertNotSame(x, y);
521          assertEquals(x.size(), y.size());
522          assertEquals(x.toString(), y.toString());
523          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 514 | Line 528 | public class ConcurrentLinkedQueueTest e
528          assertTrue(y.isEmpty());
529      }
530  
531 +    /**
532 +     * remove(null), contains(null) always return false
533 +     */
534 +    public void testNeverContainsNull() {
535 +        Collection<?>[] qs = {
536 +            new ConcurrentLinkedQueue<Object>(),
537 +            populatedQueue(2),
538 +        };
539 +
540 +        for (Collection<?> q : qs) {
541 +            assertFalse(q.contains(null));
542 +            assertFalse(q.remove(null));
543 +        }
544 +    }
545   }

Diff Legend

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