test/tck/CyclicBarrierTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
import java.util.concurrent.atomic.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;

public class CyclicBarrierTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(CyclicBarrierTest.class);
    }

    private volatile int countAction;
    private class MyAction implements Runnable {
        public void run() { ++countAction; }
    }

    /**
     * Creating with negative parties throws IAE
     */
    public void testConstructor1() {
        try {
            new CyclicBarrier(-1, (Runnable)null);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Creating with negative parties and no action throws IAE
     */
    public void testConstructor2() {
        try {
            new CyclicBarrier(-1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * getParties returns the number of parties given in constructor
     */
    public void testGetParties() {
        CyclicBarrier b = new CyclicBarrier(2);
        assertEquals(2, b.getParties());
        assertEquals(0, b.getNumberWaiting());
    }

    /**
     * A 1-party barrier triggers after single await
     */
    public void testSingleParty() throws Exception {
        CyclicBarrier b = new CyclicBarrier(1);
        assertEquals(1, b.getParties());
        assertEquals(0, b.getNumberWaiting());
        b.await();
        b.await();
        assertEquals(0, b.getNumberWaiting());
    }

    /**
     * The supplied barrier action is run at barrier
     */
    public void testBarrierAction() throws Exception {
        countAction = 0;
        CyclicBarrier b = new CyclicBarrier(1, new MyAction());
        assertEquals(1, b.getParties());
        assertEquals(0, b.getNumberWaiting());
        b.await();
        b.await();
        assertEquals(0, b.getNumberWaiting());
        assertEquals(countAction, 2);
    }

    /**
     * A 2-party/thread barrier triggers after both threads invoke await
     */
    public void testTwoParties() throws Exception {
        final CyclicBarrier b = new CyclicBarrier(2);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                b.await();
                b.await();
                b.await();
                b.await();
            }});

        b.await();
        b.await();
        b.await();
        b.await();
        awaitTermination(t);
    }

    /**
     * An interruption in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait1_Interrupted_BrokenBarrier() {
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await();
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await();
            }};

        t1.start();
        t2.start();
        await(pleaseInterrupt);
        t1.interrupt();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * An interruption in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseInterrupt.countDown();
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};

        t1.start();
        t2.start();
        await(pleaseInterrupt);
        t1.interrupt();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A timeout in timed await throws TimeoutException
     */
    public void testAwait3_TimeoutException() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(2);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t);
    }

    /**
     * A timeout in one party causes others waiting in timed await to
     * throw BrokenBarrierException
     */
    public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                try {
                    c.await(LONG_DELAY_MS, MILLISECONDS);
                    shouldThrow();
                } catch (BrokenBarrierException success) {}
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                while (c.getNumberWaiting() == 0)
                    Thread.yield();
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A timeout in one party causes others waiting in await to
     * throw BrokenBarrierException
     */
    public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(3);
        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                try {
                    c.await();
                    shouldThrow();
                } catch (BrokenBarrierException success) {}
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                while (c.getNumberWaiting() == 0)
                    Thread.yield();
                long startTime = System.nanoTime();
                try {
                    c.await(timeoutMillis(), MILLISECONDS);
                    shouldThrow();
                } catch (TimeoutException success) {}
                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
            }});

        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A reset of an active barrier causes waiting threads to throw
     * BrokenBarrierException
     */
    public void testReset_BrokenBarrier() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(3);
        final CountDownLatch pleaseReset = new CountDownLatch(2);
        Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseReset.countDown();
                c.await();
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                pleaseReset.countDown();
                c.await();
            }};

        t1.start();
        t2.start();
        await(pleaseReset);
        c.reset();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * A reset before threads enter barrier does not throw
     * BrokenBarrierException
     */
    public void testReset_NoBrokenBarrier() throws Exception {
        final CyclicBarrier c = new CyclicBarrier(3);
        c.reset();

        Thread t1 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                c.await();
            }});
        Thread t2 = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                c.await();
            }});

        c.await();
        awaitTermination(t1);
        awaitTermination(t2);
    }

    /**
     * All threads block while a barrier is broken.
     */
    public void testReset_Leakage() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(2);
        final AtomicBoolean done = new AtomicBoolean();
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() {
                while (!done.get()) {
                    try {
                        while (c.isBroken())
                            c.reset();

                        c.await();
                        shouldThrow();
                    }
                    catch (BrokenBarrierException ok) {}
                    catch (InterruptedException ok) {}
                }}});

        for (int i = 0; i < 4; i++) {
            delay(timeoutMillis());
            t.interrupt();
        }
        done.set(true);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * Reset of a non-broken barrier does not break barrier
     */
    public void testResetWithoutBreakage() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 3; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }});

            Thread t2 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }});

            start.await();
            barrier.await();
            awaitTermination(t1);
            awaitTermination(t2);
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            if (i == 1) barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after interruption reinitializes it.
     */
    public void testResetAfterInterrupt() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            t1.start();
            t2.start();
            start.await();
            t1.interrupt();
            awaitTermination(t1);
            awaitTermination(t2);
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after timeout reinitializes it.
     */
    public void testResetAfterTimeout() throws Exception {
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            assertEquals(0, barrier.getNumberWaiting());
            Thread t1 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    try {
                        barrier.await();
                        shouldThrow();
                    } catch (BrokenBarrierException success) {}
                }});
            Thread t2 = newStartedThread(new CheckedRunnable() {
                public void realRun() throws Exception {
                    while (barrier.getNumberWaiting() == 0)
                        Thread.yield();
                    long startTime = System.nanoTime();
                    try {
                        barrier.await(timeoutMillis(), MILLISECONDS);
                        shouldThrow();
                    } catch (TimeoutException success) {}
                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
                }});

            awaitTermination(t1);
            awaitTermination(t2);
            assertEquals(0, barrier.getNumberWaiting());
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }

    /**
     * Reset of a barrier after a failed command reinitializes it.
     */
    public void testResetAfterCommandException() throws Exception {
        final CyclicBarrier barrier =
            new CyclicBarrier(3, new Runnable() {
                    public void run() {
                        throw new NullPointerException(); }});
        for (int i = 0; i < 2; i++) {
            final CyclicBarrier start = new CyclicBarrier(3);
            Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

            Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
                public void realRun() throws Exception {
                    start.await();
                    barrier.await();
                }};

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