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.12 by jsr166, Sat Nov 21 02:33:20 2009 UTC vs.
Revision 1.28 by jsr166, Sun Aug 11 22:29:26 2019 UTC

#	Line 1 | Line 1
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
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);
23		}
24
25		/**
26	<	* negative constructor argument throws IAE
26	>	* negative constructor argument throws IllegalArgumentException
27		*/
28		public void testConstructor() {
29		try {
#	Line 56 | Line 59 | public class CountDownLatchTest extends
59		*/
60		public void testAwait() {
61		final CountDownLatch l = new CountDownLatch(2);
62	+	final CountDownLatch pleaseCountDown = new CountDownLatch(1);
63
64	<	Thread t = new Thread(new Runnable() {
65	<	public void run() {
66	<	try {
67	<	threadAssertTrue(l.getCount() > 0);
68	<	l.await();
69	<	threadAssertTrue(l.getCount() == 0);
70	<	} catch (InterruptedException e) {
67	<	threadUnexpectedException();
68	<	}
69	<	}
70	<	});
71	<	t.start();
72	<	try {
73	<	assertEquals(l.getCount(), 2);
74	<	Thread.sleep(SHORT_DELAY_MS);
75	<	l.countDown();
76	<	assertEquals(l.getCount(), 1);
77	<	l.countDown();
78	<	assertEquals(l.getCount(), 0);
79	<	t.join();
80	<	} catch (InterruptedException e) {
81	<	unexpectedException();
82	<	}
83	<	}
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 = new Thread(new Runnable() {
90	<	public void run() {
91	<	try {
92	<	threadAssertTrue(l.getCount() > 0);
93	<	threadAssertTrue(l.await(SMALL_DELAY_MS, MILLISECONDS));
94	<	} catch (InterruptedException e) {
95	<	threadUnexpectedException();
96	<	}
97	<	}
98	<	});
99	<	t.start();
100	<	try {
101	<	assertEquals(l.getCount(), 2);
102	<	Thread.sleep(SHORT_DELAY_MS);
103	<	l.countDown();
104	<	assertEquals(l.getCount(), 1);
108	<	l.countDown();
109	<	assertEquals(l.getCount(), 0);
110	<	t.join();
111	<	} catch (InterruptedException e) {
112	<	unexpectedException();
113	<	}
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 IE if interrupted before counted down
108	>	* await throws InterruptedException if interrupted before counted down
109		*/
110	<	public void testAwait_InterruptedException() {
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	<	threadAssertTrue(l.getCount() > 0);
116	<	l.await();
117	<	threadShouldThrow();
118	<	} catch (InterruptedException success) {}
119	<	}
120	<	});
121	<	t.start();
122	<	try {
123	<	assertEquals(l.getCount(), 1);
124	<	t.interrupt();
125	<	t.join();
126	<	} catch (InterruptedException e) {
127	<	unexpectedException();
128	<	}
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 IE if interrupted before counted down
140	<	*/
141	<	public void testTimedAwait_InterruptedException() {
142	<	final CountDownLatch l = new CountDownLatch(1);
143	<	Thread t = new Thread(new Runnable() {
144	<	public void run() {
145	<	try {
146	<	threadAssertTrue(l.getCount() > 0);
147	<	l.await(MEDIUM_DELAY_MS, MILLISECONDS);
148	<	threadShouldThrow();
149	<	} catch (InterruptedException success) {}
150	<	}
151	<	});
152	<	t.start();
153	<	try {
154	<	Thread.sleep(SHORT_DELAY_MS);
155	<	assertEquals(l.getCount(), 1);
156	<	t.interrupt();
157	<	t.join();
158	<	} catch (InterruptedException e) {
159	<	unexpectedException();
160	<	}
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() {
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	<	threadAssertTrue(l.getCount() > 0);
182	<	threadAssertFalse(l.await(SHORT_DELAY_MS, MILLISECONDS));
183	<	threadAssertTrue(l.getCount() > 0);
184	<	} catch (InterruptedException ie) {
185	<	threadUnexpectedException();
186	<	}
187	<	}
188	<	});
189	<	t.start();
190	<	try {
183	<	assertEquals(l.getCount(), 1);
184	<	t.join();
185	<	} catch (InterruptedException e) {
186	<	unexpectedException();
187	<	}
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		/**
#	Line 192 | Line 195 | public class CountDownLatchTest extends
195		*/
196		public void testToString() {
197		CountDownLatch s = new CountDownLatch(2);
198	<	String us = s.toString();
196	<	assertTrue(us.indexOf("Count = 2") >= 0);
198	>	assertTrue(s.toString().contains("Count = 2"));
199		s.countDown();
200	<	String s1 = s.toString();
199	<	assertTrue(s1.indexOf("Count = 1") >= 0);
200	>	assertTrue(s.toString().contains("Count = 1"));
201		s.countDown();
202	<	String s2 = s.toString();
202	<	assertTrue(s2.indexOf("Count = 0") >= 0);
202	>	assertTrue(s.toString().contains("Count = 0"));
203		}
204
205		}

Diff Legend

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