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.18 by jsr166, Wed Aug 25 01:47:17 2010 UTC

# Line 14 | 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() {
# Line 73 | Line 73 | public class ConcurrentLinkedQueueTest e
73                  ints[i] = new Integer(i);
74              ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
75              shouldThrow();
76 <        }
77 <        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)
90 <                assertEquals(ints[i], q.poll());
91 <        }
92 <        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 197 | Line 193 | public class ConcurrentLinkedQueueTest e
193              shouldThrow();
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 216 | Line 213 | public class ConcurrentLinkedQueueTest e
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)
228 <                assertEquals(ints[i], q.poll());
229 <        }
230 <        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 236 | 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());
236      }
# Line 247 | 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());
250      }
# Line 261 | 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();
# Line 276 | Line 270 | public class ConcurrentLinkedQueueTest e
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();
# Line 401 | Line 395 | public class ConcurrentLinkedQueueTest e
395       * toArray(null) throws NPE
396       */
397      public void testToArray_BadArg() {
398 +        ConcurrentLinkedQueue q = populatedQueue(SIZE);
399          try {
405 –            ConcurrentLinkedQueue q = populatedQueue(SIZE);
400              Object o[] = q.toArray(null);
401              shouldThrow();
402          } catch (NullPointerException success) {}
# Line 412 | Line 406 | public class ConcurrentLinkedQueueTest e
406       * toArray with incompatible array type throws ArrayStoreException
407       */
408      public void testToArray1_BadArg() {
409 +        ConcurrentLinkedQueue q = populatedQueue(SIZE);
410          try {
411 <            ConcurrentLinkedQueue q = populatedQueue(SIZE);
417 <            Object o[] = q.toArray(new String[10] );
411 >            Object o[] = q.toArray(new String[10]);
412              shouldThrow();
413          } catch (ArrayStoreException success) {}
414      }
# Line 444 | Line 438 | public class ConcurrentLinkedQueueTest e
438  
439          int k = 0;
440          for (Iterator it = q.iterator(); it.hasNext();) {
441 <            int i = ((Integer)(it.next())).intValue();
448 <            assertEquals(++k, i);
441 >            assertEquals(++k, it.next());
442          }
443  
444          assertEquals(3, k);
# Line 454 | Line 447 | public class ConcurrentLinkedQueueTest e
447      /**
448       * Modifications do not cause iterators to fail
449       */
450 <    public void testWeaklyConsistentIteration () {
450 >    public void testWeaklyConsistentIteration() {
451          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
452          q.add(one);
453          q.add(two);
# Line 471 | Line 464 | public class ConcurrentLinkedQueueTest e
464      /**
465       * iterator.remove removes current element
466       */
467 <    public void testIteratorRemove () {
467 >    public void testIteratorRemove() {
468          final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
469          q.add(one);
470          q.add(two);
# Line 480 | Line 473 | public class ConcurrentLinkedQueueTest e
473          it.next();
474          it.remove();
475          it = q.iterator();
476 <        assertEquals(it.next(), two);
477 <        assertEquals(it.next(), three);
476 >        assertSame(it.next(), two);
477 >        assertSame(it.next(), three);
478          assertFalse(it.hasNext());
479      }
480  

Diff Legend

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