ViewVC Help

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

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

Comparing jsr166/src/test/tck/CountDownLatchTest.java (file contents):
Revision 1.2 by dl, Sun Sep 14 20:42:40 2003 UTC vs.
Revision 1.28 by jsr166, Sun Aug 11 22:29:26 2019 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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.*;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11	>	import java.util.concurrent.CountDownLatch;
12	>	import java.util.concurrent.ThreadLocalRandom;
13	>
14	>	import junit.framework.Test;
15	>	import junit.framework.TestSuite;
16
17		public class CountDownLatchTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run (suite());
19	>	main(suite(), args);
20		}
21		public static Test suite() {
22	<	return new TestSuite(CountDownLatchTest.class);
22	>	return new TestSuite(CountDownLatchTest.class);
23		}
24
25	<	public void testConstructor(){
25	>	/**
26	>	* negative constructor argument throws IllegalArgumentException
27	>	*/
28	>	public void testConstructor() {
29		try {
30		new CountDownLatch(-1);
31	<	fail("should throw IllegalArgumentException");
32	<	} catch(IllegalArgumentException success){}
25	<	}
26	<
27	<	public void testGetCount(){
28	<	final CountDownLatch l = new CountDownLatch(2);
29	<	assertEquals(2, l.getCount());
30	<	l.countDown();
31	<	assertEquals(1, l.getCount());
32	<	}
33	<
34	<	public void testAwait(){
35	<	final CountDownLatch l = new CountDownLatch(2);
36	<
37	<	Thread t = new Thread(new Runnable(){
38	<	public void run(){
39	<	try {
40	<	l.await();
41	<	} catch(InterruptedException e){
42	<	threadFail("unexpected exception");
43	<	}
44	<	}
45	<	});
46	<	t.start();
47	<	try {
48	<	assertEquals(l.getCount(), 2);
49	<	Thread.sleep(SHORT_DELAY_MS);
50	<	l.countDown();
51	<	assertEquals(l.getCount(), 1);
52	<	l.countDown();
53	<	assertEquals(l.getCount(), 0);
54	<	t.join();
55	<	} catch (InterruptedException e){
56	<	fail("unexpected exception");
57	<	}
58	<	}
59	<
60	<
61	<	public void testTimedAwait(){
62	<	final CountDownLatch l = new CountDownLatch(2);
63	<
64	<	Thread t = new Thread(new Runnable(){
65	<	public void run(){
66	<	try {
67	<	threadAssertTrue(l.await(SMALL_DELAY_MS, TimeUnit.MILLISECONDS));
68	<	} catch(InterruptedException e){
69	<	threadFail("unexpected exception");
70	<	}
71	<	}
72	<	});
73	<	t.start();
74	<	try {
75	<	assertEquals(l.getCount(), 2);
76	<	Thread.sleep(SHORT_DELAY_MS);
77	<	l.countDown();
78	<	assertEquals(l.getCount(), 1);
79	<	l.countDown();
80	<	assertEquals(l.getCount(), 0);
81	<	t.join();
82	<	} catch (InterruptedException e){
83	<	fail("unexpected exception");
84	<	}
31	>	shouldThrow();
32	>	} catch (IllegalArgumentException success) {}
33		}
86	–
87	–
88	–
34
35	<	public void testAwait_InterruptedException(){
35	>	/**
36	>	* getCount returns initial count and decreases after countDown
37	>	*/
38	>	public void testGetCount() {
39	>	final CountDownLatch l = new CountDownLatch(2);
40	>	assertEquals(2, l.getCount());
41	>	l.countDown();
42	>	assertEquals(1, l.getCount());
43	>	}
44	>
45	>	/**
46	>	* countDown decrements count when positive and has no effect when zero
47	>	*/
48	>	public void testCountDown() {
49		final CountDownLatch l = new CountDownLatch(1);
50	<	Thread t = new Thread(new Runnable(){
51	<	public void run(){
52	<	try {
53	<	l.await();
54	<	threadFail("should throw");
55	<	} catch(InterruptedException success){}
56	<	}
57	<	});
58	<	t.start();
59	<	try {
60	<	assertEquals(l.getCount(), 1);
61	<	t.interrupt();
62	<	t.join();
63	<	} catch (InterruptedException e){
64	<	fail("unexpected exception");
65	<	}
66	<	}
67	<
68	<	public void testTimedAwait_InterruptedException(){
50	>	assertEquals(1, l.getCount());
51	>	l.countDown();
52	>	assertEquals(0, l.getCount());
53	>	l.countDown();
54	>	assertEquals(0, l.getCount());
55	>	}
56	>
57	>	/**
58	>	* await returns after countDown to zero, but not before
59	>	*/
60	>	public void testAwait() {
61	>	final CountDownLatch l = new CountDownLatch(2);
62	>	final CountDownLatch pleaseCountDown = new CountDownLatch(1);
63	>
64	>	Thread t = newStartedThread(new CheckedRunnable() {
65	>	public void realRun() throws InterruptedException {
66	>	assertEquals(2, l.getCount());
67	>	pleaseCountDown.countDown();
68	>	l.await();
69	>	assertEquals(0, l.getCount());
70	>	}});
71	>
72	>	await(pleaseCountDown);
73	>	assertEquals(2, l.getCount());
74	>	l.countDown();
75	>	assertEquals(1, l.getCount());
76	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
77	>	l.countDown();
78	>	assertEquals(0, l.getCount());
79	>	awaitTermination(t);
80	>	}
81	>
82	>	/**
83	>	* timed await returns after countDown to zero
84	>	*/
85	>	public void testTimedAwait() {
86	>	final CountDownLatch l = new CountDownLatch(2);
87	>	final CountDownLatch pleaseCountDown = new CountDownLatch(1);
88	>
89	>	Thread t = newStartedThread(new CheckedRunnable() {
90	>	public void realRun() throws InterruptedException {
91	>	assertEquals(2, l.getCount());
92	>	pleaseCountDown.countDown();
93	>	assertTrue(l.await(LONG_DELAY_MS, MILLISECONDS));
94	>	assertEquals(0, l.getCount());
95	>	}});
96	>
97	>	await(pleaseCountDown);
98	>	assertEquals(2, l.getCount());
99	>	l.countDown();
100	>	assertEquals(1, l.getCount());
101	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
102	>	l.countDown();
103	>	assertEquals(0, l.getCount());
104	>	awaitTermination(t);
105	>	}
106	>
107	>	/**
108	>	* await throws InterruptedException if interrupted before counted down
109	>	*/
110	>	public void testAwait_Interruptible() {
111		final CountDownLatch l = new CountDownLatch(1);
112	<	Thread t = new Thread(new Runnable(){
113	<	public void run(){
114	<	try {
115	<	l.await(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
116	<	threadFail("should throw");
117	<	} catch(InterruptedException success){}
118	<	}
119	<	});
120	<	t.start();
121	<	try {
122	<	Thread.sleep(SHORT_DELAY_MS);
123	<	assertEquals(l.getCount(), 1);
124	<	t.interrupt();
125	<	t.join();
126	<	} catch (InterruptedException e){
127	<	fail("unexpected exception");
128	<	}
129	<	}
130	<
131	<	public void testAwaitTimeout(){
112	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
113	>	Thread t = newStartedThread(new CheckedRunnable() {
114	>	public void realRun() throws InterruptedException {
115	>	Thread.currentThread().interrupt();
116	>	try {
117	>	l.await();
118	>	shouldThrow();
119	>	} catch (InterruptedException success) {}
120	>	assertFalse(Thread.interrupted());
121	>
122	>	pleaseInterrupt.countDown();
123	>	try {
124	>	l.await();
125	>	shouldThrow();
126	>	} catch (InterruptedException success) {}
127	>	assertFalse(Thread.interrupted());
128	>
129	>	assertEquals(1, l.getCount());
130	>	}});
131	>
132	>	await(pleaseInterrupt);
133	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
134	>	t.interrupt();
135	>	awaitTermination(t);
136	>	}
137	>
138	>	/**
139	>	* timed await throws InterruptedException if interrupted before counted down
140	>	*/
141	>	public void testTimedAwait_Interruptible() {
142	>	final int initialCount = ThreadLocalRandom.current().nextInt(1, 3);
143	>	final CountDownLatch l = new CountDownLatch(initialCount);
144	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
145	>	Thread t = newStartedThread(new CheckedRunnable() {
146	>	public void realRun() throws InterruptedException {
147	>	long startTime = System.nanoTime();
148	>
149	>	Thread.currentThread().interrupt();
150	>	try {
151	>	l.await(randomTimeout(), randomTimeUnit());
152	>	shouldThrow();
153	>	} catch (InterruptedException success) {}
154	>	assertFalse(Thread.interrupted());
155	>
156	>	pleaseInterrupt.countDown();
157	>	try {
158	>	l.await(LONG_DELAY_MS, MILLISECONDS);
159	>	shouldThrow();
160	>	} catch (InterruptedException success) {}
161	>	assertFalse(Thread.interrupted());
162	>
163	>	assertEquals(initialCount, l.getCount());
164	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
165	>	}});
166	>
167	>	await(pleaseInterrupt);
168	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
169	>	t.interrupt();
170	>	awaitTermination(t);
171	>	}
172	>
173	>	/**
174	>	* timed await times out if not counted down before timeout
175	>	*/
176	>	public void testAwaitTimeout() throws InterruptedException {
177		final CountDownLatch l = new CountDownLatch(1);
178	<	Thread t = new Thread(new Runnable(){
179	<	public void run(){
180	<	try {
181	<	threadAssertFalse(l.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
182	<	} catch(InterruptedException ie){
183	<	threadFail("unexpected exception");
184	<	}
185	<	}
186	<	});
187	<	t.start();
188	<	try {
189	<	assertEquals(l.getCount(), 1);
190	<	t.join();
191	<	} catch (InterruptedException e){
192	<	fail("unexpected exception");
193	<	}
178	>	Thread t = newStartedThread(new CheckedRunnable() {
179	>	public void realRun() throws InterruptedException {
180	>	assertEquals(1, l.getCount());
181	>
182	>	long startTime = System.nanoTime();
183	>	assertFalse(l.await(timeoutMillis(), MILLISECONDS));
184	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
185	>
186	>	assertEquals(1, l.getCount());
187	>	}});
188	>
189	>	awaitTermination(t);
190	>	assertEquals(1, l.getCount());
191	>	}
192	>
193	>	/**
194	>	* toString indicates current count
195	>	*/
196	>	public void testToString() {
197	>	CountDownLatch s = new CountDownLatch(2);
198	>	assertTrue(s.toString().contains("Count = 2"));
199	>	s.countDown();
200	>	assertTrue(s.toString().contains("Count = 1"));
201	>	s.countDown();
202	>	assertTrue(s.toString().contains("Count = 0"));
203		}
204
205		}

Diff Legend

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