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.40 by jsr166, Thu Dec 8 19:05:42 2011 UTC vs.
Revision 1.52 by jsr166, Sat Mar 18 20:42:20 2017 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;
15 – import java.util.Queue;
16   import java.util.concurrent.BlockingQueue;
17   import java.util.concurrent.CountDownLatch;
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;
21 >
22 > import junit.framework.Test;
23  
24   public class SynchronousQueueTest extends JSR166TestCase {
25  
# Line 35 | 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 256 | Line 257 | public class SynchronousQueueTest extend
257                  pleaseOffer.countDown();
258                  startTime = System.nanoTime();
259                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
259 –                assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
260  
261                  Thread.currentThread().interrupt();
262                  try {
# Line 271 | Line 271 | public class SynchronousQueueTest extend
271                      shouldThrow();
272                  } catch (InterruptedException success) {}
273                  assertFalse(Thread.interrupted());
274 +
275 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
276              }});
277  
278          await(pleaseOffer);
279          long startTime = System.nanoTime();
280          try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
281          catch (InterruptedException e) { threadUnexpectedException(e); }
282 <        assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
282 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
283  
284          await(pleaseInterrupt);
285          assertThreadStaysAlive(t);
# Line 399 | Line 401 | public class SynchronousQueueTest extend
401      public void testToArray2()      { testToArray2(false); }
402      public void testToArray2_fair() { testToArray2(true); }
403      public void testToArray2(boolean fair) {
404 <        final SynchronousQueue<Integer> q
403 <            = new SynchronousQueue<Integer>(fair);
404 >        final SynchronousQueue<Integer> q = new SynchronousQueue<>(fair);
405          Integer[] a;
406  
407          a = new Integer[0];
408          assertSame(a, q.toArray(a));
409 <        
409 >
410          a = new Integer[3];
411          Arrays.fill(a, 42);
412          assertSame(a, q.toArray(a));
# Line 422 | Line 423 | public class SynchronousQueueTest extend
423      public void testToArray_null(boolean fair) {
424          final SynchronousQueue q = new SynchronousQueue(fair);
425          try {
426 <            Object o[] = q.toArray(null);
426 >            Object[] o = q.toArray(null);
427              shouldThrow();
428          } catch (NullPointerException success) {}
429      }
# Line 433 | Line 434 | public class SynchronousQueueTest extend
434      public void testIterator()      { testIterator(false); }
435      public void testIterator_fair() { testIterator(true); }
436      public void testIterator(boolean fair) {
437 <        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) {}
437 >        assertIteratorExhausted(new SynchronousQueue(fair).iterator());
438      }
439  
440      /**
# Line 474 | Line 469 | public class SynchronousQueueTest extend
469      public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
470      public void testOfferInExecutor(boolean fair) {
471          final SynchronousQueue q = new SynchronousQueue(fair);
477 –        ExecutorService executor = Executors.newFixedThreadPool(2);
472          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
473 +        final ExecutorService executor = Executors.newFixedThreadPool(2);
474 +        try (PoolCleaner cleaner = cleaner(executor)) {
475  
476 <        executor.execute(new CheckedRunnable() {
477 <            public void realRun() throws InterruptedException {
478 <                assertFalse(q.offer(one));
479 <                threadsStarted.await();
480 <                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
481 <                assertEquals(0, q.remainingCapacity());
482 <            }});
483 <
484 <        executor.execute(new CheckedRunnable() {
485 <            public void realRun() throws InterruptedException {
486 <                threadsStarted.await();
487 <                assertSame(one, q.take());
488 <            }});
489 <
494 <        joinPool(executor);
476 >            executor.execute(new CheckedRunnable() {
477 >                public void realRun() throws InterruptedException {
478 >                    assertFalse(q.offer(one));
479 >                    threadsStarted.await();
480 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
481 >                    assertEquals(0, q.remainingCapacity());
482 >                }});
483 >
484 >            executor.execute(new CheckedRunnable() {
485 >                public void realRun() throws InterruptedException {
486 >                    threadsStarted.await();
487 >                    assertSame(one, q.take());
488 >                }});
489 >        }
490      }
491  
492      /**
# Line 502 | Line 497 | public class SynchronousQueueTest extend
497      public void testPollInExecutor(boolean fair) {
498          final SynchronousQueue q = new SynchronousQueue(fair);
499          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
500 <        ExecutorService executor = Executors.newFixedThreadPool(2);
501 <        executor.execute(new CheckedRunnable() {
502 <            public void realRun() throws InterruptedException {
503 <                assertNull(q.poll());
504 <                threadsStarted.await();
505 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
506 <                assertTrue(q.isEmpty());
507 <            }});
508 <
509 <        executor.execute(new CheckedRunnable() {
510 <            public void realRun() throws InterruptedException {
511 <                threadsStarted.await();
512 <                q.put(one);
513 <            }});
514 <
515 <        joinPool(executor);
500 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
501 >        try (PoolCleaner cleaner = cleaner(executor)) {
502 >            executor.execute(new CheckedRunnable() {
503 >                public void realRun() throws InterruptedException {
504 >                    assertNull(q.poll());
505 >                    threadsStarted.await();
506 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
507 >                    assertTrue(q.isEmpty());
508 >                }});
509 >
510 >            executor.execute(new CheckedRunnable() {
511 >                public void realRun() throws InterruptedException {
512 >                    threadsStarted.await();
513 >                    q.put(one);
514 >                }});
515 >        }
516      }
517  
518      /**
# Line 532 | Line 527 | public class SynchronousQueueTest extend
527          SynchronousQueue[] qs = { x, y, z };
528          for (SynchronousQueue q : qs) {
529              SynchronousQueue clone = serialClone(q);
530 <            assert(q != clone);
530 >            assertNotSame(q, clone);
531              assertSerialEquals(q, clone);
532              assertTrue(clone.isEmpty());
533              assertEquals(0, clone.size());
# Line 574 | Line 569 | public class SynchronousQueueTest extend
569                  fail("timed out");
570              Thread.yield();
571          }
572 <        assertTrue(l.size() == 1);
572 >        assertEquals(1, l.size());
573          assertSame(one, l.get(0));
574          awaitTermination(t);
575      }
# Line 595 | Line 590 | public class SynchronousQueueTest extend
590              }});
591  
592          ArrayList l = new ArrayList();
593 <        delay(SHORT_DELAY_MS);
594 <        q.drainTo(l, 1);
593 >        int drained;
594 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
595 >        assertEquals(1, drained);
596          assertEquals(1, l.size());
597 <        q.drainTo(l, 1);
597 >        while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
598 >        assertEquals(1, drained);
599          assertEquals(2, l.size());
600          assertTrue(l.contains(one));
601          assertTrue(l.contains(two));
# Line 606 | Line 603 | public class SynchronousQueueTest extend
603          awaitTermination(t2);
604      }
605  
606 +    /**
607 +     * remove(null), contains(null) always return false
608 +     */
609 +    public void testNeverContainsNull() {
610 +        Collection<?> q = new SynchronousQueue();
611 +        assertFalse(q.contains(null));
612 +        assertFalse(q.remove(null));
613 +    }
614 +
615   }

Diff Legend

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