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.13 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.45 by jsr166, Sat Mar 11 18:20:46 2017 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.*;
11 < import java.util.concurrent.*;
12 < import java.io.*;
9 > import java.util.Arrays;
10 > import java.util.Collection;
11 > import java.util.Iterator;
12 > import java.util.NoSuchElementException;
13 > import java.util.Queue;
14 > import java.util.concurrent.ConcurrentLinkedQueue;
15 >
16 > import junit.framework.Test;
17  
18   public class ConcurrentLinkedQueueTest extends JSR166TestCase {
19  
20      public static void main(String[] args) {
21 <        junit.textui.TestRunner.run (suite());
21 >        main(suite(), args);
22      }
23  
24      public static Test suite() {
25 <        return new TestSuite(ConcurrentLinkedQueueTest.class);
25 >        class Implementation implements CollectionImplementation {
26 >            public Class<?> klazz() { return ConcurrentLinkedQueue.class; }
27 >            public Collection emptyCollection() { return new ConcurrentLinkedQueue(); }
28 >            public Object makeElement(int i) { return i; }
29 >            public boolean isConcurrent() { return true; }
30 >            public boolean permitsNulls() { return false; }
31 >        }
32 >        return newTestSuite(ConcurrentLinkedQueueTest.class,
33 >                            CollectionTest.testSuite(new Implementation()));
34      }
35  
36      /**
37 <     * Create a queue of given size containing consecutive
38 <     * Integers 0 ... n.
37 >     * Returns a new queue of given size containing consecutive
38 >     * Integers 0 ... n - 1.
39       */
40 <    private ConcurrentLinkedQueue populatedQueue(int n) {
41 <        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
40 >    private static ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
41 >        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<>();
42          assertTrue(q.isEmpty());
43          for (int i = 0; i < n; ++i)
44              assertTrue(q.offer(new Integer(i)));
45          assertFalse(q.isEmpty());
46          assertEquals(n, q.size());
47 +        assertEquals((Integer) 0, q.peek());
48          return q;
49      }
50  
# Line 43 | Line 56 | public class ConcurrentLinkedQueueTest e
56      }
57  
58      /**
59 <     *  Initializing from null Collection throws NPE
59 >     * Initializing from null Collection throws NPE
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 57 | Line 70 | public class ConcurrentLinkedQueueTest e
70       */
71      public void testConstructor4() {
72          try {
73 <            Integer[] ints = new Integer[SIZE];
61 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
73 >            new ConcurrentLinkedQueue(Arrays.asList(new Integer[SIZE]));
74              shouldThrow();
75          } catch (NullPointerException success) {}
76      }
# Line 67 | 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];
72 <            for (int i = 0; i < SIZE-1; ++i)
73 <                ints[i] = new Integer(i);
74 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
86 >            new ConcurrentLinkedQueue(Arrays.asList(ints));
87              shouldThrow();
88 <        }
77 <        catch (NullPointerException success) {}
88 >        } catch (NullPointerException success) {}
89      }
90  
91      /**
92       * Queue contains all elements of collection used to initialize
93       */
94      public void testConstructor6() {
95 <        try {
96 <            Integer[] ints = new Integer[SIZE];
97 <            for (int i = 0; i < SIZE; ++i)
98 <                ints[i] = new Integer(i);
99 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
100 <            for (int i = 0; i < SIZE; ++i)
90 <                assertEquals(ints[i], q.poll());
91 <        }
92 <        finally {}
95 >        Integer[] ints = new Integer[SIZE];
96 >        for (int i = 0; i < SIZE; ++i)
97 >            ints[i] = new Integer(i);
98 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
99 >        for (int i = 0; i < SIZE; ++i)
100 >            assertEquals(ints[i], q.poll());
101      }
102  
103      /**
# Line 112 | 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 125 | Line 133 | public class ConcurrentLinkedQueueTest e
133       * offer(null) throws NPE
134       */
135      public void testOfferNull() {
136 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
137          try {
129 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
138              q.offer(null);
139              shouldThrow();
140          } catch (NullPointerException success) {}
# Line 136 | Line 144 | public class ConcurrentLinkedQueueTest e
144       * add(null) throws NPE
145       */
146      public void testAddNull() {
147 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
148          try {
140 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
149              q.add(null);
150              shouldThrow();
151          } catch (NullPointerException success) {}
152      }
153  
146 –
154      /**
155       * Offer returns true
156       */
# Line 168 | Line 175 | public class ConcurrentLinkedQueueTest e
175       * addAll(null) throws NPE
176       */
177      public void testAddAll1() {
178 +        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
179          try {
172 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
180              q.addAll(null);
181              shouldThrow();
182          } catch (NullPointerException success) {}
# Line 179 | Line 186 | public class ConcurrentLinkedQueueTest e
186       * addAll(this) throws IAE
187       */
188      public void testAddAllSelf() {
189 +        ConcurrentLinkedQueue q = populatedQueue(SIZE);
190          try {
183 –            ConcurrentLinkedQueue q = populatedQueue(SIZE);
191              q.addAll(q);
192              shouldThrow();
193          } catch (IllegalArgumentException success) {}
# Line 190 | 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();
195 <            Integer[] ints = new Integer[SIZE];
196 <            q.addAll(Arrays.asList(ints));
202 >            q.addAll(Arrays.asList(new Integer[SIZE]));
203              shouldThrow();
204          } catch (NullPointerException success) {}
205      }
206 +
207      /**
208 <     *  addAll of a collection with any null elements throws NPE after
208 >     * addAll of a collection with any null elements throws NPE after
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 {
206 –            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
207 –            Integer[] ints = new Integer[SIZE];
208 –            for (int i = 0; i < SIZE-1; ++i)
209 –                ints[i] = new Integer(i);
217              q.addAll(Arrays.asList(ints));
218              shouldThrow();
219          } catch (NullPointerException success) {}
# Line 216 | Line 223 | public class ConcurrentLinkedQueueTest e
223       * Queue contains all elements, in traversal order, of successful addAll
224       */
225      public void testAddAll5() {
226 <        try {
227 <            Integer[] empty = new Integer[0];
228 <            Integer[] ints = new Integer[SIZE];
229 <            for (int i = 0; i < SIZE; ++i)
230 <                ints[i] = new Integer(i);
231 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
232 <            assertFalse(q.addAll(Arrays.asList(empty)));
233 <            assertTrue(q.addAll(Arrays.asList(ints)));
234 <            for (int i = 0; i < SIZE; ++i)
228 <                assertEquals(ints[i], q.poll());
229 <        }
230 <        finally {}
226 >        Integer[] empty = new Integer[0];
227 >        Integer[] ints = new Integer[SIZE];
228 >        for (int i = 0; i < SIZE; ++i)
229 >            ints[i] = new Integer(i);
230 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
231 >        assertFalse(q.addAll(Arrays.asList(empty)));
232 >        assertTrue(q.addAll(Arrays.asList(ints)));
233 >        for (int i = 0; i < SIZE; ++i)
234 >            assertEquals(ints[i], q.poll());
235      }
236  
237      /**
# Line 236 | Line 240 | public class ConcurrentLinkedQueueTest e
240      public void testPoll() {
241          ConcurrentLinkedQueue q = populatedQueue(SIZE);
242          for (int i = 0; i < SIZE; ++i) {
243 <            assertEquals(i, ((Integer)q.poll()).intValue());
243 >            assertEquals(i, q.poll());
244          }
245          assertNull(q.poll());
246      }
# Line 247 | Line 251 | public class ConcurrentLinkedQueueTest e
251      public void testPeek() {
252          ConcurrentLinkedQueue q = populatedQueue(SIZE);
253          for (int i = 0; i < SIZE; ++i) {
254 <            assertEquals(i, ((Integer)q.peek()).intValue());
255 <            q.poll();
254 >            assertEquals(i, q.peek());
255 >            assertEquals(i, q.poll());
256              assertTrue(q.peek() == null ||
257 <                       i != ((Integer)q.peek()).intValue());
257 >                       !q.peek().equals(i));
258          }
259          assertNull(q.peek());
260      }
# Line 261 | Line 265 | public class ConcurrentLinkedQueueTest e
265      public void testElement() {
266          ConcurrentLinkedQueue q = populatedQueue(SIZE);
267          for (int i = 0; i < SIZE; ++i) {
268 <            assertEquals(i, ((Integer)q.element()).intValue());
269 <            q.poll();
268 >            assertEquals(i, q.element());
269 >            assertEquals(i, q.poll());
270          }
271          try {
272              q.element();
# Line 271 | Line 275 | public class ConcurrentLinkedQueueTest e
275      }
276  
277      /**
278 <     *  remove removes next element, or throws NSEE if empty
278 >     * remove removes next element, or throws NSEE if empty
279       */
280      public void testRemove() {
281          ConcurrentLinkedQueue q = populatedQueue(SIZE);
282          for (int i = 0; i < SIZE; ++i) {
283 <            assertEquals(i, ((Integer)q.remove()).intValue());
283 >            assertEquals(i, q.remove());
284          }
285          try {
286              q.remove();
# Line 289 | 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) {
297 <            assertTrue(q.remove(new Integer(i)));
298 <        }
299 <        for (int i = 0; i < SIZE; i+=2) {
300 <            assertTrue(q.remove(new Integer(i)));
301 <            assertFalse(q.remove(new Integer(i+1)));
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));
301 >        }
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));
308          }
309          assertTrue(q.isEmpty());
310      }
# Line 353 | 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 366 | 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      }
386  
387      /**
388 <     * toArray contains all elements
388 >     * toArray contains all elements in FIFO order
389       */
390      public void testToArray() {
391          ConcurrentLinkedQueue q = populatedQueue(SIZE);
392          Object[] o = q.toArray();
383 –        Arrays.sort(o);
393          for (int i = 0; i < o.length; i++)
394 <            assertEquals(o[i], q.poll());
394 >            assertSame(o[i], q.poll());
395      }
396  
397      /**
398 <     *  toArray(a) contains all elements
398 >     * toArray(a) contains all elements in FIFO order
399       */
400      public void testToArray2() {
401 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
401 >        ConcurrentLinkedQueue<Integer> q = populatedQueue(SIZE);
402          Integer[] ints = new Integer[SIZE];
403 <        ints = (Integer[])q.toArray(ints);
404 <        Arrays.sort(ints);
403 >        Integer[] array = q.toArray(ints);
404 >        assertSame(ints, array);
405          for (int i = 0; i < ints.length; i++)
406 <            assertEquals(ints[i], q.poll());
406 >            assertSame(ints[i], q.poll());
407      }
408  
409      /**
410 <     * toArray(null) throws NPE
410 >     * toArray(null) throws NullPointerException
411       */
412 <    public void testToArray_BadArg() {
412 >    public void testToArray_NullArg() {
413 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
414          try {
415 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
406 <            Object o[] = q.toArray(null);
415 >            q.toArray(null);
416              shouldThrow();
417          } catch (NullPointerException success) {}
418      }
419  
420      /**
421 <     * toArray with incompatible array type throws ArrayStoreException
421 >     * toArray(incompatible array type) throws ArrayStoreException
422       */
423      public void testToArray1_BadArg() {
424 +        ConcurrentLinkedQueue q = populatedQueue(SIZE);
425          try {
426 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
417 <            Object o[] = q.toArray(new String[10] );
426 >            q.toArray(new String[10]);
427              shouldThrow();
428          } catch (ArrayStoreException success) {}
429      }
430  
431      /**
432 <     *  iterator iterates through all elements
432 >     * iterator iterates through all elements
433       */
434      public void testIterator() {
435          ConcurrentLinkedQueue q = populatedQueue(SIZE);
427 –        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()));
431 –            ++i;
432 –        }
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 444 | Line 459 | public class ConcurrentLinkedQueueTest e
459  
460          int k = 0;
461          for (Iterator it = q.iterator(); it.hasNext();) {
462 <            int i = ((Integer)(it.next())).intValue();
448 <            assertEquals(++k, i);
462 >            assertEquals(++k, it.next());
463          }
464  
465          assertEquals(3, k);
# Line 454 | Line 468 | public class ConcurrentLinkedQueueTest e
468      /**
469       * Modifications do not cause iterators to fail
470       */
471 <    public void testWeaklyConsistentIteration () {
471 >    public void testWeaklyConsistentIteration() {
472          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
473          q.add(one);
474          q.add(two);
# Line 471 | Line 485 | public class ConcurrentLinkedQueueTest e
485      /**
486       * iterator.remove removes current element
487       */
488 <    public void testIteratorRemove () {
488 >    public void testIteratorRemove() {
489          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
490          q.add(one);
491          q.add(two);
# Line 480 | Line 494 | public class ConcurrentLinkedQueueTest e
494          it.next();
495          it.remove();
496          it = q.iterator();
497 <        assertEquals(it.next(), two);
498 <        assertEquals(it.next(), three);
497 >        assertSame(it.next(), two);
498 >        assertSame(it.next(), three);
499          assertFalse(it.hasNext());
500      }
501  
488 –
502      /**
503       * toString contains toStrings of elements
504       */
# Line 493 | Line 506 | public class ConcurrentLinkedQueueTest e
506          ConcurrentLinkedQueue q = populatedQueue(SIZE);
507          String s = q.toString();
508          for (int i = 0; i < SIZE; ++i) {
509 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
509 >            assertTrue(s.contains(String.valueOf(i)));
510          }
511      }
512  
# Line 501 | Line 514 | public class ConcurrentLinkedQueueTest e
514       * A deserialized serialized queue has same elements in same order
515       */
516      public void testSerialization() throws Exception {
517 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
518 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
519 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
520 <        out.writeObject(q);
521 <        out.close();
522 <
523 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
524 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
525 <        ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
526 <        assertEquals(q.size(), r.size());
527 <        while (!q.isEmpty())
528 <            assertEquals(q.remove(), r.remove());
517 >        Queue x = populatedQueue(SIZE);
518 >        Queue y = serialClone(x);
519 >
520 >        assertNotSame(x, y);
521 >        assertEquals(x.size(), y.size());
522 >        assertEquals(x.toString(), y.toString());
523 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
524 >        while (!x.isEmpty()) {
525 >            assertFalse(y.isEmpty());
526 >            assertEquals(x.remove(), y.remove());
527 >        }
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