--- jsr166/src/test/tck/LinkedTransferQueueTest.java	2009/11/26 15:42:15	1.21
+++ jsr166/src/test/tck/LinkedTransferQueueTest.java	2009/12/01 09:56:28	1.24
@@ -351,8 +351,7 @@ public class LinkedTransferQueueTest ext
             public void realRun() throws InterruptedException {
                 for (int i = 0; i < SIZE; ++i) {
                     long t0 = System.nanoTime();
-                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
-                                                       MILLISECONDS));
+                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
                     long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
                     assertTrue(millisElapsed < SMALL_DELAY_MS);
                 }
@@ -462,7 +461,7 @@ public class LinkedTransferQueueTest ext
         assertTrue(q.remove(one));
         assertTrue(q.remove(two));
         assertTrue(q.add(three));
-        assertTrue(q.take() == three);
+        assertSame(q.take(), three);
     }
 
     /**
@@ -615,8 +614,8 @@ public class LinkedTransferQueueTest ext
         it.remove();
 
         it = q.iterator();
-        assertEquals(it.next(), one);
-        assertEquals(it.next(), three);
+        assertSame(it.next(), one);
+        assertSame(it.next(), three);
         assertFalse(it.hasNext());
     }
 
@@ -675,14 +674,13 @@ public class LinkedTransferQueueTest ext
 
         executor.execute(new CheckedRunnable() {
             public void realRun() {
-                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
-                                         MILLISECONDS));
+                assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
             }});
 
         executor.execute(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 Thread.sleep(SMALL_DELAY_MS);
-                threadAssertEquals(one, q.take());
+                assertSame(one, q.take());
             }});
 
         joinPool(executor);
@@ -697,10 +695,9 @@ public class LinkedTransferQueueTest ext
 
         executor.execute(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertNull(q.poll());
-                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
-                                                MILLISECONDS));
-                threadAssertTrue(q.isEmpty());
+                assertNull(q.poll());
+                assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
+                assertTrue(q.isEmpty());
             }});
 
         executor.execute(new CheckedRunnable() {
@@ -859,14 +856,14 @@ public class LinkedTransferQueueTest ext
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 Thread.sleep(SMALL_DELAY_MS);
-                threadAssertTrue(q.hasWaitingConsumer());
-                threadAssertEquals(q.getWaitingConsumerCount(), 1);
-                threadAssertTrue(q.offer(new Object()));
-                threadAssertFalse(q.hasWaitingConsumer());
-                threadAssertEquals(q.getWaitingConsumerCount(), 0);
+                assertTrue(q.hasWaitingConsumer());
+                assertEquals(q.getWaitingConsumerCount(), 1);
+                assertTrue(q.offer(one));
+                assertFalse(q.hasWaitingConsumer());
+                assertEquals(q.getWaitingConsumerCount(), 0);
             }});
 
-        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
+        assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
         assertEquals(q.getWaitingConsumerCount(), 0);
         assertFalse(q.hasWaitingConsumer());
         t.join();
@@ -894,7 +891,7 @@ public class LinkedTransferQueueTest ext
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.transfer(SIZE);
-                threadAssertTrue(q.isEmpty());
+                assertTrue(q.isEmpty());
             }});
 
         Thread.sleep(SHORT_DELAY_MS);
@@ -915,8 +912,8 @@ public class LinkedTransferQueueTest ext
             public void realRun() throws InterruptedException {
                 Integer i = SIZE + 1;
                 q.transfer(i);
-                threadAssertTrue(!q.contains(i));
-                threadAssertEquals(1, q.size());
+                assertTrue(!q.contains(i));
+                assertEquals(1, q.size());
             }});
 
         Thread interruptedThread = newStartedThread(
@@ -949,13 +946,13 @@ public class LinkedTransferQueueTest ext
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.transfer(four);
-                threadAssertFalse(q.contains(four));
-                threadAssertEquals(three, q.poll());
+                assertFalse(q.contains(four));
+                assertSame(three, q.poll());
             }});
 
         Thread.sleep(SHORT_DELAY_MS);
         assertTrue(q.offer(three));
-        assertEquals(four, q.poll());
+        assertSame(four, q.poll());
         t.join();
     }
 
@@ -1013,13 +1010,13 @@ public class LinkedTransferQueueTest ext
             public void realRun() {
                 while (! q.hasWaitingConsumer())
                     Thread.yield();
-                threadAssertTrue(q.hasWaitingConsumer());
-                threadAssertTrue(q.isEmpty());
-                threadAssertTrue(q.size() == 0);
-                threadAssertTrue(q.tryTransfer(hotPotato));
+                assertTrue(q.hasWaitingConsumer());
+                assertTrue(q.isEmpty());
+                assertEquals(q.size(), 0);
+                assertTrue(q.tryTransfer(hotPotato));
             }});
 
-        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
+        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
         checkEmpty(q);
         t.join();
     }
@@ -1036,13 +1033,13 @@ public class LinkedTransferQueueTest ext
             public void realRun() {
                 while (! q.hasWaitingConsumer())
                     Thread.yield();
-                threadAssertTrue(q.hasWaitingConsumer());
-                threadAssertTrue(q.isEmpty());
-                threadAssertTrue(q.size() == 0);
-                threadAssertTrue(q.tryTransfer(hotPotato));
+                assertTrue(q.hasWaitingConsumer());
+                assertTrue(q.isEmpty());
+                assertEquals(q.size(), 0);
+                assertTrue(q.tryTransfer(hotPotato));
             }});
 
-        assertTrue(q.take() == hotPotato);
+        assertSame(q.take(), hotPotato);
         checkEmpty(q);
         t.join();
     }
@@ -1072,9 +1069,8 @@ public class LinkedTransferQueueTest ext
 
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertFalse
-                    (q.tryTransfer(new Object(),
-                                   SHORT_DELAY_MS, MILLISECONDS));
+                assertFalse(q.tryTransfer(new Object(),
+                                          SHORT_DELAY_MS, MILLISECONDS));
             }});
 
         Thread.sleep(SMALL_DELAY_MS);
@@ -1092,15 +1088,14 @@ public class LinkedTransferQueueTest ext
 
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
-                threadAssertTrue(q.tryTransfer(five,
-                                               MEDIUM_DELAY_MS, MILLISECONDS));
-                threadAssertTrue(q.isEmpty());
+                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
+                assertTrue(q.isEmpty());
             }});
 
         Thread.sleep(SHORT_DELAY_MS);
         assertEquals(2, q.size());
-        assertEquals(four, q.poll());
-        assertEquals(five, q.poll());
+        assertSame(four, q.poll());
+        assertSame(five, q.poll());
         checkEmpty(q);
         t.join();
     }
@@ -1115,7 +1110,7 @@ public class LinkedTransferQueueTest ext
         assertEquals(1, q.size());
         assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
         assertEquals(1, q.size());
-        assertEquals(four, q.poll());
+        assertSame(four, q.poll());
         assertNull(q.poll());
         checkEmpty(q);
     }