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.5 by dl, Sun Oct 5 23:00:40 2003 UTC vs.
Revision 1.31 by jsr166, Sun Nov 23 22:27:06 2014 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
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/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.*;
10 > import java.util.Arrays;
11 > import java.util.Collection;
12 > import java.util.Iterator;
13 > import java.util.NoSuchElementException;
14 > import java.util.Queue;
15 > import java.util.concurrent.ConcurrentLinkedQueue;
16  
17   public class ConcurrentLinkedQueueTest extends JSR166TestCase {
18  
19      public static void main(String[] args) {
20 <        junit.textui.TestRunner.run (suite());  
20 >        junit.textui.TestRunner.run(suite());
21      }
22  
23      public static Test suite() {
24 <        return new TestSuite(ConcurrentLinkedQueueTest.class);
24 >        return new TestSuite(ConcurrentLinkedQueueTest.class);
25      }
26  
27      /**
28 <     * Create a queue of given size containing consecutive
28 >     * Returns a new queue of given size containing consecutive
29       * Integers 0 ... n.
30       */
31 <    private ConcurrentLinkedQueue populatedQueue(int n) {
32 <        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
31 >    private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
32 >        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
33          assertTrue(q.isEmpty());
34 <        for(int i = 0; i < n; ++i)
35 <            assertTrue(q.offer(new Integer(i)));
34 >        for (int i = 0; i < n; ++i)
35 >            assertTrue(q.offer(new Integer(i)));
36          assertFalse(q.isEmpty());
37 <        assertEquals(n, q.size());
37 >        assertEquals(n, q.size());
38          return q;
39      }
40 <
40 >
41      /**
42       * new queue is empty
43       */
# Line 42 | Line 46 | public class ConcurrentLinkedQueueTest e
46      }
47  
48      /**
49 <     *  Initializing from null Collection throws NPE
49 >     * Initializing from null Collection throws NPE
50       */
51      public void testConstructor3() {
52          try {
53              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
54              shouldThrow();
55 <        }
52 <        catch (NullPointerException success) {}
55 >        } catch (NullPointerException success) {}
56      }
57  
58      /**
# Line 60 | Line 63 | public class ConcurrentLinkedQueueTest e
63              Integer[] ints = new Integer[SIZE];
64              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
65              shouldThrow();
66 <        }
64 <        catch (NullPointerException success) {}
66 >        } catch (NullPointerException success) {}
67      }
68  
69      /**
# Line 74 | Line 76 | public class ConcurrentLinkedQueueTest e
76                  ints[i] = new Integer(i);
77              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
78              shouldThrow();
79 <        }
78 <        catch (NullPointerException success) {}
79 >        } catch (NullPointerException success) {}
80      }
81  
82      /**
83       * Queue contains all elements of collection used to initialize
84       */
85      public void testConstructor6() {
86 <        try {
87 <            Integer[] ints = new Integer[SIZE];
88 <            for (int i = 0; i < SIZE; ++i)
89 <                ints[i] = new Integer(i);
90 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
91 <            for (int i = 0; i < SIZE; ++i)
91 <                assertEquals(ints[i], q.poll());
92 <        }
93 <        finally {}
86 >        Integer[] ints = new Integer[SIZE];
87 >        for (int i = 0; i < SIZE; ++i)
88 >            ints[i] = new Integer(i);
89 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
90 >        for (int i = 0; i < SIZE; ++i)
91 >            assertEquals(ints[i], q.poll());
92      }
93  
94      /**
# Line 126 | Line 124 | public class ConcurrentLinkedQueueTest e
124       * offer(null) throws NPE
125       */
126      public void testOfferNull() {
127 <        try {
127 >        try {
128              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
129              q.offer(null);
130              shouldThrow();
131 <        } catch (NullPointerException success) { }  
131 >        } catch (NullPointerException success) {}
132      }
133  
134      /**
135       * add(null) throws NPE
136       */
137      public void testAddNull() {
138 <        try {
138 >        try {
139              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
140              q.add(null);
141              shouldThrow();
142 <        } catch (NullPointerException success) { }  
142 >        } catch (NullPointerException success) {}
143      }
144  
147 –
145      /**
146       * Offer returns true
147       */
# Line 173 | Line 170 | public class ConcurrentLinkedQueueTest e
170              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
171              q.addAll(null);
172              shouldThrow();
173 <        }
177 <        catch (NullPointerException success) {}
173 >        } catch (NullPointerException success) {}
174      }
175  
176      /**
# Line 185 | Line 181 | public class ConcurrentLinkedQueueTest e
181              ConcurrentLinkedQueue q = populatedQueue(SIZE);
182              q.addAll(q);
183              shouldThrow();
184 <        }
189 <        catch (IllegalArgumentException success) {}
184 >        } catch (IllegalArgumentException success) {}
185      }
186  
187      /**
# Line 198 | Line 193 | public class ConcurrentLinkedQueueTest e
193              Integer[] ints = new Integer[SIZE];
194              q.addAll(Arrays.asList(ints));
195              shouldThrow();
196 <        }
202 <        catch (NullPointerException success) {}
196 >        } catch (NullPointerException success) {}
197      }
198 +
199      /**
200 <     *  addAll of a collection with any null elements throws NPE after
200 >     * addAll of a collection with any null elements throws NPE after
201       * possibly adding some elements
202       */
203      public void testAddAll3() {
# Line 213 | Line 208 | public class ConcurrentLinkedQueueTest e
208                  ints[i] = new Integer(i);
209              q.addAll(Arrays.asList(ints));
210              shouldThrow();
211 <        }
217 <        catch (NullPointerException success) {}
211 >        } catch (NullPointerException success) {}
212      }
213  
214      /**
215       * Queue contains all elements, in traversal order, of successful addAll
216       */
217      public void testAddAll5() {
218 <        try {
219 <            Integer[] empty = new Integer[0];
220 <            Integer[] ints = new Integer[SIZE];
221 <            for (int i = 0; i < SIZE; ++i)
222 <                ints[i] = new Integer(i);
223 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
224 <            assertFalse(q.addAll(Arrays.asList(empty)));
225 <            assertTrue(q.addAll(Arrays.asList(ints)));
226 <            for (int i = 0; i < SIZE; ++i)
233 <                assertEquals(ints[i], q.poll());
234 <        }
235 <        finally {}
218 >        Integer[] empty = new Integer[0];
219 >        Integer[] ints = new Integer[SIZE];
220 >        for (int i = 0; i < SIZE; ++i)
221 >            ints[i] = new Integer(i);
222 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
223 >        assertFalse(q.addAll(Arrays.asList(empty)));
224 >        assertTrue(q.addAll(Arrays.asList(ints)));
225 >        for (int i = 0; i < SIZE; ++i)
226 >            assertEquals(ints[i], q.poll());
227      }
228  
229      /**
# Line 241 | Line 232 | public class ConcurrentLinkedQueueTest e
232      public void testPoll() {
233          ConcurrentLinkedQueue q = populatedQueue(SIZE);
234          for (int i = 0; i < SIZE; ++i) {
235 <            assertEquals(i, ((Integer)q.poll()).intValue());
235 >            assertEquals(i, q.poll());
236          }
237 <        assertNull(q.poll());
237 >        assertNull(q.poll());
238      }
239  
240      /**
# Line 252 | Line 243 | public class ConcurrentLinkedQueueTest e
243      public void testPeek() {
244          ConcurrentLinkedQueue q = populatedQueue(SIZE);
245          for (int i = 0; i < SIZE; ++i) {
246 <            assertEquals(i, ((Integer)q.peek()).intValue());
247 <            q.poll();
246 >            assertEquals(i, q.peek());
247 >            assertEquals(i, q.poll());
248              assertTrue(q.peek() == null ||
249 <                       i != ((Integer)q.peek()).intValue());
249 >                       !q.peek().equals(i));
250          }
251 <        assertNull(q.peek());
251 >        assertNull(q.peek());
252      }
253  
254      /**
# Line 266 | Line 257 | public class ConcurrentLinkedQueueTest e
257      public void testElement() {
258          ConcurrentLinkedQueue q = populatedQueue(SIZE);
259          for (int i = 0; i < SIZE; ++i) {
260 <            assertEquals(i, ((Integer)q.element()).intValue());
261 <            q.poll();
260 >            assertEquals(i, q.element());
261 >            assertEquals(i, q.poll());
262          }
263          try {
264              q.element();
265              shouldThrow();
266 <        }
276 <        catch (NoSuchElementException success) {}
266 >        } catch (NoSuchElementException success) {}
267      }
268  
269      /**
270 <     *  remove removes next element, or throws NSEE if empty
270 >     * remove removes next element, or throws NSEE if empty
271       */
272      public void testRemove() {
273          ConcurrentLinkedQueue q = populatedQueue(SIZE);
274          for (int i = 0; i < SIZE; ++i) {
275 <            assertEquals(i, ((Integer)q.remove()).intValue());
275 >            assertEquals(i, q.remove());
276          }
277          try {
278              q.remove();
279              shouldThrow();
280 <        } catch (NoSuchElementException success){
291 <        }  
280 >        } catch (NoSuchElementException success) {}
281      }
282  
283      /**
# Line 297 | Line 286 | public class ConcurrentLinkedQueueTest e
286      public void testRemoveElement() {
287          ConcurrentLinkedQueue q = populatedQueue(SIZE);
288          for (int i = 1; i < SIZE; i+=2) {
289 <            assertTrue(q.remove(new Integer(i)));
289 >            assertTrue(q.contains(i));
290 >            assertTrue(q.remove(i));
291 >            assertFalse(q.contains(i));
292 >            assertTrue(q.contains(i-1));
293          }
294          for (int i = 0; i < SIZE; i+=2) {
295 <            assertTrue(q.remove(new Integer(i)));
296 <            assertFalse(q.remove(new Integer(i+1)));
295 >            assertTrue(q.contains(i));
296 >            assertTrue(q.remove(i));
297 >            assertFalse(q.contains(i));
298 >            assertFalse(q.remove(i+1));
299 >            assertFalse(q.contains(i+1));
300          }
301          assertTrue(q.isEmpty());
302      }
303 <        
303 >
304      /**
305       * contains(x) reports true when elements added but not yet removed
306       */
# Line 382 | Line 377 | public class ConcurrentLinkedQueueTest e
377      }
378  
379      /**
380 <     * toArray contains all elements
380 >     * toArray contains all elements in FIFO order
381       */
382      public void testToArray() {
383          ConcurrentLinkedQueue q = populatedQueue(SIZE);
384 <        Object[] o = q.toArray();
385 <        Arrays.sort(o);
386 <        for(int i = 0; i < o.length; i++)
392 <            assertEquals(o[i], q.poll());
384 >        Object[] o = q.toArray();
385 >        for (int i = 0; i < o.length; i++)
386 >            assertSame(o[i], q.poll());
387      }
388  
389      /**
390 <     *  toArray(a) contains all elements
390 >     * toArray(a) contains all elements in FIFO order
391       */
392      public void testToArray2() {
393 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
394 <        Integer[] ints = new Integer[SIZE];
395 <        ints = (Integer[])q.toArray(ints);
396 <        Arrays.sort(ints);
397 <        for(int i = 0; i < ints.length; i++)
398 <            assertEquals(ints[i], q.poll());
393 >        ConcurrentLinkedQueue<Integer> q = populatedQueue(SIZE);
394 >        Integer[] ints = new Integer[SIZE];
395 >        Integer[] array = q.toArray(ints);
396 >        assertSame(ints, array);
397 >        for (int i = 0; i < ints.length; i++)
398 >            assertSame(ints[i], q.poll());
399      }
400  
401      /**
402 <     * toArray(null) throws NPE
402 >     * toArray(null) throws NullPointerException
403       */
404 <    public void testToArray_BadArg() {
405 <        try {
406 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
407 <            Object o[] = q.toArray(null);
408 <            shouldThrow();
409 <        } catch(NullPointerException success){}
404 >    public void testToArray_NullArg() {
405 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
406 >        try {
407 >            q.toArray(null);
408 >            shouldThrow();
409 >        } catch (NullPointerException success) {}
410      }
411  
412      /**
413 <     * toArray with incompatable array type throws CCE
413 >     * toArray(incompatible array type) throws ArrayStoreException
414       */
415      public void testToArray1_BadArg() {
416 <        try {
417 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
418 <            Object o[] = q.toArray(new String[10] );
419 <            shouldThrow();
420 <        } catch(ArrayStoreException  success){}
416 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
417 >        try {
418 >            q.toArray(new String[10]);
419 >            shouldThrow();
420 >        } catch (ArrayStoreException success) {}
421      }
422 <    
422 >
423      /**
424 <     *  iterator iterates through all elements
424 >     * iterator iterates through all elements
425       */
426      public void testIterator() {
427          ConcurrentLinkedQueue q = populatedQueue(SIZE);
428          int i = 0;
429 <        Iterator it = q.iterator();
430 <        while(it.hasNext()) {
429 >        Iterator it = q.iterator();
430 >        while (it.hasNext()) {
431              assertTrue(q.contains(it.next()));
432              ++i;
433          }
# Line 451 | Line 445 | public class ConcurrentLinkedQueueTest e
445  
446          int k = 0;
447          for (Iterator it = q.iterator(); it.hasNext();) {
448 <            int i = ((Integer)(it.next())).intValue();
455 <            assertEquals(++k, i);
448 >            assertEquals(++k, it.next());
449          }
450  
451          assertEquals(3, k);
# Line 461 | Line 454 | public class ConcurrentLinkedQueueTest e
454      /**
455       * Modifications do not cause iterators to fail
456       */
457 <    public void testWeaklyConsistentIteration () {
457 >    public void testWeaklyConsistentIteration() {
458          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
459          q.add(one);
460          q.add(two);
461          q.add(three);
462  
463 <        try {
464 <            for (Iterator it = q.iterator(); it.hasNext();) {
465 <                q.remove();
473 <                it.next();
474 <            }
475 <        }
476 <        catch (ConcurrentModificationException e) {
477 <            shouldThrow();
463 >        for (Iterator it = q.iterator(); it.hasNext();) {
464 >            q.remove();
465 >            it.next();
466          }
467  
468          assertEquals("queue should be empty again", 0, q.size());
# Line 483 | Line 471 | public class ConcurrentLinkedQueueTest e
471      /**
472       * iterator.remove removes current element
473       */
474 <    public void testIteratorRemove () {
474 >    public void testIteratorRemove() {
475          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
476          q.add(one);
477          q.add(two);
# Line 492 | Line 480 | public class ConcurrentLinkedQueueTest e
480          it.next();
481          it.remove();
482          it = q.iterator();
483 <        assertEquals(it.next(), two);
484 <        assertEquals(it.next(), three);
483 >        assertSame(it.next(), two);
484 >        assertSame(it.next(), three);
485          assertFalse(it.hasNext());
486      }
487  
500 –
488      /**
489       * toString contains toStrings of elements
490       */
# Line 505 | Line 492 | public class ConcurrentLinkedQueueTest e
492          ConcurrentLinkedQueue q = populatedQueue(SIZE);
493          String s = q.toString();
494          for (int i = 0; i < SIZE; ++i) {
495 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
495 >            assertTrue(s.contains(String.valueOf(i)));
496          }
497 <    }        
497 >    }
498  
499      /**
500       * A deserialized serialized queue has same elements in same order
501       */
502 <    public void testSerialization() {
503 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
504 <        try {
505 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
506 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
507 <            out.writeObject(q);
508 <            out.close();
509 <
510 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
511 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
512 <            ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
526 <            assertEquals(q.size(), r.size());
527 <            while (!q.isEmpty())
528 <                assertEquals(q.remove(), r.remove());
529 <        } catch(Exception e){
530 <            unexpectedException();
502 >    public void testSerialization() throws Exception {
503 >        Queue x = populatedQueue(SIZE);
504 >        Queue y = serialClone(x);
505 >
506 >        assertNotSame(x, y);
507 >        assertEquals(x.size(), y.size());
508 >        assertEquals(x.toString(), y.toString());
509 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
510 >        while (!x.isEmpty()) {
511 >            assertFalse(y.isEmpty());
512 >            assertEquals(x.remove(), y.remove());
513          }
514 +        assertTrue(y.isEmpty());
515      }
516  
517 +    /**
518 +     * remove(null), contains(null) always return false
519 +     */
520 +    public void testNeverContainsNull() {
521 +        Collection<?>[] qs = {
522 +            new ConcurrentLinkedQueue<Object>(),
523 +            populatedQueue(2),
524 +        };
525 +
526 +        for (Collection<?> q : qs) {
527 +            assertFalse(q.contains(null));
528 +            assertFalse(q.remove(null));
529 +        }
530 +    }
531   }

Diff Legend

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