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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.14, Sat Nov 21 02:07:27 2009 UTC revision 1.29, Fri Mar 25 04:53:28 2016 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
9    import static java.util.concurrent.TimeUnit.DAYS;
10    import static java.util.concurrent.TimeUnit.HOURS;
11    import static java.util.concurrent.TimeUnit.MICROSECONDS;
12    import static java.util.concurrent.TimeUnit.MILLISECONDS;
13    import static java.util.concurrent.TimeUnit.MINUTES;
14    import static java.util.concurrent.TimeUnit.NANOSECONDS;
15    import static java.util.concurrent.TimeUnit.SECONDS;
16    
17    import java.time.temporal.ChronoUnit;
18    import java.util.concurrent.CountDownLatch;
19    import java.util.concurrent.TimeUnit;
20    
21  import junit.framework.*;  import junit.framework.Test;
22  import java.util.concurrent.*;  import junit.framework.TestSuite;
 import java.io.*;  
23    
24  public class TimeUnitTest extends JSR166TestCase {  public class TimeUnitTest extends JSR166TestCase {
25      public static void main(String[] args) {      public static void main(String[] args) {
26          junit.textui.TestRunner.run(suite());          main(suite(), args);
27      }      }
28    
29      public static Test suite() {      public static Test suite() {
# Line 28  Line 38 
38      public void testConvert() {      public void testConvert() {
39          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
40              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
41                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
42              assertEquals(t*60*60,              assertEquals(t*60*60,
43                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
44              assertEquals(t*60,              assertEquals(t*60,
45                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
46              assertEquals(t,              assertEquals(t,
47                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
48              assertEquals(t,              assertEquals(t,
49                           TimeUnit.SECONDS.convert(1000L*t,                           SECONDS.convert(1000L*t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
50              assertEquals(t,              assertEquals(t,
51                           TimeUnit.SECONDS.convert(1000000L*t,                           SECONDS.convert(1000000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
52              assertEquals(t,              assertEquals(t,
53                           TimeUnit.SECONDS.convert(1000000000L*t,                           SECONDS.convert(1000000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
   
54    
55              assertEquals(1000L*t*60*60*24,              assertEquals(1000L*t*60*60*24,
56                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
57              assertEquals(1000L*t*60*60,              assertEquals(1000L*t*60*60,
58                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
59              assertEquals(1000L*t*60,              assertEquals(1000L*t*60,
60                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
61              assertEquals(1000L*t,              assertEquals(1000L*t,
62                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
63              assertEquals(t,              assertEquals(t,
64                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
65              assertEquals(t,              assertEquals(t,
66                           TimeUnit.MILLISECONDS.convert(1000L*t,                           MILLISECONDS.convert(1000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
67              assertEquals(t,              assertEquals(t,
68                           TimeUnit.MILLISECONDS.convert(1000000L*t,                           MILLISECONDS.convert(1000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
69    
70              assertEquals(1000000L*t*60*60*24,              assertEquals(1000000L*t*60*60*24,
71                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
72              assertEquals(1000000L*t*60*60,              assertEquals(1000000L*t*60*60,
73                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
74              assertEquals(1000000L*t*60,              assertEquals(1000000L*t*60,
75                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
76              assertEquals(1000000L*t,              assertEquals(1000000L*t,
77                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
78              assertEquals(1000L*t,              assertEquals(1000L*t,
79                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
80              assertEquals(t,              assertEquals(t,
81                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
82              assertEquals(t,              assertEquals(t,
83                           TimeUnit.MICROSECONDS.convert(1000L*t,                           MICROSECONDS.convert(1000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
84    
85              assertEquals(1000000000L*t*60*60*24,              assertEquals(1000000000L*t*60*60*24,
86                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
87              assertEquals(1000000000L*t*60*60,              assertEquals(1000000000L*t*60*60,
88                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
89              assertEquals(1000000000L*t*60,              assertEquals(1000000000L*t*60,
90                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
91              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
92                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
93              assertEquals(1000000L*t,              assertEquals(1000000L*t,
94                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
95              assertEquals(1000L*t,              assertEquals(1000L*t,
96                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
97              assertEquals(t,              assertEquals(t,
98                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, NANOSECONDS));
99                                                    TimeUnit.NANOSECONDS));          }
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    
# Line 125  Line 115 
115      public void testToNanos() {      public void testToNanos() {
116          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
117              assertEquals(t*1000000000L*60*60*24,              assertEquals(t*1000000000L*60*60*24,
118                           TimeUnit.DAYS.toNanos(t));                           DAYS.toNanos(t));
119              assertEquals(t*1000000000L*60*60,              assertEquals(t*1000000000L*60*60,
120                           TimeUnit.HOURS.toNanos(t));                           HOURS.toNanos(t));
121              assertEquals(t*1000000000L*60,              assertEquals(t*1000000000L*60,
122                           TimeUnit.MINUTES.toNanos(t));                           MINUTES.toNanos(t));
123              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
124                           TimeUnit.SECONDS.toNanos(t));                           SECONDS.toNanos(t));
125              assertEquals(1000000L*t,              assertEquals(1000000L*t,
126                           TimeUnit.MILLISECONDS.toNanos(t));                           MILLISECONDS.toNanos(t));
127              assertEquals(1000L*t,              assertEquals(1000L*t,
128                           TimeUnit.MICROSECONDS.toNanos(t));                           MICROSECONDS.toNanos(t));
129              assertEquals(t,              assertEquals(t,
130                           TimeUnit.NANOSECONDS.toNanos(t));                           NANOSECONDS.toNanos(t));
131          }          }
132      }      }
133    
# Line 148  Line 138 
138      public void testToMicros() {      public void testToMicros() {
139          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
140              assertEquals(t*1000000L*60*60*24,              assertEquals(t*1000000L*60*60*24,
141                           TimeUnit.DAYS.toMicros(t));                           DAYS.toMicros(t));
142              assertEquals(t*1000000L*60*60,              assertEquals(t*1000000L*60*60,
143                           TimeUnit.HOURS.toMicros(t));                           HOURS.toMicros(t));
144              assertEquals(t*1000000L*60,              assertEquals(t*1000000L*60,
145                           TimeUnit.MINUTES.toMicros(t));                           MINUTES.toMicros(t));
146              assertEquals(1000000L*t,              assertEquals(1000000L*t,
147                           TimeUnit.SECONDS.toMicros(t));                           SECONDS.toMicros(t));
148              assertEquals(1000L*t,              assertEquals(1000L*t,
149                           TimeUnit.MILLISECONDS.toMicros(t));                           MILLISECONDS.toMicros(t));
150              assertEquals(t,              assertEquals(t,
151                           TimeUnit.MICROSECONDS.toMicros(t));                           MICROSECONDS.toMicros(t));
152              assertEquals(t,              assertEquals(t,
153                           TimeUnit.NANOSECONDS.toMicros(t*1000L));                           NANOSECONDS.toMicros(t*1000L));
154          }          }
155      }      }
156    
# Line 171  Line 161 
161      public void testToMillis() {      public void testToMillis() {
162          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
163              assertEquals(t*1000L*60*60*24,              assertEquals(t*1000L*60*60*24,
164                           TimeUnit.DAYS.toMillis(t));                           DAYS.toMillis(t));
165              assertEquals(t*1000L*60*60,              assertEquals(t*1000L*60*60,
166                           TimeUnit.HOURS.toMillis(t));                           HOURS.toMillis(t));
167              assertEquals(t*1000L*60,              assertEquals(t*1000L*60,
168                           TimeUnit.MINUTES.toMillis(t));                           MINUTES.toMillis(t));
169              assertEquals(1000L*t,              assertEquals(1000L*t,
170                           TimeUnit.SECONDS.toMillis(t));                           SECONDS.toMillis(t));
171              assertEquals(t,              assertEquals(t,
172                           TimeUnit.MILLISECONDS.toMillis(t));                           MILLISECONDS.toMillis(t));
173              assertEquals(t,              assertEquals(t,
174                           TimeUnit.MICROSECONDS.toMillis(t*1000L));                           MICROSECONDS.toMillis(t*1000L));
175              assertEquals(t,              assertEquals(t,
176                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));                           NANOSECONDS.toMillis(t*1000000L));
177          }          }
178      }      }
179    
# Line 194  Line 184 
184      public void testToSeconds() {      public void testToSeconds() {
185          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
186              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
187                           TimeUnit.DAYS.toSeconds(t));                           DAYS.toSeconds(t));
188              assertEquals(t*60*60,              assertEquals(t*60*60,
189                           TimeUnit.HOURS.toSeconds(t));                           HOURS.toSeconds(t));
190              assertEquals(t*60,              assertEquals(t*60,
191                           TimeUnit.MINUTES.toSeconds(t));                           MINUTES.toSeconds(t));
192              assertEquals(t,              assertEquals(t,
193                           TimeUnit.SECONDS.toSeconds(t));                           SECONDS.toSeconds(t));
194              assertEquals(t,              assertEquals(t,
195                           TimeUnit.MILLISECONDS.toSeconds(t*1000L));                           MILLISECONDS.toSeconds(t*1000L));
196              assertEquals(t,              assertEquals(t,
197                           TimeUnit.MICROSECONDS.toSeconds(t*1000000L));                           MICROSECONDS.toSeconds(t*1000000L));
198              assertEquals(t,              assertEquals(t,
199                           TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));                           NANOSECONDS.toSeconds(t*1000000000L));
200          }          }
201      }      }
202    
# Line 217  Line 207 
207      public void testToMinutes() {      public void testToMinutes() {
208          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
209              assertEquals(t*60*24,              assertEquals(t*60*24,
210                           TimeUnit.DAYS.toMinutes(t));                           DAYS.toMinutes(t));
211              assertEquals(t*60,              assertEquals(t*60,
212                           TimeUnit.HOURS.toMinutes(t));                           HOURS.toMinutes(t));
213              assertEquals(t,              assertEquals(t,
214                           TimeUnit.MINUTES.toMinutes(t));                           MINUTES.toMinutes(t));
215              assertEquals(t,              assertEquals(t,
216                           TimeUnit.SECONDS.toMinutes(t*60));                           SECONDS.toMinutes(t*60));
217              assertEquals(t,              assertEquals(t,
218                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));                           MILLISECONDS.toMinutes(t*1000L*60));
219              assertEquals(t,              assertEquals(t,
220                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));                           MICROSECONDS.toMinutes(t*1000000L*60));
221              assertEquals(t,              assertEquals(t,
222                           TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));                           NANOSECONDS.toMinutes(t*1000000000L*60));
223          }          }
224      }      }
225    
# Line 240  Line 230 
230      public void testToHours() {      public void testToHours() {
231          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
232              assertEquals(t*24,              assertEquals(t*24,
233                           TimeUnit.DAYS.toHours(t));                           DAYS.toHours(t));
234              assertEquals(t,              assertEquals(t,
235                           TimeUnit.HOURS.toHours(t));                           HOURS.toHours(t));
236              assertEquals(t,              assertEquals(t,
237                           TimeUnit.MINUTES.toHours(t*60));                           MINUTES.toHours(t*60));
238              assertEquals(t,              assertEquals(t,
239                           TimeUnit.SECONDS.toHours(t*60*60));                           SECONDS.toHours(t*60*60));
240              assertEquals(t,              assertEquals(t,
241                           TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));                           MILLISECONDS.toHours(t*1000L*60*60));
242              assertEquals(t,              assertEquals(t,
243                           TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));                           MICROSECONDS.toHours(t*1000000L*60*60));
244              assertEquals(t,              assertEquals(t,
245                           TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));                           NANOSECONDS.toHours(t*1000000000L*60*60));
246          }          }
247      }      }
248    
# Line 263  Line 253 
253      public void testToDays() {      public void testToDays() {
254          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
255              assertEquals(t,              assertEquals(t,
256                           TimeUnit.DAYS.toDays(t));                           DAYS.toDays(t));
257              assertEquals(t,              assertEquals(t,
258                           TimeUnit.HOURS.toDays(t*24));                           HOURS.toDays(t*24));
259              assertEquals(t,              assertEquals(t,
260                           TimeUnit.MINUTES.toDays(t*60*24));                           MINUTES.toDays(t*60*24));
261              assertEquals(t,              assertEquals(t,
262                           TimeUnit.SECONDS.toDays(t*60*60*24));                           SECONDS.toDays(t*60*60*24));
263              assertEquals(t,              assertEquals(t,
264                           TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));                           MILLISECONDS.toDays(t*1000L*60*60*24));
265              assertEquals(t,              assertEquals(t,
266                           TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));                           MICROSECONDS.toDays(t*1000000L*60*60*24));
267              assertEquals(t,              assertEquals(t,
268                           TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));                           NANOSECONDS.toDays(t*1000000000L*60*60*24));
269          }          }
270      }      }
271    
   
272      /**      /**
273       * convert saturates positive too-large values to Long.MAX_VALUE       * convert saturates positive too-large values to Long.MAX_VALUE
274       * and negative to LONG.MIN_VALUE       * and negative to LONG.MIN_VALUE
275       */       */
276      public void testConvertSaturate() {      public void testConvertSaturate() {
277          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
278                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
                                                   TimeUnit.SECONDS));  
279          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
280                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
                                                   TimeUnit.SECONDS));  
281          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
282                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
                                                   TimeUnit.MINUTES));  
283          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
284                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
                                                   TimeUnit.MINUTES));  
285          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
286                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
                                                   TimeUnit.HOURS));  
287          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
288                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
                                                   TimeUnit.HOURS));  
289          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
290                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
                                                   TimeUnit.DAYS));  
291          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
292                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
                                                   TimeUnit.DAYS));  
293    
294            for (TimeUnit x : TimeUnit.values())
295                for (TimeUnit y : TimeUnit.values()) {
296                    long ratio = x.toNanos(1) / y.toNanos(1);
297                    if (ratio >= 1) {
298                        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                        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                        assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
311                        assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
312                    }
313                }
314      }      }
315    
316      /**      /**
# Line 318  Line 319 
319       */       */
320      public void testToNanosSaturate() {      public void testToNanosSaturate() {
321          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
322                       TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
323          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
324                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                       MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
325    
326            for (TimeUnit x : TimeUnit.values()) {
327                long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
328                if (ratio >= 1) {
329                    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                    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                    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                if (ratio >= 1) {
355                    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                    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                    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       * toString returns string containing common name of unit       * 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                if (ratio >= 1) {
381                    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                    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                    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                if (ratio >= 1) {
407                    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                    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                    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                if (ratio >= 1) {
453                    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                    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                    assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
462                    assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
463                }
464            }
465        }
466    
467        /**
468         * toString returns name of unit
469       */       */
470      public void testToString() {      public void testToString() {
471          String s = TimeUnit.SECONDS.toString();          assertEquals("SECONDS", SECONDS.toString());
         assertTrue(s.indexOf("ECOND") >= 0);  
472      }      }
473    
474        /**
475         * name returns name of unit
476         */
477        public void testName() {
478            assertEquals("SECONDS", SECONDS.name());
479        }
480    
481      /**      /**
482       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
483       *  IllegalMonitorStateException       *  IllegalMonitorStateException
484       */       */
485      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
486          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
487              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
488                  Object o = new Object();                  Object o = new Object();
489                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
490    
491                  try {                  try {
492                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
493                      threadShouldThrow();                      threadShouldThrow();
494                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
495                }});
496    
497          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
498      }      }
499    
500      /**      /**
501       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
502       */       */
503      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
504          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
505            Thread t = newStartedThread(new CheckedRunnable() {
506              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
507                  Object o = new Object();                  Object o = new Object();
508                    TimeUnit tu = MILLISECONDS;
509    
510                  TimeUnit tu = TimeUnit.MILLISECONDS;                  Thread.currentThread().interrupt();
511                    try {
512                  synchronized(o) {                  synchronized(o) {
513                      tu.timedWait(o,MEDIUM_DELAY_MS);                          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              }});              }});
528          t.start();  
529          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
530            assertThreadStaysAlive(t);
531          t.interrupt();          t.interrupt();
532          t.join();          awaitTermination(t);
533      }      }
534    
   
535      /**      /**
536       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
537       */       */
538      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
539          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
540            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
541              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
542                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
543              }});              }});
544          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
545              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
546                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
547                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
548              }});;                  try {
549          s.start();                      tu.timedJoin(s, LONG_DELAY_MS);
550          t.start();                      shouldThrow();
551          Thread.sleep(SHORT_DELAY_MS);                  } 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                }});
561    
562            await(pleaseInterrupt);
563            assertThreadStaysAlive(t);
564          t.interrupt();          t.interrupt();
565          t.join();          awaitTermination(t);
566          s.interrupt();          s.interrupt();
567          s.join();          awaitTermination(s);
568      }      }
569    
570      /**      /**
571       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
572       */       */
573      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
574          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
575            Thread t = newStartedThread(new CheckedRunnable() {
576              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
577                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
578                  tu.sleep(MEDIUM_DELAY_MS);                  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              }});              }});
592    
593          t.start();          await(pleaseInterrupt);
594          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
595          t.interrupt();          t.interrupt();
596          t.join();          awaitTermination(t);
597      }      }
598    
599      /**      /**
600       * a deserialized serialized unit is the same instance       * a deserialized serialized unit is the same instance
601       */       */
602      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
603          TimeUnit q = TimeUnit.MILLISECONDS;          for (TimeUnit x : TimeUnit.values())
604                assertSame(x, serialClone(x));
605        }
606    
607        /**
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          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);      /**
625          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));       * tests for TimeUnit.of(ChronoUnit).
626          out.writeObject(q);       */
627          out.close();      public void testTimeUnitOf() throws Exception {
628            assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
629          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());          assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
630          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));          assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
631          TimeUnit r = (TimeUnit)in.readObject();          assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
632          assertSame(q, r);          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  }  }

Legend:
Removed from v.1.14  
changed lines
  Added in v.1.29

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8