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.11 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 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 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
28		public static Test suite() {
29	<	return new TestSuite(TimeUnitTest.class);
29	>	return new TestSuite(TimeUnitTest.class);
30		}
31
32	<	// (loops to 88888 check increments at all time divisions.)
33	<
34	<	/**
35	<	* convert correctly converts sample values across the units
36	<	*/
37	<	public void testConvert() {
38	<	for (long t = 0; t < 88888; ++t) {
39	<	assertEquals(t*60*60*24,
40	<	TimeUnit.SECONDS.convert(t,
41	<	TimeUnit.DAYS));
42	<	assertEquals(t*60*60,
34	<	TimeUnit.SECONDS.convert(t,
35	<	TimeUnit.HOURS));
36	<	assertEquals(t*60,
37	<	TimeUnit.SECONDS.convert(t,
38	<	TimeUnit.MINUTES));
39	<	assertEquals(t,
40	<	TimeUnit.SECONDS.convert(t,
41	<	TimeUnit.SECONDS));
42	<	assertEquals(t,
43	<	TimeUnit.SECONDS.convert(1000L*t,
44	<	TimeUnit.MILLISECONDS));
45	<	assertEquals(t,
46	<	TimeUnit.SECONDS.convert(1000000L*t,
47	<	TimeUnit.MICROSECONDS));
48	<	assertEquals(t,
49	<	TimeUnit.SECONDS.convert(1000000000L*t,
50	<	TimeUnit.NANOSECONDS));
51	<
52	<
53	<	assertEquals(1000L*t*60*60*24,
54	<	TimeUnit.MILLISECONDS.convert(t,
55	<	TimeUnit.DAYS));
56	<	assertEquals(1000L*t*60*60,
57	<	TimeUnit.MILLISECONDS.convert(t,
58	<	TimeUnit.HOURS));
59	<	assertEquals(1000L*t*60,
60	<	TimeUnit.MILLISECONDS.convert(t,
61	<	TimeUnit.MINUTES));
62	<	assertEquals(1000L*t,
63	<	TimeUnit.MILLISECONDS.convert(t,
64	<	TimeUnit.SECONDS));
65	<	assertEquals(t,
66	<	TimeUnit.MILLISECONDS.convert(t,
67	<	TimeUnit.MILLISECONDS));
68	<	assertEquals(t,
69	<	TimeUnit.MILLISECONDS.convert(1000L*t,
70	<	TimeUnit.MICROSECONDS));
71	<	assertEquals(t,
72	<	TimeUnit.MILLISECONDS.convert(1000000L*t,
73	<	TimeUnit.NANOSECONDS));
74	<
75	<	assertEquals(1000000L*t*60*60*24,
76	<	TimeUnit.MICROSECONDS.convert(t,
77	<	TimeUnit.DAYS));
78	<	assertEquals(1000000L*t*60*60,
79	<	TimeUnit.MICROSECONDS.convert(t,
80	<	TimeUnit.HOURS));
81	<	assertEquals(1000000L*t*60,
82	<	TimeUnit.MICROSECONDS.convert(t,
83	<	TimeUnit.MINUTES));
84	<	assertEquals(1000000L*t,
85	<	TimeUnit.MICROSECONDS.convert(t,
86	<	TimeUnit.SECONDS));
87	<	assertEquals(1000L*t,
88	<	TimeUnit.MICROSECONDS.convert(t,
89	<	TimeUnit.MILLISECONDS));
90	<	assertEquals(t,
91	<	TimeUnit.MICROSECONDS.convert(t,
92	<	TimeUnit.MICROSECONDS));
93	<	assertEquals(t,
94	<	TimeUnit.MICROSECONDS.convert(1000L*t,
95	<	TimeUnit.NANOSECONDS));
96	<
97	<	assertEquals(1000000000L*t*60*60*24,
98	<	TimeUnit.NANOSECONDS.convert(t,
99	<	TimeUnit.DAYS));
100	<	assertEquals(1000000000L*t*60*60,
101	<	TimeUnit.NANOSECONDS.convert(t,
102	<	TimeUnit.HOURS));
103	<	assertEquals(1000000000L*t*60,
104	<	TimeUnit.NANOSECONDS.convert(t,
105	<	TimeUnit.MINUTES));
106	<	assertEquals(1000000000L*t,
107	<	TimeUnit.NANOSECONDS.convert(t,
108	<	TimeUnit.SECONDS));
109	<	assertEquals(1000000L*t,
110	<	TimeUnit.NANOSECONDS.convert(t,
111	<	TimeUnit.MILLISECONDS));
112	<	assertEquals(1000L*t,
113	<	TimeUnit.NANOSECONDS.convert(t,
114	<	TimeUnit.MICROSECONDS));
115	<	assertEquals(t,
116	<	TimeUnit.NANOSECONDS.convert(t,
117	<	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		}
119	–	}
44
45	<	/**
122	<	* toNanos correctly converts sample values in different units to
123	<	* nanoseconds
124	<	*/
125	<	public void testToNanos() {
126	<	for (long t = 0; t < 88888; ++t) {
127	<	assertEquals(t*1000000000L*60*60*24,
128	<	TimeUnit.DAYS.toNanos(t));
129	<	assertEquals(t*1000000000L*60*60,
130	<	TimeUnit.HOURS.toNanos(t));
131	<	assertEquals(t*1000000000L*60,
132	<	TimeUnit.MINUTES.toNanos(t));
133	<	assertEquals(1000000000L*t,
134	<	TimeUnit.SECONDS.toNanos(t));
135	<	assertEquals(1000000L*t,
136	<	TimeUnit.MILLISECONDS.toNanos(t));
137	<	assertEquals(1000L*t,
138	<	TimeUnit.MICROSECONDS.toNanos(t));
139	<	assertEquals(t,
140	<	TimeUnit.NANOSECONDS.toNanos(t));
141	<	}
45	>	if (n > 0) testConversion(x, y, -n, -expected);
46		}
47
48	<	/**
49	<	* toMicros correctly converts sample values in different units to
50	<	* microseconds
51	<	*/
52	<	public void testToMicros() {
53	<	for (long t = 0; t < 88888; ++t) {
54	<	assertEquals(t*1000000L*60*60*24,
55	<	TimeUnit.DAYS.toMicros(t));
56	<	assertEquals(t*1000000L*60*60,
57	<	TimeUnit.HOURS.toMicros(t));
154	<	assertEquals(t*1000000L*60,
155	<	TimeUnit.MINUTES.toMicros(t));
156	<	assertEquals(1000000L*t,
157	<	TimeUnit.SECONDS.toMicros(t));
158	<	assertEquals(1000L*t,
159	<	TimeUnit.MILLISECONDS.toMicros(t));
160	<	assertEquals(t,
161	<	TimeUnit.MICROSECONDS.toMicros(t));
162	<	assertEquals(t,
163	<	TimeUnit.NANOSECONDS.toMicros(t*1000L));
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	<	* toMillis correctly converts sample values in different units to
169	<	* milliseconds
62	>	* Conversion methods correctly convert sample values
63		*/
64	<	public void testToMillis() {
65	<	for (long t = 0; t < 88888; ++t) {
66	<	assertEquals(t*1000L*60*60*24,
67	<	TimeUnit.DAYS.toMillis(t));
68	<	assertEquals(t*1000L*60*60,
69	<	TimeUnit.HOURS.toMillis(t));
70	<	assertEquals(t*1000L*60,
71	<	TimeUnit.MINUTES.toMillis(t));
72	<	assertEquals(1000L*t,
180	<	TimeUnit.SECONDS.toMillis(t));
181	<	assertEquals(t,
182	<	TimeUnit.MILLISECONDS.toMillis(t));
183	<	assertEquals(t,
184	<	TimeUnit.MICROSECONDS.toMillis(t*1000L));
185	<	assertEquals(t,
186	<	TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187	<	}
188	<	}
189	<
190	<	/**
191	<	* toSeconds correctly converts sample values in different units to
192	<	* seconds
193	<	*/
194	<	public void testToSeconds() {
195	<	for (long t = 0; t < 88888; ++t) {
196	<	assertEquals(t*60*60*24,
197	<	TimeUnit.DAYS.toSeconds(t));
198	<	assertEquals(t*60*60,
199	<	TimeUnit.HOURS.toSeconds(t));
200	<	assertEquals(t*60,
201	<	TimeUnit.MINUTES.toSeconds(t));
202	<	assertEquals(t,
203	<	TimeUnit.SECONDS.toSeconds(t));
204	<	assertEquals(t,
205	<	TimeUnit.MILLISECONDS.toSeconds(t*1000L));
206	<	assertEquals(t,
207	<	TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
208	<	assertEquals(t,
209	<	TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
210	<	}
211	<	}
212	<
213	<	/**
214	<	* toMinutes correctly converts sample values in different units to
215	<	* minutes
216	<	*/
217	<	public void testToMinutes() {
218	<	for (long t = 0; t < 88888; ++t) {
219	<	assertEquals(t*60*24,
220	<	TimeUnit.DAYS.toMinutes(t));
221	<	assertEquals(t*60,
222	<	TimeUnit.HOURS.toMinutes(t));
223	<	assertEquals(t,
224	<	TimeUnit.MINUTES.toMinutes(t));
225	<	assertEquals(t,
226	<	TimeUnit.SECONDS.toMinutes(t*60));
227	<	assertEquals(t,
228	<	TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
229	<	assertEquals(t,
230	<	TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
231	<	assertEquals(t,
232	<	TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
233	<	}
234	<	}
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	<	* toHours correctly converts sample values in different units to
238	<	* hours
239	<	*/
240	<	public void testToHours() {
241	<	for (long t = 0; t < 88888; ++t) {
242	<	assertEquals(t*24,
243	<	TimeUnit.DAYS.toHours(t));
244	<	assertEquals(t,
245	<	TimeUnit.HOURS.toHours(t));
246	<	assertEquals(t,
247	<	TimeUnit.MINUTES.toHours(t*60));
248	<	assertEquals(t,
249	<	TimeUnit.SECONDS.toHours(t*60*60));
250	<	assertEquals(t,
251	<	TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
252	<	assertEquals(t,
253	<	TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
254	<	assertEquals(t,
255	<	TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
74	>	for (TimeUnit x : TimeUnit.values()) {
75	>	assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76		}
257	–	}
77
78	<	/**
79	<	* toDays correctly converts sample values in different units to
80	<	* days
81	<	*/
263	<	public void testToDays() {
264	<	for (long t = 0; t < 88888; ++t) {
265	<	assertEquals(t,
266	<	TimeUnit.DAYS.toDays(t));
267	<	assertEquals(t,
268	<	TimeUnit.HOURS.toDays(t*24));
269	<	assertEquals(t,
270	<	TimeUnit.MINUTES.toDays(t*60*24));
271	<	assertEquals(t,
272	<	TimeUnit.SECONDS.toDays(t*60*60*24));
273	<	assertEquals(t,
274	<	TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275	<	assertEquals(t,
276	<	TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277	<	assertEquals(t,
278	<	TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279	<	}
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
282	–
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,
290	<	TimeUnit.SECONDS));
90	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
91		assertEquals(Long.MIN_VALUE,
92	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293	<	TimeUnit.SECONDS));
92	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
93		assertEquals(Long.MAX_VALUE,
94	<	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
296	<	TimeUnit.MINUTES));
94	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
95		assertEquals(Long.MIN_VALUE,
96	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
299	<	TimeUnit.MINUTES));
96	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
97		assertEquals(Long.MAX_VALUE,
98	<	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
302	<	TimeUnit.HOURS));
98	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
99		assertEquals(Long.MIN_VALUE,
100	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
305	<	TimeUnit.HOURS));
100	>	NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
101		assertEquals(Long.MAX_VALUE,
102	<	TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
308	<	TimeUnit.DAYS));
102	>	NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
103		assertEquals(Long.MIN_VALUE,
104	<	TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
311	<	TimeUnit.DAYS));
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		/**
#	Line 317 | Line 130 | public class TimeUnitTest extends JSR166
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));
324	<	}
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	<	* toString returns string containing common name of unit
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
335	–
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	<	public void testTimedWait_IllegalMonitorException() {
190	<	//created a new thread with anonymous runnable
191	<
192	<	Thread t = new Thread(new Runnable() {
193	<	public void run() {
194	<	Object o = new Object();
195	<	TimeUnit tu = TimeUnit.MILLISECONDS;
196	<	try {
197	<	tu.timedWait(o,LONG_DELAY_MS);
198	<	threadShouldThrow();
199	<	}
351	<	catch (InterruptedException ie) {
352	<	threadUnexpectedException();
353	<	}
354	<	catch (IllegalMonitorStateException success) {
355	<	}
356	<
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) {
365	<	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
211		/**
212	<	* timedWait throws InterruptedException when interrupted
212	>	* toSeconds saturates positive too-large values to Long.MAX_VALUE
213	>	* and negative to LONG.MIN_VALUE
214		*/
215	<	public void testTimedWait() {
216	<	Thread t = new Thread(new Runnable() {
217	<	public void run() {
218	<	Object o = new Object();
219	<
220	<	TimeUnit tu = TimeUnit.MILLISECONDS;
221	<	try {
222	<	synchronized(o) {
223	<	tu.timedWait(o,MEDIUM_DELAY_MS);
224	<	}
225	<	threadShouldThrow();
226	<	}
227	<	catch (InterruptedException success) {}
228	<	catch (IllegalMonitorStateException failure) {
229	<	threadUnexpectedException();
230	<	}
231	<	}
232	<	});
233	<	t.start();
391	<	try {
392	<	Thread.sleep(SHORT_DELAY_MS);
393	<	t.interrupt();
394	<	t.join();
395	<	} catch (Exception e) {
396	<	unexpectedException();
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	<	* timedJoin throws InterruptedException when interrupted
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();
419	<	}
420	<	catch (Exception e) {}
421	<	}
422	<	});
423	<	t.start();
424	<	try {
425	<	Thread.sleep(SHORT_DELAY_MS);
426	<	t.interrupt();
427	<	t.join();
428	<	} catch (Exception e) {
429	<	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
279		/**
280	<	*  timedSleep throws InterruptedException when interrupted
280	>	* toString returns name of unit
281		*/
282	<	public void testTimedSleep() {
283	<	//created a new thread with anonymous runnable
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	<	Thread t = new Thread(new Runnable() {
293	<	public void run() {
294	<	TimeUnit tu = TimeUnit.MILLISECONDS;
295	<	try {
296	<	tu.sleep(MEDIUM_DELAY_MS);
297	<	threadShouldThrow();
445	<	}
446	<	catch (InterruptedException success) {}
447	<	}
448	<	});
449	<	t.start();
450	<	try {
451	<	Thread.sleep(SHORT_DELAY_MS);
452	<	t.interrupt();
453	<	t.join();
454	<	} catch (Exception e) {
455	<	unexpectedException();
456	<	}
292	>	/**
293	>	* name returns name of unit
294	>	*/
295	>	public void testName() {
296	>	for (TimeUnit x : TimeUnit.values())
297	>	assertEquals(x.toString(), x.name());
298		}
299
300		/**
301	<	* a deserialized serialized unit is equal
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	<	try {
315	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
316	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
317	<	out.writeObject(q);
318	<	out.close();
319	<
320	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
321	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
322	<	TimeUnit r = (TimeUnit)in.readObject();
323	<
324	<	assertEquals(q.toString(), r.toString());
325	<	} catch (Exception e){
326	<	e.printStackTrace();
327	<	unexpectedException();
328	<	}
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	>	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