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/licenses/publicdomain
 * 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 = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                b.await();
                b.await();
                b.await();
                b.await();
            }});

        t.start();
        b.await();
        b.await();
        b.await();
        b.await();
        t.join();
    }


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

        t1.start();
        t2.start();
        Thread.sleep(SHORT_DELAY_MS);
        t1.interrupt();
        t1.join();
        t2.join();
    }

    /**
     * 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);
        Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
            public void realRun() throws Exception {
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                c.await(LONG_DELAY_MS, MILLISECONDS);
            }};

        t1.start();
        t2.start();
        Thread.sleep(SHORT_DELAY_MS);
        t1.interrupt();
        t1.join();
        t2.join();
    }

    /**
     * A timeout in timed await throws TimeoutException
     */
    public void testAwait3_TimeOutException() throws InterruptedException {
        final CyclicBarrier c = new CyclicBarrier(2);
        Thread t = new ThreadShouldThrow(TimeoutException.class) {
            public void realRun() throws Exception {
                c.await(SHORT_DELAY_MS, MILLISECONDS);
            }};

        t.start();
        t.join();
    }

    /**
     * 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 = new ThreadShouldThrow(TimeoutException.class) {
            public void realRun() throws Exception {
                c.await(SHORT_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                c.await(MEDIUM_DELAY_MS, MILLISECONDS);
            }};

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

    /**
     * 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 = new ThreadShouldThrow(TimeoutException.class) {
            public void realRun() throws Exception {
                c.await(SHORT_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
            public void realRun() throws Exception {
                c.await();
            }};

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }

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

        t1.start();
        t2.start();
        Thread.sleep(SHORT_DELAY_MS);
        c.reset();
        t1.join();
        t2.join();
    }

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

        c.reset();
        t1.start();
        t2.start();
        c.await();
        t1.join();
        t2.join();
    }

    /**
     * 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 = new Thread() {
                public void run() {
                    while (!done.get()) {
                        try {
                            while (c.isBroken())
                                c.reset();

                            c.await();
                            threadFail("await should not return");
                        }
                        catch (BrokenBarrierException e) {
                        }
                        catch (InterruptedException ie) {
                        }
                    }
                }
            };

        t.start();
        for (int i = 0; i < 4; i++) {
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
        }
        done.set(true);
        t.interrupt();
        t.join();
    }

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

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

            t1.start();
            t2.start();
            start.await();
            barrier.await();
            t1.join();
            t2.join();
            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 start = new CyclicBarrier(3);
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            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();
            t1.join();
            t2.join();
            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 start = new CyclicBarrier(3);
        final CyclicBarrier barrier = new CyclicBarrier(3);
        for (int i = 0; i < 2; i++) {
            Thread t1 = new ThreadShouldThrow(TimeoutException.class) {
                    public void realRun() throws Exception {
                        start.await();
                        barrier.await(MEDIUM_DELAY_MS, MILLISECONDS);
                    }};

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

            t1.start();
            t2.start();
            start.await();
            t1.join();
            t2.join();
            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 start = new CyclicBarrier(3);
        final CyclicBarrier barrier =
            new CyclicBarrier(3, new Runnable() {
                    public void run() {
                        throw new NullPointerException(); }});
        for (int i = 0; i < 2; i++) {
            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) {}
            t1.join();
            t2.join();
            assertTrue(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
            barrier.reset();
            assertFalse(barrier.isBroken());
            assertEquals(0, barrier.getNumberWaiting());
        }
    }
}
Revision:	1.15
Committed:	Wed Aug 25 00:07:03 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.14:	+1 -1 lines
Log Message:	whitespace
#	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/licenses/publicdomain
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 = new Thread(new CheckedRunnable() {
90	public void realRun() throws Exception {
91	b.await();
92	b.await();
93	b.await();
94	b.await();
95	}});
96
97	t.start();
98	b.await();
99	b.await();
100	b.await();
101	b.await();
102	t.join();
103	}
104
105
106	/**
107	* An interruption in one party causes others waiting in await to
108	* throw BrokenBarrierException
109	*/
110	public void testAwait1_Interrupted_BrokenBarrier() throws Exception {
111	final CyclicBarrier c = new CyclicBarrier(3);
112	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
113	public void realRun() throws Exception {
114	c.await();
115	}};
116	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
117	public void realRun() throws Exception {
118	c.await();
119	}};
120
121	t1.start();
122	t2.start();
123	Thread.sleep(SHORT_DELAY_MS);
124	t1.interrupt();
125	t1.join();
126	t2.join();
127	}
128
129	/**
130	* An interruption in one party causes others waiting in timed await to
131	* throw BrokenBarrierException
132	*/
133	public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
134	final CyclicBarrier c = new CyclicBarrier(3);
135	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
136	public void realRun() throws Exception {
137	c.await(LONG_DELAY_MS, MILLISECONDS);
138	}};
139	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
140	public void realRun() throws Exception {
141	c.await(LONG_DELAY_MS, MILLISECONDS);
142	}};
143
144	t1.start();
145	t2.start();
146	Thread.sleep(SHORT_DELAY_MS);
147	t1.interrupt();
148	t1.join();
149	t2.join();
150	}
151
152	/**
153	* A timeout in timed await throws TimeoutException
154	*/
155	public void testAwait3_TimeOutException() throws InterruptedException {
156	final CyclicBarrier c = new CyclicBarrier(2);
157	Thread t = new ThreadShouldThrow(TimeoutException.class) {
158	public void realRun() throws Exception {
159	c.await(SHORT_DELAY_MS, MILLISECONDS);
160	}};
161
162	t.start();
163	t.join();
164	}
165
166	/**
167	* A timeout in one party causes others waiting in timed await to
168	* throw BrokenBarrierException
169	*/
170	public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
171	final CyclicBarrier c = new CyclicBarrier(3);
172	Thread t1 = new ThreadShouldThrow(TimeoutException.class) {
173	public void realRun() throws Exception {
174	c.await(SHORT_DELAY_MS, MILLISECONDS);
175	}};
176	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
177	public void realRun() throws Exception {
178	c.await(MEDIUM_DELAY_MS, MILLISECONDS);
179	}};
180
181	t1.start();
182	t2.start();
183	t1.join();
184	t2.join();
185	}
186
187	/**
188	* A timeout in one party causes others waiting in await to
189	* throw BrokenBarrierException
190	*/
191	public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
192	final CyclicBarrier c = new CyclicBarrier(3);
193	Thread t1 = new ThreadShouldThrow(TimeoutException.class) {
194	public void realRun() throws Exception {
195	c.await(SHORT_DELAY_MS, MILLISECONDS);
196	}};
197	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
198	public void realRun() throws Exception {
199	c.await();
200	}};
201
202	t1.start();
203	t2.start();
204	t1.join();
205	t2.join();
206	}
207
208	/**
209	* A reset of an active barrier causes waiting threads to throw
210	* BrokenBarrierException
211	*/
212	public void testReset_BrokenBarrier() throws InterruptedException {
213	final CyclicBarrier c = new CyclicBarrier(3);
214	Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
215	public void realRun() throws Exception {
216	c.await();
217	}};
218	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
219	public void realRun() throws Exception {
220	c.await();
221	}};
222
223	t1.start();
224	t2.start();
225	Thread.sleep(SHORT_DELAY_MS);
226	c.reset();
227	t1.join();
228	t2.join();
229	}
230
231	/**
232	* A reset before threads enter barrier does not throw
233	* BrokenBarrierException
234	*/
235	public void testReset_NoBrokenBarrier() throws Exception {
236	final CyclicBarrier c = new CyclicBarrier(3);
237	Thread t1 = new Thread(new CheckedRunnable() {
238	public void realRun() throws Exception {
239	c.await();
240	}});
241	Thread t2 = new Thread(new CheckedRunnable() {
242	public void realRun() throws Exception {
243	c.await();
244	}});
245
246	c.reset();
247	t1.start();
248	t2.start();
249	c.await();
250	t1.join();
251	t2.join();
252	}
253
254	/**
255	* All threads block while a barrier is broken.
256	*/
257	public void testReset_Leakage() throws InterruptedException {
258	final CyclicBarrier c = new CyclicBarrier(2);
259	final AtomicBoolean done = new AtomicBoolean();
260	Thread t = new Thread() {
261	public void run() {
262	while (!done.get()) {
263	try {
264	while (c.isBroken())
265	c.reset();
266
267	c.await();
268	threadFail("await should not return");
269	}
270	catch (BrokenBarrierException e) {
271	}
272	catch (InterruptedException ie) {
273	}
274	}
275	}
276	};
277
278	t.start();
279	for (int i = 0; i < 4; i++) {
280	Thread.sleep(SHORT_DELAY_MS);
281	t.interrupt();
282	}
283	done.set(true);
284	t.interrupt();
285	t.join();
286	}
287
288	/**
289	* Reset of a non-broken barrier does not break barrier
290	*/
291	public void testResetWithoutBreakage() throws Exception {
292	final CyclicBarrier start = new CyclicBarrier(3);
293	final CyclicBarrier barrier = new CyclicBarrier(3);
294	for (int i = 0; i < 3; i++) {
295	Thread t1 = new Thread(new CheckedRunnable() {
296	public void realRun() throws Exception {
297	start.await();
298	barrier.await();
299	}});
300
301	Thread t2 = new Thread(new CheckedRunnable() {
302	public void realRun() throws Exception {
303	start.await();
304	barrier.await();
305	}});
306
307	t1.start();
308	t2.start();
309	start.await();
310	barrier.await();
311	t1.join();
312	t2.join();
313	assertFalse(barrier.isBroken());
314	assertEquals(0, barrier.getNumberWaiting());
315	if (i == 1) barrier.reset();
316	assertFalse(barrier.isBroken());
317	assertEquals(0, barrier.getNumberWaiting());
318	}
319	}
320
321	/**
322	* Reset of a barrier after interruption reinitializes it.
323	*/
324	public void testResetAfterInterrupt() throws Exception {
325	final CyclicBarrier start = new CyclicBarrier(3);
326	final CyclicBarrier barrier = new CyclicBarrier(3);
327	for (int i = 0; i < 2; i++) {
328	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
329	public void realRun() throws Exception {
330	start.await();
331	barrier.await();
332	}};
333
334	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
335	public void realRun() throws Exception {
336	start.await();
337	barrier.await();
338	}};
339
340	t1.start();
341	t2.start();
342	start.await();
343	t1.interrupt();
344	t1.join();
345	t2.join();
346	assertTrue(barrier.isBroken());
347	assertEquals(0, barrier.getNumberWaiting());
348	barrier.reset();
349	assertFalse(barrier.isBroken());
350	assertEquals(0, barrier.getNumberWaiting());
351	}
352	}
353
354	/**
355	* Reset of a barrier after timeout reinitializes it.
356	*/
357	public void testResetAfterTimeout() throws Exception {
358	final CyclicBarrier start = new CyclicBarrier(3);
359	final CyclicBarrier barrier = new CyclicBarrier(3);
360	for (int i = 0; i < 2; i++) {
361	Thread t1 = new ThreadShouldThrow(TimeoutException.class) {
362	public void realRun() throws Exception {
363	start.await();
364	barrier.await(MEDIUM_DELAY_MS, MILLISECONDS);
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.join();
377	t2.join();
378	assertTrue(barrier.isBroken());
379	assertEquals(0, barrier.getNumberWaiting());
380	barrier.reset();
381	assertFalse(barrier.isBroken());
382	assertEquals(0, barrier.getNumberWaiting());
383	}
384	}
385
386
387	/**
388	* Reset of a barrier after a failed command reinitializes it.
389	*/
390	public void testResetAfterCommandException() throws Exception {
391	final CyclicBarrier start = new CyclicBarrier(3);
392	final CyclicBarrier barrier =
393	new CyclicBarrier(3, new Runnable() {
394	public void run() {
395	throw new NullPointerException(); }});
396	for (int i = 0; i < 2; i++) {
397	Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
398	public void realRun() throws Exception {
399	start.await();
400	barrier.await();
401	}};
402
403	Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
404	public void realRun() throws Exception {
405	start.await();
406	barrier.await();
407	}};
408
409	t1.start();
410	t2.start();
411	start.await();
412	while (barrier.getNumberWaiting() < 2) { Thread.yield(); }
413	try {
414	barrier.await();
415	shouldThrow();
416	} catch (NullPointerException success) {}
417	t1.join();
418	t2.join();
419	assertTrue(barrier.isBroken());
420	assertEquals(0, barrier.getNumberWaiting());
421	barrier.reset();
422	assertFalse(barrier.isBroken());
423	assertEquals(0, barrier.getNumberWaiting());
424	}
425	}
426	}