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.1 by dl, Sun Aug 31 19:24:56 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.*;
11	<
12	<	public class TimeUnitTest extends TestCase {
13	<	static public boolean DEBUG = false;
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	>	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	<	public void testConvert() {
49	<	for (long t = 0; t < 10; ++t) {
50	<	assertEquals(t,
51	<	TimeUnit.SECONDS.convert(t,
52	<	TimeUnit.SECONDS));
53	<	assertEquals(t,
54	<	TimeUnit.SECONDS.convert(1000 * t,
55	<	TimeUnit.MILLISECONDS));
56	<	assertEquals(t,
57	<	TimeUnit.SECONDS.convert(1000000 * t,
34	<	TimeUnit.MICROSECONDS));
35	<	assertEquals(t,
36	<	TimeUnit.SECONDS.convert(1000000000 * t,
37	<	TimeUnit.NANOSECONDS));
38	<	assertEquals(1000 * t,
39	<	TimeUnit.MILLISECONDS.convert(t,
40	<	TimeUnit.SECONDS));
41	<	assertEquals(t,
42	<	TimeUnit.MILLISECONDS.convert(t,
43	<	TimeUnit.MILLISECONDS));
44	<	assertEquals(t,
45	<	TimeUnit.MILLISECONDS.convert(1000 * t,
46	<	TimeUnit.MICROSECONDS));
47	<	assertEquals(t,
48	<	TimeUnit.MILLISECONDS.convert(1000000 * t,
49	<	TimeUnit.NANOSECONDS));
50	<	assertEquals(1000000 * t,
51	<	TimeUnit.MICROSECONDS.convert(t,
52	<	TimeUnit.SECONDS));
53	<	assertEquals(1000 * t,
54	<	TimeUnit.MICROSECONDS.convert(t,
55	<	TimeUnit.MILLISECONDS));
56	<	assertEquals(t,
57	<	TimeUnit.MICROSECONDS.convert(t,
58	<	TimeUnit.MICROSECONDS));
59	<	assertEquals(t,
60	<	TimeUnit.MICROSECONDS.convert(1000 * t,
61	<	TimeUnit.NANOSECONDS));
62	<	assertEquals(1000000000 * t,
63	<	TimeUnit.NANOSECONDS.convert(t,
64	<	TimeUnit.SECONDS));
65	<	assertEquals(1000000 * t,
66	<	TimeUnit.NANOSECONDS.convert(t,
67	<	TimeUnit.MILLISECONDS));
68	<	assertEquals(1000 * t,
69	<	TimeUnit.NANOSECONDS.convert(t,
70	<	TimeUnit.MICROSECONDS));
71	<	assertEquals(t,
72	<	TimeUnit.NANOSECONDS.convert(t,
73	<	TimeUnit.NANOSECONDS));
74	<	}
75	<	}
76	<
77	<	public void testToNanos() {
78	<	for (long t = 0; t < 10; ++t) {
79	<	assertEquals(1000000000 * t,
80	<	TimeUnit.SECONDS.toNanos(t));
81	<
82	<	assertEquals(1000000 * t,
83	<	TimeUnit.MILLISECONDS.toNanos(t));
84	<	assertEquals(1000 * t,
85	<	TimeUnit.MICROSECONDS.toNanos(t));
86	<	assertEquals(t,
87	<	TimeUnit.SECONDS.NANOSECONDS.toNanos(t));
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	+	* Conversion methods correctly convert sample values
63	+	*/
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	+	* convert saturates positive too-large values to Long.MAX_VALUE
86	+	* and negative to LONG.MIN_VALUE
87	+	*/
88		public void testConvertSaturate() {
89		assertEquals(Long.MAX_VALUE,
90	<	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
91	<	TimeUnit.SECONDS));
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	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
101	<	TimeUnit.SECONDS));
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	+	* toNanos saturates positive too-large values to Long.MAX_VALUE
130	+	* and negative to LONG.MIN_VALUE
131	+	*/
132		public void testToNanosSaturate() {
133	<	assertEquals(Long.MAX_VALUE,
134	<	TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
135	<	assertEquals(Long.MIN_VALUE,
136	<	TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
137	<
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	>	* toMicros saturates positive too-large values to Long.MAX_VALUE
161	>	* and negative to LONG.MIN_VALUE
162	>	*/
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	>
185	>	/**
186	>	* toMillis saturates positive too-large values to Long.MAX_VALUE
187	>	* and negative to LONG.MIN_VALUE
188	>	*/
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	>	* toSeconds saturates positive too-large values to Long.MAX_VALUE
213	>	* and negative to LONG.MIN_VALUE
214	>	*/
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
237	+	/**
238	+	* toMinutes saturates positive too-large values to Long.MAX_VALUE
239	+	* and negative to LONG.MIN_VALUE
240	+	*/
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
257	+	/**
258	+	* toHours saturates positive too-large values to Long.MAX_VALUE
259	+	* and negative to LONG.MIN_VALUE
260	+	*/
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	+	assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
274	+	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
275	+	}
276	+	}
277	+	}
278	+
279	+	/**
280	+	* toString returns name of unit
281	+	*/
282		public void testToString() {
283	<	String s = TimeUnit.SECONDS.toString();
284	<	assertTrue(s.indexOf("econd") >= 0);
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
116	–	// Exception tests
117	–
292		/**
293	<	*  This test specifically to catch the unreported exception
293	>	* name returns name of unit
294		*/
295	<	public void testTimedWaitForUnreportedIllegalMonitorException() {
296	<	//created a new thread with anonymous runnable
295	>	public void testName() {
296	>	for (TimeUnit x : TimeUnit.values())
297	>	assertEquals(x.toString(), x.name());
298	>	}
299
300	<	Thread t = new Thread(new Runnable() {
301	<	public void run() {
302	<	Object o = new Object();
303	<	TimeUnit tu = TimeUnit.MILLISECONDS;
304	<	try {
305	<	tu.timedWait(o,40000);
306	<	fail("should throw");
300	>	/**
301	>	* Timed wait without holding lock throws
302	>	* IllegalMonitorStateException
303	>	*/
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	>	awaitTermination(t);
315	>	}
316	>
317	>	/**
318	>	* timedWait throws InterruptedException when interrupted
319	>	*/
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	<	catch (InterruptedException ie) {
332	<	fail("should not throw IE here");
333	<	}
334	<	catch(IllegalMonitorStateException success) {
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	<
341	<	}
342	<	});
343	<	t.start();
344	<	try {
345	<	Thread.sleep(100);
346	<	t.interrupt();
347	<	t.join();
348	<	} catch(Exception e) {
349	<	fail("Unexpected exception");
350	<	}
351	<	}
352	<
353	<	/**
354	<	*  Test to verify that timedWait will throw InterruptedException.
355	<	*  Thread t waits on timedWait while the main thread interrupts it.
356	<	*  Note:  This does not throw IllegalMonitorException since timeWait
357	<	*         is synchronized on o
358	<	*/
359	<	public void testTimedWait() {
360	<	Thread t = new Thread(new Runnable() {
361	<	public void run() {
362	<	Object o = new Object();
363	<
364	<	TimeUnit tu = TimeUnit.MILLISECONDS;
365	<	try {
366	<	synchronized(o) {
367	<	tu.timedWait(o,1000);
368	<	}
369	<	fail("should throw");
370	<	}
371	<	catch(InterruptedException success) {}
372	<	catch(IllegalMonitorStateException failure) {
373	<	fail("should not throw");
374	<	}
375	<	}
376	<	});
377	<	t.start();
378	<	try {
379	<	Thread.sleep(100);
380	<	t.interrupt();
381	<	t.join();
382	<	} catch(Exception e) {
383	<	fail("Unexpected exception");
384	<	}
385	<	}
386	<
387	<
388	<	/**
389	<	*  Test to verify that timedJoin will throw InterruptedException.
390	<	*  Thread t waits on timedJoin while the main thread interrupts it.
391	<	*/
392	<	public void testTimedJoin() {
393	<	Thread t = new Thread(new Runnable() {
394	<	public void run() {
395	<	TimeUnit tu = TimeUnit.MILLISECONDS;
396	<	try {
397	<	Thread s = new Thread(new Runnable() {
398	<	public void run() {
399	<	try{
400	<	Thread.sleep(1000);
401	<	}catch(InterruptedException success){}
402	<	}
403	<	});
404	<	s.start();
405	<	tu.timedJoin(s,1000);
406	<	fail("should throw");
407	<	}
408	<	catch(Exception e) {}
409	<	}
410	<	});
411	<	t.start();
412	<	try {
413	<	Thread.sleep(100);
414	<	t.interrupt();
415	<	t.join();
416	<	} catch(Exception e) {
417	<	fail("Unexpected exception");
418	<	}
419	<	}
420	<
421	<	/**
422	<	*  Test to verify that timedSleep will throw InterruptedException.
220	<	*  Thread t waits on timedSleep while the main thread interrupts it.
221	<	*/
222	<	public void testTimedSleep() {
223	<	//created a new thread with anonymous runnable
224	<
225	<	Thread t = new Thread(new Runnable() {
226	<	public void run() {
227	<	TimeUnit tu = TimeUnit.MILLISECONDS;
228	<	try {
229	<	tu.sleep(1000);
230	<	fail("should throw");
231	<	}
232	<	catch(InterruptedException success) {}
233	<	}
234	<	});
235	<	t.start();
236	<	try {
237	<	Thread.sleep(100);
238	<	t.interrupt();
239	<	t.join();
240	<	} catch(Exception e) {
241	<	fail("Unexpected exception");
242	<	}
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	>	/**
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