ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/CyclicBarrierTest.java

Comparing jsr166/src/test/tck/CyclicBarrierTest.java (file contents):
Revision 1.3 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.4 by dl, Thu Sep 25 11:02:41 2003 UTC

#	Line 23 | Line 23 | public class CyclicBarrierTest extends J
23		}
24
25		/**
26	<	*
26	>	* Creating with negative parties throws IAE
27		*/
28		public void testConstructor1() {
29		try {
#	Line 33 | Line 33 | public class CyclicBarrierTest extends J
33		}
34
35		/**
36	<	*
36	>	* Creating with negative parties and no action throws IAE
37		*/
38		public void testConstructor2() {
39		try {
#	Line 43 | Line 43 | public class CyclicBarrierTest extends J
43		}
44
45		/**
46	<	*
46	>	* getParties returns the number of parties given in constructor
47		*/
48	<	public void testConstructor3() {
48	>	public void testGetParties() {
49		CyclicBarrier b = new CyclicBarrier(2);
50		assertEquals(2, b.getParties());
51		assertEquals(0, b.getNumberWaiting());
52		}
53
54		/**
55	<	*
55	>	* A 1-party barrier triggers properly
56		*/
57		public void testSingleParty() {
58		try {
#	Line 69 | Line 69 | public class CyclicBarrierTest extends J
69		}
70
71		/**
72	<	*
72	>	* The supplied barrier action is run at barrier
73		*/
74		public void testBarrierAction() {
75		try {
#	Line 87 | Line 87 | public class CyclicBarrierTest extends J
87		}
88		}
89
90	–
90		/**
91	<	*
91	>	* A 2-party/thread barrier triggers properly
92		*/
93		public void testTwoParties() {
94		final CyclicBarrier b = new CyclicBarrier(2);
#	Line 118 | Line 117 | public class CyclicBarrierTest extends J
117
118
119		/**
120	<	*
120	>	* An interruption in one party causes others waiting in await to
121	>	* throw BrokenBarrierException
122		*/
123		public void testAwait1_Interrupted_BrokenBarrier() {
124		final CyclicBarrier c = new CyclicBarrier(3);
#	Line 129 | Line 129 | public class CyclicBarrierTest extends J
129		threadShouldThrow();
130		} catch(InterruptedException success){}
131		catch(Exception b){
132	<	threadFail("should throw IE");
132	>	threadUnexpectedException();
133		}
134		}
135		});
#	Line 140 | Line 140 | public class CyclicBarrierTest extends J
140		threadShouldThrow();
141		} catch(BrokenBarrierException success){
142		} catch(Exception i){
143	<	threadFail("should throw BBE");
143	>	threadUnexpectedException();
144		}
145		}
146		});
#	Line 157 | Line 157 | public class CyclicBarrierTest extends J
157		}
158
159		/**
160	<	*
160	>	* An interruption in one party causes others waiting in timed await to
161	>	* throw BrokenBarrierException
162		*/
163		public void testAwait2_Interrupted_BrokenBarrier() {
164		final CyclicBarrier c = new CyclicBarrier(3);
#	Line 168 | Line 169 | public class CyclicBarrierTest extends J
169		threadShouldThrow();
170		} catch(InterruptedException success){
171		} catch(Exception b){
172	<	threadFail("should throw IE");
172	>	threadUnexpectedException();
173		}
174		}
175		});
#	Line 179 | Line 180 | public class CyclicBarrierTest extends J
180		threadShouldThrow();
181		} catch(BrokenBarrierException success){
182		} catch(Exception i){
183	<	threadFail("should throw BBE");
183	>	threadUnexpectedException();
184		}
185		}
186		});
#	Line 196 | Line 197 | public class CyclicBarrierTest extends J
197		}
198
199		/**
200	<	*
200	>	* A timeout in timed await throws TimeoutException
201		*/
202		public void testAwait3_TimeOutException() {
203		final CyclicBarrier c = new CyclicBarrier(2);
#	Line 207 | Line 208 | public class CyclicBarrierTest extends J
208		threadShouldThrow();
209		} catch(TimeoutException success){
210		} catch(Exception b){
211	<	threadFail("should throw TOE");
211	>	threadUnexpectedException();
212
213		}
214		}
#	Line 220 | Line 221 | public class CyclicBarrierTest extends J
221		}
222		}
223
224	+	/**
225	+	* A reset of an active barrier causes waiting threads to throw
226	+	* BrokenBarrierException
227	+	*/
228	+	public void testReset_BrokenBarrier() {
229	+	final CyclicBarrier c = new CyclicBarrier(3);
230	+	Thread t1 = new Thread(new Runnable() {
231	+	public void run() {
232	+	try {
233	+	c.await();
234	+	threadShouldThrow();
235	+	} catch(BrokenBarrierException success){}
236	+	catch(Exception b){
237	+	threadUnexpectedException();
238	+	}
239	+	}
240	+	});
241	+	Thread t2 = new Thread(new Runnable() {
242	+	public void run() {
243	+	try {
244	+	c.await();
245	+	threadShouldThrow();
246	+	} catch(BrokenBarrierException success){
247	+	} catch(Exception i){
248	+	threadUnexpectedException();
249	+	}
250	+	}
251	+	});
252	+	try {
253	+	t1.start();
254	+	t2.start();
255	+	Thread.sleep(SHORT_DELAY_MS);
256	+	c.reset();
257	+	t1.join();
258	+	t2.join();
259	+	} catch(InterruptedException e){
260	+	unexpectedException();
261	+	}
262	+	}
263	+
264	+	/**
265	+	* A reset before threads enter barrier does not throw
266	+	* BrokenBarrierException
267	+	*/
268	+	public void testReset_NoBrokenBarrier() {
269	+	final CyclicBarrier c = new CyclicBarrier(3);
270	+	Thread t1 = new Thread(new Runnable() {
271	+	public void run() {
272	+	try {
273	+	c.await();
274	+	} catch(Exception b){
275	+	threadUnexpectedException();
276	+	}
277	+	}
278	+	});
279	+	Thread t2 = new Thread(new Runnable() {
280	+	public void run() {
281	+	try {
282	+	c.await();
283	+	} catch(Exception i){
284	+	threadUnexpectedException();
285	+	}
286	+	}
287	+	});
288	+	try {
289	+	c.reset();
290	+	t1.start();
291	+	t2.start();
292	+	c.await();
293	+	t1.join();
294	+	t2.join();
295	+	} catch(Exception e){
296	+	unexpectedException();
297	+	}
298	+	}
299	+
300		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines