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 static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;

import junit.framework.Test;
import junit.framework.TestSuite;

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

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

    /**
     * Spin-waits till the number of waiters == numberOfWaiters.
     */
    void awaitNumberWaiting(CyclicBarrier barrier, int numberOfWaiters) {
        long startTime = System.nanoTime();
        while (barrier.getNumberWaiting() != numberOfWaiters) {
            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
                fail("timed out");
            Thread.yield();
        }
    }

    /**
     * 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(2, countAction);
    }

    /**
     * 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 {
                awaitNumberWaiting(c, 1);
                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 {
                awaitNumberWaiting(c, 1);
                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);

        awaitNumberWaiting(c, 2);
        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 {
                    awaitNumberWaiting(barrier, 1);
                    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();
            awaitNumberWaiting(barrier, 2);
            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.27
Committed:	Sat Apr 25 04:55:30 2015 UTC (9 years ago) by jsr166
Branch:	MAIN
Changes since 1.26:	+1 -1 lines
Log Message:	improve main methods; respect system properties; actually fail if a test fails
#	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 static java.util.concurrent.TimeUnit.MILLISECONDS;
10
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	main(suite(), args);
23	}
24	public static Test suite() {
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
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	* Creating with negative parties throws IAE
47	*/
48	public void testConstructor1() {
49	try {
50	new CyclicBarrier(-1, (Runnable)null);
51	shouldThrow();
52	} catch (IllegalArgumentException success) {}
53	}
54
55	/**
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 success) {}
63	}
64
65	/**
66	* getParties returns the number of parties given in constructor
67	*/
68	public void testGetParties() {
69	CyclicBarrier b = new CyclicBarrier(2);
70	assertEquals(2, b.getParties());
71	assertEquals(0, b.getNumberWaiting());
72	}
73
74	/**
75	* A 1-party barrier triggers after single await
76	*/
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
86	/**
87	* The supplied barrier action is run at barrier
88	*/
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
100	/**
101	* A 2-party/thread barrier triggers after both threads invoke await
102	*/
103	public void testTwoParties() throws Exception {
104	final CyclicBarrier b = new CyclicBarrier(2);
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	/**
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	* A timeout in timed await throws TimeoutException
174	*/
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 = 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	shouldThrow();
311	}
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	start.await();
378	t1.interrupt();
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	* Reset of a barrier after timeout reinitializes it.
391	*/
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	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	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
425	/**
426	* Reset of a barrier after a failed command reinitializes it.
427	*/
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	}
464	}