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

Comparing jsr166/src/test/tck/CyclicBarrierTest.java (file contents):
Revision 1.28 by jsr166, Thu Sep 15 01:18:01 2016 UTC vs.
Revision 1.34 by jsr166, Mon Sep 9 00:46:44 2019 UTC

# Line 11 | Line 11 | import static java.util.concurrent.TimeU
11   import java.util.concurrent.BrokenBarrierException;
12   import java.util.concurrent.CountDownLatch;
13   import java.util.concurrent.CyclicBarrier;
14 + import java.util.concurrent.ExecutorService;
15 + import java.util.concurrent.Executors;
16 + import java.util.concurrent.ThreadLocalRandom;
17   import java.util.concurrent.TimeoutException;
15 – import java.util.concurrent.atomic.AtomicBoolean;
18   import java.util.concurrent.atomic.AtomicInteger;
19  
20   import junit.framework.Test;
# Line 39 | Line 41 | public class CyclicBarrierTest extends J
41      }
42  
43      /**
44 <     * Creating with negative parties throws IAE
44 >     * Creating with negative parties throws IllegalArgumentException
45       */
46      public void testConstructor1() {
47          try {
# Line 49 | Line 51 | public class CyclicBarrierTest extends J
51      }
52  
53      /**
54 <     * Creating with negative parties and no action throws IAE
54 >     * Creating with negative parties and no action throws
55 >     * IllegalArgumentException
56       */
57      public void testConstructor2() {
58          try {
# Line 292 | Line 295 | public class CyclicBarrierTest extends J
295      }
296  
297      /**
295 –     * All threads block while a barrier is broken.
296 –     */
297 –    public void testReset_Leakage() throws InterruptedException {
298 –        final CyclicBarrier c = new CyclicBarrier(2);
299 –        final AtomicBoolean done = new AtomicBoolean();
300 –        Thread t = newStartedThread(new CheckedRunnable() {
301 –            public void realRun() {
302 –                while (!done.get()) {
303 –                    try {
304 –                        while (c.isBroken())
305 –                            c.reset();
306 –
307 –                        c.await();
308 –                        shouldThrow();
309 –                    }
310 –                    catch (BrokenBarrierException ok) {}
311 –                    catch (InterruptedException ok) {}
312 –                }}});
313 –
314 –        for (int i = 0; i < 4; i++) {
315 –            delay(timeoutMillis());
316 –            t.interrupt();
317 –        }
318 –        done.set(true);
319 –        t.interrupt();
320 –        awaitTermination(t);
321 –    }
322 –
323 –    /**
298       * Reset of a non-broken barrier does not break barrier
299       */
300      public void testResetWithoutBreakage() throws Exception {
# Line 459 | Line 433 | public class CyclicBarrierTest extends J
433              assertEquals(0, barrier.getNumberWaiting());
434          }
435      }
436 +
437 +    /**
438 +     * There can be more threads calling await() than parties, as long as each
439 +     * task only calls await once and the task count is a multiple of parties.
440 +     */
441 +    public void testMoreTasksThanParties() throws Exception {
442 +        final ThreadLocalRandom rnd = ThreadLocalRandom.current();
443 +        final int parties = rnd.nextInt(1, 5);
444 +        final int nTasks = rnd.nextInt(1, 5) * parties;
445 +        final AtomicInteger tripCount = new AtomicInteger(0);
446 +        final AtomicInteger awaitCount = new AtomicInteger(0);
447 +        final CyclicBarrier barrier =
448 +            new CyclicBarrier(parties, () -> tripCount.getAndIncrement());
449 +        final ExecutorService e = Executors.newFixedThreadPool(nTasks);
450 +        final Runnable awaiter = () -> {
451 +            try {
452 +                if (randomBoolean())
453 +                    barrier.await();
454 +                else
455 +                    barrier.await(LONG_DELAY_MS, MILLISECONDS);
456 +                awaitCount.getAndIncrement();
457 +            } catch (Throwable fail) { threadUnexpectedException(fail); }};
458 +        try (PoolCleaner cleaner = cleaner(e)) {
459 +            for (int i = nTasks; i--> 0; )
460 +                e.execute(awaiter);
461 +        }
462 +        assertEquals(nTasks / parties, tripCount.get());
463 +        assertEquals(nTasks, awaitCount.get());
464 +        assertEquals(0, barrier.getNumberWaiting());
465 +    }
466   }

Diff Legend

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