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.66 by jsr166, Sun Oct 18 04:48:32 2015 UTC vs.
Revision 1.84 by jsr166, Fri Sep 6 22:43:50 2019 UTC

# Line 15 | Line 15 | import java.util.List;
15   import java.util.NoSuchElementException;
16   import java.util.Queue;
17   import java.util.concurrent.BlockingQueue;
18 + import java.util.concurrent.Callable;
19   import java.util.concurrent.CountDownLatch;
20   import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
# Line 24 | Line 25 | import junit.framework.Test;
25  
26   @SuppressWarnings({"unchecked", "rawtypes"})
27   public class LinkedTransferQueueTest extends JSR166TestCase {
27 –    static class Implementation implements CollectionImplementation {
28 –        public Class<?> klazz() { return LinkedTransferQueue.class; }
29 –        public Collection emptyCollection() { return new LinkedTransferQueue(); }
30 –        public Object makeElement(int i) { return i; }
31 –        public boolean isConcurrent() { return true; }
32 –        public boolean permitsNulls() { return false; }
33 –    }
34 –
28      public static class Generic extends BlockingQueueTest {
29          protected BlockingQueue emptyCollection() {
30              return new LinkedTransferQueue();
# Line 43 | Line 36 | public class LinkedTransferQueueTest ext
36      }
37  
38      public static Test suite() {
39 +        class Implementation implements CollectionImplementation {
40 +            public Class<?> klazz() { return LinkedTransferQueue.class; }
41 +            public Collection emptyCollection() { return new LinkedTransferQueue(); }
42 +            public Object makeElement(int i) { return i; }
43 +            public boolean isConcurrent() { return true; }
44 +            public boolean permitsNulls() { return false; }
45 +        }
46          return newTestSuite(LinkedTransferQueueTest.class,
47                              new Generic().testSuite(),
48                              CollectionTest.testSuite(new Implementation()));
# Line 183 | Line 183 | public class LinkedTransferQueueTest ext
183       * all elements successfully put are contained
184       */
185      public void testPut() {
186 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
186 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
187          for (int i = 0; i < SIZE; ++i) {
188              assertEquals(i, q.size());
189              q.put(i);
# Line 209 | Line 209 | public class LinkedTransferQueueTest ext
209          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210          Thread t = newStartedThread(new CheckedRunnable() {
211              public void realRun() throws InterruptedException {
212 <                for (int i = 0; i < SIZE; ++i) {
213 <                    assertEquals(i, q.take());
214 <                }
212 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213  
214                  Thread.currentThread().interrupt();
215                  try {
# Line 229 | Line 227 | public class LinkedTransferQueueTest ext
227              }});
228  
229          await(pleaseInterrupt);
230 <        assertThreadStaysAlive(t);
230 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
231          t.interrupt();
232          awaitTermination(t);
233      }
# Line 280 | Line 278 | public class LinkedTransferQueueTest ext
278       */
279      public void testInterruptedTimedPoll() throws InterruptedException {
280          final BlockingQueue<Integer> q = populatedQueue(SIZE);
281 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
281 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282          Thread t = newStartedThread(new CheckedRunnable() {
283              public void realRun() throws InterruptedException {
284 <                long startTime = System.nanoTime();
287 <                for (int i = 0; i < SIZE; ++i)
284 >                for (int i = 0; i < SIZE; i++)
285                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
286 <                aboutToWait.countDown();
286 >
287 >                Thread.currentThread().interrupt();
288                  try {
289 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
289 >                    q.poll(randomTimeout(), randomTimeUnit());
290                      shouldThrow();
291                  } catch (InterruptedException success) {}
292 <                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
292 >                assertFalse(Thread.interrupted());
293 >
294 >                pleaseInterrupt.countDown();
295 >                try {
296 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
297 >                    shouldThrow();
298 >                } catch (InterruptedException success) {}
299 >                assertFalse(Thread.interrupted());
300              }});
301  
302 <        aboutToWait.await();
303 <        waitForThreadToEnterWaitState(t);
302 >        await(pleaseInterrupt);
303 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
304          t.interrupt();
305          awaitTermination(t);
306          checkEmpty(q);
# Line 309 | Line 314 | public class LinkedTransferQueueTest ext
314          final BlockingQueue<Integer> q = populatedQueue(SIZE);
315          Thread t = newStartedThread(new CheckedRunnable() {
316              public void realRun() throws InterruptedException {
312 –                long startTime = System.nanoTime();
317                  Thread.currentThread().interrupt();
318                  for (int i = 0; i < SIZE; ++i)
319 <                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
319 >                    assertEquals(i, (int) q.poll(randomTimeout(), randomTimeUnit()));
320                  try {
321 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
321 >                    q.poll(randomTimeout(), randomTimeUnit());
322                      shouldThrow();
323                  } catch (InterruptedException success) {}
324 <                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
324 >                assertFalse(Thread.interrupted());
325              }});
326  
327          awaitTermination(t);
# Line 416 | Line 420 | public class LinkedTransferQueueTest ext
420       */
421      public void testContainsAll() {
422          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
423 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
423 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
424          for (int i = 0; i < SIZE; ++i) {
425              assertTrue(q.containsAll(p));
426              assertFalse(p.containsAll(q));
# Line 466 | Line 470 | public class LinkedTransferQueueTest ext
470       */
471      public void testToArray() {
472          LinkedTransferQueue q = populatedQueue(SIZE);
473 <        Object[] o = q.toArray();
474 <        for (int i = 0; i < o.length; i++) {
475 <            assertSame(o[i], q.poll());
476 <        }
473 >        Object[] a = q.toArray();
474 >        assertSame(Object[].class, a.getClass());
475 >        for (Object o : a)
476 >            assertSame(o, q.poll());
477 >        assertTrue(q.isEmpty());
478      }
479  
480      /**
# Line 480 | Line 485 | public class LinkedTransferQueueTest ext
485          Integer[] ints = new Integer[SIZE];
486          Integer[] array = q.toArray(ints);
487          assertSame(ints, array);
488 <        for (int i = 0; i < ints.length; i++) {
489 <            assertSame(ints[i], q.poll());
490 <        }
488 >        for (Integer o : ints)
489 >            assertSame(o, q.poll());
490 >        assertTrue(q.isEmpty());
491      }
492  
493      /**
# Line 545 | Line 550 | public class LinkedTransferQueueTest ext
550       * iterator ordering is FIFO
551       */
552      public void testIteratorOrdering() {
553 <        final LinkedTransferQueue<Integer> q
549 <            = new LinkedTransferQueue<Integer>();
553 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
554          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
555          q.add(one);
556          q.add(two);
# Line 639 | Line 643 | public class LinkedTransferQueueTest ext
643      }
644  
645      /**
646 <     * A deserialized serialized queue has same elements in same order
646 >     * A deserialized/reserialized queue has same elements in same order
647       */
648      public void testSerialization() throws Exception {
649          Queue x = populatedQueue(SIZE);
# Line 741 | Line 745 | public class LinkedTransferQueueTest ext
745              }});
746  
747          threadStarted.await();
748 <        waitForThreadToEnterWaitState(t);
749 <        assertEquals(1, q.getWaitingConsumerCount());
750 <        assertTrue(q.hasWaitingConsumer());
748 >        Callable<Boolean> oneConsumer
749 >            = new Callable<Boolean>() { public Boolean call() {
750 >                return q.hasWaitingConsumer()
751 >                && q.getWaitingConsumerCount() == 1; }};
752 >        waitForThreadToEnterWaitState(t, oneConsumer);
753  
754          assertTrue(q.offer(one));
755          assertEquals(0, q.getWaitingConsumerCount());
# Line 764 | Line 770 | public class LinkedTransferQueueTest ext
770      }
771  
772      /**
773 <     * transfer waits until a poll occurs. The transfered element
774 <     * is returned by this associated poll.
773 >     * transfer waits until a poll occurs. The transferred element
774 >     * is returned by the associated poll.
775       */
776      public void testTransfer2() throws InterruptedException {
777 <        final LinkedTransferQueue<Integer> q
772 <            = new LinkedTransferQueue<Integer>();
777 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
778          final CountDownLatch threadStarted = new CountDownLatch(1);
779  
780          Thread t = newStartedThread(new CheckedRunnable() {
# Line 780 | Line 785 | public class LinkedTransferQueueTest ext
785              }});
786  
787          threadStarted.await();
788 <        waitForThreadToEnterWaitState(t);
789 <        assertEquals(1, q.size());
788 >        Callable<Boolean> oneElement
789 >            = new Callable<Boolean>() { public Boolean call() {
790 >                return !q.isEmpty() && q.size() == 1; }};
791 >        waitForThreadToEnterWaitState(t, oneElement);
792 >
793          assertSame(five, q.poll());
794          checkEmpty(q);
795          awaitTermination(t);
# Line 791 | Line 799 | public class LinkedTransferQueueTest ext
799       * transfer waits until a poll occurs, and then transfers in fifo order
800       */
801      public void testTransfer3() throws InterruptedException {
802 <        final LinkedTransferQueue<Integer> q
795 <            = new LinkedTransferQueue<Integer>();
802 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
803  
804          Thread first = newStartedThread(new CheckedRunnable() {
805              public void realRun() throws InterruptedException {
806                  q.transfer(four);
807 <                assertTrue(!q.contains(four));
807 >                assertFalse(q.contains(four));
808                  assertEquals(1, q.size());
809              }});
810  
# Line 844 | Line 851 | public class LinkedTransferQueueTest ext
851      }
852  
853      /**
854 <     * transfer waits until a take occurs. The transfered element
855 <     * is returned by this associated take.
854 >     * transfer waits until a take occurs. The transferred element
855 >     * is returned by the associated take.
856       */
857      public void testTransfer5() throws InterruptedException {
858 <        final LinkedTransferQueue<Integer> q
852 <            = new LinkedTransferQueue<Integer>();
858 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
859  
860          Thread t = newStartedThread(new CheckedRunnable() {
861              public void realRun() throws InterruptedException {
# Line 947 | Line 953 | public class LinkedTransferQueueTest ext
953                  long startTime = System.nanoTime();
954                  Thread.currentThread().interrupt();
955                  try {
956 <                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
956 >                    q.tryTransfer(new Object(), randomTimeout(), randomTimeUnit());
957                      shouldThrow();
958                  } catch (InterruptedException success) {}
959                  assertFalse(Thread.interrupted());
# Line 958 | Line 964 | public class LinkedTransferQueueTest ext
964                      shouldThrow();
965                  } catch (InterruptedException success) {}
966                  assertFalse(Thread.interrupted());
967 +
968                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
969              }});
970  
971          await(pleaseInterrupt);
972 <        assertThreadStaysAlive(t);
972 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
973          t.interrupt();
974          awaitTermination(t);
975          checkEmpty(q);
# Line 1030 | Line 1037 | public class LinkedTransferQueueTest ext
1037      }
1038  
1039      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1040 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1040 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1041          checkEmpty(q);
1042          for (int i = 0; i < n; i++) {
1043              assertEquals(i, q.size());

Diff Legend

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