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

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.11 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.14 by jsr166, Sat Nov 21 21:00:34 2009 UTC

# Line 323 | Line 323 | public class LinkedBlockingDequeTest ext
323       * Deque contains all elements of collection used to initialize
324       */
325      public void testConstructor6() {
326 <        try {
327 <            Integer[] ints = new Integer[SIZE];
328 <            for (int i = 0; i < SIZE; ++i)
329 <                ints[i] = new Integer(i);
330 <            LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
331 <            for (int i = 0; i < SIZE; ++i)
332 <                assertEquals(ints[i], q.poll());
333 <        }
334 <        finally {}
326 >        Integer[] ints = new Integer[SIZE];
327 >        for (int i = 0; i < SIZE; ++i)
328 >            ints[i] = new Integer(i);
329 >        LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
330 >        for (int i = 0; i < SIZE; ++i)
331 >            assertEquals(ints[i], q.poll());
332      }
333  
334      /**
# Line 530 | Line 527 | public class LinkedBlockingDequeTest ext
527       * Deque contains all elements, in traversal order, of successful addAll
528       */
529      public void testAddAll5() {
530 <        try {
531 <            Integer[] empty = new Integer[0];
532 <            Integer[] ints = new Integer[SIZE];
533 <            for (int i = 0; i < SIZE; ++i)
534 <                ints[i] = new Integer(i);
535 <            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
536 <            assertFalse(q.addAll(Arrays.asList(empty)));
537 <            assertTrue(q.addAll(Arrays.asList(ints)));
538 <            for (int i = 0; i < SIZE; ++i)
542 <                assertEquals(ints[i], q.poll());
543 <        }
544 <        finally {}
530 >        Integer[] empty = new Integer[0];
531 >        Integer[] ints = new Integer[SIZE];
532 >        for (int i = 0; i < SIZE; ++i)
533 >            ints[i] = new Integer(i);
534 >        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
535 >        assertFalse(q.addAll(Arrays.asList(empty)));
536 >        assertTrue(q.addAll(Arrays.asList(ints)));
537 >        for (int i = 0; i < SIZE; ++i)
538 >            assertEquals(ints[i], q.poll());
539      }
540  
541  
# Line 728 | Line 722 | public class LinkedBlockingDequeTest ext
722       * returning timeout status
723       */
724      public void testInterruptedTimedPoll() throws InterruptedException {
725 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
725 >        Thread t = new Thread(new CheckedRunnable() {
726              public void realRun() throws InterruptedException {
727                  LinkedBlockingDeque q = populatedDeque(SIZE);
728                  for (int i = 0; i < SIZE; ++i) {
729 <                    threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
729 >                    assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
730                  }
731 <                q.poll(SMALL_DELAY_MS, MILLISECONDS);
732 <            }};
731 >                try {
732 >                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
733 >                    shouldThrow();
734 >                } catch (InterruptedException success) {}
735 >            }});
736  
737          t.start();
738          Thread.sleep(SHORT_DELAY_MS);
# Line 749 | Line 746 | public class LinkedBlockingDequeTest ext
746       */
747      public void testTimedPollWithOffer() throws InterruptedException {
748          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
749 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
749 >        Thread t = new Thread(new CheckedRunnable() {
750              public void realRun() throws InterruptedException {
751 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
752 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
753 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
754 <            }};
751 >                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
752 >                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
753 >                try {
754 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
755 >                    shouldThrow();
756 >                } catch (InterruptedException success) {}
757 >            }});
758  
759          t.start();
760          Thread.sleep(SMALL_DELAY_MS);
# Line 936 | Line 936 | public class LinkedBlockingDequeTest ext
936       * returning timeout status
937       */
938      public void testInterruptedTimedPollFirst() throws InterruptedException {
939 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
939 >        Thread t = new Thread(new CheckedRunnable() {
940              public void realRun() throws InterruptedException {
941                  LinkedBlockingDeque q = populatedDeque(SIZE);
942                  for (int i = 0; i < SIZE; ++i) {
943 <                    threadAssertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
943 >                    assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
944                  }
945 <                q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
946 <            }};
945 >                try {
946 >                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
947 >                    shouldThrow();
948 >                } catch (InterruptedException success) {}
949 >            }});
950  
951          t.start();
952          Thread.sleep(SHORT_DELAY_MS);
# Line 957 | Line 960 | public class LinkedBlockingDequeTest ext
960       */
961      public void testTimedPollFirstWithOfferFirst() throws InterruptedException {
962          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
963 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
963 >        Thread t = new Thread(new CheckedRunnable() {
964              public void realRun() throws InterruptedException {
965 <                threadAssertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
966 <                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
967 <                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
968 <            }};
965 >                assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
966 >                assertSame(zero, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
967 >                try {
968 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
969 >                    shouldThrow();
970 >                } catch (InterruptedException success) {}
971 >            }});
972  
973          t.start();
974          Thread.sleep(SMALL_DELAY_MS);
# Line 1143 | Line 1149 | public class LinkedBlockingDequeTest ext
1149       * returning timeout status
1150       */
1151      public void testInterruptedTimedPollLast() throws InterruptedException {
1152 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
1152 >        Thread t = new Thread(new CheckedRunnable() {
1153              public void realRun() throws InterruptedException {
1154                  LinkedBlockingDeque q = populatedDeque(SIZE);
1155                  for (int i = 0; i < SIZE; ++i) {
1156 <                    threadAssertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1156 >                    assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1157                  }
1158 <                q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
1159 <            }};
1158 >                try {
1159 >                    q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
1160 >                    shouldThrow();
1161 >                } catch (InterruptedException success) {}
1162 >            }});
1163  
1164          t.start();
1165          Thread.sleep(SHORT_DELAY_MS);

Diff Legend

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