ViewVC Help

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

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

Comparing jsr166/src/test/tck/TimeUnitTest.java (file contents):
Revision 1.5 by dl, Thu Sep 25 11:02:42 2003 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 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 static java.util.concurrent.TimeUnit.DAYS;
10	+	import static java.util.concurrent.TimeUnit.HOURS;
11	+	import static java.util.concurrent.TimeUnit.MICROSECONDS;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13	+	import static java.util.concurrent.TimeUnit.MINUTES;
14	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
15	+	import static java.util.concurrent.TimeUnit.SECONDS;
16
17	<	import junit.framework.*;
18	<	import java.util.concurrent.*;
19	<	import java.io.*;
17	>	import java.util.concurrent.CountDownLatch;
18	>	import java.util.concurrent.TimeUnit;
19	>
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class TimeUnitTest extends JSR166TestCase {
24		public static void main(String[] args) {
25	<	junit.textui.TestRunner.run(suite());
25	>	main(suite(), args);
26		}
27	<
27	>
28		public static Test suite() {
29	<	return new TestSuite(TimeUnitTest.class);
29	>	return new TestSuite(TimeUnitTest.class);
30		}
31
32	<	/**
33	<	* convert correctly converts sample values across the four units
34	<	*/
35	<	public void testConvert() {
36	<	for (long t = 0; t < 10; ++t) {
37	<	assertEquals(t,
38	<	TimeUnit.SECONDS.convert(t,
39	<	TimeUnit.SECONDS));
40	<	assertEquals(t,
41	<	TimeUnit.SECONDS.convert(1000 * t,
42	<	TimeUnit.MILLISECONDS));
43	<	assertEquals(t,
44	<	TimeUnit.SECONDS.convert(1000000 * t,
45	<	TimeUnit.MICROSECONDS));
46	<	assertEquals(t,
47	<	TimeUnit.SECONDS.convert(1000000000 * t,
48	<	TimeUnit.NANOSECONDS));
49	<	assertEquals(1000 * t,
50	<	TimeUnit.MILLISECONDS.convert(t,
51	<	TimeUnit.SECONDS));
52	<	assertEquals(t,
53	<	TimeUnit.MILLISECONDS.convert(t,
54	<	TimeUnit.MILLISECONDS));
55	<	assertEquals(t,
56	<	TimeUnit.MILLISECONDS.convert(1000 * t,
57	<	TimeUnit.MICROSECONDS));
48	<	assertEquals(t,
49	<	TimeUnit.MILLISECONDS.convert(1000000 * t,
50	<	TimeUnit.NANOSECONDS));
51	<	assertEquals(1000000 * t,
52	<	TimeUnit.MICROSECONDS.convert(t,
53	<	TimeUnit.SECONDS));
54	<	assertEquals(1000 * t,
55	<	TimeUnit.MICROSECONDS.convert(t,
56	<	TimeUnit.MILLISECONDS));
57	<	assertEquals(t,
58	<	TimeUnit.MICROSECONDS.convert(t,
59	<	TimeUnit.MICROSECONDS));
60	<	assertEquals(t,
61	<	TimeUnit.MICROSECONDS.convert(1000 * t,
62	<	TimeUnit.NANOSECONDS));
63	<	assertEquals(1000000000 * t,
64	<	TimeUnit.NANOSECONDS.convert(t,
65	<	TimeUnit.SECONDS));
66	<	assertEquals(1000000 * t,
67	<	TimeUnit.NANOSECONDS.convert(t,
68	<	TimeUnit.MILLISECONDS));
69	<	assertEquals(1000 * t,
70	<	TimeUnit.NANOSECONDS.convert(t,
71	<	TimeUnit.MICROSECONDS));
72	<	assertEquals(t,
73	<	TimeUnit.NANOSECONDS.convert(t,
74	<	TimeUnit.NANOSECONDS));
32	>	void testConversion(TimeUnit x, TimeUnit y, long n, long expected) {
33	>	assertEquals(expected, x.convert(n, y));
34	>	switch (x) {
35	>	case NANOSECONDS:  assertEquals(expected, y.toNanos(n));   break;
36	>	case MICROSECONDS: assertEquals(expected, y.toMicros(n));  break;
37	>	case MILLISECONDS: assertEquals(expected, y.toMillis(n));  break;
38	>	case SECONDS:      assertEquals(expected, y.toSeconds(n)); break;
39	>	case MINUTES:      assertEquals(expected, y.toMinutes(n)); break;
40	>	case HOURS:        assertEquals(expected, y.toHours(n));   break;
41	>	case DAYS:         assertEquals(expected, y.toDays(n));    break;
42	>	default: throw new AssertionError();
43	>	}
44	>
45	>	if (n > 0) testConversion(x, y, -n, -expected);
46	>	}
47	>
48	>	void testConversion(TimeUnit x, TimeUnit y) {
49	>	long ratio = x.toNanos(1)/y.toNanos(1);
50	>	assertTrue(ratio > 0);
51	>	long[] ns = { 0, 1, 2, Long.MAX_VALUE/ratio, Long.MIN_VALUE/ratio };
52	>	for (long n : ns) {
53	>	testConversion(y, x, n, n * ratio);
54	>	long[] ks = { n * ratio, n * ratio + 1, n * ratio - 1 };
55	>	for (long k : ks) {
56	>	testConversion(x, y, k, k / ratio);
57	>	}
58		}
59		}
60
61		/**
62	<	* toNanos correctly converts sample values in different units to
80	<	* nanoseconds
62	>	* Conversion methods correctly convert sample values
63		*/
64	<	public void testToNanos() {
65	<	for (long t = 0; t < 10; ++t) {
66	<	assertEquals(1000000000 * t,
67	<	TimeUnit.SECONDS.toNanos(t));
68	<
69	<	assertEquals(1000000 * t,
70	<	TimeUnit.MILLISECONDS.toNanos(t));
71	<	assertEquals(1000 * t,
72	<	TimeUnit.MICROSECONDS.toNanos(t));
73	<	assertEquals(t,
74	<	TimeUnit.NANOSECONDS.toNanos(t));
64	>	public void testConversions() {
65	>	// Sanity check
66	>	assertEquals(1, NANOSECONDS.toNanos(1));
67	>	assertEquals(1000L * NANOSECONDS.toNanos(1), MICROSECONDS.toNanos(1));
68	>	assertEquals(1000L * MICROSECONDS.toNanos(1), MILLISECONDS.toNanos(1));
69	>	assertEquals(1000L * MILLISECONDS.toNanos(1), SECONDS.toNanos(1));
70	>	assertEquals(60L * SECONDS.toNanos(1), MINUTES.toNanos(1));
71	>	assertEquals(60L * MINUTES.toNanos(1), HOURS.toNanos(1));
72	>	assertEquals(24L * HOURS.toNanos(1), DAYS.toNanos(1));
73	>
74	>	for (TimeUnit x : TimeUnit.values()) {
75	>	assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76		}
77	+
78	+	for (TimeUnit x : TimeUnit.values())
79	+	for (TimeUnit y : TimeUnit.values())
80	+	if (x.toNanos(1) >= y.toNanos(1))
81	+	testConversion(x, y);
82		}
83
84		/**
85	<	* toMicros correctly converts sample values in different units to
86	<	* microseconds
85	>	* convert saturates positive too-large values to Long.MAX_VALUE
86	>	* and negative to LONG.MIN_VALUE
87		*/
88	<	public void testToMicros() {
89	<	for (long t = 0; t < 10; ++t) {
90	<	assertEquals(1000000 * t,
91	<	TimeUnit.SECONDS.toMicros(t));
92	<
93	<	assertEquals(1000 * t,
94	<	TimeUnit.MILLISECONDS.toMicros(t));
95	<	assertEquals(t,
96	<	TimeUnit.MICROSECONDS.toMicros(t));
97	<	assertEquals(t,
98	<	TimeUnit.NANOSECONDS.toMicros(t * 1000));
99	<	}
88	>	public void testConvertSaturate() {
89	>	assertEquals(Long.MAX_VALUE,
90	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
91	>	assertEquals(Long.MIN_VALUE,
92	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
93	>	assertEquals(Long.MAX_VALUE,
94	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
95	>	assertEquals(Long.MIN_VALUE,
96	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
97	>	assertEquals(Long.MAX_VALUE,
98	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
99	>	assertEquals(Long.MIN_VALUE,
100	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
101	>	assertEquals(Long.MAX_VALUE,
102	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
103	>	assertEquals(Long.MIN_VALUE,
104	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
105	>
106	>	for (TimeUnit x : TimeUnit.values())
107	>	for (TimeUnit y : TimeUnit.values()) {
108	>	long ratio = x.toNanos(1) / y.toNanos(1);
109	>	if (ratio >= 1) {
110	>	assertEquals(ratio, y.convert(1, x));
111	>	assertEquals(1, x.convert(ratio, y));
112	>	long max = Long.MAX_VALUE/ratio;
113	>	assertEquals(max * ratio, y.convert(max, x));
114	>	assertEquals(-max * ratio, y.convert(-max, x));
115	>	assertEquals(max, x.convert(max * ratio, y));
116	>	assertEquals(-max, x.convert(-max * ratio, y));
117	>	if (max < Long.MAX_VALUE) {
118	>	assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
119	>	assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
120	>	assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
121	>	}
122	>	assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
123	>	assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
124	>	}
125	>	}
126		}
127
128		/**
129	<	* toMillis correctly converts sample values in different units to
130	<	* milliseconds
129	>	* toNanos saturates positive too-large values to Long.MAX_VALUE
130	>	* and negative to LONG.MIN_VALUE
131		*/
132	<	public void testToMillis() {
133	<	for (long t = 0; t < 10; ++t) {
134	<	assertEquals(1000 * t,
135	<	TimeUnit.SECONDS.toMillis(t));
136	<
137	<	assertEquals(t,
138	<	TimeUnit.MILLISECONDS.toMillis(t));
139	<	assertEquals(t,
140	<	TimeUnit.MICROSECONDS.toMillis(t * 1000));
141	<	assertEquals(t,
142	<	TimeUnit.NANOSECONDS.toMillis(t * 1000000));
132	>	public void testToNanosSaturate() {
133	>	assertEquals(Long.MAX_VALUE,
134	>	MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
135	>	assertEquals(Long.MIN_VALUE,
136	>	MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
137	>
138	>	for (TimeUnit x : TimeUnit.values()) {
139	>	long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
140	>	if (ratio >= 1) {
141	>	long max = Long.MAX_VALUE/ratio;
142	>	for (long z : new long[] {0, 1, -1, max, -max})
143	>	assertEquals(z * ratio, x.toNanos(z));
144	>	if (max < Long.MAX_VALUE) {
145	>	assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
146	>	assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
147	>	assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
148	>	}
149	>	assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
150	>	assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
151	>	if (max < Integer.MAX_VALUE) {
152	>	assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
153	>	assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
154	>	}
155	>	}
156		}
157		}
158
159		/**
160	<	* toSeconds correctly converts sample values in different units to
161	<	* seconds
160	>	* toMicros saturates positive too-large values to Long.MAX_VALUE
161	>	* and negative to LONG.MIN_VALUE
162		*/
163	<	public void testToSeconds() {
164	<	for (long t = 0; t < 10; ++t) {
165	<	assertEquals(t,
166	<	TimeUnit.SECONDS.toSeconds(t));
167	<
168	<	assertEquals(t,
169	<	TimeUnit.MILLISECONDS.toSeconds(t * 1000));
170	<	assertEquals(t,
171	<	TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
172	<	assertEquals(t,
173	<	TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
163	>	public void testToMicrosSaturate() {
164	>	for (TimeUnit x : TimeUnit.values()) {
165	>	long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
166	>	if (ratio >= 1) {
167	>	long max = Long.MAX_VALUE/ratio;
168	>	for (long z : new long[] {0, 1, -1, max, -max})
169	>	assertEquals(z * ratio, x.toMicros(z));
170	>	if (max < Long.MAX_VALUE) {
171	>	assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
172	>	assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
173	>	assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
174	>	}
175	>	assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
176	>	assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
177	>	if (max < Integer.MAX_VALUE) {
178	>	assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
179	>	assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
180	>	}
181	>	}
182		}
183		}
184
150	–
185		/**
186	<	* convert saturates positive too-large values to Long.MAX_VALUE
186	>	* toMillis saturates positive too-large values to Long.MAX_VALUE
187		* and negative to LONG.MIN_VALUE
188		*/
189	<	public void testConvertSaturate() {
190	<	assertEquals(Long.MAX_VALUE,
191	<	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
192	<	TimeUnit.SECONDS));
193	<	assertEquals(Long.MIN_VALUE,
194	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
195	<	TimeUnit.SECONDS));
189	>	public void testToMillisSaturate() {
190	>	for (TimeUnit x : TimeUnit.values()) {
191	>	long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
192	>	if (ratio >= 1) {
193	>	long max = Long.MAX_VALUE/ratio;
194	>	for (long z : new long[] {0, 1, -1, max, -max})
195	>	assertEquals(z * ratio, x.toMillis(z));
196	>	if (max < Long.MAX_VALUE) {
197	>	assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
198	>	assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
199	>	assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
200	>	}
201	>	assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
202	>	assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
203	>	if (max < Integer.MAX_VALUE) {
204	>	assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
205	>	assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
206	>	}
207	>	}
208	>	}
209		}
210
211		/**
212	<	* toNanos saturates positive too-large values to Long.MAX_VALUE
212	>	* toSeconds saturates positive too-large values to Long.MAX_VALUE
213		* and negative to LONG.MIN_VALUE
214		*/
215	<	public void testToNanosSaturate() {
216	<	assertEquals(Long.MAX_VALUE,
217	<	TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
218	<	assertEquals(Long.MIN_VALUE,
219	<	TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
215	>	public void testToSecondsSaturate() {
216	>	for (TimeUnit x : TimeUnit.values()) {
217	>	long ratio = x.toNanos(1) / SECONDS.toNanos(1);
218	>	if (ratio >= 1) {
219	>	long max = Long.MAX_VALUE/ratio;
220	>	for (long z : new long[] {0, 1, -1, max, -max})
221	>	assertEquals(z * ratio, x.toSeconds(z));
222	>	if (max < Long.MAX_VALUE) {
223	>	assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
224	>	assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
225	>	assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
226	>	}
227	>	assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
228	>	assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
229	>	if (max < Integer.MAX_VALUE) {
230	>	assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
231	>	assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
232	>	}
233	>	}
234	>	}
235		}
236
175	–
237		/**
238	<	* toString returns string containing commn name of unit
238	>	* toMinutes saturates positive too-large values to Long.MAX_VALUE
239	>	* and negative to LONG.MIN_VALUE
240		*/
241	<	public void testToString() {
242	<	String s = TimeUnit.SECONDS.toString();
243	<	assertTrue(s.indexOf("econd") >= 0);
241	>	public void testToMinutesSaturate() {
242	>	for (TimeUnit x : TimeUnit.values()) {
243	>	long ratio = x.toNanos(1) / MINUTES.toNanos(1);
244	>	if (ratio > 1) {
245	>	long max = Long.MAX_VALUE/ratio;
246	>	for (long z : new long[] {0, 1, -1, max, -max})
247	>	assertEquals(z * ratio, x.toMinutes(z));
248	>	assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
249	>	assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
250	>	assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
251	>	assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
252	>	assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
253	>	}
254	>	}
255		}
256
184	–
257		/**
258	<	*  Timed wait without holding lock throws
259	<	*  IllegalMonitorStateException
258	>	* toHours saturates positive too-large values to Long.MAX_VALUE
259	>	* and negative to LONG.MIN_VALUE
260		*/
261	<	public void testTimedWait_IllegalMonitorException() {
262	<	//created a new thread with anonymous runnable
263	<
264	<	Thread t = new Thread(new Runnable() {
265	<	public void run() {
266	<	Object o = new Object();
267	<	TimeUnit tu = TimeUnit.MILLISECONDS;
268	<	try {
269	<	tu.timedWait(o,LONG_DELAY_MS);
270	<	threadShouldThrow();
271	<	}
200	<	catch (InterruptedException ie) {
201	<	threadUnexpectedException();
202	<	}
203	<	catch(IllegalMonitorStateException success) {
204	<	}
205	<
261	>	public void testToHoursSaturate() {
262	>	for (TimeUnit x : TimeUnit.values()) {
263	>	long ratio = x.toNanos(1) / HOURS.toNanos(1);
264	>	if (ratio >= 1) {
265	>	long max = Long.MAX_VALUE/ratio;
266	>	for (long z : new long[] {0, 1, -1, max, -max})
267	>	assertEquals(z * ratio, x.toHours(z));
268	>	if (max < Long.MAX_VALUE) {
269	>	assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
270	>	assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
271	>	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
272		}
273	<	});
274	<	t.start();
275	<	try {
210	<	Thread.sleep(SHORT_DELAY_MS);
211	<	t.interrupt();
212	<	t.join();
213	<	} catch(Exception e) {
214	<	unexpectedException();
273	>	assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
274	>	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
275	>	}
276		}
277		}
278	<
278	>
279		/**
280	<	* timedWait throws InterruptedException when interrupted
280	>	* toString returns name of unit
281		*/
282	<	public void testTimedWait() {
283	<	Thread t = new Thread(new Runnable() {
284	<	public void run() {
285	<	Object o = new Object();
286	<
287	<	TimeUnit tu = TimeUnit.MILLISECONDS;
288	<	try {
289	<	synchronized(o) {
229	<	tu.timedWait(o,MEDIUM_DELAY_MS);
230	<	}
231	<	threadShouldThrow();
232	<	}
233	<	catch(InterruptedException success) {}
234	<	catch(IllegalMonitorStateException failure) {
235	<	threadUnexpectedException();
236	<	}
237	<	}
238	<	});
239	<	t.start();
240	<	try {
241	<	Thread.sleep(SHORT_DELAY_MS);
242	<	t.interrupt();
243	<	t.join();
244	<	} catch(Exception e) {
245	<	unexpectedException();
246	<	}
282	>	public void testToString() {
283	>	assertEquals("NANOSECONDS", NANOSECONDS.toString());
284	>	assertEquals("MICROSECONDS", MICROSECONDS.toString());
285	>	assertEquals("MILLISECONDS", MILLISECONDS.toString());
286	>	assertEquals("SECONDS", SECONDS.toString());
287	>	assertEquals("MINUTES", MINUTES.toString());
288	>	assertEquals("HOURS", HOURS.toString());
289	>	assertEquals("DAYS", DAYS.toString());
290		}
291	<
249	<
291	>
292		/**
293	<	* timedJoin throws InterruptedException when interrupted
293	>	* name returns name of unit
294		*/
295	<	public void testTimedJoin() {
296	<	Thread t = new Thread(new Runnable() {
297	<	public void run() {
256	<	TimeUnit tu = TimeUnit.MILLISECONDS;
257	<	try {
258	<	Thread s = new Thread(new Runnable() {
259	<	public void run() {
260	<	try {
261	<	Thread.sleep(MEDIUM_DELAY_MS);
262	<	} catch(InterruptedException success){}
263	<	}
264	<	});
265	<	s.start();
266	<	tu.timedJoin(s,MEDIUM_DELAY_MS);
267	<	threadShouldThrow();
268	<	}
269	<	catch(Exception e) {}
270	<	}
271	<	});
272	<	t.start();
273	<	try {
274	<	Thread.sleep(SHORT_DELAY_MS);
275	<	t.interrupt();
276	<	t.join();
277	<	} catch(Exception e) {
278	<	unexpectedException();
279	<	}
295	>	public void testName() {
296	>	for (TimeUnit x : TimeUnit.values())
297	>	assertEquals(x.toString(), x.name());
298		}
299	<
299	>
300		/**
301	<	*  timedSleep throws InterruptedException when interrupted
301	>	* Timed wait without holding lock throws
302	>	* IllegalMonitorStateException
303		*/
304	<	public void testTimedSleep() {
305	<	//created a new thread with anonymous runnable
304	>	public void testTimedWait_IllegalMonitorException() {
305	>	Thread t = newStartedThread(new CheckedRunnable() {
306	>	public void realRun() throws InterruptedException {
307	>	Object o = new Object();
308	>	try {
309	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310	>	threadShouldThrow();
311	>	} catch (IllegalMonitorStateException success) {}
312	>	}});
313
314	<	Thread t = new Thread(new Runnable() {
289	<	public void run() {
290	<	TimeUnit tu = TimeUnit.MILLISECONDS;
291	<	try {
292	<	tu.sleep(MEDIUM_DELAY_MS);
293	<	threadShouldThrow();
294	<	}
295	<	catch(InterruptedException success) {}
296	<	}
297	<	});
298	<	t.start();
299	<	try {
300	<	Thread.sleep(SHORT_DELAY_MS);
301	<	t.interrupt();
302	<	t.join();
303	<	} catch(Exception e) {
304	<	unexpectedException();
305	<	}
314	>	awaitTermination(t);
315		}
316
317		/**
318	<	* a deserialized serialized unit is equal
318	>	* timedWait throws InterruptedException when interrupted
319		*/
320	<	public void testSerialization() {
321	<	TimeUnit q = TimeUnit.MILLISECONDS;
320	>	public void testTimedWait_Interruptible() {
321	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
322	>	Thread t = newStartedThread(new CheckedRunnable() {
323	>	public void realRun() throws InterruptedException {
324	>	Object o = new Object();
325	>
326	>	Thread.currentThread().interrupt();
327	>	try {
328	>	synchronized (o) {
329	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
330	>	}
331	>	shouldThrow();
332	>	} catch (InterruptedException success) {}
333	>	assertFalse(Thread.interrupted());
334	>
335	>	pleaseInterrupt.countDown();
336	>	try {
337	>	synchronized (o) {
338	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
339	>	}
340	>	shouldThrow();
341	>	} catch (InterruptedException success) {}
342	>	assertFalse(Thread.interrupted());
343	>	}});
344	>
345	>	await(pleaseInterrupt);
346	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
347	>	t.interrupt();
348	>	awaitTermination(t);
349	>	}
350
351	<	try {
352	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
353	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
354	<	out.writeObject(q);
355	<	out.close();
356	<
357	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
358	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
359	<	TimeUnit r = (TimeUnit)in.readObject();
360	<
361	<	assertEquals(q.toString(), r.toString());
362	<	} catch(Exception e){
363	<	e.printStackTrace();
364	<	unexpectedException();
365	<	}
351	>	/**
352	>	* timedJoin throws InterruptedException when interrupted
353	>	*/
354	>	public void testTimedJoin_Interruptible() {
355	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
356	>	final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
357	>	public void realRun() throws InterruptedException {
358	>	Thread.sleep(LONGER_DELAY_MS);
359	>	}});
360	>	final Thread t = newStartedThread(new CheckedRunnable() {
361	>	public void realRun() throws InterruptedException {
362	>	Thread.currentThread().interrupt();
363	>	try {
364	>	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
365	>	shouldThrow();
366	>	} catch (InterruptedException success) {}
367	>	assertFalse(Thread.interrupted());
368	>
369	>	pleaseInterrupt.countDown();
370	>	try {
371	>	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
372	>	shouldThrow();
373	>	} catch (InterruptedException success) {}
374	>	assertFalse(Thread.interrupted());
375	>	}});
376	>
377	>	await(pleaseInterrupt);
378	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
379	>	t.interrupt();
380	>	awaitTermination(t);
381	>	s.interrupt();
382	>	awaitTermination(s);
383	>	}
384	>
385	>	/**
386	>	* timeUnit.sleep throws InterruptedException when interrupted
387	>	*/
388	>	public void testTimedSleep_Interruptible() {
389	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
390	>	Thread t = newStartedThread(new CheckedRunnable() {
391	>	public void realRun() throws InterruptedException {
392	>	Thread.currentThread().interrupt();
393	>	try {
394	>	MILLISECONDS.sleep(LONGER_DELAY_MS);
395	>	shouldThrow();
396	>	} catch (InterruptedException success) {}
397	>	assertFalse(Thread.interrupted());
398	>
399	>	pleaseInterrupt.countDown();
400	>	try {
401	>	MILLISECONDS.sleep(LONGER_DELAY_MS);
402	>	shouldThrow();
403	>	} catch (InterruptedException success) {}
404	>	assertFalse(Thread.interrupted());
405	>	}});
406	>
407	>	await(pleaseInterrupt);
408	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
409	>	t.interrupt();
410	>	awaitTermination(t);
411	>	}
412	>
413	>	/**
414	>	* timeUnit.sleep(x) for x <= 0 does not sleep at all.
415	>	*/
416	>	public void testTimedSleep_nonPositive() throws InterruptedException {
417	>	boolean interrupt = randomBoolean();
418	>	if (interrupt) Thread.currentThread().interrupt();
419	>	randomTimeUnit().sleep(0L);
420	>	randomTimeUnit().sleep(-1L);
421	>	randomTimeUnit().sleep(Long.MIN_VALUE);
422	>	if (interrupt) assertTrue(Thread.interrupted());
423	>	}
424	>
425	>	/**
426	>	* a deserialized/reserialized unit is the same instance
427	>	*/
428	>	public void testSerialization() throws Exception {
429	>	for (TimeUnit x : TimeUnit.values())
430	>	assertSame(x, serialClone(x));
431		}
432
433		}

Diff Legend

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