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.11 by jsr166, Sat Nov 21 02:07:26 2009 UTC vs.
Revision 1.29 by jsr166, Thu Sep 5 21:33:55 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 55 | 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) {
66	<	threadUnexpectedException();
67	<	}
68	<	}
69	<	});
70	<	t.start();
71	<	try {
72	<	assertEquals(l.getCount(), 2);
73	<	Thread.sleep(SHORT_DELAY_MS);
74	<	l.countDown();
75	<	assertEquals(l.getCount(), 1);
76	<	l.countDown();
77	<	assertEquals(l.getCount(), 0);
78	<	t.join();
79	<	} catch (InterruptedException e) {
80	<	unexpectedException();
81	<	}
82	<	}
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, TimeUnit.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);
107	<	l.countDown();
108	<	assertEquals(l.getCount(), 0);
109	<	t.join();
110	<	} catch (InterruptedException e) {
111	<	unexpectedException();
112	<	}
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, TimeUnit.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	>	Thread.currentThread().interrupt();
148	>	try {
149	>	l.await(randomTimeout(), randomTimeUnit());
150	>	shouldThrow();
151	>	} catch (InterruptedException success) {}
152	>	assertFalse(Thread.interrupted());
153	>
154	>	pleaseInterrupt.countDown();
155	>	try {
156	>	l.await(LONGER_DELAY_MS, MILLISECONDS);
157	>	shouldThrow();
158	>	} catch (InterruptedException success) {}
159	>	assertFalse(Thread.interrupted());
160	>
161	>	assertEquals(initialCount, l.getCount());
162	>	}});
163	>
164	>	await(pleaseInterrupt);
165	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
166	>	t.interrupt();
167	>	awaitTermination(t);
168		}
169
170		/**
171		* timed await times out if not counted down before timeout
172		*/
173	<	public void testAwaitTimeout() {
173	>	public void testAwaitTimeout() throws InterruptedException {
174		final CountDownLatch l = new CountDownLatch(1);
175	<	Thread t = new Thread(new Runnable() {
176	<	public void run() {
177	<	try {
178	<	threadAssertTrue(l.getCount() > 0);
179	<	threadAssertFalse(l.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
180	<	threadAssertTrue(l.getCount() > 0);
181	<	} catch (InterruptedException ie) {
182	<	threadUnexpectedException();
183	<	}
184	<	}
185	<	});
186	<	t.start();
187	<	try {
182	<	assertEquals(l.getCount(), 1);
183	<	t.join();
184	<	} catch (InterruptedException e) {
185	<	unexpectedException();
186	<	}
175	>	Thread t = newStartedThread(new CheckedRunnable() {
176	>	public void realRun() throws InterruptedException {
177	>	assertEquals(1, l.getCount());
178	>
179	>	long startTime = System.nanoTime();
180	>	assertFalse(l.await(timeoutMillis(), MILLISECONDS));
181	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
182	>
183	>	assertEquals(1, l.getCount());
184	>	}});
185	>
186	>	awaitTermination(t);
187	>	assertEquals(1, l.getCount());
188		}
189
190		/**
#	Line 191 | Line 192 | public class CountDownLatchTest extends
192		*/
193		public void testToString() {
194		CountDownLatch s = new CountDownLatch(2);
195	<	String us = s.toString();
195	<	assertTrue(us.indexOf("Count = 2") >= 0);
195	>	assertTrue(s.toString().contains("Count = 2"));
196		s.countDown();
197	<	String s1 = s.toString();
198	<	assertTrue(s1.indexOf("Count = 1") >= 0);
197	>	assertTrue(s.toString().contains("Count = 1"));
198		s.countDown();
199	<	String s2 = s.toString();
201	<	assertTrue(s2.indexOf("Count = 0") >= 0);
199	>	assertTrue(s.toString().contains("Count = 0"));
200		}
201
202		}

Diff Legend

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