ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LinkedBlockingQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LinkedBlockingQueueTest.java (file contents):
Revision 1.30 by jsr166, Tue Oct 19 00:41:14 2010 UTC vs.
Revision 1.38 by jsr166, Thu Nov 18 20:21:53 2010 UTC

# Line 41 | Line 41 | public class LinkedBlockingQueueTest ext
41       * Create a queue of given size containing consecutive
42       * Integers 0 ... n.
43       */
44 <    private LinkedBlockingQueue populatedQueue(int n) {
45 <        LinkedBlockingQueue q = new LinkedBlockingQueue(n);
44 >    private LinkedBlockingQueue<Integer> populatedQueue(int n) {
45 >        LinkedBlockingQueue<Integer> q =
46 >            new LinkedBlockingQueue<Integer>(n);
47          assertTrue(q.isEmpty());
48          for (int i = 0; i < n; i++)
49              assertTrue(q.offer(new Integer(i)));
# Line 381 | Line 382 | public class LinkedBlockingQueueTest ext
382      }
383  
384      /**
384 –     * take blocks interruptibly when empty
385 –     */
386 –    public void testTakeFromEmpty() throws InterruptedException {
387 –        final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
388 –        Thread t = new ThreadShouldThrow(InterruptedException.class) {
389 –            public void realRun() throws InterruptedException {
390 –                q.take();
391 –            }};
392 –
393 –        t.start();
394 –        Thread.sleep(SHORT_DELAY_MS);
395 –        t.interrupt();
396 –        t.join();
397 –    }
398 –
399 –    /**
385       * Take removes existing elements until empty, then blocks interruptibly
386       */
387      public void testBlockingTake() throws InterruptedException {
# Line 430 | Line 415 | public class LinkedBlockingQueueTest ext
415      }
416  
417      /**
418 <     * timed pool with zero timeout succeeds when non-empty, else times out
418 >     * timed poll with zero timeout succeeds when non-empty, else times out
419       */
420      public void testTimedPoll0() throws InterruptedException {
421          LinkedBlockingQueue q = populatedQueue(SIZE);
# Line 441 | Line 426 | public class LinkedBlockingQueueTest ext
426      }
427  
428      /**
429 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
429 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
430       */
431      public void testTimedPoll() throws InterruptedException {
432          LinkedBlockingQueue q = populatedQueue(SIZE);
# Line 523 | Line 508 | public class LinkedBlockingQueueTest ext
508      public void testRemoveElement() {
509          LinkedBlockingQueue q = populatedQueue(SIZE);
510          for (int i = 1; i < SIZE; i+=2) {
511 <            assertTrue(q.remove(new Integer(i)));
511 >            assertTrue(q.contains(i));
512 >            assertTrue(q.remove(i));
513 >            assertFalse(q.contains(i));
514 >            assertTrue(q.contains(i-1));
515          }
516          for (int i = 0; i < SIZE; i+=2) {
517 <            assertTrue(q.remove(new Integer(i)));
518 <            assertFalse(q.remove(new Integer(i+1)));
517 >            assertTrue(q.contains(i));
518 >            assertTrue(q.remove(i));
519 >            assertFalse(q.contains(i));
520 >            assertFalse(q.remove(i+1));
521 >            assertFalse(q.contains(i+1));
522          }
523          assertTrue(q.isEmpty());
524      }
# Line 623 | Line 614 | public class LinkedBlockingQueueTest ext
614      }
615  
616      /**
617 <     * toArray contains all elements
617 >     * toArray contains all elements in FIFO order
618       */
619 <    public void testToArray() throws InterruptedException {
619 >    public void testToArray() {
620          LinkedBlockingQueue q = populatedQueue(SIZE);
621          Object[] o = q.toArray();
622          for (int i = 0; i < o.length; i++)
623 <            assertEquals(o[i], q.take());
623 >            assertSame(o[i], q.poll());
624      }
625  
626      /**
627 <     * toArray(a) contains all elements
627 >     * toArray(a) contains all elements in FIFO order
628       */
629      public void testToArray2() throws InterruptedException {
630 <        LinkedBlockingQueue q = populatedQueue(SIZE);
630 >        LinkedBlockingQueue<Integer> q = populatedQueue(SIZE);
631          Integer[] ints = new Integer[SIZE];
632 <        ints = (Integer[])q.toArray(ints);
632 >        Integer[] array = q.toArray(ints);
633 >        assertSame(ints, array);
634          for (int i = 0; i < ints.length; i++)
635 <            assertEquals(ints[i], q.take());
635 >            assertSame(ints[i], q.poll());
636      }
637  
638      /**
639 <     * toArray(null) throws NPE
639 >     * toArray(null) throws NullPointerException
640       */
641 <    public void testToArray_BadArg() {
641 >    public void testToArray_NullArg() {
642          LinkedBlockingQueue q = populatedQueue(SIZE);
643          try {
644 <            Object o[] = q.toArray(null);
644 >            q.toArray(null);
645              shouldThrow();
646          } catch (NullPointerException success) {}
647      }
648  
649      /**
650 <     * toArray with incompatible array type throws CCE
650 >     * toArray(incompatible array type) throws ArrayStoreException
651       */
652      public void testToArray1_BadArg() {
653          LinkedBlockingQueue q = populatedQueue(SIZE);
654          try {
655 <            Object o[] = q.toArray(new String[10]);
655 >            q.toArray(new String[10]);
656              shouldThrow();
657          } catch (ArrayStoreException success) {}
658      }
# Line 904 | Line 896 | public class LinkedBlockingQueueTest ext
896                  assertTrue(q.offer(new Integer(j)));
897              ArrayList l = new ArrayList();
898              q.drainTo(l, i);
899 <            int k = (i < SIZE)? i : SIZE;
899 >            int k = (i < SIZE) ? i : SIZE;
900              assertEquals(l.size(), k);
901              assertEquals(q.size(), SIZE-k);
902              for (int j = 0; j < k; ++j)

Diff Legend

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