ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TimeUnitTest.java
(Generate patch)

Comparing jsr166/src/test/tck/TimeUnitTest.java (file contents):
Revision 1.22 by jsr166, Tue May 31 16:16:24 2011 UTC vs.
Revision 1.34 by jsr166, Wed Sep 4 22:18:03 2019 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
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 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() {
# Line 27 | Line 37 | public class TimeUnitTest extends JSR166
37      public void testConvert() {
38          for (long t = 0; t < 88888; ++t) {
39              assertEquals(t*60*60*24,
40 <                         TimeUnit.SECONDS.convert(t,
31 <                                                  TimeUnit.DAYS));
40 >                         SECONDS.convert(t, DAYS));
41              assertEquals(t*60*60,
42 <                         TimeUnit.SECONDS.convert(t,
34 <                                                  TimeUnit.HOURS));
42 >                         SECONDS.convert(t, HOURS));
43              assertEquals(t*60,
44 <                         TimeUnit.SECONDS.convert(t,
37 <                                                  TimeUnit.MINUTES));
44 >                         SECONDS.convert(t, MINUTES));
45              assertEquals(t,
46 <                         TimeUnit.SECONDS.convert(t,
40 <                                                  TimeUnit.SECONDS));
46 >                         SECONDS.convert(t, SECONDS));
47              assertEquals(t,
48 <                         TimeUnit.SECONDS.convert(1000L*t,
43 <                                                  TimeUnit.MILLISECONDS));
48 >                         SECONDS.convert(1000L*t, MILLISECONDS));
49              assertEquals(t,
50 <                         TimeUnit.SECONDS.convert(1000000L*t,
46 <                                                  TimeUnit.MICROSECONDS));
50 >                         SECONDS.convert(1000000L*t, MICROSECONDS));
51              assertEquals(t,
52 <                         TimeUnit.SECONDS.convert(1000000000L*t,
49 <                                                  TimeUnit.NANOSECONDS));
52 >                         SECONDS.convert(1000000000L*t, NANOSECONDS));
53  
54              assertEquals(1000L*t*60*60*24,
55 <                         TimeUnit.MILLISECONDS.convert(t,
53 <                                                  TimeUnit.DAYS));
55 >                         MILLISECONDS.convert(t, DAYS));
56              assertEquals(1000L*t*60*60,
57 <                         TimeUnit.MILLISECONDS.convert(t,
56 <                                                  TimeUnit.HOURS));
57 >                         MILLISECONDS.convert(t, HOURS));
58              assertEquals(1000L*t*60,
59 <                         TimeUnit.MILLISECONDS.convert(t,
59 <                                                  TimeUnit.MINUTES));
59 >                         MILLISECONDS.convert(t, MINUTES));
60              assertEquals(1000L*t,
61 <                         TimeUnit.MILLISECONDS.convert(t,
62 <                                                  TimeUnit.SECONDS));
61 >                         MILLISECONDS.convert(t, SECONDS));
62              assertEquals(t,
63 <                         TimeUnit.MILLISECONDS.convert(t,
65 <                                                  TimeUnit.MILLISECONDS));
63 >                         MILLISECONDS.convert(t, MILLISECONDS));
64              assertEquals(t,
65 <                         TimeUnit.MILLISECONDS.convert(1000L*t,
68 <                                                  TimeUnit.MICROSECONDS));
65 >                         MILLISECONDS.convert(1000L*t, MICROSECONDS));
66              assertEquals(t,
67 <                         TimeUnit.MILLISECONDS.convert(1000000L*t,
71 <                                                  TimeUnit.NANOSECONDS));
67 >                         MILLISECONDS.convert(1000000L*t, NANOSECONDS));
68  
69              assertEquals(1000000L*t*60*60*24,
70 <                         TimeUnit.MICROSECONDS.convert(t,
75 <                                                  TimeUnit.DAYS));
70 >                         MICROSECONDS.convert(t, DAYS));
71              assertEquals(1000000L*t*60*60,
72 <                         TimeUnit.MICROSECONDS.convert(t,
78 <                                                  TimeUnit.HOURS));
72 >                         MICROSECONDS.convert(t, HOURS));
73              assertEquals(1000000L*t*60,
74 <                         TimeUnit.MICROSECONDS.convert(t,
81 <                                                  TimeUnit.MINUTES));
74 >                         MICROSECONDS.convert(t, MINUTES));
75              assertEquals(1000000L*t,
76 <                         TimeUnit.MICROSECONDS.convert(t,
84 <                                                  TimeUnit.SECONDS));
76 >                         MICROSECONDS.convert(t, SECONDS));
77              assertEquals(1000L*t,
78 <                         TimeUnit.MICROSECONDS.convert(t,
87 <                                                  TimeUnit.MILLISECONDS));
78 >                         MICROSECONDS.convert(t, MILLISECONDS));
79              assertEquals(t,
80 <                         TimeUnit.MICROSECONDS.convert(t,
90 <                                                  TimeUnit.MICROSECONDS));
80 >                         MICROSECONDS.convert(t, MICROSECONDS));
81              assertEquals(t,
82 <                         TimeUnit.MICROSECONDS.convert(1000L*t,
93 <                                                  TimeUnit.NANOSECONDS));
82 >                         MICROSECONDS.convert(1000L*t, NANOSECONDS));
83  
84              assertEquals(1000000000L*t*60*60*24,
85 <                         TimeUnit.NANOSECONDS.convert(t,
97 <                                                  TimeUnit.DAYS));
85 >                         NANOSECONDS.convert(t, DAYS));
86              assertEquals(1000000000L*t*60*60,
87 <                         TimeUnit.NANOSECONDS.convert(t,
100 <                                                  TimeUnit.HOURS));
87 >                         NANOSECONDS.convert(t, HOURS));
88              assertEquals(1000000000L*t*60,
89 <                         TimeUnit.NANOSECONDS.convert(t,
103 <                                                  TimeUnit.MINUTES));
89 >                         NANOSECONDS.convert(t, MINUTES));
90              assertEquals(1000000000L*t,
91 <                         TimeUnit.NANOSECONDS.convert(t,
106 <                                                  TimeUnit.SECONDS));
91 >                         NANOSECONDS.convert(t, SECONDS));
92              assertEquals(1000000L*t,
93 <                         TimeUnit.NANOSECONDS.convert(t,
109 <                                                  TimeUnit.MILLISECONDS));
93 >                         NANOSECONDS.convert(t, MILLISECONDS));
94              assertEquals(1000L*t,
95 <                         TimeUnit.NANOSECONDS.convert(t,
112 <                                                  TimeUnit.MICROSECONDS));
95 >                         NANOSECONDS.convert(t, MICROSECONDS));
96              assertEquals(t,
97 <                         TimeUnit.NANOSECONDS.convert(t,
98 <                                                  TimeUnit.NANOSECONDS));
97 >                         NANOSECONDS.convert(t, NANOSECONDS));
98 >        }
99 >
100 >        for (TimeUnit x : TimeUnit.values()) {
101 >            long[] zs = {
102 >                0, 1, -1,
103 >                Integer.MAX_VALUE, Integer.MIN_VALUE,
104 >                Long.MAX_VALUE, Long.MIN_VALUE,
105 >            };
106 >            for (long z : zs) assertEquals(z, x.convert(z, x));
107          }
108      }
109  
# Line 123 | Line 114 | public class TimeUnitTest extends JSR166
114      public void testToNanos() {
115          for (long t = 0; t < 88888; ++t) {
116              assertEquals(t*1000000000L*60*60*24,
117 <                         TimeUnit.DAYS.toNanos(t));
117 >                         DAYS.toNanos(t));
118              assertEquals(t*1000000000L*60*60,
119 <                         TimeUnit.HOURS.toNanos(t));
119 >                         HOURS.toNanos(t));
120              assertEquals(t*1000000000L*60,
121 <                         TimeUnit.MINUTES.toNanos(t));
121 >                         MINUTES.toNanos(t));
122              assertEquals(1000000000L*t,
123 <                         TimeUnit.SECONDS.toNanos(t));
123 >                         SECONDS.toNanos(t));
124              assertEquals(1000000L*t,
125 <                         TimeUnit.MILLISECONDS.toNanos(t));
125 >                         MILLISECONDS.toNanos(t));
126              assertEquals(1000L*t,
127 <                         TimeUnit.MICROSECONDS.toNanos(t));
127 >                         MICROSECONDS.toNanos(t));
128              assertEquals(t,
129 <                         TimeUnit.NANOSECONDS.toNanos(t));
129 >                         NANOSECONDS.toNanos(t));
130          }
131      }
132  
# Line 146 | Line 137 | public class TimeUnitTest extends JSR166
137      public void testToMicros() {
138          for (long t = 0; t < 88888; ++t) {
139              assertEquals(t*1000000L*60*60*24,
140 <                         TimeUnit.DAYS.toMicros(t));
140 >                         DAYS.toMicros(t));
141              assertEquals(t*1000000L*60*60,
142 <                         TimeUnit.HOURS.toMicros(t));
142 >                         HOURS.toMicros(t));
143              assertEquals(t*1000000L*60,
144 <                         TimeUnit.MINUTES.toMicros(t));
144 >                         MINUTES.toMicros(t));
145              assertEquals(1000000L*t,
146 <                         TimeUnit.SECONDS.toMicros(t));
146 >                         SECONDS.toMicros(t));
147              assertEquals(1000L*t,
148 <                         TimeUnit.MILLISECONDS.toMicros(t));
148 >                         MILLISECONDS.toMicros(t));
149              assertEquals(t,
150 <                         TimeUnit.MICROSECONDS.toMicros(t));
150 >                         MICROSECONDS.toMicros(t));
151              assertEquals(t,
152 <                         TimeUnit.NANOSECONDS.toMicros(t*1000L));
152 >                         NANOSECONDS.toMicros(t*1000L));
153          }
154      }
155  
# Line 169 | Line 160 | public class TimeUnitTest extends JSR166
160      public void testToMillis() {
161          for (long t = 0; t < 88888; ++t) {
162              assertEquals(t*1000L*60*60*24,
163 <                         TimeUnit.DAYS.toMillis(t));
163 >                         DAYS.toMillis(t));
164              assertEquals(t*1000L*60*60,
165 <                         TimeUnit.HOURS.toMillis(t));
165 >                         HOURS.toMillis(t));
166              assertEquals(t*1000L*60,
167 <                         TimeUnit.MINUTES.toMillis(t));
167 >                         MINUTES.toMillis(t));
168              assertEquals(1000L*t,
169 <                         TimeUnit.SECONDS.toMillis(t));
169 >                         SECONDS.toMillis(t));
170              assertEquals(t,
171 <                         TimeUnit.MILLISECONDS.toMillis(t));
171 >                         MILLISECONDS.toMillis(t));
172              assertEquals(t,
173 <                         TimeUnit.MICROSECONDS.toMillis(t*1000L));
173 >                         MICROSECONDS.toMillis(t*1000L));
174              assertEquals(t,
175 <                         TimeUnit.NANOSECONDS.toMillis(t*1000000L));
175 >                         NANOSECONDS.toMillis(t*1000000L));
176          }
177      }
178  
# Line 192 | Line 183 | public class TimeUnitTest extends JSR166
183      public void testToSeconds() {
184          for (long t = 0; t < 88888; ++t) {
185              assertEquals(t*60*60*24,
186 <                         TimeUnit.DAYS.toSeconds(t));
186 >                         DAYS.toSeconds(t));
187              assertEquals(t*60*60,
188 <                         TimeUnit.HOURS.toSeconds(t));
188 >                         HOURS.toSeconds(t));
189              assertEquals(t*60,
190 <                         TimeUnit.MINUTES.toSeconds(t));
190 >                         MINUTES.toSeconds(t));
191              assertEquals(t,
192 <                         TimeUnit.SECONDS.toSeconds(t));
192 >                         SECONDS.toSeconds(t));
193              assertEquals(t,
194 <                         TimeUnit.MILLISECONDS.toSeconds(t*1000L));
194 >                         MILLISECONDS.toSeconds(t*1000L));
195              assertEquals(t,
196 <                         TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
196 >                         MICROSECONDS.toSeconds(t*1000000L));
197              assertEquals(t,
198 <                         TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
198 >                         NANOSECONDS.toSeconds(t*1000000000L));
199          }
200      }
201  
# Line 215 | Line 206 | public class TimeUnitTest extends JSR166
206      public void testToMinutes() {
207          for (long t = 0; t < 88888; ++t) {
208              assertEquals(t*60*24,
209 <                         TimeUnit.DAYS.toMinutes(t));
209 >                         DAYS.toMinutes(t));
210              assertEquals(t*60,
211 <                         TimeUnit.HOURS.toMinutes(t));
211 >                         HOURS.toMinutes(t));
212              assertEquals(t,
213 <                         TimeUnit.MINUTES.toMinutes(t));
213 >                         MINUTES.toMinutes(t));
214              assertEquals(t,
215 <                         TimeUnit.SECONDS.toMinutes(t*60));
215 >                         SECONDS.toMinutes(t*60));
216              assertEquals(t,
217 <                         TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
217 >                         MILLISECONDS.toMinutes(t*1000L*60));
218              assertEquals(t,
219 <                         TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
219 >                         MICROSECONDS.toMinutes(t*1000000L*60));
220              assertEquals(t,
221 <                         TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
221 >                         NANOSECONDS.toMinutes(t*1000000000L*60));
222          }
223      }
224  
# Line 238 | Line 229 | public class TimeUnitTest extends JSR166
229      public void testToHours() {
230          for (long t = 0; t < 88888; ++t) {
231              assertEquals(t*24,
232 <                         TimeUnit.DAYS.toHours(t));
232 >                         DAYS.toHours(t));
233              assertEquals(t,
234 <                         TimeUnit.HOURS.toHours(t));
234 >                         HOURS.toHours(t));
235              assertEquals(t,
236 <                         TimeUnit.MINUTES.toHours(t*60));
236 >                         MINUTES.toHours(t*60));
237              assertEquals(t,
238 <                         TimeUnit.SECONDS.toHours(t*60*60));
238 >                         SECONDS.toHours(t*60*60));
239              assertEquals(t,
240 <                         TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
240 >                         MILLISECONDS.toHours(t*1000L*60*60));
241              assertEquals(t,
242 <                         TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
242 >                         MICROSECONDS.toHours(t*1000000L*60*60));
243              assertEquals(t,
244 <                         TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
244 >                         NANOSECONDS.toHours(t*1000000000L*60*60));
245          }
246      }
247  
# Line 261 | Line 252 | public class TimeUnitTest extends JSR166
252      public void testToDays() {
253          for (long t = 0; t < 88888; ++t) {
254              assertEquals(t,
255 <                         TimeUnit.DAYS.toDays(t));
255 >                         DAYS.toDays(t));
256              assertEquals(t,
257 <                         TimeUnit.HOURS.toDays(t*24));
257 >                         HOURS.toDays(t*24));
258              assertEquals(t,
259 <                         TimeUnit.MINUTES.toDays(t*60*24));
259 >                         MINUTES.toDays(t*60*24));
260              assertEquals(t,
261 <                         TimeUnit.SECONDS.toDays(t*60*60*24));
261 >                         SECONDS.toDays(t*60*60*24));
262              assertEquals(t,
263 <                         TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
263 >                         MILLISECONDS.toDays(t*1000L*60*60*24));
264              assertEquals(t,
265 <                         TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
265 >                         MICROSECONDS.toDays(t*1000000L*60*60*24));
266              assertEquals(t,
267 <                         TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
267 >                         NANOSECONDS.toDays(t*1000000000L*60*60*24));
268          }
269      }
270  
# Line 283 | Line 274 | public class TimeUnitTest extends JSR166
274       */
275      public void testConvertSaturate() {
276          assertEquals(Long.MAX_VALUE,
277 <                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
287 <                                                  TimeUnit.SECONDS));
277 >                     NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
278          assertEquals(Long.MIN_VALUE,
279 <                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
290 <                                                  TimeUnit.SECONDS));
279 >                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
280          assertEquals(Long.MAX_VALUE,
281 <                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
293 <                                                  TimeUnit.MINUTES));
281 >                     NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
282          assertEquals(Long.MIN_VALUE,
283 <                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
296 <                                                  TimeUnit.MINUTES));
283 >                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
284          assertEquals(Long.MAX_VALUE,
285 <                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
299 <                                                  TimeUnit.HOURS));
285 >                     NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
286          assertEquals(Long.MIN_VALUE,
287 <                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
302 <                                                  TimeUnit.HOURS));
287 >                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
288          assertEquals(Long.MAX_VALUE,
289 <                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
305 <                                                  TimeUnit.DAYS));
289 >                     NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
290          assertEquals(Long.MIN_VALUE,
291 <                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
292 <                                                  TimeUnit.DAYS));
291 >                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
292 >
293 >        for (TimeUnit x : TimeUnit.values())
294 >            for (TimeUnit y : TimeUnit.values()) {
295 >                long ratio = x.toNanos(1) / y.toNanos(1);
296 >                if (ratio >= 1) {
297 >                    assertEquals(ratio, y.convert(1, x));
298 >                    assertEquals(1, x.convert(ratio, y));
299 >                    long max = Long.MAX_VALUE/ratio;
300 >                    assertEquals(max * ratio, y.convert(max, x));
301 >                    assertEquals(-max * ratio, y.convert(-max, x));
302 >                    assertEquals(max, x.convert(max * ratio, y));
303 >                    assertEquals(-max, x.convert(-max * ratio, y));
304 >                    if (max < Long.MAX_VALUE) {
305 >                        assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
306 >                        assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
307 >                        assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
308 >                    }
309 >                    assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
310 >                    assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
311 >                }
312 >            }
313      }
314  
315      /**
# Line 314 | Line 318 | public class TimeUnitTest extends JSR166
318       */
319      public void testToNanosSaturate() {
320          assertEquals(Long.MAX_VALUE,
321 <                     TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
321 >                     MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322          assertEquals(Long.MIN_VALUE,
323 <                     TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
323 >                     MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
324 >
325 >        for (TimeUnit x : TimeUnit.values()) {
326 >            long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
327 >            if (ratio >= 1) {
328 >                long max = Long.MAX_VALUE/ratio;
329 >                for (long z : new long[] {0, 1, -1, max, -max})
330 >                    assertEquals(z * ratio, x.toNanos(z));
331 >                if (max < Long.MAX_VALUE) {
332 >                    assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
333 >                    assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
334 >                    assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
335 >                }
336 >                assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
337 >                assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
338 >                if (max < Integer.MAX_VALUE) {
339 >                    assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
340 >                    assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
341 >                }
342 >            }
343 >        }
344 >    }
345 >
346 >    /**
347 >     * toMicros saturates positive too-large values to Long.MAX_VALUE
348 >     * and negative to LONG.MIN_VALUE
349 >     */
350 >    public void testToMicrosSaturate() {
351 >        for (TimeUnit x : TimeUnit.values()) {
352 >            long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
353 >            if (ratio >= 1) {
354 >                long max = Long.MAX_VALUE/ratio;
355 >                for (long z : new long[] {0, 1, -1, max, -max})
356 >                    assertEquals(z * ratio, x.toMicros(z));
357 >                if (max < Long.MAX_VALUE) {
358 >                    assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
359 >                    assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
360 >                    assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
361 >                }
362 >                assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
363 >                assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
364 >                if (max < Integer.MAX_VALUE) {
365 >                    assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
366 >                    assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
367 >                }
368 >            }
369 >        }
370 >    }
371 >
372 >    /**
373 >     * toMillis saturates positive too-large values to Long.MAX_VALUE
374 >     * and negative to LONG.MIN_VALUE
375 >     */
376 >    public void testToMillisSaturate() {
377 >        for (TimeUnit x : TimeUnit.values()) {
378 >            long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
379 >            if (ratio >= 1) {
380 >                long max = Long.MAX_VALUE/ratio;
381 >                for (long z : new long[] {0, 1, -1, max, -max})
382 >                    assertEquals(z * ratio, x.toMillis(z));
383 >                if (max < Long.MAX_VALUE) {
384 >                    assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
385 >                    assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
386 >                    assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
387 >                }
388 >                assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
389 >                assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
390 >                if (max < Integer.MAX_VALUE) {
391 >                    assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
392 >                    assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
393 >                }
394 >            }
395 >        }
396 >    }
397 >
398 >    /**
399 >     * toSeconds saturates positive too-large values to Long.MAX_VALUE
400 >     * and negative to LONG.MIN_VALUE
401 >     */
402 >    public void testToSecondsSaturate() {
403 >        for (TimeUnit x : TimeUnit.values()) {
404 >            long ratio = x.toNanos(1) / SECONDS.toNanos(1);
405 >            if (ratio >= 1) {
406 >                long max = Long.MAX_VALUE/ratio;
407 >                for (long z : new long[] {0, 1, -1, max, -max})
408 >                    assertEquals(z * ratio, x.toSeconds(z));
409 >                if (max < Long.MAX_VALUE) {
410 >                    assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
411 >                    assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
412 >                    assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
413 >                }
414 >                assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
415 >                assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
416 >                if (max < Integer.MAX_VALUE) {
417 >                    assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
418 >                    assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
419 >                }
420 >            }
421 >        }
422 >    }
423 >
424 >    /**
425 >     * toMinutes saturates positive too-large values to Long.MAX_VALUE
426 >     * and negative to LONG.MIN_VALUE
427 >     */
428 >    public void testToMinutesSaturate() {
429 >        for (TimeUnit x : TimeUnit.values()) {
430 >            long ratio = x.toNanos(1) / MINUTES.toNanos(1);
431 >            if (ratio > 1) {
432 >                long max = Long.MAX_VALUE/ratio;
433 >                for (long z : new long[] {0, 1, -1, max, -max})
434 >                    assertEquals(z * ratio, x.toMinutes(z));
435 >                assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
436 >                assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
437 >                assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
438 >                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
439 >                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
440 >            }
441 >        }
442 >    }
443 >
444 >    /**
445 >     * toHours saturates positive too-large values to Long.MAX_VALUE
446 >     * and negative to LONG.MIN_VALUE
447 >     */
448 >    public void testToHoursSaturate() {
449 >        for (TimeUnit x : TimeUnit.values()) {
450 >            long ratio = x.toNanos(1) / HOURS.toNanos(1);
451 >            if (ratio >= 1) {
452 >                long max = Long.MAX_VALUE/ratio;
453 >                for (long z : new long[] {0, 1, -1, max, -max})
454 >                    assertEquals(z * ratio, x.toHours(z));
455 >                if (max < Long.MAX_VALUE) {
456 >                    assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
457 >                    assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
458 >                    assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
459 >                }
460 >                assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
461 >                assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
462 >            }
463 >        }
464      }
465  
466      /**
467       * toString returns name of unit
468       */
469      public void testToString() {
470 <        assertEquals("SECONDS", TimeUnit.SECONDS.toString());
470 >        assertEquals("NANOSECONDS", NANOSECONDS.toString());
471 >        assertEquals("MICROSECONDS", MICROSECONDS.toString());
472 >        assertEquals("MILLISECONDS", MILLISECONDS.toString());
473 >        assertEquals("SECONDS", SECONDS.toString());
474 >        assertEquals("MINUTES", MINUTES.toString());
475 >        assertEquals("HOURS", HOURS.toString());
476 >        assertEquals("DAYS", DAYS.toString());
477      }
478  
479      /**
480       * name returns name of unit
481       */
482      public void testName() {
483 <        assertEquals("SECONDS", TimeUnit.SECONDS.name());
483 >        for (TimeUnit x : TimeUnit.values())
484 >            assertEquals(x.toString(), x.name());
485      }
486  
487      /**
# Line 340 | Line 491 | public class TimeUnitTest extends JSR166
491      public void testTimedWait_IllegalMonitorException() {
492          Thread t = newStartedThread(new CheckedRunnable() {
493              public void realRun() throws InterruptedException {
494 +                long startTime = System.nanoTime();
495                  Object o = new Object();
344 –                TimeUnit tu = TimeUnit.MILLISECONDS;
496  
497                  try {
498 <                    tu.timedWait(o, LONG_DELAY_MS);
498 >                    MILLISECONDS.timedWait(o, LONG_DELAY_MS);
499                      threadShouldThrow();
500                  } catch (IllegalMonitorStateException success) {}
501 +
502 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
503              }});
504  
505          awaitTermination(t);
# Line 359 | Line 512 | public class TimeUnitTest extends JSR166
512          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
513          Thread t = newStartedThread(new CheckedRunnable() {
514              public void realRun() throws InterruptedException {
515 +                long startTime = System.nanoTime();
516                  Object o = new Object();
363 –                TimeUnit tu = TimeUnit.MILLISECONDS;
517  
518                  Thread.currentThread().interrupt();
519                  try {
520                      synchronized (o) {
521 <                        tu.timedWait(o, LONG_DELAY_MS);
521 >                        MILLISECONDS.timedWait(o, LONG_DELAY_MS);
522                      }
523                      shouldThrow();
524                  } catch (InterruptedException success) {}
# Line 374 | Line 527 | public class TimeUnitTest extends JSR166
527                  pleaseInterrupt.countDown();
528                  try {
529                      synchronized (o) {
530 <                        tu.timedWait(o, LONG_DELAY_MS);
530 >                        MILLISECONDS.timedWait(o, LONG_DELAY_MS);
531                      }
532                      shouldThrow();
533                  } catch (InterruptedException success) {}
534                  assertFalse(Thread.interrupted());
535 +
536 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
537              }});
538  
539          await(pleaseInterrupt);
540 <        assertThreadStaysAlive(t);
540 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
541          t.interrupt();
542          awaitTermination(t);
543      }
# Line 398 | Line 553 | public class TimeUnitTest extends JSR166
553              }});
554          final Thread t = newStartedThread(new CheckedRunnable() {
555              public void realRun() throws InterruptedException {
556 <                TimeUnit tu = TimeUnit.MILLISECONDS;
556 >                long startTime = System.nanoTime();
557 >
558                  Thread.currentThread().interrupt();
559                  try {
560 <                    tu.timedJoin(s, LONG_DELAY_MS);
560 >                    MILLISECONDS.timedJoin(s, LONG_DELAY_MS);
561                      shouldThrow();
562                  } catch (InterruptedException success) {}
563                  assertFalse(Thread.interrupted());
564  
565                  pleaseInterrupt.countDown();
566                  try {
567 <                    tu.timedJoin(s, LONG_DELAY_MS);
567 >                    MILLISECONDS.timedJoin(s, LONG_DELAY_MS);
568                      shouldThrow();
569                  } catch (InterruptedException success) {}
570                  assertFalse(Thread.interrupted());
571 +
572 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
573              }});
574  
575          await(pleaseInterrupt);
576 <        assertThreadStaysAlive(t);
576 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
577          t.interrupt();
578          awaitTermination(t);
579          s.interrupt();
# Line 423 | Line 581 | public class TimeUnitTest extends JSR166
581      }
582  
583      /**
584 <     * timedSleep throws InterruptedException when interrupted
584 >     * timeUnit.sleep throws InterruptedException when interrupted
585       */
586      public void testTimedSleep_Interruptible() {
587          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
588          Thread t = newStartedThread(new CheckedRunnable() {
589              public void realRun() throws InterruptedException {
590 <                TimeUnit tu = TimeUnit.MILLISECONDS;
590 >                long startTime = System.nanoTime();
591 >
592                  Thread.currentThread().interrupt();
593                  try {
594 <                    tu.sleep(LONG_DELAY_MS);
594 >                    MILLISECONDS.sleep(LONG_DELAY_MS);
595                      shouldThrow();
596                  } catch (InterruptedException success) {}
597                  assertFalse(Thread.interrupted());
598  
599                  pleaseInterrupt.countDown();
600                  try {
601 <                    tu.sleep(LONG_DELAY_MS);
601 >                    MILLISECONDS.sleep(LONG_DELAY_MS);
602                      shouldThrow();
603                  } catch (InterruptedException success) {}
604                  assertFalse(Thread.interrupted());
605 +
606 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
607              }});
608  
609          await(pleaseInterrupt);
610 <        assertThreadStaysAlive(t);
610 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
611          t.interrupt();
612          awaitTermination(t);
613      }
614  
615      /**
616 <     * a deserialized serialized unit is the same instance
616 >     * timeUnit.sleep(x) for x <= 0 does not sleep at all.
617 >     */
618 >    public void testTimedSleep_nonPositive() throws InterruptedException {
619 >        long startTime = System.nanoTime();
620 >        boolean interrupt = randomBoolean();
621 >        if (interrupt) Thread.currentThread().interrupt();
622 >        randomTimeUnit().sleep(0L);
623 >        randomTimeUnit().sleep(-1L);
624 >        randomTimeUnit().sleep(Long.MIN_VALUE);
625 >        if (interrupt) assertTrue(Thread.interrupted());
626 >    }
627 >
628 >    /**
629 >     * a deserialized/reserialized unit is the same instance
630       */
631      public void testSerialization() throws Exception {
632 <        TimeUnit x = TimeUnit.MILLISECONDS;
633 <        assertSame(x, serialClone(x));
632 >        for (TimeUnit x : TimeUnit.values())
633 >            assertSame(x, serialClone(x));
634      }
635  
636   }

Diff Legend

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