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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.22 by jsr166, Tue Dec 1 06:03:49 2009 UTC vs.
Revision 1.24 by jsr166, Tue Dec 1 09:56:28 2009 UTC

# Line 351 | Line 351 | public class LinkedTransferQueueTest ext
351              public void realRun() throws InterruptedException {
352                  for (int i = 0; i < SIZE; ++i) {
353                      long t0 = System.nanoTime();
354 <                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
355 <                                                       MILLISECONDS));
354 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
355                      long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
356                      assertTrue(millisElapsed < SMALL_DELAY_MS);
357                  }
# Line 462 | Line 461 | public class LinkedTransferQueueTest ext
461          assertTrue(q.remove(one));
462          assertTrue(q.remove(two));
463          assertTrue(q.add(three));
464 <        assertTrue(q.take() == three);
464 >        assertSame(q.take(), three);
465      }
466  
467      /**
# Line 615 | Line 614 | public class LinkedTransferQueueTest ext
614          it.remove();
615  
616          it = q.iterator();
617 <        assertEquals(it.next(), one);
618 <        assertEquals(it.next(), three);
617 >        assertSame(it.next(), one);
618 >        assertSame(it.next(), three);
619          assertFalse(it.hasNext());
620      }
621  
# Line 675 | Line 674 | public class LinkedTransferQueueTest ext
674  
675          executor.execute(new CheckedRunnable() {
676              public void realRun() {
677 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
679 <                                         MILLISECONDS));
677 >                assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
678              }});
679  
680          executor.execute(new CheckedRunnable() {
681              public void realRun() throws InterruptedException {
682                  Thread.sleep(SMALL_DELAY_MS);
683 <                threadAssertEquals(one, q.take());
683 >                assertSame(one, q.take());
684              }});
685  
686          joinPool(executor);
# Line 893 | Line 891 | public class LinkedTransferQueueTest ext
891          Thread t = newStartedThread(new CheckedRunnable() {
892              public void realRun() throws InterruptedException {
893                  q.transfer(SIZE);
894 <                threadAssertTrue(q.isEmpty());
894 >                assertTrue(q.isEmpty());
895              }});
896  
897          Thread.sleep(SHORT_DELAY_MS);
# Line 914 | Line 912 | public class LinkedTransferQueueTest ext
912              public void realRun() throws InterruptedException {
913                  Integer i = SIZE + 1;
914                  q.transfer(i);
915 <                threadAssertTrue(!q.contains(i));
916 <                threadAssertEquals(1, q.size());
915 >                assertTrue(!q.contains(i));
916 >                assertEquals(1, q.size());
917              }});
918  
919          Thread interruptedThread = newStartedThread(
# Line 948 | Line 946 | public class LinkedTransferQueueTest ext
946          Thread t = newStartedThread(new CheckedRunnable() {
947              public void realRun() throws InterruptedException {
948                  q.transfer(four);
949 <                threadAssertFalse(q.contains(four));
950 <                threadAssertEquals(three, q.poll());
949 >                assertFalse(q.contains(four));
950 >                assertSame(three, q.poll());
951              }});
952  
953          Thread.sleep(SHORT_DELAY_MS);
954          assertTrue(q.offer(three));
955 <        assertEquals(four, q.poll());
955 >        assertSame(four, q.poll());
956          t.join();
957      }
958  
# Line 1012 | Line 1010 | public class LinkedTransferQueueTest ext
1010              public void realRun() {
1011                  while (! q.hasWaitingConsumer())
1012                      Thread.yield();
1013 <                threadAssertTrue(q.hasWaitingConsumer());
1014 <                threadAssertTrue(q.isEmpty());
1015 <                threadAssertTrue(q.size() == 0);
1016 <                threadAssertTrue(q.tryTransfer(hotPotato));
1013 >                assertTrue(q.hasWaitingConsumer());
1014 >                assertTrue(q.isEmpty());
1015 >                assertEquals(q.size(), 0);
1016 >                assertTrue(q.tryTransfer(hotPotato));
1017              }});
1018  
1019 <        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
1019 >        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1020          checkEmpty(q);
1021          t.join();
1022      }
# Line 1035 | Line 1033 | public class LinkedTransferQueueTest ext
1033              public void realRun() {
1034                  while (! q.hasWaitingConsumer())
1035                      Thread.yield();
1036 <                threadAssertTrue(q.hasWaitingConsumer());
1037 <                threadAssertTrue(q.isEmpty());
1038 <                threadAssertTrue(q.size() == 0);
1039 <                threadAssertTrue(q.tryTransfer(hotPotato));
1036 >                assertTrue(q.hasWaitingConsumer());
1037 >                assertTrue(q.isEmpty());
1038 >                assertEquals(q.size(), 0);
1039 >                assertTrue(q.tryTransfer(hotPotato));
1040              }});
1041  
1042 <        assertTrue(q.take() == hotPotato);
1042 >        assertSame(q.take(), hotPotato);
1043          checkEmpty(q);
1044          t.join();
1045      }
# Line 1071 | Line 1069 | public class LinkedTransferQueueTest ext
1069  
1070          Thread t = newStartedThread(new CheckedRunnable() {
1071              public void realRun() throws InterruptedException {
1072 <                threadAssertFalse
1073 <                    (q.tryTransfer(new Object(),
1076 <                                   SHORT_DELAY_MS, MILLISECONDS));
1072 >                assertFalse(q.tryTransfer(new Object(),
1073 >                                          SHORT_DELAY_MS, MILLISECONDS));
1074              }});
1075  
1076          Thread.sleep(SMALL_DELAY_MS);
# Line 1091 | Line 1088 | public class LinkedTransferQueueTest ext
1088  
1089          Thread t = newStartedThread(new CheckedRunnable() {
1090              public void realRun() throws InterruptedException {
1091 <                threadAssertTrue(q.tryTransfer(five,
1092 <                                               MEDIUM_DELAY_MS, MILLISECONDS));
1096 <                threadAssertTrue(q.isEmpty());
1091 >                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1092 >                assertTrue(q.isEmpty());
1093              }});
1094  
1095          Thread.sleep(SHORT_DELAY_MS);
1096          assertEquals(2, q.size());
1097 <        assertEquals(four, q.poll());
1098 <        assertEquals(five, q.poll());
1097 >        assertSame(four, q.poll());
1098 >        assertSame(five, q.poll());
1099          checkEmpty(q);
1100          t.join();
1101      }
# Line 1114 | Line 1110 | public class LinkedTransferQueueTest ext
1110          assertEquals(1, q.size());
1111          assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1112          assertEquals(1, q.size());
1113 <        assertEquals(four, q.poll());
1113 >        assertSame(four, q.poll());
1114          assertNull(q.poll());
1115          checkEmpty(q);
1116      }

Diff Legend

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