ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TimeUnitTest.java
Revision: 1.29
Committed: Fri Mar 25 04:53:28 2016 UTC (8 years, 1 month ago) by jsr166
Branch: MAIN
Changes since 1.28: +36 -24 lines
Log Message: 
more test assertions

File Contents

# User Rev Content
1 dl 1.1 /*
2 dl 1.6 * 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 jsr166 1.19 * http://creativecommons.org/publicdomain/zero/1.0/
5 jsr166 1.10 * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7 dl 1.1 */
8    
9 jsr166 1.24 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 jsr166 1.26 import java.time.temporal.ChronoUnit;
18 jsr166 1.22 import java.util.concurrent.CountDownLatch;
19     import java.util.concurrent.TimeUnit;
20 jsr166 1.24
21     import junit.framework.Test;
22     import junit.framework.TestSuite;
23 dl 1.1
24 dl 1.3 public class TimeUnitTest extends JSR166TestCase {
25 dl 1.1 public static void main(String[] args) {
26 jsr166 1.25 main(suite(), args);
27 dl 1.1 }
28 jsr166 1.10
29 dl 1.1 public static Test suite() {
30 jsr166 1.14 return new TestSuite(TimeUnitTest.class);
31 dl 1.1 }
32    
33 dl 1.9 // (loops to 88888 check increments at all time divisions.)
34    
35 dl 1.4 /**
36 dl 1.9 * convert correctly converts sample values across the units
37 dl 1.4 */
38 dl 1.1 public void testConvert() {
39 dl 1.9 for (long t = 0; t < 88888; ++t) {
40 jsr166 1.10 assertEquals(t*60*60*24,
41 jsr166 1.23 SECONDS.convert(t, DAYS));
42 jsr166 1.10 assertEquals(t*60*60,
43 jsr166 1.23 SECONDS.convert(t, HOURS));
44 jsr166 1.10 assertEquals(t*60,
45 jsr166 1.23 SECONDS.convert(t, MINUTES));
46 jsr166 1.10 assertEquals(t,
47 jsr166 1.23 SECONDS.convert(t, SECONDS));
48 jsr166 1.10 assertEquals(t,
49 jsr166 1.23 SECONDS.convert(1000L*t, MILLISECONDS));
50 jsr166 1.10 assertEquals(t,
51 jsr166 1.23 SECONDS.convert(1000000L*t, MICROSECONDS));
52 jsr166 1.10 assertEquals(t,
53 jsr166 1.23 SECONDS.convert(1000000000L*t, NANOSECONDS));
54 dl 1.9
55 jsr166 1.10 assertEquals(1000L*t*60*60*24,
56 jsr166 1.23 MILLISECONDS.convert(t, DAYS));
57 jsr166 1.10 assertEquals(1000L*t*60*60,
58 jsr166 1.23 MILLISECONDS.convert(t, HOURS));
59 jsr166 1.10 assertEquals(1000L*t*60,
60 jsr166 1.23 MILLISECONDS.convert(t, MINUTES));
61 jsr166 1.10 assertEquals(1000L*t,
62 jsr166 1.23 MILLISECONDS.convert(t, SECONDS));
63 jsr166 1.10 assertEquals(t,
64 jsr166 1.23 MILLISECONDS.convert(t, MILLISECONDS));
65 jsr166 1.10 assertEquals(t,
66 jsr166 1.23 MILLISECONDS.convert(1000L*t, MICROSECONDS));
67 jsr166 1.10 assertEquals(t,
68 jsr166 1.23 MILLISECONDS.convert(1000000L*t, NANOSECONDS));
69 dl 1.9
70 jsr166 1.10 assertEquals(1000000L*t*60*60*24,
71 jsr166 1.23 MICROSECONDS.convert(t, DAYS));
72 jsr166 1.10 assertEquals(1000000L*t*60*60,
73 jsr166 1.23 MICROSECONDS.convert(t, HOURS));
74 jsr166 1.10 assertEquals(1000000L*t*60,
75 jsr166 1.23 MICROSECONDS.convert(t, MINUTES));
76 jsr166 1.10 assertEquals(1000000L*t,
77 jsr166 1.23 MICROSECONDS.convert(t, SECONDS));
78 jsr166 1.10 assertEquals(1000L*t,
79 jsr166 1.23 MICROSECONDS.convert(t, MILLISECONDS));
80 jsr166 1.10 assertEquals(t,
81 jsr166 1.23 MICROSECONDS.convert(t, MICROSECONDS));
82 jsr166 1.10 assertEquals(t,
83 jsr166 1.23 MICROSECONDS.convert(1000L*t, NANOSECONDS));
84 dl 1.9
85 jsr166 1.10 assertEquals(1000000000L*t*60*60*24,
86 jsr166 1.23 NANOSECONDS.convert(t, DAYS));
87 jsr166 1.10 assertEquals(1000000000L*t*60*60,
88 jsr166 1.23 NANOSECONDS.convert(t, HOURS));
89 jsr166 1.10 assertEquals(1000000000L*t*60,
90 jsr166 1.23 NANOSECONDS.convert(t, MINUTES));
91 jsr166 1.10 assertEquals(1000000000L*t,
92 jsr166 1.23 NANOSECONDS.convert(t, SECONDS));
93 jsr166 1.10 assertEquals(1000000L*t,
94 jsr166 1.23 NANOSECONDS.convert(t, MILLISECONDS));
95 jsr166 1.10 assertEquals(1000L*t,
96 jsr166 1.23 NANOSECONDS.convert(t, MICROSECONDS));
97 jsr166 1.10 assertEquals(t,
98 jsr166 1.23 NANOSECONDS.convert(t, NANOSECONDS));
99 dl 1.1 }
100 jsr166 1.28
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 dl 1.1 }
110    
111 dl 1.4 /**
112 dl 1.5 * toNanos correctly converts sample values in different units to
113     * nanoseconds
114 dl 1.4 */
115 dl 1.1 public void testToNanos() {
116 dl 1.9 for (long t = 0; t < 88888; ++t) {
117 jsr166 1.10 assertEquals(t*1000000000L*60*60*24,
118 jsr166 1.23 DAYS.toNanos(t));
119 jsr166 1.10 assertEquals(t*1000000000L*60*60,
120 jsr166 1.23 HOURS.toNanos(t));
121 jsr166 1.10 assertEquals(t*1000000000L*60,
122 jsr166 1.23 MINUTES.toNanos(t));
123 jsr166 1.10 assertEquals(1000000000L*t,
124 jsr166 1.23 SECONDS.toNanos(t));
125 jsr166 1.10 assertEquals(1000000L*t,
126 jsr166 1.23 MILLISECONDS.toNanos(t));
127 jsr166 1.10 assertEquals(1000L*t,
128 jsr166 1.23 MICROSECONDS.toNanos(t));
129 jsr166 1.10 assertEquals(t,
130 jsr166 1.23 NANOSECONDS.toNanos(t));
131 dl 1.3 }
132     }
133    
134 dl 1.4 /**
135 dl 1.5 * toMicros correctly converts sample values in different units to
136     * microseconds
137 dl 1.4 */
138 dl 1.3 public void testToMicros() {
139 dl 1.9 for (long t = 0; t < 88888; ++t) {
140 jsr166 1.10 assertEquals(t*1000000L*60*60*24,
141 jsr166 1.23 DAYS.toMicros(t));
142 jsr166 1.10 assertEquals(t*1000000L*60*60,
143 jsr166 1.23 HOURS.toMicros(t));
144 jsr166 1.10 assertEquals(t*1000000L*60,
145 jsr166 1.23 MINUTES.toMicros(t));
146 jsr166 1.10 assertEquals(1000000L*t,
147 jsr166 1.23 SECONDS.toMicros(t));
148 jsr166 1.10 assertEquals(1000L*t,
149 jsr166 1.23 MILLISECONDS.toMicros(t));
150 jsr166 1.10 assertEquals(t,
151 jsr166 1.23 MICROSECONDS.toMicros(t));
152 jsr166 1.10 assertEquals(t,
153 jsr166 1.23 NANOSECONDS.toMicros(t*1000L));
154 dl 1.3 }
155     }
156    
157 dl 1.4 /**
158 dl 1.5 * toMillis correctly converts sample values in different units to
159     * milliseconds
160 dl 1.4 */
161 dl 1.3 public void testToMillis() {
162 dl 1.9 for (long t = 0; t < 88888; ++t) {
163 jsr166 1.10 assertEquals(t*1000L*60*60*24,
164 jsr166 1.23 DAYS.toMillis(t));
165 jsr166 1.10 assertEquals(t*1000L*60*60,
166 jsr166 1.23 HOURS.toMillis(t));
167 jsr166 1.10 assertEquals(t*1000L*60,
168 jsr166 1.23 MINUTES.toMillis(t));
169 jsr166 1.10 assertEquals(1000L*t,
170 jsr166 1.23 SECONDS.toMillis(t));
171 jsr166 1.10 assertEquals(t,
172 jsr166 1.23 MILLISECONDS.toMillis(t));
173 jsr166 1.10 assertEquals(t,
174 jsr166 1.23 MICROSECONDS.toMillis(t*1000L));
175 jsr166 1.10 assertEquals(t,
176 jsr166 1.23 NANOSECONDS.toMillis(t*1000000L));
177 dl 1.3 }
178     }
179    
180 dl 1.4 /**
181 dl 1.5 * toSeconds correctly converts sample values in different units to
182     * seconds
183 dl 1.4 */
184 dl 1.3 public void testToSeconds() {
185 dl 1.9 for (long t = 0; t < 88888; ++t) {
186 jsr166 1.10 assertEquals(t*60*60*24,
187 jsr166 1.23 DAYS.toSeconds(t));
188 jsr166 1.10 assertEquals(t*60*60,
189 jsr166 1.23 HOURS.toSeconds(t));
190 jsr166 1.10 assertEquals(t*60,
191 jsr166 1.23 MINUTES.toSeconds(t));
192 jsr166 1.10 assertEquals(t,
193 jsr166 1.23 SECONDS.toSeconds(t));
194 jsr166 1.10 assertEquals(t,
195 jsr166 1.23 MILLISECONDS.toSeconds(t*1000L));
196 jsr166 1.10 assertEquals(t,
197 jsr166 1.23 MICROSECONDS.toSeconds(t*1000000L));
198 jsr166 1.10 assertEquals(t,
199 jsr166 1.23 NANOSECONDS.toSeconds(t*1000000000L));
200 dl 1.9 }
201     }
202 dl 1.3
203 dl 1.9 /**
204     * toMinutes correctly converts sample values in different units to
205     * minutes
206     */
207     public void testToMinutes() {
208     for (long t = 0; t < 88888; ++t) {
209 jsr166 1.10 assertEquals(t*60*24,
210 jsr166 1.23 DAYS.toMinutes(t));
211 jsr166 1.10 assertEquals(t*60,
212 jsr166 1.23 HOURS.toMinutes(t));
213 jsr166 1.10 assertEquals(t,
214 jsr166 1.23 MINUTES.toMinutes(t));
215 jsr166 1.10 assertEquals(t,
216 jsr166 1.23 SECONDS.toMinutes(t*60));
217 jsr166 1.10 assertEquals(t,
218 jsr166 1.23 MILLISECONDS.toMinutes(t*1000L*60));
219 jsr166 1.10 assertEquals(t,
220 jsr166 1.23 MICROSECONDS.toMinutes(t*1000000L*60));
221 jsr166 1.10 assertEquals(t,
222 jsr166 1.23 NANOSECONDS.toMinutes(t*1000000000L*60));
223 dl 1.9 }
224     }
225    
226     /**
227     * 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 jsr166 1.10 assertEquals(t*24,
233 jsr166 1.23 DAYS.toHours(t));
234 jsr166 1.10 assertEquals(t,
235 jsr166 1.23 HOURS.toHours(t));
236 jsr166 1.10 assertEquals(t,
237 jsr166 1.23 MINUTES.toHours(t*60));
238 jsr166 1.10 assertEquals(t,
239 jsr166 1.23 SECONDS.toHours(t*60*60));
240 jsr166 1.10 assertEquals(t,
241 jsr166 1.23 MILLISECONDS.toHours(t*1000L*60*60));
242 jsr166 1.10 assertEquals(t,
243 jsr166 1.23 MICROSECONDS.toHours(t*1000000L*60*60));
244 jsr166 1.10 assertEquals(t,
245 jsr166 1.23 NANOSECONDS.toHours(t*1000000000L*60*60));
246 dl 1.9 }
247     }
248    
249     /**
250     * toDays correctly converts sample values in different units to
251     * days
252     */
253     public void testToDays() {
254     for (long t = 0; t < 88888; ++t) {
255 jsr166 1.10 assertEquals(t,
256 jsr166 1.23 DAYS.toDays(t));
257 jsr166 1.10 assertEquals(t,
258 jsr166 1.23 HOURS.toDays(t*24));
259 jsr166 1.10 assertEquals(t,
260 jsr166 1.23 MINUTES.toDays(t*60*24));
261 jsr166 1.10 assertEquals(t,
262 jsr166 1.23 SECONDS.toDays(t*60*60*24));
263 jsr166 1.10 assertEquals(t,
264 jsr166 1.23 MILLISECONDS.toDays(t*1000L*60*60*24));
265 jsr166 1.10 assertEquals(t,
266 jsr166 1.23 MICROSECONDS.toDays(t*1000000L*60*60*24));
267 jsr166 1.10 assertEquals(t,
268 jsr166 1.23 NANOSECONDS.toDays(t*1000000000L*60*60*24));
269 dl 1.1 }
270     }
271    
272 dl 1.4 /**
273 jsr166 1.10 * convert saturates positive too-large values to Long.MAX_VALUE
274 dl 1.5 * and negative to LONG.MIN_VALUE
275 dl 1.4 */
276 dl 1.1 public void testConvertSaturate() {
277     assertEquals(Long.MAX_VALUE,
278 jsr166 1.23 NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
279 dl 1.1 assertEquals(Long.MIN_VALUE,
280 jsr166 1.23 NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
281 dl 1.9 assertEquals(Long.MAX_VALUE,
282 jsr166 1.23 NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
283 dl 1.9 assertEquals(Long.MIN_VALUE,
284 jsr166 1.23 NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
285 dl 1.9 assertEquals(Long.MAX_VALUE,
286 jsr166 1.23 NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
287 dl 1.9 assertEquals(Long.MIN_VALUE,
288 jsr166 1.23 NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
289 dl 1.9 assertEquals(Long.MAX_VALUE,
290 jsr166 1.23 NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
291 dl 1.9 assertEquals(Long.MIN_VALUE,
292 jsr166 1.23 NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
293 jsr166 1.28
294     for (TimeUnit x : TimeUnit.values())
295     for (TimeUnit y : TimeUnit.values()) {
296     long ratio = x.toNanos(1) / y.toNanos(1);
297 jsr166 1.29 if (ratio >= 1) {
298 jsr166 1.28 assertEquals(ratio, y.convert(1, x));
299     assertEquals(1, x.convert(ratio, y));
300     long max = Long.MAX_VALUE/ratio;
301     assertEquals(max * ratio, y.convert(max, x));
302     assertEquals(-max * ratio, y.convert(-max, x));
303     assertEquals(max, x.convert(max * ratio, y));
304     assertEquals(-max, x.convert(-max * ratio, y));
305 jsr166 1.29 if (max < Long.MAX_VALUE) {
306     assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
307     assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
308     assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
309     }
310 jsr166 1.28 assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
311     assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
312     }
313     }
314 dl 1.1 }
315    
316 dl 1.4 /**
317 jsr166 1.10 * toNanos saturates positive too-large values to Long.MAX_VALUE
318 dl 1.5 * and negative to LONG.MIN_VALUE
319 dl 1.4 */
320 dl 1.1 public void testToNanosSaturate() {
321 jsr166 1.13 assertEquals(Long.MAX_VALUE,
322 jsr166 1.23 MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
323 jsr166 1.13 assertEquals(Long.MIN_VALUE,
324 jsr166 1.23 MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
325 jsr166 1.28
326     for (TimeUnit x : TimeUnit.values()) {
327     long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
328 jsr166 1.29 if (ratio >= 1) {
329 jsr166 1.28 long max = Long.MAX_VALUE/ratio;
330     for (long z : new long[] {0, 1, -1, max, -max})
331     assertEquals(z * ratio, x.toNanos(z));
332 jsr166 1.29 if (max < Long.MAX_VALUE) {
333     assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
334     assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
335     assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
336     }
337 jsr166 1.28 assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
338     assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
339     if (max < Integer.MAX_VALUE) {
340     assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
341     assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
342     }
343     }
344     }
345     }
346    
347     /**
348     * toMicros saturates positive too-large values to Long.MAX_VALUE
349     * and negative to LONG.MIN_VALUE
350     */
351     public void testToMicrosSaturate() {
352     for (TimeUnit x : TimeUnit.values()) {
353     long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
354 jsr166 1.29 if (ratio >= 1) {
355 jsr166 1.28 long max = Long.MAX_VALUE/ratio;
356     for (long z : new long[] {0, 1, -1, max, -max})
357     assertEquals(z * ratio, x.toMicros(z));
358 jsr166 1.29 if (max < Long.MAX_VALUE) {
359     assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
360     assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
361     assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
362     }
363 jsr166 1.28 assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
364     assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
365     if (max < Integer.MAX_VALUE) {
366     assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
367     assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
368     }
369     }
370     }
371     }
372    
373     /**
374     * toMillis saturates positive too-large values to Long.MAX_VALUE
375     * and negative to LONG.MIN_VALUE
376     */
377     public void testToMillisSaturate() {
378     for (TimeUnit x : TimeUnit.values()) {
379     long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
380 jsr166 1.29 if (ratio >= 1) {
381 jsr166 1.28 long max = Long.MAX_VALUE/ratio;
382     for (long z : new long[] {0, 1, -1, max, -max})
383     assertEquals(z * ratio, x.toMillis(z));
384 jsr166 1.29 if (max < Long.MAX_VALUE) {
385     assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
386     assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
387     assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
388     }
389 jsr166 1.28 assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
390     assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
391     if (max < Integer.MAX_VALUE) {
392     assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
393     assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
394     }
395     }
396     }
397     }
398    
399     /**
400     * toSeconds saturates positive too-large values to Long.MAX_VALUE
401     * and negative to LONG.MIN_VALUE
402     */
403     public void testToSecondsSaturate() {
404     for (TimeUnit x : TimeUnit.values()) {
405     long ratio = x.toNanos(1) / SECONDS.toNanos(1);
406 jsr166 1.29 if (ratio >= 1) {
407 jsr166 1.28 long max = Long.MAX_VALUE/ratio;
408     for (long z : new long[] {0, 1, -1, max, -max})
409     assertEquals(z * ratio, x.toSeconds(z));
410 jsr166 1.29 if (max < Long.MAX_VALUE) {
411     assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
412     assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
413     assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
414     }
415 jsr166 1.28 assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
416     assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
417     if (max < Integer.MAX_VALUE) {
418     assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
419     assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
420     }
421     }
422     }
423     }
424    
425     /**
426     * toMinutes saturates positive too-large values to Long.MAX_VALUE
427     * and negative to LONG.MIN_VALUE
428     */
429     public void testToMinutesSaturate() {
430     for (TimeUnit x : TimeUnit.values()) {
431     long ratio = x.toNanos(1) / MINUTES.toNanos(1);
432     if (ratio > 1) {
433     long max = Long.MAX_VALUE/ratio;
434     for (long z : new long[] {0, 1, -1, max, -max})
435     assertEquals(z * ratio, x.toMinutes(z));
436     assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
437     assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
438     assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
439     assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
440     assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
441     }
442     }
443     }
444    
445     /**
446     * toHours saturates positive too-large values to Long.MAX_VALUE
447     * and negative to LONG.MIN_VALUE
448     */
449     public void testToHoursSaturate() {
450     for (TimeUnit x : TimeUnit.values()) {
451     long ratio = x.toNanos(1) / HOURS.toNanos(1);
452 jsr166 1.29 if (ratio >= 1) {
453 jsr166 1.28 long max = Long.MAX_VALUE/ratio;
454     for (long z : new long[] {0, 1, -1, max, -max})
455     assertEquals(z * ratio, x.toHours(z));
456 jsr166 1.29 if (max < Long.MAX_VALUE) {
457     assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
458     assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
459     assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
460     }
461 jsr166 1.28 assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
462     assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
463     }
464     }
465 dl 1.1 }
466    
467 dl 1.4 /**
468 jsr166 1.20 * toString returns name of unit
469 dl 1.4 */
470 dl 1.1 public void testToString() {
471 jsr166 1.23 assertEquals("SECONDS", SECONDS.toString());
472 dl 1.1 }
473    
474 jsr166 1.20 /**
475     * name returns name of unit
476     */
477     public void testName() {
478 jsr166 1.23 assertEquals("SECONDS", SECONDS.name());
479 jsr166 1.20 }
480 jsr166 1.10
481 dl 1.1 /**
482 jsr166 1.17 * Timed wait without holding lock throws
483     * IllegalMonitorStateException
484 dl 1.1 */
485 jsr166 1.21 public void testTimedWait_IllegalMonitorException() {
486     Thread t = newStartedThread(new CheckedRunnable() {
487 jsr166 1.13 public void realRun() throws InterruptedException {
488     Object o = new Object();
489 jsr166 1.23 TimeUnit tu = MILLISECONDS;
490 jsr166 1.21
491 jsr166 1.13 try {
492 jsr166 1.21 tu.timedWait(o, LONG_DELAY_MS);
493 jsr166 1.13 threadShouldThrow();
494 jsr166 1.21 } catch (IllegalMonitorStateException success) {}
495     }});
496 dl 1.1
497 jsr166 1.21 awaitTermination(t);
498 dl 1.1 }
499 jsr166 1.10
500 dl 1.1 /**
501 dl 1.5 * timedWait throws InterruptedException when interrupted
502 dl 1.4 */
503 jsr166 1.21 public void testTimedWait_Interruptible() {
504     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
505     Thread t = newStartedThread(new CheckedRunnable() {
506 jsr166 1.14 public void realRun() throws InterruptedException {
507 jsr166 1.13 Object o = new Object();
508 jsr166 1.23 TimeUnit tu = MILLISECONDS;
509 jsr166 1.13
510 jsr166 1.21 Thread.currentThread().interrupt();
511     try {
512     synchronized (o) {
513     tu.timedWait(o, LONG_DELAY_MS);
514     }
515     shouldThrow();
516     } catch (InterruptedException success) {}
517     assertFalse(Thread.interrupted());
518    
519     pleaseInterrupt.countDown();
520     try {
521     synchronized (o) {
522     tu.timedWait(o, LONG_DELAY_MS);
523     }
524     shouldThrow();
525     } catch (InterruptedException success) {}
526     assertFalse(Thread.interrupted());
527 jsr166 1.13 }});
528 jsr166 1.21
529     await(pleaseInterrupt);
530     assertThreadStaysAlive(t);
531 jsr166 1.13 t.interrupt();
532 jsr166 1.21 awaitTermination(t);
533 dl 1.1 }
534 jsr166 1.10
535 dl 1.1 /**
536 dl 1.5 * timedJoin throws InterruptedException when interrupted
537 dl 1.4 */
538 jsr166 1.21 public void testTimedJoin_Interruptible() {
539     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
540     final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
541 jsr166 1.13 public void realRun() throws InterruptedException {
542 jsr166 1.21 Thread.sleep(LONG_DELAY_MS);
543 jsr166 1.13 }});
544 jsr166 1.21 final Thread t = newStartedThread(new CheckedRunnable() {
545 jsr166 1.14 public void realRun() throws InterruptedException {
546 jsr166 1.23 TimeUnit tu = MILLISECONDS;
547 jsr166 1.21 Thread.currentThread().interrupt();
548     try {
549     tu.timedJoin(s, LONG_DELAY_MS);
550     shouldThrow();
551     } catch (InterruptedException success) {}
552     assertFalse(Thread.interrupted());
553    
554     pleaseInterrupt.countDown();
555     try {
556     tu.timedJoin(s, LONG_DELAY_MS);
557     shouldThrow();
558     } catch (InterruptedException success) {}
559     assertFalse(Thread.interrupted());
560 jsr166 1.18 }});
561 jsr166 1.21
562     await(pleaseInterrupt);
563     assertThreadStaysAlive(t);
564 jsr166 1.13 t.interrupt();
565 jsr166 1.21 awaitTermination(t);
566 jsr166 1.13 s.interrupt();
567 jsr166 1.21 awaitTermination(s);
568 dl 1.1 }
569 jsr166 1.10
570 dl 1.1 /**
571 jsr166 1.17 * timedSleep throws InterruptedException when interrupted
572 dl 1.4 */
573 jsr166 1.21 public void testTimedSleep_Interruptible() {
574     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
575     Thread t = newStartedThread(new CheckedRunnable() {
576 jsr166 1.14 public void realRun() throws InterruptedException {
577 jsr166 1.23 TimeUnit tu = MILLISECONDS;
578 jsr166 1.21 Thread.currentThread().interrupt();
579     try {
580     tu.sleep(LONG_DELAY_MS);
581     shouldThrow();
582     } catch (InterruptedException success) {}
583     assertFalse(Thread.interrupted());
584    
585     pleaseInterrupt.countDown();
586     try {
587     tu.sleep(LONG_DELAY_MS);
588     shouldThrow();
589     } catch (InterruptedException success) {}
590     assertFalse(Thread.interrupted());
591 jsr166 1.13 }});
592 dl 1.1
593 jsr166 1.21 await(pleaseInterrupt);
594     assertThreadStaysAlive(t);
595 jsr166 1.13 t.interrupt();
596 jsr166 1.21 awaitTermination(t);
597 dl 1.1 }
598 dl 1.2
599 dl 1.4 /**
600 jsr166 1.13 * a deserialized serialized unit is the same instance
601 dl 1.4 */
602 jsr166 1.13 public void testSerialization() throws Exception {
603 jsr166 1.27 for (TimeUnit x : TimeUnit.values())
604     assertSame(x, serialClone(x));
605 dl 1.2 }
606    
607 jsr166 1.26 /**
608     * tests for toChronoUnit.
609     */
610     public void testToChronoUnit() throws Exception {
611     assertSame(ChronoUnit.NANOS, NANOSECONDS.toChronoUnit());
612     assertSame(ChronoUnit.MICROS, MICROSECONDS.toChronoUnit());
613     assertSame(ChronoUnit.MILLIS, MILLISECONDS.toChronoUnit());
614     assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
615     assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
616     assertSame(ChronoUnit.HOURS, HOURS.toChronoUnit());
617     assertSame(ChronoUnit.DAYS, DAYS.toChronoUnit());
618    
619     // Every TimeUnit has a defined ChronoUnit equivalent
620     for (TimeUnit x : TimeUnit.values())
621     assertSame(x, TimeUnit.of(x.toChronoUnit()));
622     }
623    
624     /**
625     * tests for TimeUnit.of(ChronoUnit).
626     */
627     public void testTimeUnitOf() throws Exception {
628     assertSame(NANOSECONDS, TimeUnit.of(ChronoUnit.NANOS));
629     assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
630     assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
631     assertSame(SECONDS, TimeUnit.of(ChronoUnit.SECONDS));
632     assertSame(MINUTES, TimeUnit.of(ChronoUnit.MINUTES));
633     assertSame(HOURS, TimeUnit.of(ChronoUnit.HOURS));
634     assertSame(DAYS, TimeUnit.of(ChronoUnit.DAYS));
635    
636     assertThrows(NullPointerException.class,
637     () -> TimeUnit.of((ChronoUnit)null));
638    
639     // ChronoUnits either round trip to their TimeUnit
640     // equivalents, or throw IllegalArgumentException.
641     for (ChronoUnit cu : ChronoUnit.values()) {
642     final TimeUnit tu;
643     try {
644     tu = TimeUnit.of(cu);
645     } catch (IllegalArgumentException acceptable) {
646     continue;
647     }
648     assertSame(cu, tu.toChronoUnit());
649     }
650     }
651    
652 dl 1.1 }