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
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.6	* 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	jsr166	1.17	* http://creativecommons.org/publicdomain/zero/1.0/
5	jsr166	1.9	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.*;
11			import java.util.concurrent.*;
12	dl	1.8	import java.util.concurrent.locks.*;
13			import java.util.concurrent.atomic.*;
14	jsr166	1.13	import static java.util.concurrent.TimeUnit.MILLISECONDS;
15	dl	1.1
16	jsr166	1.11	public class CyclicBarrierTest extends JSR166TestCase {
17	dl	1.1	public static void main(String[] args) {
18	jsr166	1.15	junit.textui.TestRunner.run(suite());
19	dl	1.1	}
20			public static Test suite() {
21	jsr166	1.12	return new TestSuite(CyclicBarrierTest.class);
22	dl	1.1	}
23	dl	1.3
24			private volatile int countAction;
25			private class MyAction implements Runnable {
26			public void run() { ++countAction; }
27			}
28	jsr166	1.9
29	dl	1.3	/**
30	dl	1.4	* Creating with negative parties throws IAE
31	dl	1.3	*/
32			public void testConstructor1() {
33			try {
34	dl	1.1	new CyclicBarrier(-1, (Runnable)null);
35	dl	1.3	shouldThrow();
36	jsr166	1.14	} catch (IllegalArgumentException success) {}
37	dl	1.1	}
38
39	dl	1.3	/**
40	dl	1.4	* Creating with negative parties and no action throws IAE
41	dl	1.3	*/
42			public void testConstructor2() {
43			try {
44	dl	1.1	new CyclicBarrier(-1);
45	dl	1.3	shouldThrow();
46	jsr166	1.14	} catch (IllegalArgumentException success) {}
47	dl	1.1	}
48
49	dl	1.3	/**
50	dl	1.4	* getParties returns the number of parties given in constructor
51	dl	1.3	*/
52	dl	1.4	public void testGetParties() {
53	dl	1.1	CyclicBarrier b = new CyclicBarrier(2);
54	jsr166	1.12	assertEquals(2, b.getParties());
55	dl	1.1	assertEquals(0, b.getNumberWaiting());
56			}
57
58	dl	1.3	/**
59	dl	1.5	* A 1-party barrier triggers after single await
60	dl	1.3	*/
61	jsr166	1.14	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	dl	1.1	}
69	jsr166	1.9
70	dl	1.3	/**
71	dl	1.4	* The supplied barrier action is run at barrier
72	dl	1.3	*/
73	jsr166	1.14	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	dl	1.1	}
83
84	dl	1.3	/**
85	dl	1.5	* A 2-party/thread barrier triggers after both threads invoke await
86	dl	1.3	*/
87	jsr166	1.14	public void testTwoParties() throws Exception {
88	dl	1.1	final CyclicBarrier b = new CyclicBarrier(2);
89	jsr166	1.21	Thread t = newStartedThread(new CheckedRunnable() {
90	jsr166	1.14	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	jsr166	1.21	awaitTermination(t);
102	dl	1.1	}
103
104	dl	1.3	/**
105	dl	1.4	* An interruption in one party causes others waiting in await to
106			* throw BrokenBarrierException
107	dl	1.3	*/
108	jsr166	1.21	public void testAwait1_Interrupted_BrokenBarrier() {
109	dl	1.1	final CyclicBarrier c = new CyclicBarrier(3);
110	jsr166	1.21	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
111	jsr166	1.14	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
112			public void realRun() throws Exception {
113	jsr166	1.21	pleaseInterrupt.countDown();
114	jsr166	1.14	c.await();
115			}};
116			Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
117			public void realRun() throws Exception {
118	jsr166	1.21	pleaseInterrupt.countDown();
119	jsr166	1.14	c.await();
120			}};
121
122			t1.start();
123			t2.start();
124	jsr166	1.21	await(pleaseInterrupt);
125	jsr166	1.14	t1.interrupt();
126	jsr166	1.21	awaitTermination(t1);
127			awaitTermination(t2);
128	dl	1.1	}
129
130	dl	1.3	/**
131	dl	1.4	* An interruption in one party causes others waiting in timed await to
132			* throw BrokenBarrierException
133	dl	1.3	*/
134	jsr166	1.14	public void testAwait2_Interrupted_BrokenBarrier() throws Exception {
135	dl	1.8	final CyclicBarrier c = new CyclicBarrier(3);
136	jsr166	1.21	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
137	jsr166	1.14	Thread t1 = new ThreadShouldThrow(InterruptedException.class) {
138			public void realRun() throws Exception {
139	jsr166	1.21	pleaseInterrupt.countDown();
140	jsr166	1.14	c.await(LONG_DELAY_MS, MILLISECONDS);
141			}};
142			Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
143			public void realRun() throws Exception {
144	jsr166	1.21	pleaseInterrupt.countDown();
145	jsr166	1.14	c.await(LONG_DELAY_MS, MILLISECONDS);
146			}};
147
148			t1.start();
149			t2.start();
150	jsr166	1.21	await(pleaseInterrupt);
151	jsr166	1.14	t1.interrupt();
152	jsr166	1.21	awaitTermination(t1);
153			awaitTermination(t2);
154	dl	1.1	}
155	jsr166	1.9
156	dl	1.3	/**
157	dl	1.4	* A timeout in timed await throws TimeoutException
158	dl	1.3	*/
159	jsr166	1.19	public void testAwait3_TimeoutException() throws InterruptedException {
160	dl	1.1	final CyclicBarrier c = new CyclicBarrier(2);
161	jsr166	1.21	Thread t = newStartedThread(new CheckedRunnable() {
162	jsr166	1.14	public void realRun() throws Exception {
163	jsr166	1.21	long startTime = System.nanoTime();
164			try {
165			c.await(timeoutMillis(), MILLISECONDS);
166			shouldThrow();
167			} catch (TimeoutException success) {}
168			assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
169			}});
170	jsr166	1.9
171	jsr166	1.21	awaitTermination(t);
172	dl	1.5	}
173
174			/**
175			* A timeout in one party causes others waiting in timed await to
176			* throw BrokenBarrierException
177			*/
178	jsr166	1.14	public void testAwait4_Timeout_BrokenBarrier() throws InterruptedException {
179	dl	1.8	final CyclicBarrier c = new CyclicBarrier(3);
180	jsr166	1.21	Thread t1 = newStartedThread(new CheckedRunnable() {
181	jsr166	1.14	public void realRun() throws Exception {
182	jsr166	1.21	try {
183			c.await(LONG_DELAY_MS, MILLISECONDS);
184			shouldThrow();
185			} catch (BrokenBarrierException success) {}
186			}});
187			Thread t2 = newStartedThread(new CheckedRunnable() {
188	jsr166	1.14	public void realRun() throws Exception {
189	jsr166	1.21	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	jsr166	1.14
199	jsr166	1.21	awaitTermination(t1);
200			awaitTermination(t2);
201	dl	1.5	}
202
203			/**
204			* A timeout in one party causes others waiting in await to
205			* throw BrokenBarrierException
206			*/
207	jsr166	1.14	public void testAwait5_Timeout_BrokenBarrier() throws InterruptedException {
208	dl	1.8	final CyclicBarrier c = new CyclicBarrier(3);
209	jsr166	1.21	Thread t1 = newStartedThread(new CheckedRunnable() {
210	jsr166	1.14	public void realRun() throws Exception {
211	jsr166	1.21	try {
212			c.await();
213			shouldThrow();
214			} catch (BrokenBarrierException success) {}
215			}});
216			Thread t2 = newStartedThread(new CheckedRunnable() {
217	jsr166	1.14	public void realRun() throws Exception {
218	jsr166	1.21	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	jsr166	1.14
228	jsr166	1.21	awaitTermination(t1);
229			awaitTermination(t2);
230	dl	1.1	}
231	jsr166	1.9
232	dl	1.4	/**
233			* A reset of an active barrier causes waiting threads to throw
234			* BrokenBarrierException
235			*/
236	jsr166	1.14	public void testReset_BrokenBarrier() throws InterruptedException {
237	dl	1.4	final CyclicBarrier c = new CyclicBarrier(3);
238	jsr166	1.21	final CountDownLatch pleaseReset = new CountDownLatch(2);
239	jsr166	1.14	Thread t1 = new ThreadShouldThrow(BrokenBarrierException.class) {
240			public void realRun() throws Exception {
241	jsr166	1.21	pleaseReset.countDown();
242	jsr166	1.14	c.await();
243			}};
244			Thread t2 = new ThreadShouldThrow(BrokenBarrierException.class) {
245			public void realRun() throws Exception {
246	jsr166	1.21	pleaseReset.countDown();
247	jsr166	1.14	c.await();
248			}};
249
250			t1.start();
251			t2.start();
252	jsr166	1.21	await(pleaseReset);
253	jsr166	1.14	c.reset();
254	jsr166	1.21	awaitTermination(t1);
255			awaitTermination(t2);
256	dl	1.4	}
257
258			/**
259			* A reset before threads enter barrier does not throw
260			* BrokenBarrierException
261			*/
262	jsr166	1.14	public void testReset_NoBrokenBarrier() throws Exception {
263	dl	1.4	final CyclicBarrier c = new CyclicBarrier(3);
264	jsr166	1.21	c.reset();
265
266			Thread t1 = newStartedThread(new CheckedRunnable() {
267	jsr166	1.14	public void realRun() throws Exception {
268			c.await();
269			}});
270	jsr166	1.21	Thread t2 = newStartedThread(new CheckedRunnable() {
271	jsr166	1.14	public void realRun() throws Exception {
272			c.await();
273			}});
274
275			c.await();
276	jsr166	1.21	awaitTermination(t1);
277			awaitTermination(t2);
278	dl	1.4	}
279
280	dl	1.8	/**
281			* All threads block while a barrier is broken.
282			*/
283	jsr166	1.14	public void testReset_Leakage() throws InterruptedException {
284			final CyclicBarrier c = new CyclicBarrier(2);
285			final AtomicBoolean done = new AtomicBoolean();
286	jsr166	1.21	Thread t = newStartedThread(new CheckedRunnable() {
287	jsr166	1.20	public void realRun() {
288			while (!done.get()) {
289			try {
290			while (c.isBroken())
291			c.reset();
292
293			c.await();
294			shouldThrow();
295	dl	1.8	}
296	jsr166	1.20	catch (BrokenBarrierException ok) {}
297			catch (InterruptedException ok) {}
298			}}});
299	jsr166	1.9
300	jsr166	1.14	for (int i = 0; i < 4; i++) {
301	jsr166	1.20	delay(timeoutMillis());
302	dl	1.8	t.interrupt();
303			}
304	jsr166	1.14	done.set(true);
305			t.interrupt();
306	jsr166	1.20	awaitTermination(t);
307	dl	1.8	}
308
309			/**
310			* Reset of a non-broken barrier does not break barrier
311			*/
312	jsr166	1.14	public void testResetWithoutBreakage() throws Exception {
313			final CyclicBarrier barrier = new CyclicBarrier(3);
314			for (int i = 0; i < 3; i++) {
315	jsr166	1.21	final CyclicBarrier start = new CyclicBarrier(3);
316			Thread t1 = newStartedThread(new CheckedRunnable() {
317	jsr166	1.14	public void realRun() throws Exception {
318			start.await();
319			barrier.await();
320			}});
321
322	jsr166	1.21	Thread t2 = newStartedThread(new CheckedRunnable() {
323	jsr166	1.14	public void realRun() throws Exception {
324			start.await();
325			barrier.await();
326			}});
327
328			start.await();
329			barrier.await();
330	jsr166	1.21	awaitTermination(t1);
331			awaitTermination(t2);
332	jsr166	1.14	assertFalse(barrier.isBroken());
333			assertEquals(0, barrier.getNumberWaiting());
334			if (i == 1) barrier.reset();
335			assertFalse(barrier.isBroken());
336			assertEquals(0, barrier.getNumberWaiting());
337	dl	1.8	}
338			}
339	jsr166	1.9
340	dl	1.8	/**
341			* Reset of a barrier after interruption reinitializes it.
342			*/
343	jsr166	1.14	public void testResetAfterInterrupt() throws Exception {
344			final CyclicBarrier barrier = new CyclicBarrier(3);
345			for (int i = 0; i < 2; i++) {
346	jsr166	1.21	final CyclicBarrier start = new CyclicBarrier(3);
347	jsr166	1.14	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	jsr166	1.21	awaitTermination(t1);
364			awaitTermination(t2);
365	jsr166	1.14	assertTrue(barrier.isBroken());
366			assertEquals(0, barrier.getNumberWaiting());
367			barrier.reset();
368			assertFalse(barrier.isBroken());
369			assertEquals(0, barrier.getNumberWaiting());
370	dl	1.8	}
371			}
372	jsr166	1.9
373	dl	1.8	/**
374			* Reset of a barrier after timeout reinitializes it.
375			*/
376	jsr166	1.14	public void testResetAfterTimeout() throws Exception {
377			final CyclicBarrier barrier = new CyclicBarrier(3);
378			for (int i = 0; i < 2; i++) {
379	jsr166	1.21	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	jsr166	1.14	public void realRun() throws Exception {
389	jsr166	1.21	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	jsr166	1.14
399	jsr166	1.21	awaitTermination(t1);
400			awaitTermination(t2);
401			assertEquals(0, barrier.getNumberWaiting());
402	jsr166	1.14	assertTrue(barrier.isBroken());
403			assertEquals(0, barrier.getNumberWaiting());
404			barrier.reset();
405			assertFalse(barrier.isBroken());
406			assertEquals(0, barrier.getNumberWaiting());
407	dl	1.8	}
408			}
409
410			/**
411			* Reset of a barrier after a failed command reinitializes it.
412			*/
413	jsr166	1.14	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	jsr166	1.21	final CyclicBarrier start = new CyclicBarrier(3);
420	jsr166	1.14	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	jsr166	1.21	awaitTermination(t1);
441			awaitTermination(t2);
442	jsr166	1.14	assertTrue(barrier.isBroken());
443			assertEquals(0, barrier.getNumberWaiting());
444			barrier.reset();
445			assertFalse(barrier.isBroken());
446			assertEquals(0, barrier.getNumberWaiting());
447	dl	1.8	}
448			}
449	dl	1.1	}