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.20 by jsr166, Sun Nov 22 18:57:17 2009 UTC vs.
Revision 1.24 by jsr166, Tue Dec 1 09:56:28 2009 UTC

# Line 271 | Line 271 | public class LinkedTransferQueueTest ext
271      public void testTakeFromEmpty() throws InterruptedException {
272          final LinkedTransferQueue q = new LinkedTransferQueue();
273          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
274 <            void realRun() throws InterruptedException {
274 >            public void realRun() throws InterruptedException {
275                  q.take();
276              }});
277          Thread.sleep(SHORT_DELAY_MS);
# Line 348 | Line 348 | public class LinkedTransferQueueTest ext
348      public void testInterruptedTimedPoll() throws InterruptedException {
349          final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
350          Thread t = newStartedThread(new CheckedRunnable() {
351 <            void realRun() throws InterruptedException {
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 375 | Line 374 | public class LinkedTransferQueueTest ext
374      public void testTimedPollWithOffer() throws InterruptedException {
375          final LinkedTransferQueue q = new LinkedTransferQueue();
376          Thread t = new Thread(new CheckedRunnable() {
377 <            void realRun() throws InterruptedException {
377 >            public void realRun() throws InterruptedException {
378                  assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
379                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
380                  try {
# 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 674 | Line 673 | public class LinkedTransferQueueTest ext
673          ExecutorService executor = Executors.newFixedThreadPool(2);
674  
675          executor.execute(new CheckedRunnable() {
676 <            void realRun() {
677 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
679 <                                         MILLISECONDS));
676 >            public void realRun() {
677 >                assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
678              }});
679  
680          executor.execute(new CheckedRunnable() {
681 <            void realRun() throws InterruptedException {
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 696 | Line 694 | public class LinkedTransferQueueTest ext
694          ExecutorService executor = Executors.newFixedThreadPool(2);
695  
696          executor.execute(new CheckedRunnable() {
697 <            void realRun() throws InterruptedException {
698 <                threadAssertNull(q.poll());
699 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
700 <                                                MILLISECONDS));
703 <                threadAssertTrue(q.isEmpty());
697 >            public void realRun() throws InterruptedException {
698 >                assertNull(q.poll());
699 >                assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
700 >                assertTrue(q.isEmpty());
701              }});
702  
703          executor.execute(new CheckedRunnable() {
704 <            void realRun() throws InterruptedException {
704 >            public void realRun() throws InterruptedException {
705                  Thread.sleep(SMALL_DELAY_MS);
706                  q.put(one);
707              }});
# Line 790 | Line 787 | public class LinkedTransferQueueTest ext
787      public void testDrainToWithActivePut() throws InterruptedException {
788          final LinkedTransferQueue q = populatedQueue(SIZE);
789          Thread t = newStartedThread(new CheckedRunnable() {
790 <            void realRun() {
790 >            public void realRun() {
791                  q.put(SIZE + 1);
792              }});
793          ArrayList l = new ArrayList();
# Line 857 | Line 854 | public class LinkedTransferQueueTest ext
854          assertFalse(q.hasWaitingConsumer());
855  
856          Thread t = newStartedThread(new CheckedRunnable() {
857 <            void realRun() throws InterruptedException {
857 >            public void realRun() throws InterruptedException {
858                  Thread.sleep(SMALL_DELAY_MS);
859 <                threadAssertTrue(q.hasWaitingConsumer());
860 <                threadAssertEquals(q.getWaitingConsumerCount(), 1);
861 <                threadAssertTrue(q.offer(new Object()));
862 <                threadAssertFalse(q.hasWaitingConsumer());
863 <                threadAssertEquals(q.getWaitingConsumerCount(), 0);
859 >                assertTrue(q.hasWaitingConsumer());
860 >                assertEquals(q.getWaitingConsumerCount(), 1);
861 >                assertTrue(q.offer(one));
862 >                assertFalse(q.hasWaitingConsumer());
863 >                assertEquals(q.getWaitingConsumerCount(), 0);
864              }});
865  
866 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
866 >        assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
867          assertEquals(q.getWaitingConsumerCount(), 0);
868          assertFalse(q.hasWaitingConsumer());
869          t.join();
# Line 892 | Line 889 | public class LinkedTransferQueueTest ext
889              = new LinkedTransferQueue<Integer>();
890  
891          Thread t = newStartedThread(new CheckedRunnable() {
892 <            void realRun() throws InterruptedException {
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 912 | Line 909 | public class LinkedTransferQueueTest ext
909              = new LinkedTransferQueue<Integer>();
910  
911          Thread first = newStartedThread(new CheckedRunnable() {
912 <            void realRun() throws InterruptedException {
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(
920              new CheckedInterruptedRunnable() {
921 <                void realRun() throws InterruptedException {
921 >                public void realRun() throws InterruptedException {
922                      while (q.size() == 0)
923                          Thread.yield();
924                      q.transfer(SIZE);
# Line 947 | Line 944 | public class LinkedTransferQueueTest ext
944          final LinkedTransferQueue q = new LinkedTransferQueue();
945  
946          Thread t = newStartedThread(new CheckedRunnable() {
947 <            void realRun() throws InterruptedException {
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 968 | Line 965 | public class LinkedTransferQueueTest ext
965              = new LinkedTransferQueue<Integer>();
966  
967          Thread t = newStartedThread(new CheckedRunnable() {
968 <            void realRun() throws InterruptedException {
968 >            public void realRun() throws InterruptedException {
969                  q.transfer(SIZE);
970                  checkEmpty(q);
971              }});
# Line 1010 | Line 1007 | public class LinkedTransferQueueTest ext
1007          final LinkedTransferQueue q = new LinkedTransferQueue();
1008  
1009          Thread t = newStartedThread(new CheckedRunnable() {
1010 <            void realRun() {
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 1033 | Line 1030 | public class LinkedTransferQueueTest ext
1030          final LinkedTransferQueue q = new LinkedTransferQueue();
1031  
1032          Thread t = newStartedThread(new CheckedRunnable() {
1033 <            void realRun() {
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 1055 | Line 1052 | public class LinkedTransferQueueTest ext
1052          final LinkedTransferQueue q = new LinkedTransferQueue();
1053  
1054          Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1055 <            void realRun() throws InterruptedException {
1055 >            public void realRun() throws InterruptedException {
1056                  q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1057              }});
1058  
# Line 1071 | Line 1068 | public class LinkedTransferQueueTest ext
1068          final LinkedTransferQueue q = new LinkedTransferQueue();
1069  
1070          Thread t = newStartedThread(new CheckedRunnable() {
1071 <            void realRun() throws InterruptedException {
1072 <                threadAssertFalse
1073 <                    (q.tryTransfer(new Object(),
1077 <                                   SHORT_DELAY_MS, MILLISECONDS));
1071 >            public void realRun() throws InterruptedException {
1072 >                assertFalse(q.tryTransfer(new Object(),
1073 >                                          SHORT_DELAY_MS, MILLISECONDS));
1074              }});
1075  
1076          Thread.sleep(SMALL_DELAY_MS);
# Line 1091 | Line 1087 | public class LinkedTransferQueueTest ext
1087          assertTrue(q.offer(four));
1088  
1089          Thread t = newStartedThread(new CheckedRunnable() {
1090 <            void realRun() throws InterruptedException {
1091 <                threadAssertTrue(q.tryTransfer(five,
1092 <                                               MEDIUM_DELAY_MS, MILLISECONDS));
1097 <                threadAssertTrue(q.isEmpty());
1090 >            public void realRun() throws InterruptedException {
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 1115 | 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