[cvs] / jsr166 / src / test / tck / TimeUnitTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/TimeUnitTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.29 - (view) (download)

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 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8