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.4 by dl, Sat Sep 20 18:20:08 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	<	*
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));
33	<	assertEquals(t,
34	<	TimeUnit.SECONDS.convert(1000000 * t,
35	<	TimeUnit.MICROSECONDS));
36	<	assertEquals(t,
37	<	TimeUnit.SECONDS.convert(1000000000 * t,
38	<	TimeUnit.NANOSECONDS));
39	<	assertEquals(1000 * t,
40	<	TimeUnit.MILLISECONDS.convert(t,
41	<	TimeUnit.SECONDS));
42	<	assertEquals(t,
43	<	TimeUnit.MILLISECONDS.convert(t,
44	<	TimeUnit.MILLISECONDS));
45	<	assertEquals(t,
46	<	TimeUnit.MILLISECONDS.convert(1000 * t,
47	<	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		}
76	–	}
44
45	<	/**
79	<	*
80	<	*/
81	<	public void testToNanos() {
82	<	for (long t = 0; t < 10; ++t) {
83	<	assertEquals(1000000000 * t,
84	<	TimeUnit.SECONDS.toNanos(t));
85	<
86	<	assertEquals(1000000 * t,
87	<	TimeUnit.MILLISECONDS.toNanos(t));
88	<	assertEquals(1000 * t,
89	<	TimeUnit.MICROSECONDS.toNanos(t));
90	<	assertEquals(t,
91	<	TimeUnit.NANOSECONDS.toNanos(t));
92	<	}
45	>	if (n > 0) testConversion(x, y, -n, -expected);
46		}
47
48	<	/**
49	<	*
50	<	*/
51	<	public void testToMicros() {
52	<	for (long t = 0; t < 10; ++t) {
53	<	assertEquals(1000000 * t,
54	<	TimeUnit.SECONDS.toMicros(t));
55	<
56	<	assertEquals(1000 * t,
57	<	TimeUnit.MILLISECONDS.toMicros(t));
105	<	assertEquals(t,
106	<	TimeUnit.MICROSECONDS.toMicros(t));
107	<	assertEquals(t,
108	<	TimeUnit.NANOSECONDS.toMicros(t * 1000));
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	<	*
62	>	* Conversion methods correctly convert sample values
63		*/
64	<	public void testToMillis() {
65	<	for (long t = 0; t < 10; ++t) {
66	<	assertEquals(1000 * t,
67	<	TimeUnit.SECONDS.toMillis(t));
68	<
69	<	assertEquals(t,
70	<	TimeUnit.MILLISECONDS.toMillis(t));
71	<	assertEquals(t,
72	<	TimeUnit.MICROSECONDS.toMillis(t * 1000));
124	<	assertEquals(t,
125	<	TimeUnit.NANOSECONDS.toMillis(t * 1000000));
126	<	}
127	<	}
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	<	/**
75	<	*
131	<	*/
132	<	public void testToSeconds() {
133	<	for (long t = 0; t < 10; ++t) {
134	<	assertEquals(t,
135	<	TimeUnit.SECONDS.toSeconds(t));
136	<
137	<	assertEquals(t,
138	<	TimeUnit.MILLISECONDS.toSeconds(t * 1000));
139	<	assertEquals(t,
140	<	TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
141	<	assertEquals(t,
142	<	TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
74	>	for (TimeUnit x : TimeUnit.values()) {
75	>	assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76		}
144	–	}
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	<	*
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,
153	<	TimeUnit.SECONDS));
90	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
91		assertEquals(Long.MIN_VALUE,
92	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
93	<	TimeUnit.SECONDS));
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	<	*
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));
168	<
169	<	}
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	<	*
160	>	* toMicros saturates positive too-large values to Long.MAX_VALUE
161	>	* and negative to LONG.MIN_VALUE
162		*/
163	<	public void testToString() {
164	<	String s = TimeUnit.SECONDS.toString();
165	<	assertTrue(s.indexOf("econd") >= 0);
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
180	–
185		/**
186	<	*  Timed wait without holding lock throws
187	<	*  IllegalMonitorStateException
186	>	* toMillis saturates positive too-large values to Long.MAX_VALUE
187	>	* and negative to LONG.MIN_VALUE
188		*/
189	<	/**
190	<	*
191	<	*/
192	<	public void testTimedWait_IllegalMonitorException() {
193	<	//created a new thread with anonymous runnable
194	<
195	<	Thread t = new Thread(new Runnable() {
196	<	public void run() {
197	<	Object o = new Object();
198	<	TimeUnit tu = TimeUnit.MILLISECONDS;
199	<	try {
196	<	tu.timedWait(o,LONG_DELAY_MS);
197	<	threadShouldThrow();
198	<	}
199	<	catch (InterruptedException ie) {
200	<	threadUnexpectedException();
201	<	}
202	<	catch(IllegalMonitorStateException success) {
203	<	}
204	<
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	<	});
202	<	t.start();
203	<	try {
204	<	Thread.sleep(SHORT_DELAY_MS);
205	<	t.interrupt();
206	<	t.join();
207	<	} catch(Exception e) {
213	<	unexpectedException();
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	<
210	>
211		/**
212	<	*   timedWait will throw InterruptedException.
213	<	*  Thread t waits on timedWait while the main thread interrupts it.
214	<	*  Note:  This does not throw IllegalMonitorException since timeWait
215	<	*         is synchronized on o
216	<	*/
217	<	/**
218	<	*
219	<	*/
220	<	public void testTimedWait() {
221	<	Thread t = new Thread(new Runnable() {
222	<	public void run() {
223	<	Object o = new Object();
224	<
225	<	TimeUnit tu = TimeUnit.MILLISECONDS;
226	<	try {
227	<	synchronized(o) {
228	<	tu.timedWait(o,MEDIUM_DELAY_MS);
229	<	}
230	<	threadShouldThrow();
231	<	}
232	<	catch(InterruptedException success) {}
233	<	catch(IllegalMonitorStateException failure) {
240	<	threadUnexpectedException();
241	<	}
242	<	}
243	<	});
244	<	t.start();
245	<	try {
246	<	Thread.sleep(SHORT_DELAY_MS);
247	<	t.interrupt();
248	<	t.join();
249	<	} catch(Exception e) {
250	<	unexpectedException();
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	<
254	<
236	>
237		/**
238	<	*   timedJoin will throw InterruptedException.
239	<	*  Thread t waits on timedJoin while the main thread interrupts it.
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	<	*
258	>	* toHours saturates positive too-large values to Long.MAX_VALUE
259	>	* and negative to LONG.MIN_VALUE
260		*/
261	<	public void testTimedJoin() {
262	<	Thread t = new Thread(new Runnable() {
263	<	public void run() {
264	<	TimeUnit tu = TimeUnit.MILLISECONDS;
265	<	try {
266	<	Thread s = new Thread(new Runnable() {
267	<	public void run() {
268	<	try {
269	<	Thread.sleep(MEDIUM_DELAY_MS);
270	<	} catch(InterruptedException success){}
271	<	}
272	<	});
273	<	s.start();
274	<	tu.timedJoin(s,MEDIUM_DELAY_MS);
275	<	threadShouldThrow();
277	<	}
278	<	catch(Exception e) {}
279	<	}
280	<	});
281	<	t.start();
282	<	try {
283	<	Thread.sleep(SHORT_DELAY_MS);
284	<	t.interrupt();
285	<	t.join();
286	<	} catch(Exception e) {
287	<	unexpectedException();
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	<
278	>
279		/**
280	<	*   timedSleep will throw InterruptedException.
293	<	*  Thread t waits on timedSleep while the main thread interrupts it.
280	>	* toString returns name of unit
281		*/
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	+
292		/**
293	<	*
293	>	* name returns name of unit
294		*/
295	<	public void testTimedSleep() {
296	<	//created a new thread with anonymous runnable
297	<
301	<	Thread t = new Thread(new Runnable() {
302	<	public void run() {
303	<	TimeUnit tu = TimeUnit.MILLISECONDS;
304	<	try {
305	<	tu.sleep(MEDIUM_DELAY_MS);
306	<	threadShouldThrow();
307	<	}
308	<	catch(InterruptedException success) {}
309	<	}
310	<	});
311	<	t.start();
312	<	try {
313	<	Thread.sleep(SHORT_DELAY_MS);
314	<	t.interrupt();
315	<	t.join();
316	<	} catch(Exception e) {
317	<	unexpectedException();
318	<	}
295	>	public void testName() {
296	>	for (TimeUnit x : TimeUnit.values())
297	>	assertEquals(x.toString(), x.name());
298		}
299
300		/**
301	<	*
301	>	* Timed wait without holding lock throws
302	>	* IllegalMonitorStateException
303		*/
304	<	public void testSerialization() {
305	<	TimeUnit q = TimeUnit.MILLISECONDS;
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	<	try {
318	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
319	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
320	<	out.writeObject(q);
321	<	out.close();
322	<
323	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
324	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
325	<	TimeUnit r = (TimeUnit)in.readObject();
326	<
327	<	assertEquals(q.toString(), r.toString());
328	<	} catch(Exception e){
329	<	e.printStackTrace();
330	<	unexpectedException();
331	<	}
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	>	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	>	/**
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