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.8 by jsr166, Tue Aug 4 20:35:11 2009 UTC vs.
Revision 1.9 by jsr166, Wed Aug 5 00:43:23 2009 UTC

# Line 249 | Line 249 | public class LinkedTransferQueueTest ext
249       */
250      public void testTakeFromEmpty() throws InterruptedException {
251          final LinkedTransferQueue q = new LinkedTransferQueue();
252 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
252 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
253              void realRun() throws InterruptedException {
254                  q.take();
255              }});
256 –        t.start();
256          Thread.sleep(SHORT_DELAY_MS);
257          t.interrupt();
258          t.join();
# Line 263 | Line 262 | public class LinkedTransferQueueTest ext
262       * Take removes existing elements until empty, then blocks interruptibly
263       */
264      public void testBlockingTake() throws InterruptedException {
265 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
265 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
266              void realRun() throws InterruptedException {
267                  LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
268                  for (int i = 0; i < SIZE; ++i) {
# Line 271 | Line 270 | public class LinkedTransferQueueTest ext
270                  }
271                  q.take();
272              }});
274 –        t.start();
273          Thread.sleep(SHORT_DELAY_MS);
274          t.interrupt();
275          t.join();
# Line 315 | Line 313 | public class LinkedTransferQueueTest ext
313       * returning timeout status
314       */
315      public void testInterruptedTimedPoll() throws InterruptedException {
316 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
316 >        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
317 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
318              void realRun() throws InterruptedException {
320 –                LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
319                  for (int i = 0; i < SIZE; ++i) {
320 <                    threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS,
320 >                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
321                                                         MILLISECONDS));
322                  }
323 <                q.poll(SHORT_DELAY_MS, MILLISECONDS);
323 >                q.poll(LONG_DELAY_MS, MILLISECONDS);
324              }});
325 <        t.start();
328 <        Thread.sleep(SHORT_DELAY_MS);
325 >        Thread.sleep(SMALL_DELAY_MS);
326          t.interrupt();
327          t.join();
328 +        assertEquals(q.size(), 0);
329 +        assertNull(q.poll());
330      }
331  
332      /**
# Line 336 | Line 335 | public class LinkedTransferQueueTest ext
335       */
336      public void testTimedPollWithOffer() throws InterruptedException {
337          final LinkedTransferQueue q = new LinkedTransferQueue();
338 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
338 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
339              void realRun() throws InterruptedException {
340                  threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
341                  q.poll(LONG_DELAY_MS, MILLISECONDS);
342                  q.poll(LONG_DELAY_MS, MILLISECONDS);
343              }});
345 –        t.start();
344          Thread.sleep(SMALL_DELAY_MS);
345          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
346          t.interrupt();
# Line 748 | Line 746 | public class LinkedTransferQueueTest ext
746       */
747      public void testDrainToWithActivePut() throws InterruptedException {
748          final LinkedTransferQueue q = populatedQueue(SIZE);
749 <        Thread t = new Thread(new CheckedRunnable() {
749 >        Thread t = newStartedThread(new CheckedRunnable() {
750              void realRun() {
751                  q.put(SIZE + 1);
752              }});
755 –        t.start();
753          ArrayList l = new ArrayList();
754          q.drainTo(l);
755          assertTrue(l.size() >= SIZE);
# Line 815 | Line 812 | public class LinkedTransferQueueTest ext
812      public void testWaitingConsumer() throws InterruptedException {
813          final LinkedTransferQueue q = new LinkedTransferQueue();
814          final ConsumerObserver waiting = new ConsumerObserver();
815 <        new Thread(new CheckedRunnable() {
816 <            void realRun() {
815 >
816 >        Thread t = newStartedThread(new CheckedRunnable() {
817 >            void realRun() throws InterruptedException {
818 >                Thread.sleep(SMALL_DELAY_MS);
819                  threadAssertTrue(q.hasWaitingConsumer());
820                  waiting.setWaitingConsumer(q.getWaitingConsumerCount());
821                  threadAssertTrue(q.offer(new Object()));
822 <            }}).start();
822 >            }});
823 >
824          assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
825          assertTrue(q.getWaitingConsumerCount()
826                     < waiting.getWaitingConsumers());
827 +        t.join();
828      }
829  
830      /**
# Line 846 | Line 847 | public class LinkedTransferQueueTest ext
847          final LinkedTransferQueue<Integer> q
848              = new LinkedTransferQueue<Integer>();
849  
850 <        new Thread(new CheckedRunnable() {
850 >        Thread t = newStartedThread(new CheckedRunnable() {
851              void realRun() throws InterruptedException {
852                  q.transfer(SIZE);
853                  threadAssertTrue(q.isEmpty());
854 <            }}).start();
854 >            }});
855  
856          Thread.sleep(SHORT_DELAY_MS);
857          assertEquals(1, q.size());
858          assertEquals(SIZE, (int) q.poll());
859          assertTrue(q.isEmpty());
860 +        t.join();
861      }
862  
863      /**
# Line 865 | Line 867 | public class LinkedTransferQueueTest ext
867          final LinkedTransferQueue<Integer> q
868              = new LinkedTransferQueue<Integer>();
869  
870 <        Thread first = new Thread(new CheckedRunnable() {
870 >        Thread first = newStartedThread(new CheckedRunnable() {
871              void realRun() throws InterruptedException {
872                  Integer i = SIZE + 1;
873                  q.transfer(i);
874                  threadAssertTrue(!q.contains(i));
875                  threadAssertEquals(1, q.size());
876              }});
875 –        first.start();
877  
878 <        Thread interruptedThread = new Thread(new CheckedInterruptedRunnable() {
879 <            void realRun() throws InterruptedException {
880 <                while (q.size() == 0)
881 <                    Thread.yield();
882 <                q.transfer(SIZE);
883 <            }});
884 <        interruptedThread.start();
878 >        Thread interruptedThread = newStartedThread(
879 >            new CheckedInterruptedRunnable() {
880 >                void realRun() throws InterruptedException {
881 >                    while (q.size() == 0)
882 >                        Thread.yield();
883 >                    q.transfer(SIZE);
884 >                }});
885  
886          while (q.size() < 2)
887              Thread.yield();
# Line 900 | Line 901 | public class LinkedTransferQueueTest ext
901       */
902      public void testTransfer4() throws InterruptedException {
903          final LinkedTransferQueue q = new LinkedTransferQueue();
904 <        new Thread(new CheckedRunnable() {
904 >
905 >        Thread t = newStartedThread(new CheckedRunnable() {
906              void realRun() throws InterruptedException {
907                  q.transfer(four);
908                  threadAssertFalse(q.contains(four));
909                  threadAssertEquals(three, q.poll());
910 <            }}).start();
911 <        Thread.sleep(MEDIUM_DELAY_MS);
910 >            }});
911 >
912 >        Thread.sleep(SHORT_DELAY_MS);
913          assertTrue(q.offer(three));
914          assertEquals(four, q.poll());
915 +        t.join();
916      }
917  
918      /**
# Line 919 | Line 923 | public class LinkedTransferQueueTest ext
923          final LinkedTransferQueue<Integer> q
924              = new LinkedTransferQueue<Integer>();
925  
926 <        new Thread(new CheckedRunnable() {
926 >        Thread t = newStartedThread(new CheckedRunnable() {
927              void realRun() throws InterruptedException {
928                  q.transfer(SIZE);
929                  threadAssertTrue(q.isEmpty());
930 <            }}).start();
930 >            }});
931  
932          Thread.sleep(SHORT_DELAY_MS);
933          assertEquals(SIZE, (int) q.take());
934          assertTrue(q.isEmpty());
935 +        t.join();
936      }
937  
938      /**
# Line 961 | Line 966 | public class LinkedTransferQueueTest ext
966      public void testTryTransfer3() throws InterruptedException {
967          final Object hotPotato = new Object();
968          final LinkedTransferQueue q = new LinkedTransferQueue();
969 <        new Thread(new CheckedRunnable() {
969 >
970 >        Thread t = newStartedThread(new CheckedRunnable() {
971              void realRun() {
972                  while (! q.hasWaitingConsumer())
973                      Thread.yield();
# Line 969 | Line 975 | public class LinkedTransferQueueTest ext
975                  threadAssertTrue(q.isEmpty());
976                  threadAssertTrue(q.size() == 0);
977                  threadAssertTrue(q.tryTransfer(hotPotato));
978 <            }}).start();
979 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) == hotPotato);
978 >            }});
979 >
980 >        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
981          assertTrue(q.isEmpty());
982 +        t.join();
983      }
984  
985      /**
# Line 981 | Line 989 | public class LinkedTransferQueueTest ext
989      public void testTryTransfer4() throws InterruptedException {
990          final Object hotPotato = new Object();
991          final LinkedTransferQueue q = new LinkedTransferQueue();
992 <        new Thread(new CheckedRunnable() {
992 >
993 >        Thread t = newStartedThread(new CheckedRunnable() {
994              void realRun() {
995                  while (! q.hasWaitingConsumer())
996                      Thread.yield();
# Line 989 | Line 998 | public class LinkedTransferQueueTest ext
998                  threadAssertTrue(q.isEmpty());
999                  threadAssertTrue(q.size() == 0);
1000                  threadAssertTrue(q.tryTransfer(hotPotato));
1001 <            }}).start();
1001 >            }});
1002 >
1003          assertTrue(q.take() == hotPotato);
1004          assertTrue(q.isEmpty());
1005 +        t.join();
1006      }
1007  
1008      /**
# Line 1000 | Line 1011 | public class LinkedTransferQueueTest ext
1011       */
1012      public void testTryTransfer5() throws InterruptedException {
1013          final LinkedTransferQueue q = new LinkedTransferQueue();
1014 <        Thread toInterrupt = new Thread(new CheckedInterruptedRunnable() {
1014 >
1015 >        Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1016              void realRun() throws InterruptedException {
1017                  q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1018              }});
1019 <        toInterrupt.start();
1019 >
1020          Thread.sleep(SMALL_DELAY_MS);
1021          toInterrupt.interrupt();
1022 +        toInterrupt.join();
1023      }
1024  
1025      /**
# Line 1014 | Line 1027 | public class LinkedTransferQueueTest ext
1027       */
1028      public void testTryTransfer6() throws InterruptedException {
1029          final LinkedTransferQueue q = new LinkedTransferQueue();
1030 <        new Thread(new CheckedRunnable() {
1030 >
1031 >        Thread t = newStartedThread(new CheckedRunnable() {
1032              void realRun() throws InterruptedException {
1033                  threadAssertFalse
1034                      (q.tryTransfer(new Object(),
1035                                     SHORT_DELAY_MS, MILLISECONDS));
1036 <            }}).start();
1037 <        Thread.sleep(LONG_DELAY_MS);
1036 >            }});
1037 >
1038 >        Thread.sleep(SMALL_DELAY_MS);
1039          assertTrue(q.isEmpty());
1040 +        t.join();
1041      }
1042  
1043      /**
# Line 1031 | Line 1047 | public class LinkedTransferQueueTest ext
1047      public void testTryTransfer7() throws InterruptedException {
1048          final LinkedTransferQueue q = new LinkedTransferQueue();
1049          assertTrue(q.offer(four));
1050 <        new Thread(new CheckedRunnable() {
1050 >
1051 >        Thread t = newStartedThread(new CheckedRunnable() {
1052              void realRun() throws InterruptedException {
1053                  threadAssertTrue(q.tryTransfer(five,
1054 <                                               LONG_DELAY_MS, MILLISECONDS));
1054 >                                               MEDIUM_DELAY_MS, MILLISECONDS));
1055                  threadAssertTrue(q.isEmpty());
1056 <            }}).start();
1056 >            }});
1057 >
1058          Thread.sleep(SHORT_DELAY_MS);
1059          assertEquals(2, q.size());
1060          assertEquals(four, q.poll());
1061          assertEquals(five, q.poll());
1062          assertTrue(q.isEmpty());
1063 +        t.join();
1064      }
1065  
1066      /**

Diff Legend

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