[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.31, Sat May 13 23:50:00 2017 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 junit.framework.*;  import java.util.concurrent.CountDownLatch;
18  import java.util.concurrent.*;  import java.util.concurrent.TimeUnit;
19  import java.io.*;  
20    import junit.framework.Test;
21    import junit.framework.TestSuite;
22    
23  public class TimeUnitTest extends JSR166TestCase {  public class TimeUnitTest extends JSR166TestCase {
24      public static void main(String[] args) {      public static void main(String[] args) {
25          junit.textui.TestRunner.run(suite());          main(suite(), args);
26      }      }
27    
28      public static Test suite() {      public static Test suite() {
# Line 28  Line 37 
37      public void testConvert() {      public void testConvert() {
38          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
39              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
40                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
41              assertEquals(t*60*60,              assertEquals(t*60*60,
42                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
43              assertEquals(t*60,              assertEquals(t*60,
44                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
45              assertEquals(t,              assertEquals(t,
46                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
47              assertEquals(t,              assertEquals(t,
48                           TimeUnit.SECONDS.convert(1000L*t,                           SECONDS.convert(1000L*t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
49              assertEquals(t,              assertEquals(t,
50                           TimeUnit.SECONDS.convert(1000000L*t,                           SECONDS.convert(1000000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
51              assertEquals(t,              assertEquals(t,
52                           TimeUnit.SECONDS.convert(1000000000L*t,                           SECONDS.convert(1000000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
   
53    
54              assertEquals(1000L*t*60*60*24,              assertEquals(1000L*t*60*60*24,
55                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
56              assertEquals(1000L*t*60*60,              assertEquals(1000L*t*60*60,
57                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
58              assertEquals(1000L*t*60,              assertEquals(1000L*t*60,
59                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
60              assertEquals(1000L*t,              assertEquals(1000L*t,
61                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
62              assertEquals(t,              assertEquals(t,
63                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
64              assertEquals(t,              assertEquals(t,
65                           TimeUnit.MILLISECONDS.convert(1000L*t,                           MILLISECONDS.convert(1000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
66              assertEquals(t,              assertEquals(t,
67                           TimeUnit.MILLISECONDS.convert(1000000L*t,                           MILLISECONDS.convert(1000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
68    
69              assertEquals(1000000L*t*60*60*24,              assertEquals(1000000L*t*60*60*24,
70                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
71              assertEquals(1000000L*t*60*60,              assertEquals(1000000L*t*60*60,
72                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
73              assertEquals(1000000L*t*60,              assertEquals(1000000L*t*60,
74                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
75              assertEquals(1000000L*t,              assertEquals(1000000L*t,
76                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
77              assertEquals(1000L*t,              assertEquals(1000L*t,
78                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
79              assertEquals(t,              assertEquals(t,
80                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
81              assertEquals(t,              assertEquals(t,
82                           TimeUnit.MICROSECONDS.convert(1000L*t,                           MICROSECONDS.convert(1000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
83    
84              assertEquals(1000000000L*t*60*60*24,              assertEquals(1000000000L*t*60*60*24,
85                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
86              assertEquals(1000000000L*t*60*60,              assertEquals(1000000000L*t*60*60,
87                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
88              assertEquals(1000000000L*t*60,              assertEquals(1000000000L*t*60,
89                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
90              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
91                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
92              assertEquals(1000000L*t,              assertEquals(1000000L*t,
93                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
94              assertEquals(1000L*t,              assertEquals(1000L*t,
95                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
96              assertEquals(t,              assertEquals(t,
97                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, NANOSECONDS));
98                                                    TimeUnit.NANOSECONDS));          }
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 125  Line 114 
114      public void testToNanos() {      public void testToNanos() {
115          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
116              assertEquals(t*1000000000L*60*60*24,              assertEquals(t*1000000000L*60*60*24,
117                           TimeUnit.DAYS.toNanos(t));                           DAYS.toNanos(t));
118              assertEquals(t*1000000000L*60*60,              assertEquals(t*1000000000L*60*60,
119                           TimeUnit.HOURS.toNanos(t));                           HOURS.toNanos(t));
120              assertEquals(t*1000000000L*60,              assertEquals(t*1000000000L*60,
121                           TimeUnit.MINUTES.toNanos(t));                           MINUTES.toNanos(t));
122              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
123                           TimeUnit.SECONDS.toNanos(t));                           SECONDS.toNanos(t));
124              assertEquals(1000000L*t,              assertEquals(1000000L*t,
125                           TimeUnit.MILLISECONDS.toNanos(t));                           MILLISECONDS.toNanos(t));
126              assertEquals(1000L*t,              assertEquals(1000L*t,
127                           TimeUnit.MICROSECONDS.toNanos(t));                           MICROSECONDS.toNanos(t));
128              assertEquals(t,              assertEquals(t,
129                           TimeUnit.NANOSECONDS.toNanos(t));                           NANOSECONDS.toNanos(t));
130          }          }
131      }      }
132    
# Line 148  Line 137 
137      public void testToMicros() {      public void testToMicros() {
138          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
139              assertEquals(t*1000000L*60*60*24,              assertEquals(t*1000000L*60*60*24,
140                           TimeUnit.DAYS.toMicros(t));                           DAYS.toMicros(t));
141              assertEquals(t*1000000L*60*60,              assertEquals(t*1000000L*60*60,
142                           TimeUnit.HOURS.toMicros(t));                           HOURS.toMicros(t));
143              assertEquals(t*1000000L*60,              assertEquals(t*1000000L*60,
144                           TimeUnit.MINUTES.toMicros(t));                           MINUTES.toMicros(t));
145              assertEquals(1000000L*t,              assertEquals(1000000L*t,
146                           TimeUnit.SECONDS.toMicros(t));                           SECONDS.toMicros(t));
147              assertEquals(1000L*t,              assertEquals(1000L*t,
148                           TimeUnit.MILLISECONDS.toMicros(t));                           MILLISECONDS.toMicros(t));
149              assertEquals(t,              assertEquals(t,
150                           TimeUnit.MICROSECONDS.toMicros(t));                           MICROSECONDS.toMicros(t));
151              assertEquals(t,              assertEquals(t,
152                           TimeUnit.NANOSECONDS.toMicros(t*1000L));                           NANOSECONDS.toMicros(t*1000L));
153          }          }
154      }      }
155    
# Line 171  Line 160 
160      public void testToMillis() {      public void testToMillis() {
161          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
162              assertEquals(t*1000L*60*60*24,              assertEquals(t*1000L*60*60*24,
163                           TimeUnit.DAYS.toMillis(t));                           DAYS.toMillis(t));
164              assertEquals(t*1000L*60*60,              assertEquals(t*1000L*60*60,
165                           TimeUnit.HOURS.toMillis(t));                           HOURS.toMillis(t));
166              assertEquals(t*1000L*60,              assertEquals(t*1000L*60,
167                           TimeUnit.MINUTES.toMillis(t));                           MINUTES.toMillis(t));
168              assertEquals(1000L*t,              assertEquals(1000L*t,
169                           TimeUnit.SECONDS.toMillis(t));                           SECONDS.toMillis(t));
170              assertEquals(t,              assertEquals(t,
171                           TimeUnit.MILLISECONDS.toMillis(t));                           MILLISECONDS.toMillis(t));
172              assertEquals(t,              assertEquals(t,
173                           TimeUnit.MICROSECONDS.toMillis(t*1000L));                           MICROSECONDS.toMillis(t*1000L));
174              assertEquals(t,              assertEquals(t,
175                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));                           NANOSECONDS.toMillis(t*1000000L));
176          }          }
177      }      }
178    
# Line 194  Line 183 
183      public void testToSeconds() {      public void testToSeconds() {
184          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
185              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
186                           TimeUnit.DAYS.toSeconds(t));                           DAYS.toSeconds(t));
187              assertEquals(t*60*60,              assertEquals(t*60*60,
188                           TimeUnit.HOURS.toSeconds(t));                           HOURS.toSeconds(t));
189              assertEquals(t*60,              assertEquals(t*60,
190                           TimeUnit.MINUTES.toSeconds(t));                           MINUTES.toSeconds(t));
191              assertEquals(t,              assertEquals(t,
192                           TimeUnit.SECONDS.toSeconds(t));                           SECONDS.toSeconds(t));
193              assertEquals(t,              assertEquals(t,
194                           TimeUnit.MILLISECONDS.toSeconds(t*1000L));                           MILLISECONDS.toSeconds(t*1000L));
195              assertEquals(t,              assertEquals(t,
196                           TimeUnit.MICROSECONDS.toSeconds(t*1000000L));                           MICROSECONDS.toSeconds(t*1000000L));
197              assertEquals(t,              assertEquals(t,
198                           TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));                           NANOSECONDS.toSeconds(t*1000000000L));
199          }          }
200      }      }
201    
# Line 217  Line 206 
206      public void testToMinutes() {      public void testToMinutes() {
207          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
208              assertEquals(t*60*24,              assertEquals(t*60*24,
209                           TimeUnit.DAYS.toMinutes(t));                           DAYS.toMinutes(t));
210              assertEquals(t*60,              assertEquals(t*60,
211                           TimeUnit.HOURS.toMinutes(t));                           HOURS.toMinutes(t));
212              assertEquals(t,              assertEquals(t,
213                           TimeUnit.MINUTES.toMinutes(t));                           MINUTES.toMinutes(t));
214              assertEquals(t,              assertEquals(t,
215                           TimeUnit.SECONDS.toMinutes(t*60));                           SECONDS.toMinutes(t*60));
216              assertEquals(t,              assertEquals(t,
217                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));                           MILLISECONDS.toMinutes(t*1000L*60));
218              assertEquals(t,              assertEquals(t,
219                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));                           MICROSECONDS.toMinutes(t*1000000L*60));
220              assertEquals(t,              assertEquals(t,
221                           TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));                           NANOSECONDS.toMinutes(t*1000000000L*60));
222          }          }
223      }      }
224    
# Line 240  Line 229 
229      public void testToHours() {      public void testToHours() {
230          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
231              assertEquals(t*24,              assertEquals(t*24,
232                           TimeUnit.DAYS.toHours(t));                           DAYS.toHours(t));
233              assertEquals(t,              assertEquals(t,
234                           TimeUnit.HOURS.toHours(t));                           HOURS.toHours(t));
235              assertEquals(t,              assertEquals(t,
236                           TimeUnit.MINUTES.toHours(t*60));                           MINUTES.toHours(t*60));
237              assertEquals(t,              assertEquals(t,
238                           TimeUnit.SECONDS.toHours(t*60*60));                           SECONDS.toHours(t*60*60));
239              assertEquals(t,              assertEquals(t,
240                           TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));                           MILLISECONDS.toHours(t*1000L*60*60));
241              assertEquals(t,              assertEquals(t,
242                           TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));                           MICROSECONDS.toHours(t*1000000L*60*60));
243              assertEquals(t,              assertEquals(t,
244                           TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));                           NANOSECONDS.toHours(t*1000000000L*60*60));
245          }          }
246      }      }
247    
# Line 263  Line 252 
252      public void testToDays() {      public void testToDays() {
253          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
254              assertEquals(t,              assertEquals(t,
255                           TimeUnit.DAYS.toDays(t));                           DAYS.toDays(t));
256              assertEquals(t,              assertEquals(t,
257                           TimeUnit.HOURS.toDays(t*24));                           HOURS.toDays(t*24));
258              assertEquals(t,              assertEquals(t,
259                           TimeUnit.MINUTES.toDays(t*60*24));                           MINUTES.toDays(t*60*24));
260              assertEquals(t,              assertEquals(t,
261                           TimeUnit.SECONDS.toDays(t*60*60*24));                           SECONDS.toDays(t*60*60*24));
262              assertEquals(t,              assertEquals(t,
263                           TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));                           MILLISECONDS.toDays(t*1000L*60*60*24));
264              assertEquals(t,              assertEquals(t,
265                           TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));                           MICROSECONDS.toDays(t*1000000L*60*60*24));
266              assertEquals(t,              assertEquals(t,
267                           TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));                           NANOSECONDS.toDays(t*1000000000L*60*60*24));
268          }          }
269      }      }
270    
   
271      /**      /**
272       * convert saturates positive too-large values to Long.MAX_VALUE       * convert saturates positive too-large values to Long.MAX_VALUE
273       * and negative to LONG.MIN_VALUE       * and negative to LONG.MIN_VALUE
274       */       */
275      public void testConvertSaturate() {      public void testConvertSaturate() {
276          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
277                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
                                                   TimeUnit.SECONDS));  
278          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
279                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
                                                   TimeUnit.SECONDS));  
280          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
281                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
                                                   TimeUnit.MINUTES));  
282          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
283                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
                                                   TimeUnit.MINUTES));  
284          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
285                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
                                                   TimeUnit.HOURS));  
286          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
287                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
                                                   TimeUnit.HOURS));  
288          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
289                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
                                                   TimeUnit.DAYS));  
290          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
291                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
                                                   TimeUnit.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 318  Line 318 
318       */       */
319      public void testToNanosSaturate() {      public void testToNanosSaturate() {
320          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
321                       TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
323                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                       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 string containing common name of unit       * toString returns name of unit
468       */       */
469      public void testToString() {      public void testToString() {
470          String s = TimeUnit.SECONDS.toString();          assertEquals("SECONDS", SECONDS.toString());
         assertTrue(s.indexOf("ECOND") >= 0);  
471      }      }
472    
473        /**
474         * name returns name of unit
475         */
476        public void testName() {
477            assertEquals("SECONDS", SECONDS.name());
478        }
479    
480      /**      /**
481       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
482       *  IllegalMonitorStateException       *  IllegalMonitorStateException
483       */       */
484      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
485          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
486              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
487                  Object o = new Object();                  Object o = new Object();
488                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
489    
490                  try {                  try {
491                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
492                      threadShouldThrow();                      threadShouldThrow();
493                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
494                }});
495    
496          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
497      }      }
498    
499      /**      /**
500       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
501       */       */
502      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
503          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
504            Thread t = newStartedThread(new CheckedRunnable() {
505              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
506                  Object o = new Object();                  Object o = new Object();
507                    TimeUnit tu = MILLISECONDS;
508    
509                    Thread.currentThread().interrupt();
510                    try {
511                        synchronized (o) {
512                            tu.timedWait(o, LONG_DELAY_MS);
513                        }
514                        shouldThrow();
515                    } catch (InterruptedException success) {}
516                    assertFalse(Thread.interrupted());
517    
518                  TimeUnit tu = TimeUnit.MILLISECONDS;                  pleaseInterrupt.countDown();
519                    try {
520                  synchronized(o) {                  synchronized(o) {
521                      tu.timedWait(o,MEDIUM_DELAY_MS);                          tu.timedWait(o, LONG_DELAY_MS);
522                  }                  }
523                        shouldThrow();
524                    } catch (InterruptedException success) {}
525                    assertFalse(Thread.interrupted());
526              }});              }});
527          t.start();  
528          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
529            assertThreadBlocks(t, Thread.State.TIMED_WAITING);
530          t.interrupt();          t.interrupt();
531          t.join();          awaitTermination(t);
532      }      }
533    
   
534      /**      /**
535       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
536       */       */
537      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
538          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
539            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
540              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
541                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
542              }});              }});
543          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
544              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
545                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
546                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
547              }});;                  try {
548          s.start();                      tu.timedJoin(s, LONG_DELAY_MS);
549          t.start();                      shouldThrow();
550          Thread.sleep(SHORT_DELAY_MS);                  } catch (InterruptedException success) {}
551                    assertFalse(Thread.interrupted());
552    
553                    pleaseInterrupt.countDown();
554                    try {
555                        tu.timedJoin(s, LONG_DELAY_MS);
556                        shouldThrow();
557                    } catch (InterruptedException success) {}
558                    assertFalse(Thread.interrupted());
559                }});
560    
561            await(pleaseInterrupt);
562            assertThreadBlocks(t, Thread.State.TIMED_WAITING);
563          t.interrupt();          t.interrupt();
564          t.join();          awaitTermination(t);
565          s.interrupt();          s.interrupt();
566          s.join();          awaitTermination(s);
567      }      }
568    
569      /**      /**
570       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
571       */       */
572      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
573          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
574            Thread t = newStartedThread(new CheckedRunnable() {
575              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
576                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
577                  tu.sleep(MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
578                    try {
579                        tu.sleep(LONG_DELAY_MS);
580                        shouldThrow();
581                    } catch (InterruptedException success) {}
582                    assertFalse(Thread.interrupted());
583    
584                    pleaseInterrupt.countDown();
585                    try {
586                        tu.sleep(LONG_DELAY_MS);
587                        shouldThrow();
588                    } catch (InterruptedException success) {}
589                    assertFalse(Thread.interrupted());
590              }});              }});
591    
592          t.start();          await(pleaseInterrupt);
593          Thread.sleep(SHORT_DELAY_MS);          assertThreadBlocks(t, Thread.State.TIMED_WAITING);
594          t.interrupt();          t.interrupt();
595          t.join();          awaitTermination(t);
596      }      }
597    
598      /**      /**
599       * a deserialized serialized unit is the same instance       * a deserialized serialized unit is the same instance
600       */       */
601      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
602          TimeUnit q = TimeUnit.MILLISECONDS;          for (TimeUnit x : TimeUnit.values())
603                assertSame(x, serialClone(x));
         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);  
         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));  
         out.writeObject(q);  
         out.close();  
   
         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());  
         ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));  
         TimeUnit r = (TimeUnit)in.readObject();  
         assertSame(q, r);  
604      }      }
605    
606  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8