--- jsr166/src/test/tck/LinkedBlockingDequeTest.java	2010/11/05 00:17:22	1.32
+++ jsr166/src/test/tck/LinkedBlockingDequeTest.java	2011/05/21 06:24:33	1.38
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 import junit.framework.*;
@@ -617,7 +617,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(SIZE, q.size());
@@ -641,10 +641,10 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         assertEquals(q.remainingCapacity(), 0);
         assertEquals(0, q.take());
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(q.remainingCapacity(), 0);
@@ -655,21 +655,24 @@ public class LinkedBlockingDequeTest ext
      */
     public void testTimedOffer() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new CheckedRunnable() {
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.put(new Object());
                 q.put(new Object());
-                assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
+                long startTime = System.nanoTime();
+                assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+                pleaseInterrupt.countDown();
                 try {
-                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
+                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
                     shouldThrow();
                 } catch (InterruptedException success) {}
             }});
 
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
+        await(pleaseInterrupt);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
     }
 
     /**
@@ -699,7 +702,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -743,46 +746,54 @@ public class LinkedBlockingDequeTest ext
      * returning timeout status
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
-        Thread t = new Thread(new CheckedRunnable() {
+        final BlockingQueue<Integer> q = populatedDeque(SIZE);
+        final CountDownLatch aboutToWait = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                LinkedBlockingDeque q = populatedDeque(SIZE);
                 for (int i = 0; i < SIZE; ++i) {
-                    assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
+                    long t0 = System.nanoTime();
+                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
+                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
                 }
+                long t0 = System.nanoTime();
+                aboutToWait.countDown();
                 try {
-                    q.poll(SMALL_DELAY_MS, MILLISECONDS);
+                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
                     shouldThrow();
-                } catch (InterruptedException success) {}
+                } catch (InterruptedException success) {
+                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
+                }
             }});
 
-        t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        aboutToWait.await();
+        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
         t.interrupt();
-        t.join();
+        awaitTermination(t, MEDIUM_DELAY_MS);
+        checkEmpty(q);
     }
 
     /**
      * putFirst(null) throws NPE
      */
-     public void testPutFirstNull() throws InterruptedException {
+    public void testPutFirstNull() throws InterruptedException {
         try {
             LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
             q.putFirst(null);
             shouldThrow();
         } catch (NullPointerException success) {}
-     }
+    }
 
     /**
      * all elements successfully putFirst are contained
      */
-     public void testPutFirst() throws InterruptedException {
-         LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-         for (int i = 0; i < SIZE; ++i) {
-             Integer I = new Integer(i);
-             q.putFirst(I);
-             assertTrue(q.contains(I));
-         }
-         assertEquals(0, q.remainingCapacity());
+    public void testPutFirst() throws InterruptedException {
+        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            Integer I = new Integer(i);
+            q.putFirst(I);
+            assertTrue(q.contains(I));
+        }
+        assertEquals(0, q.remainingCapacity());
     }
 
     /**
@@ -803,7 +814,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(SIZE, q.size());
@@ -827,10 +838,10 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         assertEquals(q.remainingCapacity(), 0);
         assertEquals(capacity - 1, q.take());
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(q.remainingCapacity(), 0);
@@ -841,21 +852,24 @@ public class LinkedBlockingDequeTest ext
      */
     public void testTimedOfferFirst() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new CheckedRunnable() {
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.putFirst(new Object());
                 q.putFirst(new Object());
-                assertFalse(q.offerFirst(new Object(), SHORT_DELAY_MS, MILLISECONDS));
+                long startTime = System.nanoTime();
+                assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+                pleaseInterrupt.countDown();
                 try {
-                    q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
+                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
                     shouldThrow();
                 } catch (InterruptedException success) {}
             }});
 
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
+        await(pleaseInterrupt);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
     }
 
     /**
@@ -879,7 +893,7 @@ public class LinkedBlockingDequeTest ext
             }};
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -900,7 +914,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -946,7 +960,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -968,7 +982,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SMALL_DELAY_MS);
+        delay(SMALL_DELAY_MS);
         assertTrue(q.offerFirst(zero, SHORT_DELAY_MS, MILLISECONDS));
         t.interrupt();
         t.join();
@@ -977,25 +991,25 @@ public class LinkedBlockingDequeTest ext
     /**
      * putLast(null) throws NPE
      */
-     public void testPutLastNull() throws InterruptedException {
+    public void testPutLastNull() throws InterruptedException {
         try {
             LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
             q.putLast(null);
             shouldThrow();
         } catch (NullPointerException success) {}
-     }
+    }
 
     /**
      * all elements successfully putLast are contained
      */
-     public void testPutLast() throws InterruptedException {
-         LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
-         for (int i = 0; i < SIZE; ++i) {
-             Integer I = new Integer(i);
-             q.putLast(I);
-             assertTrue(q.contains(I));
-         }
-         assertEquals(0, q.remainingCapacity());
+    public void testPutLast() throws InterruptedException {
+        LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
+        for (int i = 0; i < SIZE; ++i) {
+            Integer I = new Integer(i);
+            q.putLast(I);
+            assertTrue(q.contains(I));
+        }
+        assertEquals(0, q.remainingCapacity());
     }
 
     /**
@@ -1016,7 +1030,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(SIZE, q.size());
@@ -1040,10 +1054,10 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         assertEquals(q.remainingCapacity(), 0);
         assertEquals(0, q.take());
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
         assertEquals(q.remainingCapacity(), 0);
@@ -1054,21 +1068,24 @@ public class LinkedBlockingDequeTest ext
      */
     public void testTimedOfferLast() throws InterruptedException {
         final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
-        Thread t = new Thread(new CheckedRunnable() {
+        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
+        Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.putLast(new Object());
                 q.putLast(new Object());
-                assertFalse(q.offerLast(new Object(), SHORT_DELAY_MS, MILLISECONDS));
+                long startTime = System.nanoTime();
+                assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
+                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
+                pleaseInterrupt.countDown();
                 try {
-                    q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
+                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
                     shouldThrow();
                 } catch (InterruptedException success) {}
             }});
 
-        t.start();
-        Thread.sleep(SMALL_DELAY_MS);
+        await(pleaseInterrupt);
         t.interrupt();
-        t.join();
+        awaitTermination(t);
     }
 
     /**
@@ -1092,7 +1109,7 @@ public class LinkedBlockingDequeTest ext
             }};
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -1113,7 +1130,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -1158,7 +1175,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SHORT_DELAY_MS);
+        delay(SHORT_DELAY_MS);
         t.interrupt();
         t.join();
     }
@@ -1180,7 +1197,7 @@ public class LinkedBlockingDequeTest ext
             }});
 
         t.start();
-        Thread.sleep(SMALL_DELAY_MS);
+        delay(SMALL_DELAY_MS);
         assertTrue(q.offerLast(zero, SHORT_DELAY_MS, MILLISECONDS));
         t.interrupt();
         t.join();
@@ -1208,11 +1225,17 @@ public class LinkedBlockingDequeTest ext
     public void testRemoveElement() {
         LinkedBlockingDeque q = populatedDeque(SIZE);
         for (int i = 1; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
+            assertTrue(q.contains(i));
+            assertTrue(q.remove(i));
+            assertFalse(q.contains(i));
+            assertTrue(q.contains(i-1));
         }
         for (int i = 0; i < SIZE; i+=2) {
-            assertTrue(q.remove(new Integer(i)));
-            assertFalse(q.remove(new Integer(i+1)));
+            assertTrue(q.contains(i));
+            assertTrue(q.remove(i));
+            assertFalse(q.contains(i));
+            assertFalse(q.remove(i+1));
+            assertFalse(q.contains(i+1));
         }
         assertTrue(q.isEmpty());
     }
@@ -1494,7 +1517,7 @@ public class LinkedBlockingDequeTest ext
 
         executor.execute(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                Thread.sleep(SMALL_DELAY_MS);
+                delay(SMALL_DELAY_MS);
                 assertSame(one, q.take());
             }});
 
@@ -1516,7 +1539,7 @@ public class LinkedBlockingDequeTest ext
 
         executor.execute(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                Thread.sleep(SMALL_DELAY_MS);
+                delay(SMALL_DELAY_MS);
                 q.put(one);
             }});