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.3 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.27 by jsr166, Sat Apr 25 04:55:30 2015 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
2 > * Written by Doug Lea with assistance from members of JCP JSR-166
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
9 < import java.util.*;
10 < import java.util.concurrent.*;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 < public class CyclicBarrierTest extends JSR166TestCase{
11 > import java.util.concurrent.BrokenBarrierException;
12 > import java.util.concurrent.CountDownLatch;
13 > import java.util.concurrent.CyclicBarrier;
14 > import java.util.concurrent.TimeoutException;
15 > import java.util.concurrent.atomic.AtomicBoolean;
16 >
17 > import junit.framework.Test;
18 > import junit.framework.TestSuite;
19 >
20 > public class CyclicBarrierTest extends JSR166TestCase {
21      public static void main(String[] args) {
22 <        junit.textui.TestRunner.run (suite());  
22 >        main(suite(), args);
23      }
24      public static Test suite() {
25 <        return new TestSuite(CyclicBarrierTest.class);
25 >        return new TestSuite(CyclicBarrierTest.class);
26      }
27  
28      private volatile int countAction;
29      private class MyAction implements Runnable {
30          public void run() { ++countAction; }
31      }
32 <    
32 >
33 >    /**
34 >     * Spin-waits till the number of waiters == numberOfWaiters.
35 >     */
36 >    void awaitNumberWaiting(CyclicBarrier barrier, int numberOfWaiters) {
37 >        long startTime = System.nanoTime();
38 >        while (barrier.getNumberWaiting() != numberOfWaiters) {
39 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
40 >                fail("timed out");
41 >            Thread.yield();
42 >        }
43 >    }
44 >
45      /**
46 <     *
46 >     * Creating with negative parties throws IAE
47       */
48      public void testConstructor1() {
49          try {
50              new CyclicBarrier(-1, (Runnable)null);
51              shouldThrow();
52 <        } catch(IllegalArgumentException e){}
52 >        } catch (IllegalArgumentException success) {}
53      }
54  
55      /**
56 <     *
56 >     * Creating with negative parties and no action throws IAE
57       */
58      public void testConstructor2() {
59          try {
60              new CyclicBarrier(-1);
61              shouldThrow();
62 <        } catch(IllegalArgumentException e){}
62 >        } catch (IllegalArgumentException success) {}
63      }
64  
65      /**
66 <     *
66 >     * getParties returns the number of parties given in constructor
67       */
68 <    public void testConstructor3() {
68 >    public void testGetParties() {
69          CyclicBarrier b = new CyclicBarrier(2);
70 <        assertEquals(2, b.getParties());
70 >        assertEquals(2, b.getParties());
71          assertEquals(0, b.getNumberWaiting());
72      }
73  
74      /**
75 <     *
75 >     * A 1-party barrier triggers after single await
76       */
77 <    public void testSingleParty() {
78 <        try {
79 <            CyclicBarrier b = new CyclicBarrier(1);
80 <            assertEquals(1, b.getParties());
81 <            assertEquals(0, b.getNumberWaiting());
82 <            b.await();
83 <            b.await();
64 <            assertEquals(0, b.getNumberWaiting());
65 <        }
66 <        catch(Exception e) {
67 <            unexpectedException();
68 <        }
77 >    public void testSingleParty() throws Exception {
78 >        CyclicBarrier b = new CyclicBarrier(1);
79 >        assertEquals(1, b.getParties());
80 >        assertEquals(0, b.getNumberWaiting());
81 >        b.await();
82 >        b.await();
83 >        assertEquals(0, b.getNumberWaiting());
84      }
85 <    
85 >
86      /**
87 <     *
87 >     * The supplied barrier action is run at barrier
88       */
89 <    public void testBarrierAction() {
90 <        try {
91 <            countAction = 0;
92 <            CyclicBarrier b = new CyclicBarrier(1, new MyAction());
93 <            assertEquals(1, b.getParties());
94 <            assertEquals(0, b.getNumberWaiting());
95 <            b.await();
96 <            b.await();
97 <            assertEquals(0, b.getNumberWaiting());
83 <            assertEquals(countAction, 2);
84 <        }
85 <        catch(Exception e) {
86 <            unexpectedException();
87 <        }
89 >    public void testBarrierAction() throws Exception {
90 >        countAction = 0;
91 >        CyclicBarrier b = new CyclicBarrier(1, new MyAction());
92 >        assertEquals(1, b.getParties());
93 >        assertEquals(0, b.getNumberWaiting());
94 >        b.await();
95 >        b.await();
96 >        assertEquals(0, b.getNumberWaiting());
97 >        assertEquals(2, countAction);
98      }
99  
90
100      /**
101 <     *
101 >     * A 2-party/thread barrier triggers after both threads invoke await
102       */
103 <    public void testTwoParties() {
103 >    public void testTwoParties() throws Exception {
104          final CyclicBarrier b = new CyclicBarrier(2);
105 <        Thread t = new Thread(new Runnable() {
106 <                public void run() {
107 <                    try {
108 <                        b.await();
109 <                        b.await();
110 <                        b.await();
111 <                        b.await();
112 <                    } catch(Exception e){
113 <                        threadUnexpectedException();
114 <                    }}});
105 >        Thread t = newStartedThread(new CheckedRunnable() {
106 >            public void realRun() throws Exception {
107 >                b.await();
108 >                b.await();
109 >                b.await();
110 >                b.await();
111 >            }});
112 >
113 >        b.await();
114 >        b.await();
115 >        b.await();
116 >        b.await();
117 >        awaitTermination(t);
118 >    }
119  
120 <        try {
121 <            t.start();
122 <            b.await();
123 <            b.await();
124 <            b.await();
125 <            b.await();
126 <            t.join();
127 <        } catch(Exception e){
128 <            unexpectedException();
129 <        }
120 >    /**
121 >     * An interruption in one party causes others waiting in await to
122 >     * throw BrokenBarrierException
123 >     */
124 >    public void testAwait1_Interrupted_BrokenBarrier() {
125 >        final CyclicBarrier c = new CyclicBarrier(3);
126 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
127 >        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
128 >            public void realRun() throws Exception {
129 >                pleaseInterrupt.countDown();
130 >                c.await();
131 >            }};
132 >        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
133 >            public void realRun() throws Exception {
134 >                pleaseInterrupt.countDown();
135 >                c.await();
136 >            }};
137 >
138 >        t1.start();
139 >        t2.start();
140 >        await(pleaseInterrupt);
141 >        t1.interrupt();
142 >        awaitTermination(t1);
143 >        awaitTermination(t2);
144      }
145  
146 +    /**
147 +     * An interruption in one party causes others waiting in timed await to
148 +     * throw BrokenBarrierException
149 +     */
150 +    public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
151 +        final CyclicBarrier c = new CyclicBarrier(3);
152 +        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
153 +        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
154 +            public void realRun() throws Exception {
155 +                pleaseInterrupt.countDown();
156 +                c.await(LONG_DELAY_MS, MILLISECONDS);
157 +            }};
158 +        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
159 +            public void realRun() throws Exception {
160 +                pleaseInterrupt.countDown();
161 +                c.await(LONG_DELAY_MS, MILLISECONDS);
162 +            }};
163 +
164 +        t1.start();
165 +        t2.start();
166 +        await(pleaseInterrupt);
167 +        t1.interrupt();
168 +        awaitTermination(t1);
169 +        awaitTermination(t2);
170 +    }
171  
172      /**
173 <     *
173 >     * A timeout in timed await throws TimeoutException
174       */
175 <    public void testAwait1_Interrupted_BrokenBarrier() {
175 >    public void testAwait3_TimeoutException() throws InterruptedException {
176 >        final CyclicBarrier c = new CyclicBarrier(2);
177 >        Thread t = newStartedThread(new CheckedRunnable() {
178 >            public void realRun() throws Exception {
179 >                long startTime = System.nanoTime();
180 >                try {
181 >                    c.await(timeoutMillis(), MILLISECONDS);
182 >                    shouldThrow();
183 >                } catch (TimeoutException success) {}
184 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
185 >            }});
186 >
187 >        awaitTermination(t);
188 >    }
189 >
190 >    /**
191 >     * A timeout in one party causes others waiting in timed await to
192 >     * throw BrokenBarrierException
193 >     */
194 >    public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
195          final CyclicBarrier c = new CyclicBarrier(3);
196 <        Thread t1 = new Thread(new Runnable() {
197 <                public void run() {
198 <                    try {
199 <                        c.await();
200 <                        threadShouldThrow();
201 <                    } catch(InterruptedException success){}                
202 <                    catch(Exception b){
203 <                        threadFail("should throw IE");
204 <                    }
205 <                }
206 <            });
207 <        Thread t2 = new Thread(new Runnable() {
208 <                public void run() {
196 >        Thread t1 = newStartedThread(new CheckedRunnable() {
197 >            public void realRun() throws Exception {
198 >                try {
199 >                    c.await(LONG_DELAY_MS, MILLISECONDS);
200 >                    shouldThrow();
201 >                } catch (BrokenBarrierException success) {}
202 >            }});
203 >        Thread t2 = newStartedThread(new CheckedRunnable() {
204 >            public void realRun() throws Exception {
205 >                awaitNumberWaiting(c, 1);
206 >                long startTime = System.nanoTime();
207 >                try {
208 >                    c.await(timeoutMillis(), MILLISECONDS);
209 >                    shouldThrow();
210 >                } catch (TimeoutException success) {}
211 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
212 >            }});
213 >
214 >        awaitTermination(t1);
215 >        awaitTermination(t2);
216 >    }
217 >
218 >    /**
219 >     * A timeout in one party causes others waiting in await to
220 >     * throw BrokenBarrierException
221 >     */
222 >    public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
223 >        final CyclicBarrier c = new CyclicBarrier(3);
224 >        Thread t1 = newStartedThread(new CheckedRunnable() {
225 >            public void realRun() throws Exception {
226 >                try {
227 >                    c.await();
228 >                    shouldThrow();
229 >                } catch (BrokenBarrierException success) {}
230 >            }});
231 >        Thread t2 = newStartedThread(new CheckedRunnable() {
232 >            public void realRun() throws Exception {
233 >                awaitNumberWaiting(c, 1);
234 >                long startTime = System.nanoTime();
235 >                try {
236 >                    c.await(timeoutMillis(), MILLISECONDS);
237 >                    shouldThrow();
238 >                } catch (TimeoutException success) {}
239 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
240 >            }});
241 >
242 >        awaitTermination(t1);
243 >        awaitTermination(t2);
244 >    }
245 >
246 >    /**
247 >     * A reset of an active barrier causes waiting threads to throw
248 >     * BrokenBarrierException
249 >     */
250 >    public void testReset_BrokenBarrier() throws InterruptedException {
251 >        final CyclicBarrier c = new CyclicBarrier(3);
252 >        final CountDownLatch pleaseReset = new CountDownLatch(2);
253 >        Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
254 >            public void realRun() throws Exception {
255 >                pleaseReset.countDown();
256 >                c.await();
257 >            }};
258 >        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
259 >            public void realRun() throws Exception {
260 >                pleaseReset.countDown();
261 >                c.await();
262 >            }};
263 >
264 >        t1.start();
265 >        t2.start();
266 >        await(pleaseReset);
267 >
268 >        awaitNumberWaiting(c, 2);
269 >        c.reset();
270 >        awaitTermination(t1);
271 >        awaitTermination(t2);
272 >    }
273 >
274 >    /**
275 >     * A reset before threads enter barrier does not throw
276 >     * BrokenBarrierException
277 >     */
278 >    public void testReset_NoBrokenBarrier() throws Exception {
279 >        final CyclicBarrier c = new CyclicBarrier(3);
280 >        c.reset();
281 >
282 >        Thread t1 = newStartedThread(new CheckedRunnable() {
283 >            public void realRun() throws Exception {
284 >                c.await();
285 >            }});
286 >        Thread t2 = newStartedThread(new CheckedRunnable() {
287 >            public void realRun() throws Exception {
288 >                c.await();
289 >            }});
290 >
291 >        c.await();
292 >        awaitTermination(t1);
293 >        awaitTermination(t2);
294 >    }
295 >
296 >    /**
297 >     * All threads block while a barrier is broken.
298 >     */
299 >    public void testReset_Leakage() throws InterruptedException {
300 >        final CyclicBarrier c = new CyclicBarrier(2);
301 >        final AtomicBoolean done = new AtomicBoolean();
302 >        Thread t = newStartedThread(new CheckedRunnable() {
303 >            public void realRun() {
304 >                while (!done.get()) {
305                      try {
306 +                        while (c.isBroken())
307 +                            c.reset();
308 +
309                          c.await();
310 <                        threadShouldThrow();                        
141 <                    } catch(BrokenBarrierException success){
142 <                    } catch(Exception i){
143 <                        threadFail("should throw BBE");
310 >                        shouldThrow();
311                      }
312 <                }
313 <            });
314 <        try {
312 >                    catch (BrokenBarrierException ok) {}
313 >                    catch (InterruptedException ok) {}
314 >                }}});
315 >
316 >        for (int i = 0; i < 4; i++) {
317 >            delay(timeoutMillis());
318 >            t.interrupt();
319 >        }
320 >        done.set(true);
321 >        t.interrupt();
322 >        awaitTermination(t);
323 >    }
324 >
325 >    /**
326 >     * Reset of a non-broken barrier does not break barrier
327 >     */
328 >    public void testResetWithoutBreakage() throws Exception {
329 >        final CyclicBarrier barrier = new CyclicBarrier(3);
330 >        for (int i = 0; i < 3; i++) {
331 >            final CyclicBarrier start = new CyclicBarrier(3);
332 >            Thread t1 = newStartedThread(new CheckedRunnable() {
333 >                public void realRun() throws Exception {
334 >                    start.await();
335 >                    barrier.await();
336 >                }});
337 >
338 >            Thread t2 = newStartedThread(new CheckedRunnable() {
339 >                public void realRun() throws Exception {
340 >                    start.await();
341 >                    barrier.await();
342 >                }});
343 >
344 >            start.await();
345 >            barrier.await();
346 >            awaitTermination(t1);
347 >            awaitTermination(t2);
348 >            assertFalse(barrier.isBroken());
349 >            assertEquals(0, barrier.getNumberWaiting());
350 >            if (i == 1) barrier.reset();
351 >            assertFalse(barrier.isBroken());
352 >            assertEquals(0, barrier.getNumberWaiting());
353 >        }
354 >    }
355 >
356 >    /**
357 >     * Reset of a barrier after interruption reinitializes it.
358 >     */
359 >    public void testResetAfterInterrupt() throws Exception {
360 >        final CyclicBarrier barrier = new CyclicBarrier(3);
361 >        for (int i = 0; i < 2; i++) {
362 >            final CyclicBarrier start = new CyclicBarrier(3);
363 >            Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
364 >                public void realRun() throws Exception {
365 >                    start.await();
366 >                    barrier.await();
367 >                }};
368 >
369 >            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
370 >                public void realRun() throws Exception {
371 >                    start.await();
372 >                    barrier.await();
373 >                }};
374 >
375              t1.start();
376              t2.start();
377 <            Thread.sleep(SHORT_DELAY_MS);
377 >            start.await();
378              t1.interrupt();
379 <            t1.join();
380 <            t2.join();
381 <        } catch(InterruptedException e){
382 <            unexpectedException();
379 >            awaitTermination(t1);
380 >            awaitTermination(t2);
381 >            assertTrue(barrier.isBroken());
382 >            assertEquals(0, barrier.getNumberWaiting());
383 >            barrier.reset();
384 >            assertFalse(barrier.isBroken());
385 >            assertEquals(0, barrier.getNumberWaiting());
386          }
387      }
388  
389      /**
390 <     *
390 >     * Reset of a barrier after timeout reinitializes it.
391       */
392 <    public void testAwait2_Interrupted_BrokenBarrier() {
393 <      final CyclicBarrier c = new CyclicBarrier(3);
394 <        Thread t1 = new Thread(new Runnable() {
395 <                public void run() {
392 >    public void testResetAfterTimeout() throws Exception {
393 >        final CyclicBarrier barrier = new CyclicBarrier(3);
394 >        for (int i = 0; i < 2; i++) {
395 >            assertEquals(0, barrier.getNumberWaiting());
396 >            Thread t1 = newStartedThread(new CheckedRunnable() {
397 >                public void realRun() throws Exception {
398                      try {
399 <                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
400 <                        threadShouldThrow();
401 <                    } catch(InterruptedException success){
402 <                    } catch(Exception b){
403 <                        threadFail("should throw IE");
404 <                    }
405 <                }
406 <            });
175 <        Thread t2 = new Thread(new Runnable() {
176 <                public void run() {
399 >                        barrier.await();
400 >                        shouldThrow();
401 >                    } catch (BrokenBarrierException success) {}
402 >                }});
403 >            Thread t2 = newStartedThread(new CheckedRunnable() {
404 >                public void realRun() throws Exception {
405 >                    awaitNumberWaiting(barrier, 1);
406 >                    long startTime = System.nanoTime();
407                      try {
408 <                        c.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
409 <                        threadShouldThrow();                        
410 <                    } catch(BrokenBarrierException success){
411 <                    } catch(Exception i){
412 <                        threadFail("should throw BBE");
413 <                    }
414 <                }
415 <            });
416 <        try {
417 <            t1.start();
418 <            t2.start();
419 <            Thread.sleep(SHORT_DELAY_MS);
420 <            t1.interrupt();
421 <            t1.join();
192 <            t2.join();
193 <        } catch(InterruptedException e){
194 <            unexpectedException();
408 >                        barrier.await(timeoutMillis(), MILLISECONDS);
409 >                        shouldThrow();
410 >                    } catch (TimeoutException success) {}
411 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
412 >                }});
413 >
414 >            awaitTermination(t1);
415 >            awaitTermination(t2);
416 >            assertEquals(0, barrier.getNumberWaiting());
417 >            assertTrue(barrier.isBroken());
418 >            assertEquals(0, barrier.getNumberWaiting());
419 >            barrier.reset();
420 >            assertFalse(barrier.isBroken());
421 >            assertEquals(0, barrier.getNumberWaiting());
422          }
423      }
424 <    
424 >
425      /**
426 <     *
426 >     * Reset of a barrier after a failed command reinitializes it.
427       */
428 <    public void testAwait3_TimeOutException() {
429 <        final CyclicBarrier c = new CyclicBarrier(2);
430 <        Thread t = new Thread(new Runnable() {
431 <                public void run() {
432 <                    try {
433 <                        c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
434 <                        threadShouldThrow();
435 <                    } catch(TimeoutException success){
436 <                    } catch(Exception b){
437 <                        threadFail("should throw TOE");
438 <                        
439 <                    }
440 <                }
441 <            });
442 <        try {
443 <            t.start();
444 <            t.join();
445 <        } catch(InterruptedException e){
446 <            unexpectedException();
428 >    public void testResetAfterCommandException() throws Exception {
429 >        final CyclicBarrier barrier =
430 >            new CyclicBarrier(3, new Runnable() {
431 >                    public void run() {
432 >                        throw new NullPointerException(); }});
433 >        for (int i = 0; i < 2; i++) {
434 >            final CyclicBarrier start = new CyclicBarrier(3);
435 >            Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
436 >                public void realRun() throws Exception {
437 >                    start.await();
438 >                    barrier.await();
439 >                }};
440 >
441 >            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
442 >                public void realRun() throws Exception {
443 >                    start.await();
444 >                    barrier.await();
445 >                }};
446 >
447 >            t1.start();
448 >            t2.start();
449 >            start.await();
450 >            awaitNumberWaiting(barrier, 2);
451 >            try {
452 >                barrier.await();
453 >                shouldThrow();
454 >            } catch (NullPointerException success) {}
455 >            awaitTermination(t1);
456 >            awaitTermination(t2);
457 >            assertTrue(barrier.isBroken());
458 >            assertEquals(0, barrier.getNumberWaiting());
459 >            barrier.reset();
460 >            assertFalse(barrier.isBroken());
461 >            assertEquals(0, barrier.getNumberWaiting());
462          }
463      }
222    
464   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines