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.37 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.63 by jsr166, Sun Aug 11 22:29:27 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.Arrays;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11   import java.util.ArrayList;
12 + import java.util.Arrays;
13   import java.util.Collection;
14   import java.util.Iterator;
15   import java.util.NoSuchElementException;
# Line 17 | Line 18 | import java.util.concurrent.CountDownLat
18   import java.util.concurrent.Executors;
19   import java.util.concurrent.ExecutorService;
20   import java.util.concurrent.SynchronousQueue;
21 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
22 < import java.io.*;
21 > import java.util.concurrent.ThreadLocalRandom;
22 >
23 > import junit.framework.Test;
24  
25   public class SynchronousQueueTest extends JSR166TestCase {
26  
# Line 35 | Line 37 | public class SynchronousQueueTest extend
37      }
38  
39      public static void main(String[] args) {
40 <        junit.textui.TestRunner.run(suite());
40 >        main(suite(), args);
41      }
42  
43      public static Test suite() {
# Line 95 | Line 97 | public class SynchronousQueueTest extend
97      }
98  
99      /**
100 <     * addAll throws ISE if no active taker
100 >     * addAll throws IllegalStateException if no active taker
101       */
102      public void testAddAll_ISE()      { testAddAll_ISE(false); }
103      public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
# Line 137 | Line 139 | public class SynchronousQueueTest extend
139              }});
140  
141          await(pleaseInterrupt);
142 <        assertThreadStaysAlive(t);
142 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
143          t.interrupt();
144          awaitTermination(t);
145          assertEquals(0, q.remainingCapacity());
# Line 157 | Line 159 | public class SynchronousQueueTest extend
159                  pleaseTake.countDown();
160                  q.put(one);
161  
162 +                Thread.currentThread().interrupt();
163 +                try {
164 +                    q.put(99);
165 +                    shouldThrow();
166 +                } catch (InterruptedException success) {}
167 +                assertFalse(Thread.interrupted());
168 +
169                  pleaseInterrupt.countDown();
170                  try {
171                      q.put(99);
# Line 166 | Line 175 | public class SynchronousQueueTest extend
175              }});
176  
177          await(pleaseTake);
178 <        assertEquals(q.remainingCapacity(), 0);
178 >        assertEquals(0, q.remainingCapacity());
179          try { assertSame(one, q.take()); }
180          catch (InterruptedException e) { threadUnexpectedException(e); }
181  
182          await(pleaseInterrupt);
183 <        assertThreadStaysAlive(t);
183 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
184          t.interrupt();
185          awaitTermination(t);
186 <        assertEquals(q.remainingCapacity(), 0);
186 >        assertEquals(0, q.remainingCapacity());
187      }
188  
189      /**
190       * timed offer times out if elements not taken
191       */
192 <    public void testTimedOffer()      { testTimedOffer(false); }
193 <    public void testTimedOffer_fair() { testTimedOffer(true); }
185 <    public void testTimedOffer(boolean fair) {
192 >    public void testTimedOffer() {
193 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
194          final SynchronousQueue q = new SynchronousQueue(fair);
195          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
196          Thread t = newStartedThread(new CheckedRunnable() {
197              public void realRun() throws InterruptedException {
198                  long startTime = System.nanoTime();
199 +
200                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
201                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
202 +
203 +                Thread.currentThread().interrupt();
204 +                try {
205 +                    q.offer(new Object(), randomTimeout(), randomTimeUnit());
206 +                    shouldThrow();
207 +                } catch (InterruptedException success) {}
208 +                assertFalse(Thread.interrupted());
209 +
210                  pleaseInterrupt.countDown();
211                  try {
212 <                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
212 >                    q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
213                      shouldThrow();
214                  } catch (InterruptedException success) {}
215 +                assertFalse(Thread.interrupted());
216 +
217 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
218              }});
219  
220          await(pleaseInterrupt);
221 <        assertThreadStaysAlive(t);
221 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
222          t.interrupt();
223          awaitTermination(t);
224      }
# Line 227 | Line 247 | public class SynchronousQueueTest extend
247      /**
248       * timed poll with nonzero timeout times out if no active putter
249       */
250 <    public void testTimedPoll()      { testTimedPoll(false); }
251 <    public void testTimedPoll_fair() { testTimedPoll(true); }
232 <    public void testTimedPoll(boolean fair) {
250 >    public void testTimedPoll() {
251 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
252          final SynchronousQueue q = new SynchronousQueue(fair);
253 <        long startTime = System.nanoTime();
253 >        final long startTime = System.nanoTime();
254          try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
255          catch (InterruptedException e) { threadUnexpectedException(e); }
256          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
# Line 241 | Line 260 | public class SynchronousQueueTest extend
260       * timed poll before a delayed offer times out, returning null;
261       * after offer succeeds; on interruption throws
262       */
263 <    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
264 <    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
246 <    public void testTimedPollWithOffer(boolean fair) {
263 >    public void testTimedPollWithOffer() {
264 >        final boolean fair = ThreadLocalRandom.current().nextBoolean();
265          final SynchronousQueue q = new SynchronousQueue(fair);
266          final CountDownLatch pleaseOffer = new CountDownLatch(1);
267          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
# Line 256 | Line 274 | public class SynchronousQueueTest extend
274                  pleaseOffer.countDown();
275                  startTime = System.nanoTime();
276                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
259 –                assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
277  
278                  Thread.currentThread().interrupt();
279                  try {
280 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
280 >                    q.poll(randomTimeout(), randomTimeUnit());
281                      shouldThrow();
282                  } catch (InterruptedException success) {}
283                  assertFalse(Thread.interrupted());
# Line 271 | Line 288 | public class SynchronousQueueTest extend
288                      shouldThrow();
289                  } catch (InterruptedException success) {}
290                  assertFalse(Thread.interrupted());
291 +
292 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
293              }});
294  
295          await(pleaseOffer);
296          long startTime = System.nanoTime();
297          try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
298          catch (InterruptedException e) { threadUnexpectedException(e); }
299 <        assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
299 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
300  
301          await(pleaseInterrupt);
302 <        assertThreadStaysAlive(t);
302 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
303          t.interrupt();
304          awaitTermination(t);
305      }
# Line 322 | Line 341 | public class SynchronousQueueTest extend
341      }
342  
343      /**
325 –     * remove(x) returns false
326 –     */
327 –    public void testRemoveElement()      { testRemoveElement(false); }
328 –    public void testRemoveElement_fair() { testRemoveElement(true); }
329 –    public void testRemoveElement(boolean fair) {
330 –        final SynchronousQueue q = new SynchronousQueue(fair);
331 –        assertFalse(q.remove(zero));
332 –        assertTrue(q.isEmpty());
333 –    }
334 –
335 –    /**
344       * contains returns false
345       */
346      public void testContains()      { testContains(false); }
# Line 400 | Line 408 | public class SynchronousQueueTest extend
408      public void testToArray(boolean fair) {
409          final SynchronousQueue q = new SynchronousQueue(fair);
410          Object[] o = q.toArray();
411 <        assertEquals(o.length, 0);
411 >        assertEquals(0, o.length);
412      }
413  
414      /**
415 <     * toArray(a) is nulled at position 0
415 >     * toArray(Integer array) returns its argument with the first
416 >     * element (if present) nulled out
417       */
418      public void testToArray2()      { testToArray2(false); }
419      public void testToArray2_fair() { testToArray2(true); }
420      public void testToArray2(boolean fair) {
421 <        final SynchronousQueue q = new SynchronousQueue(fair);
422 <        Integer[] ints = new Integer[1];
423 <        assertNull(ints[0]);
421 >        final SynchronousQueue<Integer> q = new SynchronousQueue<>(fair);
422 >        Integer[] a;
423 >
424 >        a = new Integer[0];
425 >        assertSame(a, q.toArray(a));
426 >
427 >        a = new Integer[3];
428 >        Arrays.fill(a, 42);
429 >        assertSame(a, q.toArray(a));
430 >        assertNull(a[0]);
431 >        for (int i = 1; i < a.length; i++)
432 >            assertEquals(42, (int) a[i]);
433      }
434  
435      /**
# Line 422 | Line 440 | public class SynchronousQueueTest extend
440      public void testToArray_null(boolean fair) {
441          final SynchronousQueue q = new SynchronousQueue(fair);
442          try {
443 <            Object o[] = q.toArray(null);
443 >            Object[] o = q.toArray((Object[])null);
444              shouldThrow();
445          } catch (NullPointerException success) {}
446      }
# Line 433 | Line 451 | public class SynchronousQueueTest extend
451      public void testIterator()      { testIterator(false); }
452      public void testIterator_fair() { testIterator(true); }
453      public void testIterator(boolean fair) {
454 <        final SynchronousQueue q = new SynchronousQueue(fair);
437 <        Iterator it = q.iterator();
438 <        assertFalse(it.hasNext());
439 <        try {
440 <            Object x = it.next();
441 <            shouldThrow();
442 <        } catch (NoSuchElementException success) {}
454 >        assertIteratorExhausted(new SynchronousQueue(fair).iterator());
455      }
456  
457      /**
458 <     * iterator remove throws ISE
458 >     * iterator remove throws IllegalStateException
459       */
460      public void testIteratorRemove()      { testIteratorRemove(false); }
461      public void testIteratorRemove_fair() { testIteratorRemove(true); }
# Line 474 | Line 486 | public class SynchronousQueueTest extend
486      public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
487      public void testOfferInExecutor(boolean fair) {
488          final SynchronousQueue q = new SynchronousQueue(fair);
477 –        ExecutorService executor = Executors.newFixedThreadPool(2);
489          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
490 +        final ExecutorService executor = Executors.newFixedThreadPool(2);
491 +        try (PoolCleaner cleaner = cleaner(executor)) {
492  
493 <        executor.execute(new CheckedRunnable() {
494 <            public void realRun() throws InterruptedException {
495 <                assertFalse(q.offer(one));
496 <                threadsStarted.await();
497 <                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
498 <                assertEquals(0, q.remainingCapacity());
499 <            }});
500 <
501 <        executor.execute(new CheckedRunnable() {
502 <            public void realRun() throws InterruptedException {
503 <                threadsStarted.await();
504 <                assertSame(one, q.take());
505 <            }});
506 <
494 <        joinPool(executor);
493 >            executor.execute(new CheckedRunnable() {
494 >                public void realRun() throws InterruptedException {
495 >                    assertFalse(q.offer(one));
496 >                    threadsStarted.await();
497 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
498 >                    assertEquals(0, q.remainingCapacity());
499 >                }});
500 >
501 >            executor.execute(new CheckedRunnable() {
502 >                public void realRun() throws InterruptedException {
503 >                    threadsStarted.await();
504 >                    assertSame(one, q.take());
505 >                }});
506 >        }
507      }
508  
509      /**
# Line 502 | Line 514 | public class SynchronousQueueTest extend
514      public void testPollInExecutor(boolean fair) {
515          final SynchronousQueue q = new SynchronousQueue(fair);
516          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
517 <        ExecutorService executor = Executors.newFixedThreadPool(2);
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 <        joinPool(executor);
517 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
518 >        try (PoolCleaner cleaner = cleaner(executor)) {
519 >            executor.execute(new CheckedRunnable() {
520 >                public void realRun() throws InterruptedException {
521 >                    assertNull(q.poll());
522 >                    threadsStarted.await();
523 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
524 >                    assertTrue(q.isEmpty());
525 >                }});
526 >
527 >            executor.execute(new CheckedRunnable() {
528 >                public void realRun() throws InterruptedException {
529 >                    threadsStarted.await();
530 >                    q.put(one);
531 >                }});
532 >        }
533      }
534  
535      /**
536 <     * a deserialized serialized queue is usable
536 >     * a deserialized/reserialized queue is usable
537       */
538 <    public void testSerialization()      { testSerialization(false); }
539 <    public void testSerialization_fair() { testSerialization(true); }
540 <    public void testSerialization(boolean fair) {
541 <        final SynchronousQueue q = new SynchronousQueue(fair);
542 <        final SynchronousQueue r = serialClone(q);
543 <        assertTrue(q != r);
544 <        assertEquals(q.size(), r.size());
545 <        while (!q.isEmpty())
546 <            assertEquals(q.remove(), r.remove());
538 >    public void testSerialization() {
539 >        final SynchronousQueue x = new SynchronousQueue();
540 >        final SynchronousQueue y = new SynchronousQueue(false);
541 >        final SynchronousQueue z = new SynchronousQueue(true);
542 >        assertSerialEquals(x, y);
543 >        assertNotSerialEquals(x, z);
544 >        SynchronousQueue[] qs = { x, y, z };
545 >        for (SynchronousQueue q : qs) {
546 >            SynchronousQueue clone = serialClone(q);
547 >            assertNotSame(q, clone);
548 >            assertSerialEquals(q, clone);
549 >            assertTrue(clone.isEmpty());
550 >            assertEquals(0, clone.size());
551 >            assertEquals(0, clone.remainingCapacity());
552 >            assertFalse(clone.offer(zero));
553 >        }
554      }
555  
556      /**
# Line 543 | Line 562 | public class SynchronousQueueTest extend
562          final SynchronousQueue q = new SynchronousQueue(fair);
563          ArrayList l = new ArrayList();
564          q.drainTo(l);
565 <        assertEquals(q.size(), 0);
566 <        assertEquals(l.size(), 0);
565 >        assertEquals(0, q.size());
566 >        assertEquals(0, l.size());
567      }
568  
569      /**
# Line 567 | Line 586 | public class SynchronousQueueTest extend
586                  fail("timed out");
587              Thread.yield();
588          }
589 <        assertTrue(l.size() == 1);
589 >        assertEquals(1, l.size());
590          assertSame(one, l.get(0));
591          awaitTermination(t);
592      }
# Line 588 | Line 607 | public class SynchronousQueueTest extend
607              }});
608  
609          ArrayList l = new ArrayList();
610 <        delay(SHORT_DELAY_MS);
611 <        q.drainTo(l, 1);
610 >        int drained;
611 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
612 >        assertEquals(1, drained);
613          assertEquals(1, l.size());
614 <        q.drainTo(l, 1);
614 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
615 >        assertEquals(1, drained);
616          assertEquals(2, l.size());
617          assertTrue(l.contains(one));
618          assertTrue(l.contains(two));
# Line 599 | Line 620 | public class SynchronousQueueTest extend
620          awaitTermination(t2);
621      }
622  
623 +    /**
624 +     * remove(null), contains(null) always return false
625 +     */
626 +    public void testNeverContainsNull() {
627 +        Collection<?> q = new SynchronousQueue();
628 +        assertFalse(q.contains(null));
629 +        assertFalse(q.remove(null));
630 +    }
631 +
632   }

Diff Legend

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