ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/SynchronousQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.46 by jsr166, Sat Jan 17 22:55:06 2015 UTC vs.
Revision 1.65 by jsr166, Tue Aug 13 23:06:39 2019 UTC

# Line 36 | Line 36 | public class SynchronousQueueTest extend
36      }
37  
38      public static void main(String[] args) {
39 <        junit.textui.TestRunner.run(suite());
39 >        main(suite(), args);
40      }
41  
42      public static Test suite() {
# Line 96 | Line 96 | public class SynchronousQueueTest extend
96      }
97  
98      /**
99 <     * addAll throws ISE if no active taker
99 >     * addAll throws IllegalStateException if no active taker
100       */
101      public void testAddAll_ISE()      { testAddAll_ISE(false); }
102      public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
# Line 138 | Line 138 | public class SynchronousQueueTest extend
138              }});
139  
140          await(pleaseInterrupt);
141 <        assertThreadStaysAlive(t);
141 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
142          t.interrupt();
143          awaitTermination(t);
144          assertEquals(0, q.remainingCapacity());
# Line 158 | Line 158 | public class SynchronousQueueTest extend
158                  pleaseTake.countDown();
159                  q.put(one);
160  
161 +                Thread.currentThread().interrupt();
162 +                try {
163 +                    q.put(99);
164 +                    shouldThrow();
165 +                } catch (InterruptedException success) {}
166 +                assertFalse(Thread.interrupted());
167 +
168                  pleaseInterrupt.countDown();
169                  try {
170                      q.put(99);
# Line 172 | Line 179 | public class SynchronousQueueTest extend
179          catch (InterruptedException e) { threadUnexpectedException(e); }
180  
181          await(pleaseInterrupt);
182 <        assertThreadStaysAlive(t);
182 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
183          t.interrupt();
184          awaitTermination(t);
185          assertEquals(0, q.remainingCapacity());
# Line 181 | Line 188 | public class SynchronousQueueTest extend
188      /**
189       * timed offer times out if elements not taken
190       */
191 <    public void testTimedOffer()      { testTimedOffer(false); }
192 <    public void testTimedOffer_fair() { testTimedOffer(true); }
186 <    public void testTimedOffer(boolean fair) {
191 >    public void testTimedOffer() {
192 >        final boolean fair = randomBoolean();
193          final SynchronousQueue q = new SynchronousQueue(fair);
194          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
195          Thread t = newStartedThread(new CheckedRunnable() {
196              public void realRun() throws InterruptedException {
197                  long startTime = System.nanoTime();
198 +
199                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
200                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
201 +
202 +                Thread.currentThread().interrupt();
203 +                try {
204 +                    q.offer(new Object(), randomTimeout(), randomTimeUnit());
205 +                    shouldThrow();
206 +                } catch (InterruptedException success) {}
207 +                assertFalse(Thread.interrupted());
208 +
209                  pleaseInterrupt.countDown();
210                  try {
211 <                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
211 >                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
212                      shouldThrow();
213                  } catch (InterruptedException success) {}
214 +                assertFalse(Thread.interrupted());
215 +
216 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
217              }});
218  
219          await(pleaseInterrupt);
220 <        assertThreadStaysAlive(t);
220 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
221          t.interrupt();
222          awaitTermination(t);
223      }
# Line 228 | Line 246 | public class SynchronousQueueTest extend
246      /**
247       * timed poll with nonzero timeout times out if no active putter
248       */
249 <    public void testTimedPoll()      { testTimedPoll(false); }
250 <    public void testTimedPoll_fair() { testTimedPoll(true); }
233 <    public void testTimedPoll(boolean fair) {
249 >    public void testTimedPoll() {
250 >        final boolean fair = randomBoolean();
251          final SynchronousQueue q = new SynchronousQueue(fair);
252 <        long startTime = System.nanoTime();
252 >        final long startTime = System.nanoTime();
253          try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
254          catch (InterruptedException e) { threadUnexpectedException(e); }
255          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
# Line 242 | Line 259 | public class SynchronousQueueTest extend
259       * timed poll before a delayed offer times out, returning null;
260       * after offer succeeds; on interruption throws
261       */
262 <    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
263 <    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
247 <    public void testTimedPollWithOffer(boolean fair) {
262 >    public void testTimedPollWithOffer() {
263 >        final boolean fair = randomBoolean();
264          final SynchronousQueue q = new SynchronousQueue(fair);
265          final CountDownLatch pleaseOffer = new CountDownLatch(1);
266          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
# Line 257 | Line 273 | public class SynchronousQueueTest extend
273                  pleaseOffer.countDown();
274                  startTime = System.nanoTime();
275                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
260 –                assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
276  
277                  Thread.currentThread().interrupt();
278                  try {
279 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
279 >                    q.poll(randomTimeout(), randomTimeUnit());
280                      shouldThrow();
281                  } catch (InterruptedException success) {}
282                  assertFalse(Thread.interrupted());
# Line 272 | Line 287 | public class SynchronousQueueTest extend
287                      shouldThrow();
288                  } catch (InterruptedException success) {}
289                  assertFalse(Thread.interrupted());
290 +
291 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
292              }});
293  
294          await(pleaseOffer);
295          long startTime = System.nanoTime();
296          try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
297          catch (InterruptedException e) { threadUnexpectedException(e); }
298 <        assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
298 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
299  
300          await(pleaseInterrupt);
301 <        assertThreadStaysAlive(t);
301 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
302          t.interrupt();
303          awaitTermination(t);
304      }
# Line 400 | Line 417 | public class SynchronousQueueTest extend
417      public void testToArray2()      { testToArray2(false); }
418      public void testToArray2_fair() { testToArray2(true); }
419      public void testToArray2(boolean fair) {
420 <        final SynchronousQueue<Integer> q
404 <            = new SynchronousQueue<Integer>(fair);
420 >        final SynchronousQueue<Integer> q = new SynchronousQueue<>(fair);
421          Integer[] a;
422  
423          a = new Integer[0];
# Line 423 | Line 439 | public class SynchronousQueueTest extend
439      public void testToArray_null(boolean fair) {
440          final SynchronousQueue q = new SynchronousQueue(fair);
441          try {
442 <            Object[] o = q.toArray(null);
442 >            Object[] o = q.toArray((Object[])null);
443              shouldThrow();
444          } catch (NullPointerException success) {}
445      }
# Line 438 | Line 454 | public class SynchronousQueueTest extend
454      }
455  
456      /**
457 <     * iterator remove throws ISE
457 >     * iterator remove throws IllegalStateException
458       */
459      public void testIteratorRemove()      { testIteratorRemove(false); }
460      public void testIteratorRemove_fair() { testIteratorRemove(true); }
# Line 469 | Line 485 | public class SynchronousQueueTest extend
485      public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
486      public void testOfferInExecutor(boolean fair) {
487          final SynchronousQueue q = new SynchronousQueue(fair);
472 –        ExecutorService executor = Executors.newFixedThreadPool(2);
488          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
489 +        final ExecutorService executor = Executors.newFixedThreadPool(2);
490 +        try (PoolCleaner cleaner = cleaner(executor)) {
491  
492 <        executor.execute(new CheckedRunnable() {
493 <            public void realRun() throws InterruptedException {
494 <                assertFalse(q.offer(one));
495 <                threadsStarted.await();
496 <                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
497 <                assertEquals(0, q.remainingCapacity());
498 <            }});
499 <
500 <        executor.execute(new CheckedRunnable() {
501 <            public void realRun() throws InterruptedException {
502 <                threadsStarted.await();
503 <                assertSame(one, q.take());
504 <            }});
505 <
489 <        joinPool(executor);
492 >            executor.execute(new CheckedRunnable() {
493 >                public void realRun() throws InterruptedException {
494 >                    assertFalse(q.offer(one));
495 >                    threadsStarted.await();
496 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
497 >                    assertEquals(0, q.remainingCapacity());
498 >                }});
499 >
500 >            executor.execute(new CheckedRunnable() {
501 >                public void realRun() throws InterruptedException {
502 >                    threadsStarted.await();
503 >                    assertSame(one, q.take());
504 >                }});
505 >        }
506      }
507  
508      /**
# Line 497 | Line 513 | public class SynchronousQueueTest extend
513      public void testPollInExecutor(boolean fair) {
514          final SynchronousQueue q = new SynchronousQueue(fair);
515          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
516 <        ExecutorService executor = Executors.newFixedThreadPool(2);
517 <        executor.execute(new CheckedRunnable() {
518 <            public void realRun() throws InterruptedException {
519 <                assertNull(q.poll());
520 <                threadsStarted.await();
521 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
522 <                assertTrue(q.isEmpty());
523 <            }});
524 <
525 <        executor.execute(new CheckedRunnable() {
526 <            public void realRun() throws InterruptedException {
527 <                threadsStarted.await();
528 <                q.put(one);
529 <            }});
530 <
531 <        joinPool(executor);
516 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
517 >        try (PoolCleaner cleaner = cleaner(executor)) {
518 >            executor.execute(new CheckedRunnable() {
519 >                public void realRun() throws InterruptedException {
520 >                    assertNull(q.poll());
521 >                    threadsStarted.await();
522 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
523 >                    assertTrue(q.isEmpty());
524 >                }});
525 >
526 >            executor.execute(new CheckedRunnable() {
527 >                public void realRun() throws InterruptedException {
528 >                    threadsStarted.await();
529 >                    q.put(one);
530 >                }});
531 >        }
532      }
533  
534      /**
535 <     * a deserialized serialized queue is usable
535 >     * a deserialized/reserialized queue is usable
536       */
537      public void testSerialization() {
538          final SynchronousQueue x = new SynchronousQueue();
# Line 569 | Line 585 | public class SynchronousQueueTest extend
585                  fail("timed out");
586              Thread.yield();
587          }
588 <        assertTrue(l.size() == 1);
588 >        assertEquals(1, l.size());
589          assertSame(one, l.get(0));
590          awaitTermination(t);
591      }
# Line 590 | Line 606 | public class SynchronousQueueTest extend
606              }});
607  
608          ArrayList l = new ArrayList();
609 <        delay(SHORT_DELAY_MS);
610 <        q.drainTo(l, 1);
609 >        int drained;
610 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
611 >        assertEquals(1, drained);
612          assertEquals(1, l.size());
613 <        q.drainTo(l, 1);
613 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
614 >        assertEquals(1, drained);
615          assertEquals(2, l.size());
616          assertTrue(l.contains(one));
617          assertTrue(l.contains(two));

Diff Legend

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