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.12 by jsr166, Sat Nov 21 10:29:50 2009 UTC vs.
Revision 1.16 by jsr166, Sat Nov 21 22:00:46 2009 UTC

# Line 169 | Line 169 | public class LinkedBlockingDequeTest ext
169              q.getFirst();
170              shouldThrow();
171          } catch (NoSuchElementException success) {}
172 +        assertNull(q.peekFirst());
173      }
174  
175      /**
# Line 199 | Line 200 | public class LinkedBlockingDequeTest ext
200              q.removeFirst();
201              shouldThrow();
202          } catch (NoSuchElementException success) {}
203 +        assertNull(q.peekFirst());
204 +    }
205 +
206 +    /**
207 +     *  removeLast removes last element, or throws NSEE if empty
208 +     */
209 +    public void testRemoveLast() {
210 +        LinkedBlockingDeque q = populatedDeque(SIZE);
211 +        for (int i = SIZE - 1; i >= 0; --i) {
212 +            assertEquals(i, ((Integer)q.removeLast()).intValue());
213 +        }
214 +        try {
215 +            q.removeLast();
216 +            shouldThrow();
217 +        } catch (NoSuchElementException success) {}
218 +        assertNull(q.peekLast());
219      }
220  
221      /**
# Line 523 | Line 540 | public class LinkedBlockingDequeTest ext
540              shouldThrow();
541          } catch (IllegalStateException success) {}
542      }
543 +
544      /**
545       * Deque contains all elements, in traversal order, of successful addAll
546       */
# Line 624 | Line 642 | public class LinkedBlockingDequeTest ext
642       */
643      public void testTimedOffer() throws InterruptedException {
644          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
645 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
645 >        Thread t = new Thread(new CheckedRunnable() {
646              public void realRun() throws InterruptedException {
647                  q.put(new Object());
648                  q.put(new Object());
649 <                threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
650 <                q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
651 <            }};
649 >                assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
650 >                try {
651 >                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
652 >                    shouldThrow();
653 >                } catch (InterruptedException success) {}
654 >            }});
655  
656          t.start();
657          Thread.sleep(SMALL_DELAY_MS);
# Line 722 | Line 743 | public class LinkedBlockingDequeTest ext
743       * returning timeout status
744       */
745      public void testInterruptedTimedPoll() throws InterruptedException {
746 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
746 >        Thread t = new Thread(new CheckedRunnable() {
747              public void realRun() throws InterruptedException {
748                  LinkedBlockingDeque q = populatedDeque(SIZE);
749                  for (int i = 0; i < SIZE; ++i) {
750 <                    threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
750 >                    assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
751                  }
752 <                q.poll(SMALL_DELAY_MS, MILLISECONDS);
753 <            }};
752 >                try {
753 >                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
754 >                    shouldThrow();
755 >                } catch (InterruptedException success) {}
756 >            }});
757  
758          t.start();
759          Thread.sleep(SHORT_DELAY_MS);
# Line 743 | Line 767 | public class LinkedBlockingDequeTest ext
767       */
768      public void testTimedPollWithOffer() throws InterruptedException {
769          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
770 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
770 >        Thread t = new Thread(new CheckedRunnable() {
771              public void realRun() throws InterruptedException {
772 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
773 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
774 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
775 <            }};
772 >                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
773 >                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
774 >                try {
775 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
776 >                    shouldThrow();
777 >                } catch (InterruptedException success) {}
778 >            }});
779  
780          t.start();
781          Thread.sleep(SMALL_DELAY_MS);
# Line 843 | Line 870 | public class LinkedBlockingDequeTest ext
870       */
871      public void testTimedOfferFirst() throws InterruptedException {
872          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
873 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
873 >        Thread t = new Thread(new CheckedRunnable() {
874              public void realRun() throws InterruptedException {
875                  q.putFirst(new Object());
876                  q.putFirst(new Object());
877 <                threadAssertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS));
878 <                q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
879 <            }};
877 >                assertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS));
878 >                try {
879 >                    q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
880 >                    shouldThrow();
881 >                } catch (InterruptedException success) {}
882 >            }});
883  
884          t.start();
885          Thread.sleep(SMALL_DELAY_MS);
# Line 930 | Line 960 | public class LinkedBlockingDequeTest ext
960       * returning timeout status
961       */
962      public void testInterruptedTimedPollFirst() throws InterruptedException {
963 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
963 >        Thread t = new Thread(new CheckedRunnable() {
964              public void realRun() throws InterruptedException {
965                  LinkedBlockingDeque q = populatedDeque(SIZE);
966                  for (int i = 0; i < SIZE; ++i) {
967 <                    threadAssertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
967 >                    assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
968                  }
969 <                q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
970 <            }};
969 >                try {
970 >                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
971 >                    shouldThrow();
972 >                } catch (InterruptedException success) {}
973 >            }});
974  
975          t.start();
976          Thread.sleep(SHORT_DELAY_MS);
# Line 951 | Line 984 | public class LinkedBlockingDequeTest ext
984       */
985      public void testTimedPollFirstWithOfferFirst() throws InterruptedException {
986          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
987 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
987 >        Thread t = new Thread(new CheckedRunnable() {
988              public void realRun() throws InterruptedException {
989 <                threadAssertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
990 <                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
991 <                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
992 <            }};
989 >                assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
990 >                assertSame(zero, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
991 >                try {
992 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
993 >                    shouldThrow();
994 >                } catch (InterruptedException success) {}
995 >            }});
996  
997          t.start();
998          Thread.sleep(SMALL_DELAY_MS);
# Line 1050 | Line 1086 | public class LinkedBlockingDequeTest ext
1086       */
1087      public void testTimedOfferLast() throws InterruptedException {
1088          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1089 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
1089 >        Thread t = new Thread(new CheckedRunnable() {
1090              public void realRun() throws InterruptedException {
1091                  q.putLast(new Object());
1092                  q.putLast(new Object());
1093 <                threadAssertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS));
1094 <                q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1095 <            }};
1093 >                assertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS));
1094 >                try {
1095 >                    q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1096 >                    shouldThrow();
1097 >                } catch (InterruptedException success) {}
1098 >            }});
1099  
1100          t.start();
1101          Thread.sleep(SMALL_DELAY_MS);
# Line 1137 | Line 1176 | public class LinkedBlockingDequeTest ext
1176       * returning timeout status
1177       */
1178      public void testInterruptedTimedPollLast() throws InterruptedException {
1179 <        Thread t = new ThreadShouldThrow(InterruptedException.class) {
1179 >        Thread t = new Thread(new CheckedRunnable() {
1180              public void realRun() throws InterruptedException {
1181                  LinkedBlockingDeque q = populatedDeque(SIZE);
1182                  for (int i = 0; i < SIZE; ++i) {
1183 <                    threadAssertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1183 >                    assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
1184                  }
1185 <                q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
1186 <            }};
1185 >                try {
1186 >                    q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
1187 >                    shouldThrow();
1188 >                } catch (InterruptedException success) {}
1189 >            }});
1190  
1191          t.start();
1192          Thread.sleep(SHORT_DELAY_MS);

Diff Legend

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