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.80 by jsr166, Tue Aug 15 20:30:30 2017 UTC vs.
Revision 1.84 by jsr166, Fri Sep 6 22:43:50 2019 UTC

# Line 227 | Line 227 | public class LinkedTransferQueueTest ext
227              }});
228  
229          await(pleaseInterrupt);
230 <        assertThreadBlocks(t, Thread.State.WAITING);
230 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
231          t.interrupt();
232          awaitTermination(t);
233      }
# Line 281 | Line 281 | public class LinkedTransferQueueTest ext
281          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282          Thread t = newStartedThread(new CheckedRunnable() {
283              public void realRun() throws InterruptedException {
284 –                long startTime = System.nanoTime();
284                  for (int i = 0; i < SIZE; i++)
285                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
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                  assertFalse(Thread.interrupted());
293  
294                  pleaseInterrupt.countDown();
295                  try {
296 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
296 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
297                      shouldThrow();
298                  } catch (InterruptedException success) {}
299                  assertFalse(Thread.interrupted());
301 –
302 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
300              }});
301  
302          await(pleaseInterrupt);
303 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
303 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
304          t.interrupt();
305          awaitTermination(t);
306          checkEmpty(q);
# Line 317 | 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 {
320 –                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                  assertFalse(Thread.interrupted());
329 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
325              }});
326  
327          awaitTermination(t);
# Line 475 | 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 489 | 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 957 | 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 968 | 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 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
972 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
973          t.interrupt();
974          awaitTermination(t);
975          checkEmpty(q);

Diff Legend

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