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.7 by jsr166, Mon Aug 3 19:07:51 2009 UTC vs.
Revision 1.10 by jsr166, Thu Aug 6 03:55:39 2009 UTC

# Line 21 | Line 21 | import static java.util.concurrent.TimeU
21   import junit.framework.Test;
22   import junit.framework.TestSuite;
23  
24 + @SuppressWarnings({"unchecked", "rawtypes"})
25   public class LinkedTransferQueueTest extends JSR166TestCase {
26  
27      public static void main(String[] args) {
# Line 249 | Line 250 | public class LinkedTransferQueueTest ext
250       */
251      public void testTakeFromEmpty() throws InterruptedException {
252          final LinkedTransferQueue q = new LinkedTransferQueue();
253 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
253 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
254              void realRun() throws InterruptedException {
255                  q.take();
256              }});
256 –        t.start();
257          Thread.sleep(SHORT_DELAY_MS);
258          t.interrupt();
259          t.join();
# Line 263 | Line 263 | public class LinkedTransferQueueTest ext
263       * Take removes existing elements until empty, then blocks interruptibly
264       */
265      public void testBlockingTake() throws InterruptedException {
266 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
266 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
267              void realRun() throws InterruptedException {
268                  LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
269                  for (int i = 0; i < SIZE; ++i) {
# Line 271 | Line 271 | public class LinkedTransferQueueTest ext
271                  }
272                  q.take();
273              }});
274 –        t.start();
274          Thread.sleep(SHORT_DELAY_MS);
275          t.interrupt();
276          t.join();
# Line 315 | Line 314 | public class LinkedTransferQueueTest ext
314       * returning timeout status
315       */
316      public void testInterruptedTimedPoll() throws InterruptedException {
317 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
317 >        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
318 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
319              void realRun() throws InterruptedException {
320 –                LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
320                  for (int i = 0; i < SIZE; ++i) {
321 <                    threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS,
321 >                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
322                                                         MILLISECONDS));
323                  }
324 <                q.poll(SHORT_DELAY_MS, MILLISECONDS);
324 >                q.poll(LONG_DELAY_MS, MILLISECONDS);
325              }});
326 <        t.start();
328 <        Thread.sleep(SHORT_DELAY_MS);
326 >        Thread.sleep(SMALL_DELAY_MS);
327          t.interrupt();
328          t.join();
329 +        assertEquals(q.size(), 0);
330 +        assertNull(q.poll());
331      }
332  
333      /**
# Line 336 | Line 336 | public class LinkedTransferQueueTest ext
336       */
337      public void testTimedPollWithOffer() throws InterruptedException {
338          final LinkedTransferQueue q = new LinkedTransferQueue();
339 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
339 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
340              void realRun() throws InterruptedException {
341                  threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
342                  q.poll(LONG_DELAY_MS, MILLISECONDS);
343                  q.poll(LONG_DELAY_MS, MILLISECONDS);
344              }});
345 –        t.start();
345          Thread.sleep(SMALL_DELAY_MS);
346          assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
347          t.interrupt();
# Line 553 | Line 552 | public class LinkedTransferQueueTest ext
552      public void testIterator() throws InterruptedException {
553          LinkedTransferQueue q = populatedQueue(SIZE);
554          Iterator it = q.iterator();
555 +        int i = 0;
556          while (it.hasNext()) {
557 <            assertEquals(it.next(), q.take());
557 >            assertEquals(it.next(), i++);
558          }
559 +        assertEquals(i, SIZE);
560      }
561  
562      /**
# Line 748 | Line 749 | public class LinkedTransferQueueTest ext
749       */
750      public void testDrainToWithActivePut() throws InterruptedException {
751          final LinkedTransferQueue q = populatedQueue(SIZE);
752 <        Thread t = new Thread(new CheckedRunnable() {
752 >        Thread t = newStartedThread(new CheckedRunnable() {
753              void realRun() {
754                  q.put(SIZE + 1);
755              }});
755 –        t.start();
756          ArrayList l = new ArrayList();
757          q.drainTo(l);
758          assertTrue(l.size() >= SIZE);
# Line 815 | Line 815 | public class LinkedTransferQueueTest ext
815      public void testWaitingConsumer() throws InterruptedException {
816          final LinkedTransferQueue q = new LinkedTransferQueue();
817          final ConsumerObserver waiting = new ConsumerObserver();
818 <        new Thread(new CheckedRunnable() {
819 <            void realRun() {
818 >
819 >        Thread t = newStartedThread(new CheckedRunnable() {
820 >            void realRun() throws InterruptedException {
821 >                Thread.sleep(SMALL_DELAY_MS);
822                  threadAssertTrue(q.hasWaitingConsumer());
823                  waiting.setWaitingConsumer(q.getWaitingConsumerCount());
824                  threadAssertTrue(q.offer(new Object()));
825 <            }}).start();
825 >            }});
826 >
827          assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
828          assertTrue(q.getWaitingConsumerCount()
829                     < waiting.getWaitingConsumers());
830 +        t.join();
831      }
832  
833      /**
# Line 846 | Line 850 | public class LinkedTransferQueueTest ext
850          final LinkedTransferQueue<Integer> q
851              = new LinkedTransferQueue<Integer>();
852  
853 <        new Thread(new CheckedRunnable() {
853 >        Thread t = newStartedThread(new CheckedRunnable() {
854              void realRun() throws InterruptedException {
855                  q.transfer(SIZE);
856                  threadAssertTrue(q.isEmpty());
857 <            }}).start();
857 >            }});
858  
859          Thread.sleep(SHORT_DELAY_MS);
860          assertEquals(1, q.size());
861          assertEquals(SIZE, (int) q.poll());
862          assertTrue(q.isEmpty());
863 +        t.join();
864      }
865  
866      /**
# Line 865 | Line 870 | public class LinkedTransferQueueTest ext
870          final LinkedTransferQueue<Integer> q
871              = new LinkedTransferQueue<Integer>();
872  
873 <        Thread first = new Thread(new CheckedRunnable() {
873 >        Thread first = newStartedThread(new CheckedRunnable() {
874              void realRun() throws InterruptedException {
875                  Integer i = SIZE + 1;
876                  q.transfer(i);
877                  threadAssertTrue(!q.contains(i));
878                  threadAssertEquals(1, q.size());
879              }});
875 –        first.start();
880  
881 <        Thread interruptedThread = new Thread(new CheckedInterruptedRunnable() {
882 <            void realRun() throws InterruptedException {
883 <                while (q.size() == 0)
884 <                    Thread.yield();
885 <                q.transfer(SIZE);
886 <            }});
887 <        interruptedThread.start();
881 >        Thread interruptedThread = newStartedThread(
882 >            new CheckedInterruptedRunnable() {
883 >                void realRun() throws InterruptedException {
884 >                    while (q.size() == 0)
885 >                        Thread.yield();
886 >                    q.transfer(SIZE);
887 >                }});
888  
889          while (q.size() < 2)
890              Thread.yield();
# Line 900 | Line 904 | public class LinkedTransferQueueTest ext
904       */
905      public void testTransfer4() throws InterruptedException {
906          final LinkedTransferQueue q = new LinkedTransferQueue();
907 <        new Thread(new CheckedRunnable() {
907 >
908 >        Thread t = newStartedThread(new CheckedRunnable() {
909              void realRun() throws InterruptedException {
910                  q.transfer(four);
911                  threadAssertFalse(q.contains(four));
912                  threadAssertEquals(three, q.poll());
913 <            }}).start();
914 <        Thread.sleep(MEDIUM_DELAY_MS);
913 >            }});
914 >
915 >        Thread.sleep(SHORT_DELAY_MS);
916          assertTrue(q.offer(three));
917          assertEquals(four, q.poll());
918 +        t.join();
919      }
920  
921      /**
# Line 919 | Line 926 | public class LinkedTransferQueueTest ext
926          final LinkedTransferQueue<Integer> q
927              = new LinkedTransferQueue<Integer>();
928  
929 <        new Thread(new CheckedRunnable() {
929 >        Thread t = newStartedThread(new CheckedRunnable() {
930              void realRun() throws InterruptedException {
931                  q.transfer(SIZE);
932                  threadAssertTrue(q.isEmpty());
933 <            }}).start();
933 >            }});
934  
935          Thread.sleep(SHORT_DELAY_MS);
936          assertEquals(SIZE, (int) q.take());
937          assertTrue(q.isEmpty());
938 +        t.join();
939      }
940  
941      /**
# Line 937 | Line 945 | public class LinkedTransferQueueTest ext
945          try {
946              final LinkedTransferQueue q = new LinkedTransferQueue();
947              q.tryTransfer(null);
948 <            this.shouldThrow();
948 >            shouldThrow();
949          } catch (NullPointerException ex) {
950          }
951      }
# Line 961 | Line 969 | public class LinkedTransferQueueTest ext
969      public void testTryTransfer3() throws InterruptedException {
970          final Object hotPotato = new Object();
971          final LinkedTransferQueue q = new LinkedTransferQueue();
972 <        new Thread(new CheckedRunnable() {
972 >
973 >        Thread t = newStartedThread(new CheckedRunnable() {
974              void realRun() {
975                  while (! q.hasWaitingConsumer())
976                      Thread.yield();
# Line 969 | Line 978 | public class LinkedTransferQueueTest ext
978                  threadAssertTrue(q.isEmpty());
979                  threadAssertTrue(q.size() == 0);
980                  threadAssertTrue(q.tryTransfer(hotPotato));
981 <            }}).start();
982 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) == hotPotato);
981 >            }});
982 >
983 >        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
984          assertTrue(q.isEmpty());
985 +        t.join();
986      }
987  
988      /**
# Line 981 | Line 992 | public class LinkedTransferQueueTest ext
992      public void testTryTransfer4() throws InterruptedException {
993          final Object hotPotato = new Object();
994          final LinkedTransferQueue q = new LinkedTransferQueue();
995 <        new Thread(new CheckedRunnable() {
995 >
996 >        Thread t = newStartedThread(new CheckedRunnable() {
997              void realRun() {
998                  while (! q.hasWaitingConsumer())
999                      Thread.yield();
# Line 989 | Line 1001 | public class LinkedTransferQueueTest ext
1001                  threadAssertTrue(q.isEmpty());
1002                  threadAssertTrue(q.size() == 0);
1003                  threadAssertTrue(q.tryTransfer(hotPotato));
1004 <            }}).start();
1004 >            }});
1005 >
1006          assertTrue(q.take() == hotPotato);
1007          assertTrue(q.isEmpty());
1008 +        t.join();
1009      }
1010  
1011      /**
# Line 1000 | Line 1014 | public class LinkedTransferQueueTest ext
1014       */
1015      public void testTryTransfer5() throws InterruptedException {
1016          final LinkedTransferQueue q = new LinkedTransferQueue();
1017 <        Thread toInterrupt = new Thread(new CheckedInterruptedRunnable() {
1017 >
1018 >        Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1019              void realRun() throws InterruptedException {
1020                  q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1021              }});
1022 <        toInterrupt.start();
1022 >
1023          Thread.sleep(SMALL_DELAY_MS);
1024          toInterrupt.interrupt();
1025 +        toInterrupt.join();
1026      }
1027  
1028      /**
# Line 1014 | Line 1030 | public class LinkedTransferQueueTest ext
1030       */
1031      public void testTryTransfer6() throws InterruptedException {
1032          final LinkedTransferQueue q = new LinkedTransferQueue();
1033 <        new Thread(new CheckedRunnable() {
1033 >
1034 >        Thread t = newStartedThread(new CheckedRunnable() {
1035              void realRun() throws InterruptedException {
1036                  threadAssertFalse
1037                      (q.tryTransfer(new Object(),
1038                                     SHORT_DELAY_MS, MILLISECONDS));
1039 <            }}).start();
1040 <        Thread.sleep(LONG_DELAY_MS);
1039 >            }});
1040 >
1041 >        Thread.sleep(SMALL_DELAY_MS);
1042          assertTrue(q.isEmpty());
1043 +        t.join();
1044      }
1045  
1046      /**
# Line 1031 | Line 1050 | public class LinkedTransferQueueTest ext
1050      public void testTryTransfer7() throws InterruptedException {
1051          final LinkedTransferQueue q = new LinkedTransferQueue();
1052          assertTrue(q.offer(four));
1053 <        new Thread(new CheckedRunnable() {
1053 >
1054 >        Thread t = newStartedThread(new CheckedRunnable() {
1055              void realRun() throws InterruptedException {
1056                  threadAssertTrue(q.tryTransfer(five,
1057 <                                               LONG_DELAY_MS, MILLISECONDS));
1057 >                                               MEDIUM_DELAY_MS, MILLISECONDS));
1058                  threadAssertTrue(q.isEmpty());
1059 <            }}).start();
1059 >            }});
1060 >
1061          Thread.sleep(SHORT_DELAY_MS);
1062          assertEquals(2, q.size());
1063          assertEquals(four, q.poll());
1064          assertEquals(five, q.poll());
1065          assertTrue(q.isEmpty());
1066 +        t.join();
1067      }
1068  
1069      /**

Diff Legend

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