--- jsr166/src/test/tck/LinkedBlockingDequeTest.java	2009/11/21 08:37:39	1.9
+++ jsr166/src/test/tck/LinkedBlockingDequeTest.java	2009/11/21 21:00:34	1.14
@@ -276,7 +276,7 @@ public class LinkedBlockingDequeTest ext
     }
 
     /**
-     * Constructor throws IAE if  capacity argument nonpositive
+     * Constructor throws IAE if capacity argument nonpositive
      */
     public void testConstructor2() {
         try {
@@ -323,15 +323,12 @@ public class LinkedBlockingDequeTest ext
      * Deque contains all elements of collection used to initialize
      */
     public void testConstructor6() {
-        try {
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        LinkedBlockingDeque q = new LinkedBlockingDeque(Arrays.asList(ints));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
     /**
@@ -530,43 +527,40 @@ public class LinkedBlockingDequeTest ext
      * Deque contains all elements, in traversal order, of successful addAll
      */
     public void testAddAll5() {
-        try {
-            Integer[] empty = new Integer[0];
-            Integer[] ints = new Integer[SIZE];
-            for (int i = 0; i < SIZE; ++i)
-                ints[i] = new Integer(i);
-            LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-            assertFalse(q.addAll(Arrays.asList(empty)));
-            assertTrue(q.addAll(Arrays.asList(ints)));
-            for (int i = 0; i < SIZE; ++i)
-                assertEquals(ints[i], q.poll());
-        }
-        finally {}
+        Integer[] empty = new Integer[0];
+        Integer[] ints = new Integer[SIZE];
+        for (int i = 0; i < SIZE; ++i)
+            ints[i] = new Integer(i);
+        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+        assertFalse(q.addAll(Arrays.asList(empty)));
+        assertTrue(q.addAll(Arrays.asList(ints)));
+        for (int i = 0; i < SIZE; ++i)
+            assertEquals(ints[i], q.poll());
     }
 
 
     /**
      * put(null) throws NPE
      */
-     public void testPutNull() throws InterruptedException {
+    public void testPutNull() throws InterruptedException {
         try {
             LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
             q.put(null);
             shouldThrow();
         } catch (NullPointerException success) {}
-     }
+    }
 
     /**
      * all elements successfully put are contained
      */
-     public void testPut() throws InterruptedException {
-         LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-         for (int i = 0; i < SIZE; ++i) {
-             Integer I = new Integer(i);
-             q.put(I);
-             assertTrue(q.contains(I));
-         }
-         assertEquals(0, q.remainingCapacity());
+    public void testPut() throws InterruptedException {
+        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            Integer I = new Integer(i);
+            q.put(I);
+            assertTrue(q.contains(I));
+        }
+        assertEquals(0, q.remainingCapacity());
     }
 
     /**
@@ -600,24 +594,23 @@ public class LinkedBlockingDequeTest ext
      */
     public void testPutWithTake() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    int added = 0;
-                    try {
-                        q.put(new Object());
-                        ++added;
-                        q.put(new Object());
-                        ++added;
-                        q.put(new Object());
-                        ++added;
-                        q.put(new Object());
-                        ++added;
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                        threadAssertTrue(added >= 2);
-                    }
+        Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() {
+                int added = 0;
+                try {
+                    q.put(new Object());
+                    ++added;
+                    q.put(new Object());
+                    ++added;
+                    q.put(new Object());
+                    ++added;
+                    q.put(new Object());
+                    ++added;
+                    threadShouldThrow();
+                } catch (InterruptedException success) {
+                    threadAssertTrue(added >= 2);
                 }
-            });
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -729,14 +722,17 @@ public class LinkedBlockingDequeTest ext
      * returning timeout status
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 LinkedBlockingDeque q = populatedDeque(SIZE);
                 for (int i = 0; i < SIZE; ++i) {
-                    threadAssertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
+                    assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
                 }
-                q.poll(SMALL_DELAY_MS, MILLISECONDS);
-            }};
+                try {
+                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -750,12 +746,15 @@ public class LinkedBlockingDequeTest ext
      */
     public void testTimedPollWithOffer() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
-                q.poll(LONG_DELAY_MS, MILLISECONDS);
-                q.poll(LONG_DELAY_MS, MILLISECONDS);
-            }};
+                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
+                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
+                try {
+                    q.poll(LONG_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+            }});
 
         t.start();
         Thread.sleep(SMALL_DELAY_MS);
@@ -793,21 +792,21 @@ public class LinkedBlockingDequeTest ext
      * putFirst blocks interruptibly if full
      */
     public void testBlockingPutFirst() throws InterruptedException {
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    int added = 0;
-                    try {
-                        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-                        for (int i = 0; i < SIZE; ++i) {
-                            q.putFirst(new Integer(i));
-                            ++added;
-                        }
-                        q.putFirst(new Integer(SIZE));
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                        threadAssertEquals(added, SIZE);
+        Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() {
+                int added = 0;
+                try {
+                    LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+                    for (int i = 0; i < SIZE; ++i) {
+                        q.putFirst(new Integer(i));
+                        ++added;
                     }
-                }});
+                    q.putFirst(new Integer(SIZE));
+                    threadShouldThrow();
+                } catch (InterruptedException success) {
+                    threadAssertEquals(added, SIZE);
+                }
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -820,24 +819,23 @@ public class LinkedBlockingDequeTest ext
      */
     public void testPutFirstWithTake() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    int added = 0;
-                    try {
-                        q.putFirst(new Object());
-                        ++added;
-                        q.putFirst(new Object());
-                        ++added;
-                        q.putFirst(new Object());
-                        ++added;
-                        q.putFirst(new Object());
-                        ++added;
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                        threadAssertTrue(added >= 2);
-                    }
+        Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() {
+                int added = 0;
+                try {
+                    q.putFirst(new Object());
+                    ++added;
+                    q.putFirst(new Object());
+                    ++added;
+                    q.putFirst(new Object());
+                    ++added;
+                    q.putFirst(new Object());
+                    ++added;
+                    threadShouldThrow();
+                } catch (InterruptedException success) {
+                    threadAssertTrue(added >= 2);
                 }
-            });
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -938,14 +936,17 @@ public class LinkedBlockingDequeTest ext
      * returning timeout status
      */
     public void testInterruptedTimedPollFirst() throws InterruptedException {
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 LinkedBlockingDeque q = populatedDeque(SIZE);
                 for (int i = 0; i < SIZE; ++i) {
-                    threadAssertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
+                    assertEquals(i, ((Integer)q.pollFirst(SHORT_DELAY_MS, MILLISECONDS)).intValue());
                 }
-                q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
-            }};
+                try {
+                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -959,12 +960,15 @@ public class LinkedBlockingDequeTest ext
      */
     public void testTimedPollFirstWithOfferFirst() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
-                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
-                q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
-            }};
+                assertNull(q.pollFirst(SHORT_DELAY_MS, MILLISECONDS));
+                assertSame(zero, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
+                try {
+                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+            }});
 
         t.start();
         Thread.sleep(SMALL_DELAY_MS);
@@ -1001,21 +1005,22 @@ public class LinkedBlockingDequeTest ext
      * putLast blocks interruptibly if full
      */
     public void testBlockingPutLast() throws InterruptedException {
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    int added = 0;
-                    try {
-                        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-                        for (int i = 0; i < SIZE; ++i) {
-                            q.putLast(new Integer(i));
-                            ++added;
-                        }
-                        q.putLast(new Integer(SIZE));
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                        threadAssertEquals(added, SIZE);
+        Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() {
+                int added = 0;
+                try {
+                    LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+                    for (int i = 0; i < SIZE; ++i) {
+                        q.putLast(new Integer(i));
+                        ++added;
                     }
-                }});
+                    q.putLast(new Integer(SIZE));
+                    threadShouldThrow();
+                } catch (InterruptedException success) {
+                    threadAssertEquals(added, SIZE);
+                }
+            }});
+
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
         t.interrupt();
@@ -1027,24 +1032,23 @@ public class LinkedBlockingDequeTest ext
      */
     public void testPutLastWithTake() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    int added = 0;
-                    try {
-                        q.putLast(new Object());
-                        ++added;
-                        q.putLast(new Object());
-                        ++added;
-                        q.putLast(new Object());
-                        ++added;
-                        q.putLast(new Object());
-                        ++added;
-                        threadShouldThrow();
-                    } catch (InterruptedException success) {
-                        threadAssertTrue(added >= 2);
-                    }
+        Thread t = new Thread(new CheckedRunnable() {
+            public void realRun() {
+                int added = 0;
+                try {
+                    q.putLast(new Object());
+                    ++added;
+                    q.putLast(new Object());
+                    ++added;
+                    q.putLast(new Object());
+                    ++added;
+                    q.putLast(new Object());
+                    ++added;
+                    threadShouldThrow();
+                } catch (InterruptedException success) {
+                    threadAssertTrue(added >= 2);
                 }
-            });
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -1145,14 +1149,17 @@ public class LinkedBlockingDequeTest ext
      * returning timeout status
      */
     public void testInterruptedTimedPollLast() throws InterruptedException {
-        Thread t = new ThreadShouldThrow(InterruptedException.class) {
+        Thread t = new Thread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 LinkedBlockingDeque q = populatedDeque(SIZE);
                 for (int i = 0; i < SIZE; ++i) {
-                    threadAssertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
+                    assertEquals(SIZE-i-1, ((Integer)q.pollLast(SHORT_DELAY_MS, MILLISECONDS)).intValue());
                 }
-                q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
-            }};
+                try {
+                    q.pollLast(SMALL_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
+            }});
 
         t.start();
         Thread.sleep(SHORT_DELAY_MS);
@@ -1559,8 +1566,7 @@ public class LinkedBlockingDequeTest ext
         try {
             q.drainTo(q);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**