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.28 by jsr166, Fri Mar 18 16:55:09 2016 UTC vs.
Revision 1.37 by jsr166, Sun Sep 8 23:45:54 2019 UTC

#	Line 14 | Line 14 | import static java.util.concurrent.TimeU
14		import static java.util.concurrent.TimeUnit.NANOSECONDS;
15		import static java.util.concurrent.TimeUnit.SECONDS;
16
17	–	import java.time.temporal.ChronoUnit;
17		import java.util.concurrent.CountDownLatch;
18		import java.util.concurrent.TimeUnit;
19
#	Line 30 | Line 29 | public class TimeUnitTest extends JSR166
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	<	SECONDS.convert(t, DAYS));
41	<	assertEquals(t*60*60,
42	<	SECONDS.convert(t, HOURS));
43	<	assertEquals(t*60,
44	<	SECONDS.convert(t, MINUTES));
45	<	assertEquals(t,
46	<	SECONDS.convert(t, SECONDS));
47	<	assertEquals(t,
48	<	SECONDS.convert(1000L*t, MILLISECONDS));
49	<	assertEquals(t,
50	<	SECONDS.convert(1000000L*t, MICROSECONDS));
51	<	assertEquals(t,
52	<	SECONDS.convert(1000000000L*t, NANOSECONDS));
53	<
54	<	assertEquals(1000L*t*60*60*24,
55	<	MILLISECONDS.convert(t, DAYS));
56	<	assertEquals(1000L*t*60*60,
57	<	MILLISECONDS.convert(t, HOURS));
59	<	assertEquals(1000L*t*60,
60	<	MILLISECONDS.convert(t, MINUTES));
61	<	assertEquals(1000L*t,
62	<	MILLISECONDS.convert(t, SECONDS));
63	<	assertEquals(t,
64	<	MILLISECONDS.convert(t, MILLISECONDS));
65	<	assertEquals(t,
66	<	MILLISECONDS.convert(1000L*t, MICROSECONDS));
67	<	assertEquals(t,
68	<	MILLISECONDS.convert(1000000L*t, NANOSECONDS));
69	<
70	<	assertEquals(1000000L*t*60*60*24,
71	<	MICROSECONDS.convert(t, DAYS));
72	<	assertEquals(1000000L*t*60*60,
73	<	MICROSECONDS.convert(t, HOURS));
74	<	assertEquals(1000000L*t*60,
75	<	MICROSECONDS.convert(t, MINUTES));
76	<	assertEquals(1000000L*t,
77	<	MICROSECONDS.convert(t, SECONDS));
78	<	assertEquals(1000L*t,
79	<	MICROSECONDS.convert(t, MILLISECONDS));
80	<	assertEquals(t,
81	<	MICROSECONDS.convert(t, MICROSECONDS));
82	<	assertEquals(t,
83	<	MICROSECONDS.convert(1000L*t, NANOSECONDS));
84	<
85	<	assertEquals(1000000000L*t*60*60*24,
86	<	NANOSECONDS.convert(t, DAYS));
87	<	assertEquals(1000000000L*t*60*60,
88	<	NANOSECONDS.convert(t, HOURS));
89	<	assertEquals(1000000000L*t*60,
90	<	NANOSECONDS.convert(t, MINUTES));
91	<	assertEquals(1000000000L*t,
92	<	NANOSECONDS.convert(t, SECONDS));
93	<	assertEquals(1000000L*t,
94	<	NANOSECONDS.convert(t, MILLISECONDS));
95	<	assertEquals(1000L*t,
96	<	NANOSECONDS.convert(t, MICROSECONDS));
97	<	assertEquals(t,
98	<	NANOSECONDS.convert(t, NANOSECONDS));
99	<	}
100	<
101	<	for (TimeUnit x : TimeUnit.values()) {
102	<	long[] zs = {
103	<	0, 1, -1,
104	<	Integer.MAX_VALUE, Integer.MIN_VALUE,
105	<	Long.MAX_VALUE, Long.MIN_VALUE,
106	<	};
107	<	for (long z : zs) assertEquals(z, x.convert(z, x));
108	<	}
109	<	}
110	<
111	<	/**
112	<	* toNanos correctly converts sample values in different units to
113	<	* nanoseconds
114	<	*/
115	<	public void testToNanos() {
116	<	for (long t = 0; t < 88888; ++t) {
117	<	assertEquals(t*1000000000L*60*60*24,
118	<	DAYS.toNanos(t));
119	<	assertEquals(t*1000000000L*60*60,
120	<	HOURS.toNanos(t));
121	<	assertEquals(t*1000000000L*60,
122	<	MINUTES.toNanos(t));
123	<	assertEquals(1000000000L*t,
124	<	SECONDS.toNanos(t));
125	<	assertEquals(1000000L*t,
126	<	MILLISECONDS.toNanos(t));
127	<	assertEquals(1000L*t,
128	<	MICROSECONDS.toNanos(t));
129	<	assertEquals(t,
130	<	NANOSECONDS.toNanos(t));
131	<	}
132	<	}
133	<
134	<	/**
135	<	* toMicros correctly converts sample values in different units to
136	<	* microseconds
137	<	*/
138	<	public void testToMicros() {
139	<	for (long t = 0; t < 88888; ++t) {
140	<	assertEquals(t*1000000L*60*60*24,
141	<	DAYS.toMicros(t));
142	<	assertEquals(t*1000000L*60*60,
143	<	HOURS.toMicros(t));
144	<	assertEquals(t*1000000L*60,
145	<	MINUTES.toMicros(t));
146	<	assertEquals(1000000L*t,
147	<	SECONDS.toMicros(t));
148	<	assertEquals(1000L*t,
149	<	MILLISECONDS.toMicros(t));
150	<	assertEquals(t,
151	<	MICROSECONDS.toMicros(t));
152	<	assertEquals(t,
153	<	NANOSECONDS.toMicros(t*1000L));
154	<	}
155	<	}
156	<
157	<	/**
158	<	* toMillis correctly converts sample values in different units to
159	<	* milliseconds
160	<	*/
161	<	public void testToMillis() {
162	<	for (long t = 0; t < 88888; ++t) {
163	<	assertEquals(t*1000L*60*60*24,
164	<	DAYS.toMillis(t));
165	<	assertEquals(t*1000L*60*60,
166	<	HOURS.toMillis(t));
167	<	assertEquals(t*1000L*60,
168	<	MINUTES.toMillis(t));
169	<	assertEquals(1000L*t,
170	<	SECONDS.toMillis(t));
171	<	assertEquals(t,
172	<	MILLISECONDS.toMillis(t));
173	<	assertEquals(t,
174	<	MICROSECONDS.toMillis(t*1000L));
175	<	assertEquals(t,
176	<	NANOSECONDS.toMillis(t*1000000L));
177	<	}
178	<	}
179	<
180	<	/**
181	<	* toSeconds correctly converts sample values in different units to
182	<	* seconds
183	<	*/
184	<	public void testToSeconds() {
185	<	for (long t = 0; t < 88888; ++t) {
186	<	assertEquals(t*60*60*24,
187	<	DAYS.toSeconds(t));
188	<	assertEquals(t*60*60,
189	<	HOURS.toSeconds(t));
190	<	assertEquals(t*60,
191	<	MINUTES.toSeconds(t));
192	<	assertEquals(t,
193	<	SECONDS.toSeconds(t));
194	<	assertEquals(t,
195	<	MILLISECONDS.toSeconds(t*1000L));
196	<	assertEquals(t,
197	<	MICROSECONDS.toSeconds(t*1000000L));
198	<	assertEquals(t,
199	<	NANOSECONDS.toSeconds(t*1000000000L));
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	<	* toMinutes correctly converts sample values in different units to
205	<	* minutes
62	>	* Conversion methods correctly convert sample values
63		*/
64	<	public void testToMinutes() {
65	<	for (long t = 0; t < 88888; ++t) {
66	<	assertEquals(t*60*24,
67	<	DAYS.toMinutes(t));
68	<	assertEquals(t*60,
69	<	HOURS.toMinutes(t));
70	<	assertEquals(t,
71	<	MINUTES.toMinutes(t));
72	<	assertEquals(t,
216	<	SECONDS.toMinutes(t*60));
217	<	assertEquals(t,
218	<	MILLISECONDS.toMinutes(t*1000L*60));
219	<	assertEquals(t,
220	<	MICROSECONDS.toMinutes(t*1000000L*60));
221	<	assertEquals(t,
222	<	NANOSECONDS.toMinutes(t*1000000000L*60));
223	<	}
224	<	}
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
228	<	* hours
229	<	*/
230	<	public void testToHours() {
231	<	for (long t = 0; t < 88888; ++t) {
232	<	assertEquals(t*24,
233	<	DAYS.toHours(t));
234	<	assertEquals(t,
235	<	HOURS.toHours(t));
236	<	assertEquals(t,
237	<	MINUTES.toHours(t*60));
238	<	assertEquals(t,
239	<	SECONDS.toHours(t*60*60));
240	<	assertEquals(t,
241	<	MILLISECONDS.toHours(t*1000L*60*60));
242	<	assertEquals(t,
243	<	MICROSECONDS.toHours(t*1000000L*60*60));
244	<	assertEquals(t,
245	<	NANOSECONDS.toHours(t*1000000000L*60*60));
74	>	for (TimeUnit x : TimeUnit.values()) {
75	>	assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x));
76		}
247	–	}
77
78	<	/**
79	<	* toDays correctly converts sample values in different units to
80	<	* days
81	<	*/
253	<	public void testToDays() {
254	<	for (long t = 0; t < 88888; ++t) {
255	<	assertEquals(t,
256	<	DAYS.toDays(t));
257	<	assertEquals(t,
258	<	HOURS.toDays(t*24));
259	<	assertEquals(t,
260	<	MINUTES.toDays(t*60*24));
261	<	assertEquals(t,
262	<	SECONDS.toDays(t*60*60*24));
263	<	assertEquals(t,
264	<	MILLISECONDS.toDays(t*1000L*60*60*24));
265	<	assertEquals(t,
266	<	MICROSECONDS.toDays(t*1000000L*60*60*24));
267	<	assertEquals(t,
268	<	NANOSECONDS.toDays(t*1000000000L*60*60*24));
269	<	}
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		/**
#	Line 294 | Line 106 | public class TimeUnitTest extends JSR166
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) {
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;
#	Line 302 | Line 114 | public class TimeUnitTest extends JSR166
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	<	assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
118	<	assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
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));
309	–	assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
124		}
125		}
126		}
#	Line 323 | Line 137 | public class TimeUnitTest extends JSR166
137
138		for (TimeUnit x : TimeUnit.values()) {
139		long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
140	<	if (ratio > 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	<	assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
145	<	assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
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));
334	–	assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
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));
#	Line 347 | Line 163 | public class TimeUnitTest extends JSR166
163		public void testToMicrosSaturate() {
164		for (TimeUnit x : TimeUnit.values()) {
165		long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
166	<	if (ratio > 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	<	assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
171	<	assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
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));
358	–	assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
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));
#	Line 371 | Line 189 | public class TimeUnitTest extends JSR166
189		public void testToMillisSaturate() {
190		for (TimeUnit x : TimeUnit.values()) {
191		long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
192	<	if (ratio > 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	<	assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
197	<	assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
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));
382	–	assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
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));
#	Line 395 | Line 215 | public class TimeUnitTest extends JSR166
215		public void testToSecondsSaturate() {
216		for (TimeUnit x : TimeUnit.values()) {
217		long ratio = x.toNanos(1) / SECONDS.toNanos(1);
218	<	if (ratio > 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	<	assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
223	<	assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
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));
406	–	assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
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));
#	Line 439 | Line 261 | public class TimeUnitTest extends JSR166
261		public void testToHoursSaturate() {
262		for (TimeUnit x : TimeUnit.values()) {
263		long ratio = x.toNanos(1) / HOURS.toNanos(1);
264	<	if (ratio > 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	<	assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
269	<	assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
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));
450	–	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
275		}
276		}
277		}
#	Line 456 | Line 280 | public class TimeUnitTest extends JSR166
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		* name returns name of unit
294		*/
295		public void testName() {
296	<	assertEquals("SECONDS", SECONDS.name());
296	>	for (TimeUnit x : TimeUnit.values())
297	>	assertEquals(x.toString(), x.name());
298		}
299
300		/**
#	Line 474 | Line 305 | public class TimeUnitTest extends JSR166
305		Thread t = newStartedThread(new CheckedRunnable() {
306		public void realRun() throws InterruptedException {
307		Object o = new Object();
477	–	TimeUnit tu = MILLISECONDS;
478	–
308		try {
309	<	tu.timedWait(o, LONG_DELAY_MS);
309	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
310		threadShouldThrow();
311		} catch (IllegalMonitorStateException success) {}
312		}});
#	Line 493 | Line 322 | public class TimeUnitTest extends JSR166
322		Thread t = newStartedThread(new CheckedRunnable() {
323		public void realRun() throws InterruptedException {
324		Object o = new Object();
496	–	TimeUnit tu = MILLISECONDS;
325
326		Thread.currentThread().interrupt();
327		try {
328		synchronized (o) {
329	<	tu.timedWait(o, LONG_DELAY_MS);
329	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
330		}
331		shouldThrow();
332		} catch (InterruptedException success) {}
#	Line 507 | Line 335 | public class TimeUnitTest extends JSR166
335		pleaseInterrupt.countDown();
336		try {
337		synchronized (o) {
338	<	tu.timedWait(o, LONG_DELAY_MS);
338	>	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
339		}
340		shouldThrow();
341		} catch (InterruptedException success) {}
#	Line 515 | Line 343 | public class TimeUnitTest extends JSR166
343		}});
344
345		await(pleaseInterrupt);
346	<	assertThreadStaysAlive(t);
346	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
347		t.interrupt();
348		awaitTermination(t);
349		}
#	Line 527 | Line 355 | public class TimeUnitTest extends JSR166
355		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
356		final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
357		public void realRun() throws InterruptedException {
358	<	Thread.sleep(LONG_DELAY_MS);
358	>	Thread.sleep(LONGER_DELAY_MS);
359		}});
360		final Thread t = newStartedThread(new CheckedRunnable() {
361		public void realRun() throws InterruptedException {
534	–	TimeUnit tu = MILLISECONDS;
362		Thread.currentThread().interrupt();
363		try {
364	<	tu.timedJoin(s, LONG_DELAY_MS);
364	>	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
365		shouldThrow();
366		} catch (InterruptedException success) {}
367		assertFalse(Thread.interrupted());
368
369		pleaseInterrupt.countDown();
370		try {
371	<	tu.timedJoin(s, LONG_DELAY_MS);
371	>	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
372		shouldThrow();
373		} catch (InterruptedException success) {}
374		assertFalse(Thread.interrupted());
375		}});
376
377		await(pleaseInterrupt);
378	<	assertThreadStaysAlive(t);
378	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
379		t.interrupt();
380		awaitTermination(t);
381		s.interrupt();
#	Line 556 | Line 383 | public class TimeUnitTest extends JSR166
383		}
384
385		/**
386	<	* timedSleep throws InterruptedException when interrupted
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 {
565	–	TimeUnit tu = MILLISECONDS;
392		Thread.currentThread().interrupt();
393		try {
394	<	tu.sleep(LONG_DELAY_MS);
394	>	MILLISECONDS.sleep(LONGER_DELAY_MS);
395		shouldThrow();
396		} catch (InterruptedException success) {}
397		assertFalse(Thread.interrupted());
398
399		pleaseInterrupt.countDown();
400		try {
401	<	tu.sleep(LONG_DELAY_MS);
401	>	MILLISECONDS.sleep(LONGER_DELAY_MS);
402		shouldThrow();
403		} catch (InterruptedException success) {}
404		assertFalse(Thread.interrupted());
405		}});
406
407		await(pleaseInterrupt);
408	<	assertThreadStaysAlive(t);
408	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
409		t.interrupt();
410		awaitTermination(t);
411		}
412
413		/**
414	<	* a deserialized serialized unit is the same instance
414	>	* timeUnit.sleep(x) for x <= 0 does not sleep at all.
415		*/
416	<	public void testSerialization() throws Exception {
417	<	for (TimeUnit x : TimeUnit.values())
418	<	assertSame(x, serialClone(x));
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	<	* tests for toChronoUnit.
426	>	* a deserialized/reserialized unit is the same instance
427		*/
428	<	public void testToChronoUnit() throws Exception {
599	<	assertSame(ChronoUnit.NANOS,   NANOSECONDS.toChronoUnit());
600	<	assertSame(ChronoUnit.MICROS,  MICROSECONDS.toChronoUnit());
601	<	assertSame(ChronoUnit.MILLIS,  MILLISECONDS.toChronoUnit());
602	<	assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
603	<	assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
604	<	assertSame(ChronoUnit.HOURS,   HOURS.toChronoUnit());
605	<	assertSame(ChronoUnit.DAYS,    DAYS.toChronoUnit());
606	<
607	<	// Every TimeUnit has a defined ChronoUnit equivalent
428	>	public void testSerialization() throws Exception {
429		for (TimeUnit x : TimeUnit.values())
430	<	assertSame(x, TimeUnit.of(x.toChronoUnit()));
610	<	}
611	<
612	<	/**
613	<	* tests for TimeUnit.of(ChronoUnit).
614	<	*/
615	<	public void testTimeUnitOf() throws Exception {
616	<	assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
617	<	assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
618	<	assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
619	<	assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
620	<	assertSame(MINUTES,      TimeUnit.of(ChronoUnit.MINUTES));
621	<	assertSame(HOURS,        TimeUnit.of(ChronoUnit.HOURS));
622	<	assertSame(DAYS,         TimeUnit.of(ChronoUnit.DAYS));
623	<
624	<	assertThrows(NullPointerException.class,
625	<	() -> TimeUnit.of((ChronoUnit)null));
626	<
627	<	// ChronoUnits either round trip to their TimeUnit
628	<	// equivalents, or throw IllegalArgumentException.
629	<	for (ChronoUnit cu : ChronoUnit.values()) {
630	<	final TimeUnit tu;
631	<	try {
632	<	tu = TimeUnit.of(cu);
633	<	} catch (IllegalArgumentException acceptable) {
634	<	continue;
635	<	}
636	<	assertSame(cu, tu.toChronoUnit());
637	<	}
430	>	assertSame(x, serialClone(x));
431		}
432
433		}

Diff Legend

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