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.24 by jsr166, Thu Nov 18 20:21:53 2010 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/licenses/publicdomain
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
# Line 13 | Line 14 | import java.io.*;
14   public class ConcurrentLinkedQueueTest extends JSR166TestCase {
15  
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run (suite());  
17 >        junit.textui.TestRunner.run(suite());
18      }
19  
20      public static Test suite() {
21 <        return new TestSuite(ConcurrentLinkedQueueTest.class);
21 >        return new TestSuite(ConcurrentLinkedQueueTest.class);
22      }
23  
24      /**
25       * Create a queue of given size containing consecutive
26       * Integers 0 ... n.
27       */
28 <    private ConcurrentLinkedQueue populatedQueue(int n) {
29 <        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
28 >    private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
29 >        ConcurrentLinkedQueue<Integer> q = new ConcurrentLinkedQueue<Integer>();
30          assertTrue(q.isEmpty());
31 <        for(int i = 0; i < n; ++i)
32 <            assertTrue(q.offer(new Integer(i)));
31 >        for (int i = 0; i < n; ++i)
32 >            assertTrue(q.offer(new Integer(i)));
33          assertFalse(q.isEmpty());
34 <        assertEquals(n, q.size());
34 >        assertEquals(n, q.size());
35          return q;
36      }
37 <
37 >
38      /**
39       * new queue is empty
40       */
# Line 42 | Line 43 | public class ConcurrentLinkedQueueTest e
43      }
44  
45      /**
46 <     *  Initializing from null Collection throws NPE
46 >     * Initializing from null Collection throws NPE
47       */
48      public void testConstructor3() {
49          try {
50              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
51              shouldThrow();
52 <        }
52 <        catch (NullPointerException success) {}
52 >        } catch (NullPointerException success) {}
53      }
54  
55      /**
# Line 60 | Line 60 | public class ConcurrentLinkedQueueTest e
60              Integer[] ints = new Integer[SIZE];
61              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
62              shouldThrow();
63 <        }
64 <        catch (NullPointerException success) {}
63 >        } catch (NullPointerException success) {}
64      }
65  
66      /**
# Line 74 | Line 73 | public class ConcurrentLinkedQueueTest e
73                  ints[i] = new Integer(i);
74              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
75              shouldThrow();
76 <        }
78 <        catch (NullPointerException success) {}
76 >        } catch (NullPointerException success) {}
77      }
78  
79      /**
80       * Queue contains all elements of collection used to initialize
81       */
82      public void testConstructor6() {
83 <        try {
84 <            Integer[] ints = new Integer[SIZE];
85 <            for (int i = 0; i < SIZE; ++i)
86 <                ints[i] = new Integer(i);
87 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
88 <            for (int i = 0; i < SIZE; ++i)
91 <                assertEquals(ints[i], q.poll());
92 <        }
93 <        finally {}
83 >        Integer[] ints = new Integer[SIZE];
84 >        for (int i = 0; i < SIZE; ++i)
85 >            ints[i] = new Integer(i);
86 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
87 >        for (int i = 0; i < SIZE; ++i)
88 >            assertEquals(ints[i], q.poll());
89      }
90  
91      /**
# Line 126 | Line 121 | public class ConcurrentLinkedQueueTest e
121       * offer(null) throws NPE
122       */
123      public void testOfferNull() {
124 <        try {
124 >        try {
125              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
126              q.offer(null);
127              shouldThrow();
128 <        } catch (NullPointerException success) { }  
128 >        } catch (NullPointerException success) {}
129      }
130  
131      /**
132       * add(null) throws NPE
133       */
134      public void testAddNull() {
135 <        try {
135 >        try {
136              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
137              q.add(null);
138              shouldThrow();
139 <        } catch (NullPointerException success) { }  
139 >        } catch (NullPointerException success) {}
140      }
141  
142  
# Line 173 | Line 168 | public class ConcurrentLinkedQueueTest e
168              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
169              q.addAll(null);
170              shouldThrow();
171 <        }
177 <        catch (NullPointerException success) {}
171 >        } catch (NullPointerException success) {}
172      }
173  
174      /**
# Line 185 | Line 179 | public class ConcurrentLinkedQueueTest e
179              ConcurrentLinkedQueue q = populatedQueue(SIZE);
180              q.addAll(q);
181              shouldThrow();
182 <        }
189 <        catch (IllegalArgumentException success) {}
182 >        } catch (IllegalArgumentException success) {}
183      }
184  
185      /**
# Line 198 | Line 191 | public class ConcurrentLinkedQueueTest e
191              Integer[] ints = new Integer[SIZE];
192              q.addAll(Arrays.asList(ints));
193              shouldThrow();
194 <        }
202 <        catch (NullPointerException success) {}
194 >        } catch (NullPointerException success) {}
195      }
196 +
197      /**
198 <     *  addAll of a collection with any null elements throws NPE after
198 >     * addAll of a collection with any null elements throws NPE after
199       * possibly adding some elements
200       */
201      public void testAddAll3() {
# Line 213 | Line 206 | public class ConcurrentLinkedQueueTest e
206                  ints[i] = new Integer(i);
207              q.addAll(Arrays.asList(ints));
208              shouldThrow();
209 <        }
217 <        catch (NullPointerException success) {}
209 >        } catch (NullPointerException success) {}
210      }
211  
212      /**
213       * Queue contains all elements, in traversal order, of successful addAll
214       */
215      public void testAddAll5() {
216 <        try {
217 <            Integer[] empty = new Integer[0];
218 <            Integer[] ints = new Integer[SIZE];
219 <            for (int i = 0; i < SIZE; ++i)
220 <                ints[i] = new Integer(i);
221 <            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
222 <            assertFalse(q.addAll(Arrays.asList(empty)));
223 <            assertTrue(q.addAll(Arrays.asList(ints)));
224 <            for (int i = 0; i < SIZE; ++i)
233 <                assertEquals(ints[i], q.poll());
234 <        }
235 <        finally {}
216 >        Integer[] empty = new Integer[0];
217 >        Integer[] ints = new Integer[SIZE];
218 >        for (int i = 0; i < SIZE; ++i)
219 >            ints[i] = new Integer(i);
220 >        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
221 >        assertFalse(q.addAll(Arrays.asList(empty)));
222 >        assertTrue(q.addAll(Arrays.asList(ints)));
223 >        for (int i = 0; i < SIZE; ++i)
224 >            assertEquals(ints[i], q.poll());
225      }
226  
227      /**
# Line 241 | Line 230 | public class ConcurrentLinkedQueueTest e
230      public void testPoll() {
231          ConcurrentLinkedQueue q = populatedQueue(SIZE);
232          for (int i = 0; i < SIZE; ++i) {
233 <            assertEquals(i, ((Integer)q.poll()).intValue());
233 >            assertEquals(i, q.poll());
234          }
235 <        assertNull(q.poll());
235 >        assertNull(q.poll());
236      }
237  
238      /**
# Line 252 | Line 241 | public class ConcurrentLinkedQueueTest e
241      public void testPeek() {
242          ConcurrentLinkedQueue q = populatedQueue(SIZE);
243          for (int i = 0; i < SIZE; ++i) {
244 <            assertEquals(i, ((Integer)q.peek()).intValue());
245 <            q.poll();
244 >            assertEquals(i, q.peek());
245 >            assertEquals(i, q.poll());
246              assertTrue(q.peek() == null ||
247 <                       i != ((Integer)q.peek()).intValue());
247 >                       !q.peek().equals(i));
248          }
249 <        assertNull(q.peek());
249 >        assertNull(q.peek());
250      }
251  
252      /**
# Line 266 | Line 255 | public class ConcurrentLinkedQueueTest e
255      public void testElement() {
256          ConcurrentLinkedQueue q = populatedQueue(SIZE);
257          for (int i = 0; i < SIZE; ++i) {
258 <            assertEquals(i, ((Integer)q.element()).intValue());
259 <            q.poll();
258 >            assertEquals(i, q.element());
259 >            assertEquals(i, q.poll());
260          }
261          try {
262              q.element();
263              shouldThrow();
264 <        }
276 <        catch (NoSuchElementException success) {}
264 >        } catch (NoSuchElementException success) {}
265      }
266  
267      /**
268 <     *  remove removes next element, or throws NSEE if empty
268 >     * remove removes next element, or throws NSEE if empty
269       */
270      public void testRemove() {
271          ConcurrentLinkedQueue q = populatedQueue(SIZE);
272          for (int i = 0; i < SIZE; ++i) {
273 <            assertEquals(i, ((Integer)q.remove()).intValue());
273 >            assertEquals(i, q.remove());
274          }
275          try {
276              q.remove();
277              shouldThrow();
278 <        } catch (NoSuchElementException success){
291 <        }  
278 >        } catch (NoSuchElementException success) {}
279      }
280  
281      /**
# Line 297 | Line 284 | public class ConcurrentLinkedQueueTest e
284      public void testRemoveElement() {
285          ConcurrentLinkedQueue q = populatedQueue(SIZE);
286          for (int i = 1; i < SIZE; i+=2) {
287 <            assertTrue(q.remove(new Integer(i)));
287 >            assertTrue(q.contains(i));
288 >            assertTrue(q.remove(i));
289 >            assertFalse(q.contains(i));
290 >            assertTrue(q.contains(i-1));
291          }
292          for (int i = 0; i < SIZE; i+=2) {
293 <            assertTrue(q.remove(new Integer(i)));
294 <            assertFalse(q.remove(new Integer(i+1)));
293 >            assertTrue(q.contains(i));
294 >            assertTrue(q.remove(i));
295 >            assertFalse(q.contains(i));
296 >            assertFalse(q.remove(i+1));
297 >            assertFalse(q.contains(i+1));
298          }
299          assertTrue(q.isEmpty());
300      }
301 <        
301 >
302      /**
303       * contains(x) reports true when elements added but not yet removed
304       */
# Line 382 | Line 375 | public class ConcurrentLinkedQueueTest e
375      }
376  
377      /**
378 <     * toArray contains all elements
378 >     * toArray contains all elements in FIFO order
379       */
380      public void testToArray() {
381          ConcurrentLinkedQueue q = populatedQueue(SIZE);
382 <        Object[] o = q.toArray();
383 <        Arrays.sort(o);
384 <        for(int i = 0; i < o.length; i++)
392 <            assertEquals(o[i], q.poll());
382 >        Object[] o = q.toArray();
383 >        for (int i = 0; i < o.length; i++)
384 >            assertSame(o[i], q.poll());
385      }
386  
387      /**
388 <     *  toArray(a) contains all elements
388 >     * toArray(a) contains all elements in FIFO order
389       */
390      public void testToArray2() {
391 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
392 <        Integer[] ints = new Integer[SIZE];
393 <        ints = (Integer[])q.toArray(ints);
394 <        Arrays.sort(ints);
395 <        for(int i = 0; i < ints.length; i++)
396 <            assertEquals(ints[i], q.poll());
391 >        ConcurrentLinkedQueue<Integer> q = populatedQueue(SIZE);
392 >        Integer[] ints = new Integer[SIZE];
393 >        Integer[] array = q.toArray(ints);
394 >        assertSame(ints, array);
395 >        for (int i = 0; i < ints.length; i++)
396 >            assertSame(ints[i], q.poll());
397      }
398  
399      /**
400 <     * toArray(null) throws NPE
400 >     * toArray(null) throws NullPointerException
401       */
402 <    public void testToArray_BadArg() {
403 <        try {
404 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
405 <            Object o[] = q.toArray(null);
406 <            shouldThrow();
407 <        } catch(NullPointerException success){}
402 >    public void testToArray_NullArg() {
403 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
404 >        try {
405 >            q.toArray(null);
406 >            shouldThrow();
407 >        } catch (NullPointerException success) {}
408      }
409  
410      /**
411 <     * toArray with incompatable array type throws CCE
411 >     * toArray(incompatible array type) throws ArrayStoreException
412       */
413      public void testToArray1_BadArg() {
414 <        try {
415 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
416 <            Object o[] = q.toArray(new String[10] );
417 <            shouldThrow();
418 <        } catch(ArrayStoreException  success){}
414 >        ConcurrentLinkedQueue q = populatedQueue(SIZE);
415 >        try {
416 >            q.toArray(new String[10]);
417 >            shouldThrow();
418 >        } catch (ArrayStoreException success) {}
419      }
420 <    
420 >
421      /**
422 <     *  iterator iterates through all elements
422 >     * iterator iterates through all elements
423       */
424      public void testIterator() {
425          ConcurrentLinkedQueue q = populatedQueue(SIZE);
426          int i = 0;
427 <        Iterator it = q.iterator();
428 <        while(it.hasNext()) {
427 >        Iterator it = q.iterator();
428 >        while (it.hasNext()) {
429              assertTrue(q.contains(it.next()));
430              ++i;
431          }
# Line 451 | Line 443 | public class ConcurrentLinkedQueueTest e
443  
444          int k = 0;
445          for (Iterator it = q.iterator(); it.hasNext();) {
446 <            int i = ((Integer)(it.next())).intValue();
455 <            assertEquals(++k, i);
446 >            assertEquals(++k, it.next());
447          }
448  
449          assertEquals(3, k);
# Line 461 | Line 452 | public class ConcurrentLinkedQueueTest e
452      /**
453       * Modifications do not cause iterators to fail
454       */
455 <    public void testWeaklyConsistentIteration () {
455 >    public void testWeaklyConsistentIteration() {
456          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
457          q.add(one);
458          q.add(two);
459          q.add(three);
460  
461 <        try {
462 <            for (Iterator it = q.iterator(); it.hasNext();) {
463 <                q.remove();
473 <                it.next();
474 <            }
475 <        }
476 <        catch (ConcurrentModificationException e) {
477 <            shouldThrow();
461 >        for (Iterator it = q.iterator(); it.hasNext();) {
462 >            q.remove();
463 >            it.next();
464          }
465  
466          assertEquals("queue should be empty again", 0, q.size());
# Line 483 | Line 469 | public class ConcurrentLinkedQueueTest e
469      /**
470       * iterator.remove removes current element
471       */
472 <    public void testIteratorRemove () {
472 >    public void testIteratorRemove() {
473          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
474          q.add(one);
475          q.add(two);
# Line 492 | Line 478 | public class ConcurrentLinkedQueueTest e
478          it.next();
479          it.remove();
480          it = q.iterator();
481 <        assertEquals(it.next(), two);
482 <        assertEquals(it.next(), three);
481 >        assertSame(it.next(), two);
482 >        assertSame(it.next(), three);
483          assertFalse(it.hasNext());
484      }
485  
# Line 507 | Line 493 | public class ConcurrentLinkedQueueTest e
493          for (int i = 0; i < SIZE; ++i) {
494              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
495          }
496 <    }        
496 >    }
497  
498      /**
499       * A deserialized serialized queue has same elements in same order
500       */
501 <    public void testSerialization() {
501 >    public void testSerialization() throws Exception {
502          ConcurrentLinkedQueue q = populatedQueue(SIZE);
503 <        try {
504 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
505 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
506 <            out.writeObject(q);
507 <            out.close();
508 <
509 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
510 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
511 <            ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
512 <            assertEquals(q.size(), r.size());
513 <            while (!q.isEmpty())
528 <                assertEquals(q.remove(), r.remove());
529 <        } catch(Exception e){
530 <            unexpectedException();
531 <        }
503 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
504 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
505 >        out.writeObject(q);
506 >        out.close();
507 >
508 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
509 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
510 >        ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
511 >        assertEquals(q.size(), r.size());
512 >        while (!q.isEmpty())
513 >            assertEquals(q.remove(), r.remove());
514      }
515  
516   }

Diff Legend

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