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.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
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; }
    }

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