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.7 by dl, Mon Dec 29 19:05:40 2003 UTC vs.
Revision 1.36 by jsr166, Sun Feb 22 04:34:44 2015 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
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
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 > 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 >        junit.textui.TestRunner.run(suite());
23      }
24  
25      public static Test suite() {
26 <        return new TestSuite(ConcurrentLinkedQueueTest.class);
26 >        return new TestSuite(ConcurrentLinkedQueueTest.class);
27      }
28  
29      /**
30 <     * Create a queue of given size containing consecutive
30 >     * Returns a new queue of given size containing consecutive
31       * Integers 0 ... n.
32       */
33 <    private ConcurrentLinkedQueue populatedQueue(int n) {
34 <        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
33 >    private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
34 >        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
35          assertTrue(q.isEmpty());
36 <        for(int i = 0; i < n; ++i)
37 <            assertTrue(q.offer(new Integer(i)));
36 >        for (int i = 0; i < n; ++i)
37 >            assertTrue(q.offer(new Integer(i)));
38          assertFalse(q.isEmpty());
39 <        assertEquals(n, q.size());
39 >        assertEquals(n, q.size());
40          return q;
41      }
42 <
42 >
43      /**
44       * new queue is empty
45       */
# Line 43 | Line 48 | public class ConcurrentLinkedQueueTest e
48      }
49  
50      /**
51 <     *  Initializing from null Collection throws NPE
51 >     * Initializing from null Collection throws NPE
52       */
53      public void testConstructor3() {
54          try {
55 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
55 >            new ConcurrentLinkedQueue((Collection)null);
56              shouldThrow();
57 <        }
53 <        catch (NullPointerException success) {}
57 >        } catch (NullPointerException success) {}
58      }
59  
60      /**
# Line 59 | Line 63 | public class ConcurrentLinkedQueueTest e
63      public void testConstructor4() {
64          try {
65              Integer[] ints = new Integer[SIZE];
66 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
66 >            new ConcurrentLinkedQueue(Arrays.asList(ints));
67              shouldThrow();
68 <        }
65 <        catch (NullPointerException success) {}
68 >        } catch (NullPointerException success) {}
69      }
70  
71      /**
# Line 73 | Line 76 | public class ConcurrentLinkedQueueTest e
76              Integer[] ints = new Integer[SIZE];
77              for (int i = 0; i < SIZE-1; ++i)
78                  ints[i] = new Integer(i);
79 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
79 >            new ConcurrentLinkedQueue(Arrays.asList(ints));
80              shouldThrow();
81 <        }
79 <        catch (NullPointerException success) {}
81 >        } catch (NullPointerException success) {}
82      }
83  
84      /**
85       * Queue contains all elements of collection used to initialize
86       */
87      public void testConstructor6() {
88 <        try {
89 <            Integer[] ints = new Integer[SIZE];
90 <            for (int i = 0; i < SIZE; ++i)
91 <                ints[i] = new Integer(i);
92 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
93 <            for (int i = 0; i < SIZE; ++i)
92 <                assertEquals(ints[i], q.poll());
93 <        }
94 <        finally {}
88 >        Integer[] ints = new Integer[SIZE];
89 >        for (int i = 0; i < SIZE; ++i)
90 >            ints[i] = new Integer(i);
91 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
92 >        for (int i = 0; i < SIZE; ++i)
93 >            assertEquals(ints[i], q.poll());
94      }
95  
96      /**
# Line 127 | Line 126 | public class ConcurrentLinkedQueueTest e
126       * offer(null) throws NPE
127       */
128      public void testOfferNull() {
129 <        try {
129 >        try {
130              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
131              q.offer(null);
132              shouldThrow();
133 <        } catch (NullPointerException success) { }  
133 >        } catch (NullPointerException success) {}
134      }
135  
136      /**
137       * add(null) throws NPE
138       */
139      public void testAddNull() {
140 <        try {
140 >        try {
141              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
142              q.add(null);
143              shouldThrow();
144 <        } catch (NullPointerException success) { }  
144 >        } catch (NullPointerException success) {}
145      }
146  
148 –
147      /**
148       * Offer returns true
149       */
# Line 174 | Line 172 | public class ConcurrentLinkedQueueTest e
172              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
173              q.addAll(null);
174              shouldThrow();
175 <        }
178 <        catch (NullPointerException success) {}
175 >        } catch (NullPointerException success) {}
176      }
177  
178      /**
# Line 186 | Line 183 | public class ConcurrentLinkedQueueTest e
183              ConcurrentLinkedQueue q = populatedQueue(SIZE);
184              q.addAll(q);
185              shouldThrow();
186 <        }
190 <        catch (IllegalArgumentException success) {}
186 >        } catch (IllegalArgumentException success) {}
187      }
188  
189      /**
# Line 199 | Line 195 | public class ConcurrentLinkedQueueTest e
195              Integer[] ints = new Integer[SIZE];
196              q.addAll(Arrays.asList(ints));
197              shouldThrow();
198 <        }
203 <        catch (NullPointerException success) {}
198 >        } catch (NullPointerException success) {}
199      }
200 +
201      /**
202 <     *  addAll of a collection with any null elements throws NPE after
202 >     * addAll of a collection with any null elements throws NPE after
203       * possibly adding some elements
204       */
205      public void testAddAll3() {
# Line 214 | Line 210 | public class ConcurrentLinkedQueueTest e
210                  ints[i] = new Integer(i);
211              q.addAll(Arrays.asList(ints));
212              shouldThrow();
213 <        }
218 <        catch (NullPointerException success) {}
213 >        } catch (NullPointerException success) {}
214      }
215  
216      /**
217       * Queue contains all elements, in traversal order, of successful addAll
218       */
219      public void testAddAll5() {
220 <        try {
221 <            Integer[] empty = new Integer[0];
222 <            Integer[] ints = new Integer[SIZE];
223 <            for (int i = 0; i < SIZE; ++i)
224 <                ints[i] = new Integer(i);
225 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
226 <            assertFalse(q.addAll(Arrays.asList(empty)));
227 <            assertTrue(q.addAll(Arrays.asList(ints)));
228 <            for (int i = 0; i < SIZE; ++i)
234 <                assertEquals(ints[i], q.poll());
235 <        }
236 <        finally {}
220 >        Integer[] empty = new Integer[0];
221 >        Integer[] ints = new Integer[SIZE];
222 >        for (int i = 0; i < SIZE; ++i)
223 >            ints[i] = new Integer(i);
224 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
225 >        assertFalse(q.addAll(Arrays.asList(empty)));
226 >        assertTrue(q.addAll(Arrays.asList(ints)));
227 >        for (int i = 0; i < SIZE; ++i)
228 >            assertEquals(ints[i], q.poll());
229      }
230  
231      /**
# Line 242 | Line 234 | public class ConcurrentLinkedQueueTest e
234      public void testPoll() {
235          ConcurrentLinkedQueue q = populatedQueue(SIZE);
236          for (int i = 0; i < SIZE; ++i) {
237 <            assertEquals(i, ((Integer)q.poll()).intValue());
237 >            assertEquals(i, q.poll());
238          }
239 <        assertNull(q.poll());
239 >        assertNull(q.poll());
240      }
241  
242      /**
# Line 253 | Line 245 | public class ConcurrentLinkedQueueTest e
245      public void testPeek() {
246          ConcurrentLinkedQueue q = populatedQueue(SIZE);
247          for (int i = 0; i < SIZE; ++i) {
248 <            assertEquals(i, ((Integer)q.peek()).intValue());
249 <            q.poll();
248 >            assertEquals(i, q.peek());
249 >            assertEquals(i, q.poll());
250              assertTrue(q.peek() == null ||
251 <                       i != ((Integer)q.peek()).intValue());
251 >                       !q.peek().equals(i));
252          }
253 <        assertNull(q.peek());
253 >        assertNull(q.peek());
254      }
255  
256      /**
# Line 267 | Line 259 | public class ConcurrentLinkedQueueTest e
259      public void testElement() {
260          ConcurrentLinkedQueue q = populatedQueue(SIZE);
261          for (int i = 0; i < SIZE; ++i) {
262 <            assertEquals(i, ((Integer)q.element()).intValue());
263 <            q.poll();
262 >            assertEquals(i, q.element());
263 >            assertEquals(i, q.poll());
264          }
265          try {
266              q.element();
267              shouldThrow();
268 <        }
277 <        catch (NoSuchElementException success) {}
268 >        } catch (NoSuchElementException success) {}
269      }
270  
271      /**
272 <     *  remove removes next element, or throws NSEE if empty
272 >     * remove removes next element, or throws NSEE if empty
273       */
274      public void testRemove() {
275          ConcurrentLinkedQueue q = populatedQueue(SIZE);
276          for (int i = 0; i < SIZE; ++i) {
277 <            assertEquals(i, ((Integer)q.remove()).intValue());
277 >            assertEquals(i, q.remove());
278          }
279          try {
280              q.remove();
281              shouldThrow();
282 <        } catch (NoSuchElementException success){
292 <        }  
282 >        } catch (NoSuchElementException success) {}
283      }
284  
285      /**
# Line 297 | Line 287 | public class ConcurrentLinkedQueueTest e
287       */
288      public void testRemoveElement() {
289          ConcurrentLinkedQueue q = populatedQueue(SIZE);
290 <        for (int i = 1; i < SIZE; i+=2) {
291 <            assertTrue(q.remove(new Integer(i)));
292 <        }
293 <        for (int i = 0; i < SIZE; i+=2) {
294 <            assertTrue(q.remove(new Integer(i)));
295 <            assertFalse(q.remove(new Integer(i+1)));
290 >        for (int i = 1; i < SIZE; i += 2) {
291 >            assertTrue(q.contains(i));
292 >            assertTrue(q.remove(i));
293 >            assertFalse(q.contains(i));
294 >            assertTrue(q.contains(i-1));
295 >        }
296 >        for (int i = 0; i < SIZE; i += 2) {
297 >            assertTrue(q.contains(i));
298 >            assertTrue(q.remove(i));
299 >            assertFalse(q.contains(i));
300 >            assertFalse(q.remove(i+1));
301 >            assertFalse(q.contains(i+1));
302          }
303          assertTrue(q.isEmpty());
304      }
305 <        
305 >
306      /**
307       * contains(x) reports true when elements added but not yet removed
308       */
# Line 376 | Line 372 | public class ConcurrentLinkedQueueTest e
372              assertTrue(q.removeAll(p));
373              assertEquals(SIZE-i, q.size());
374              for (int j = 0; j < i; ++j) {
375 <                Integer I = (Integer)(p.remove());
376 <                assertFalse(q.contains(I));
375 >                Integer x = (Integer)(p.remove());
376 >                assertFalse(q.contains(x));
377              }
378          }
379      }
380  
381      /**
382 <     * toArray contains all elements
382 >     * toArray contains all elements in FIFO order
383       */
384      public void testToArray() {
385          ConcurrentLinkedQueue q = populatedQueue(SIZE);
386 <        Object[] o = q.toArray();
387 <        Arrays.sort(o);
388 <        for(int i = 0; i < o.length; i++)
393 <            assertEquals(o[i], q.poll());
386 >        Object[] o = q.toArray();
387 >        for (int i = 0; i < o.length; i++)
388 >            assertSame(o[i], q.poll());
389      }
390  
391      /**
392 <     *  toArray(a) contains all elements
392 >     * toArray(a) contains all elements in FIFO order
393       */
394      public void testToArray2() {
395 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
396 <        Integer[] ints = new Integer[SIZE];
397 <        ints = (Integer[])q.toArray(ints);
398 <        Arrays.sort(ints);
399 <        for(int i = 0; i < ints.length; i++)
400 <            assertEquals(ints[i], q.poll());
395 >        ConcurrentLinkedQueue<Integer> q = populatedQueue(SIZE);
396 >        Integer[] ints = new Integer[SIZE];
397 >        Integer[] array = q.toArray(ints);
398 >        assertSame(ints, array);
399 >        for (int i = 0; i < ints.length; i++)
400 >            assertSame(ints[i], q.poll());
401      }
402  
403      /**
404 <     * toArray(null) throws NPE
404 >     * toArray(null) throws NullPointerException
405       */
406 <    public void testToArray_BadArg() {
407 <        try {
408 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
409 <            Object o[] = q.toArray(null);
410 <            shouldThrow();
411 <        } catch(NullPointerException success){}
406 >    public void testToArray_NullArg() {
407 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
408 >        try {
409 >            q.toArray(null);
410 >            shouldThrow();
411 >        } catch (NullPointerException success) {}
412      }
413  
414      /**
415 <     * toArray with incompatible array type throws CCE
415 >     * toArray(incompatible array type) throws ArrayStoreException
416       */
417      public void testToArray1_BadArg() {
418 <        try {
419 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
420 <            Object o[] = q.toArray(new String[10] );
421 <            shouldThrow();
422 <        } catch(ArrayStoreException  success){}
418 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
419 >        try {
420 >            q.toArray(new String[10]);
421 >            shouldThrow();
422 >        } catch (ArrayStoreException success) {}
423      }
424 <    
424 >
425      /**
426 <     *  iterator iterates through all elements
426 >     * iterator iterates through all elements
427       */
428      public void testIterator() {
429          ConcurrentLinkedQueue q = populatedQueue(SIZE);
430 <        int i = 0;
431 <        Iterator it = q.iterator();
432 <        while(it.hasNext()) {
430 >        Iterator it = q.iterator();
431 >        int i;
432 >        for (i = 0; it.hasNext(); i++)
433              assertTrue(q.contains(it.next()));
439 –            ++i;
440 –        }
434          assertEquals(i, SIZE);
435 +        assertIteratorExhausted(it);
436 +    }
437 +
438 +    /**
439 +     * iterator of empty collection has no elements
440 +     */
441 +    public void testEmptyIterator() {
442 +        assertIteratorExhausted(new ConcurrentLinkedQueue().iterator());
443      }
444  
445      /**
# Line 452 | Line 453 | public class ConcurrentLinkedQueueTest e
453  
454          int k = 0;
455          for (Iterator it = q.iterator(); it.hasNext();) {
456 <            int i = ((Integer)(it.next())).intValue();
456 <            assertEquals(++k, i);
456 >            assertEquals(++k, it.next());
457          }
458  
459          assertEquals(3, k);
# Line 462 | Line 462 | public class ConcurrentLinkedQueueTest e
462      /**
463       * Modifications do not cause iterators to fail
464       */
465 <    public void testWeaklyConsistentIteration () {
465 >    public void testWeaklyConsistentIteration() {
466          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
467          q.add(one);
468          q.add(two);
469          q.add(three);
470  
471 <        try {
472 <            for (Iterator it = q.iterator(); it.hasNext();) {
473 <                q.remove();
474 <                it.next();
475 <            }
476 <        }
477 <        catch (ConcurrentModificationException e) {
478 <            shouldThrow();
471 >        for (Iterator it = q.iterator(); it.hasNext();) {
472 >            q.remove();
473 >            it.next();
474          }
475  
476          assertEquals("queue should be empty again", 0, q.size());
# Line 484 | Line 479 | public class ConcurrentLinkedQueueTest e
479      /**
480       * iterator.remove removes current element
481       */
482 <    public void testIteratorRemove () {
482 >    public void testIteratorRemove() {
483          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
484          q.add(one);
485          q.add(two);
# Line 493 | Line 488 | public class ConcurrentLinkedQueueTest e
488          it.next();
489          it.remove();
490          it = q.iterator();
491 <        assertEquals(it.next(), two);
492 <        assertEquals(it.next(), three);
491 >        assertSame(it.next(), two);
492 >        assertSame(it.next(), three);
493          assertFalse(it.hasNext());
494      }
495  
501 –
496      /**
497       * toString contains toStrings of elements
498       */
# Line 506 | Line 500 | public class ConcurrentLinkedQueueTest e
500          ConcurrentLinkedQueue q = populatedQueue(SIZE);
501          String s = q.toString();
502          for (int i = 0; i < SIZE; ++i) {
503 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
503 >            assertTrue(s.contains(String.valueOf(i)));
504          }
505 <    }        
505 >    }
506  
507      /**
508       * A deserialized serialized queue has same elements in same order
509       */
510 <    public void testSerialization() {
511 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
512 <        try {
513 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
514 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
515 <            out.writeObject(q);
516 <            out.close();
517 <
518 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
519 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
520 <            ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
527 <            assertEquals(q.size(), r.size());
528 <            while (!q.isEmpty())
529 <                assertEquals(q.remove(), r.remove());
530 <        } catch(Exception e){
531 <            unexpectedException();
510 >    public void testSerialization() throws Exception {
511 >        Queue x = populatedQueue(SIZE);
512 >        Queue y = serialClone(x);
513 >
514 >        assertNotSame(x, y);
515 >        assertEquals(x.size(), y.size());
516 >        assertEquals(x.toString(), y.toString());
517 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
518 >        while (!x.isEmpty()) {
519 >            assertFalse(y.isEmpty());
520 >            assertEquals(x.remove(), y.remove());
521          }
522 +        assertTrue(y.isEmpty());
523      }
524  
525 +    /**
526 +     * remove(null), contains(null) always return false
527 +     */
528 +    public void testNeverContainsNull() {
529 +        Collection<?>[] qs = {
530 +            new ConcurrentLinkedQueue<Object>(),
531 +            populatedQueue(2),
532 +        };
533 +
534 +        for (Collection<?> q : qs) {
535 +            assertFalse(q.contains(null));
536 +            assertFalse(q.remove(null));
537 +        }
538 +    }
539   }

Diff Legend

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