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

Comparing jsr166/src/test/tck/TimeUnitTest.java (file contents):
Revision 1.8 by dl, Tue Jan 13 12:59:29 2004 UTC vs.
Revision 1.12 by jsr166, Mon Nov 16 05:30:08 2009 UTC

# Line 2 | Line 2
2   * 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   * http://creativecommons.org/licenses/publicdomain
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9  
# Line 13 | Line 13 | import java.io.*;
13  
14   public class TimeUnitTest extends JSR166TestCase {
15      public static void main(String[] args) {
16 <        junit.textui.TestRunner.run(suite());  
16 >        junit.textui.TestRunner.run(suite());
17      }
18 <    
18 >
19      public static Test suite() {
20          return new TestSuite(TimeUnitTest.class);
21      }
22  
23 +    // (loops to 88888 check increments at all time divisions.)
24 +
25      /**
26 <     * convert correctly converts sample values across the four units
26 >     * convert correctly converts sample values across the units
27       */
28      public void testConvert() {
29 <        for (long t = 0; t < 10; ++t) {
30 <            assertEquals(t,
31 <                         TimeUnit.SECONDS.convert(t,
29 >        for (long t = 0; t < 88888; ++t) {
30 >            assertEquals(t*60*60*24,
31 >                         TimeUnit.SECONDS.convert(t,
32 >                                                  TimeUnit.DAYS));
33 >            assertEquals(t*60*60,
34 >                         TimeUnit.SECONDS.convert(t,
35 >                                                  TimeUnit.HOURS));
36 >            assertEquals(t*60,
37 >                         TimeUnit.SECONDS.convert(t,
38 >                                                  TimeUnit.MINUTES));
39 >            assertEquals(t,
40 >                         TimeUnit.SECONDS.convert(t,
41                                                    TimeUnit.SECONDS));
42 <            assertEquals(t,
43 <                         TimeUnit.SECONDS.convert(1000 * t,
42 >            assertEquals(t,
43 >                         TimeUnit.SECONDS.convert(1000L*t,
44                                                    TimeUnit.MILLISECONDS));
45 <            assertEquals(t,
46 <                         TimeUnit.SECONDS.convert(1000000 * t,
45 >            assertEquals(t,
46 >                         TimeUnit.SECONDS.convert(1000000L*t,
47                                                    TimeUnit.MICROSECONDS));
48 <            assertEquals(t,
49 <                         TimeUnit.SECONDS.convert(1000000000 * t,
48 >            assertEquals(t,
49 >                         TimeUnit.SECONDS.convert(1000000000L*t,
50                                                    TimeUnit.NANOSECONDS));
51 <            assertEquals(1000 * t,
52 <                         TimeUnit.MILLISECONDS.convert(t,
51 >
52 >
53 >            assertEquals(1000L*t*60*60*24,
54 >                         TimeUnit.MILLISECONDS.convert(t,
55 >                                                  TimeUnit.DAYS));
56 >            assertEquals(1000L*t*60*60,
57 >                         TimeUnit.MILLISECONDS.convert(t,
58 >                                                  TimeUnit.HOURS));
59 >            assertEquals(1000L*t*60,
60 >                         TimeUnit.MILLISECONDS.convert(t,
61 >                                                  TimeUnit.MINUTES));
62 >            assertEquals(1000L*t,
63 >                         TimeUnit.MILLISECONDS.convert(t,
64                                                    TimeUnit.SECONDS));
65 <            assertEquals(t,
66 <                         TimeUnit.MILLISECONDS.convert(t,
65 >            assertEquals(t,
66 >                         TimeUnit.MILLISECONDS.convert(t,
67                                                    TimeUnit.MILLISECONDS));
68 <            assertEquals(t,
69 <                         TimeUnit.MILLISECONDS.convert(1000 * t,
68 >            assertEquals(t,
69 >                         TimeUnit.MILLISECONDS.convert(1000L*t,
70                                                    TimeUnit.MICROSECONDS));
71 <            assertEquals(t,
72 <                         TimeUnit.MILLISECONDS.convert(1000000 * t,
71 >            assertEquals(t,
72 >                         TimeUnit.MILLISECONDS.convert(1000000L*t,
73                                                    TimeUnit.NANOSECONDS));
74 <            assertEquals(1000000 * t,
75 <                         TimeUnit.MICROSECONDS.convert(t,
74 >
75 >            assertEquals(1000000L*t*60*60*24,
76 >                         TimeUnit.MICROSECONDS.convert(t,
77 >                                                  TimeUnit.DAYS));
78 >            assertEquals(1000000L*t*60*60,
79 >                         TimeUnit.MICROSECONDS.convert(t,
80 >                                                  TimeUnit.HOURS));
81 >            assertEquals(1000000L*t*60,
82 >                         TimeUnit.MICROSECONDS.convert(t,
83 >                                                  TimeUnit.MINUTES));
84 >            assertEquals(1000000L*t,
85 >                         TimeUnit.MICROSECONDS.convert(t,
86                                                    TimeUnit.SECONDS));
87 <            assertEquals(1000 * t,
88 <                         TimeUnit.MICROSECONDS.convert(t,
87 >            assertEquals(1000L*t,
88 >                         TimeUnit.MICROSECONDS.convert(t,
89                                                    TimeUnit.MILLISECONDS));
90 <            assertEquals(t,
91 <                         TimeUnit.MICROSECONDS.convert(t,
90 >            assertEquals(t,
91 >                         TimeUnit.MICROSECONDS.convert(t,
92                                                    TimeUnit.MICROSECONDS));
93 <            assertEquals(t,
94 <                         TimeUnit.MICROSECONDS.convert(1000 * t,
93 >            assertEquals(t,
94 >                         TimeUnit.MICROSECONDS.convert(1000L*t,
95                                                    TimeUnit.NANOSECONDS));
96 <            assertEquals(1000000000 * t,
97 <                         TimeUnit.NANOSECONDS.convert(t,
96 >
97 >            assertEquals(1000000000L*t*60*60*24,
98 >                         TimeUnit.NANOSECONDS.convert(t,
99 >                                                  TimeUnit.DAYS));
100 >            assertEquals(1000000000L*t*60*60,
101 >                         TimeUnit.NANOSECONDS.convert(t,
102 >                                                  TimeUnit.HOURS));
103 >            assertEquals(1000000000L*t*60,
104 >                         TimeUnit.NANOSECONDS.convert(t,
105 >                                                  TimeUnit.MINUTES));
106 >            assertEquals(1000000000L*t,
107 >                         TimeUnit.NANOSECONDS.convert(t,
108                                                    TimeUnit.SECONDS));
109 <            assertEquals(1000000 * t,
110 <                         TimeUnit.NANOSECONDS.convert(t,
109 >            assertEquals(1000000L*t,
110 >                         TimeUnit.NANOSECONDS.convert(t,
111                                                    TimeUnit.MILLISECONDS));
112 <            assertEquals(1000 * t,
113 <                         TimeUnit.NANOSECONDS.convert(t,
112 >            assertEquals(1000L*t,
113 >                         TimeUnit.NANOSECONDS.convert(t,
114                                                    TimeUnit.MICROSECONDS));
115 <            assertEquals(t,
116 <                         TimeUnit.NANOSECONDS.convert(t,
115 >            assertEquals(t,
116 >                         TimeUnit.NANOSECONDS.convert(t,
117                                                    TimeUnit.NANOSECONDS));
118          }
119      }
# Line 81 | Line 123 | public class TimeUnitTest extends JSR166
123       * nanoseconds
124       */
125      public void testToNanos() {
126 <        for (long t = 0; t < 10; ++t) {
127 <            assertEquals(1000000000 * t,
126 >        for (long t = 0; t < 88888; ++t) {
127 >            assertEquals(t*1000000000L*60*60*24,
128 >                         TimeUnit.DAYS.toNanos(t));
129 >            assertEquals(t*1000000000L*60*60,
130 >                         TimeUnit.HOURS.toNanos(t));
131 >            assertEquals(t*1000000000L*60,
132 >                         TimeUnit.MINUTES.toNanos(t));
133 >            assertEquals(1000000000L*t,
134                           TimeUnit.SECONDS.toNanos(t));
135 <
88 <            assertEquals(1000000 * t,
135 >            assertEquals(1000000L*t,
136                           TimeUnit.MILLISECONDS.toNanos(t));
137 <            assertEquals(1000 * t,
137 >            assertEquals(1000L*t,
138                           TimeUnit.MICROSECONDS.toNanos(t));
139 <            assertEquals(t,
139 >            assertEquals(t,
140                           TimeUnit.NANOSECONDS.toNanos(t));
141          }
142      }
# Line 99 | Line 146 | public class TimeUnitTest extends JSR166
146       * microseconds
147       */
148      public void testToMicros() {
149 <        for (long t = 0; t < 10; ++t) {
150 <            assertEquals(1000000 * t,
149 >        for (long t = 0; t < 88888; ++t) {
150 >            assertEquals(t*1000000L*60*60*24,
151 >                         TimeUnit.DAYS.toMicros(t));
152 >            assertEquals(t*1000000L*60*60,
153 >                         TimeUnit.HOURS.toMicros(t));
154 >            assertEquals(t*1000000L*60,
155 >                         TimeUnit.MINUTES.toMicros(t));
156 >            assertEquals(1000000L*t,
157                           TimeUnit.SECONDS.toMicros(t));
158 <
106 <            assertEquals(1000 * t,
158 >            assertEquals(1000L*t,
159                           TimeUnit.MILLISECONDS.toMicros(t));
160 <            assertEquals(t,
160 >            assertEquals(t,
161                           TimeUnit.MICROSECONDS.toMicros(t));
162 <            assertEquals(t,
163 <                         TimeUnit.NANOSECONDS.toMicros(t * 1000));
162 >            assertEquals(t,
163 >                         TimeUnit.NANOSECONDS.toMicros(t*1000L));
164          }
165      }
166  
# Line 117 | Line 169 | public class TimeUnitTest extends JSR166
169       * milliseconds
170       */
171      public void testToMillis() {
172 <        for (long t = 0; t < 10; ++t) {
173 <            assertEquals(1000 * t,
172 >        for (long t = 0; t < 88888; ++t) {
173 >            assertEquals(t*1000L*60*60*24,
174 >                         TimeUnit.DAYS.toMillis(t));
175 >            assertEquals(t*1000L*60*60,
176 >                         TimeUnit.HOURS.toMillis(t));
177 >            assertEquals(t*1000L*60,
178 >                         TimeUnit.MINUTES.toMillis(t));
179 >            assertEquals(1000L*t,
180                           TimeUnit.SECONDS.toMillis(t));
181 <
124 <            assertEquals(t,
181 >            assertEquals(t,
182                           TimeUnit.MILLISECONDS.toMillis(t));
183 <            assertEquals(t,
184 <                         TimeUnit.MICROSECONDS.toMillis(t * 1000));
185 <            assertEquals(t,
186 <                         TimeUnit.NANOSECONDS.toMillis(t * 1000000));
183 >            assertEquals(t,
184 >                         TimeUnit.MICROSECONDS.toMillis(t*1000L));
185 >            assertEquals(t,
186 >                         TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187          }
188      }
189  
# Line 135 | Line 192 | public class TimeUnitTest extends JSR166
192       * seconds
193       */
194      public void testToSeconds() {
195 <        for (long t = 0; t < 10; ++t) {
196 <            assertEquals(t,
195 >        for (long t = 0; t < 88888; ++t) {
196 >            assertEquals(t*60*60*24,
197 >                         TimeUnit.DAYS.toSeconds(t));
198 >            assertEquals(t*60*60,
199 >                         TimeUnit.HOURS.toSeconds(t));
200 >            assertEquals(t*60,
201 >                         TimeUnit.MINUTES.toSeconds(t));
202 >            assertEquals(t,
203                           TimeUnit.SECONDS.toSeconds(t));
204 +            assertEquals(t,
205 +                         TimeUnit.MILLISECONDS.toSeconds(t*1000L));
206 +            assertEquals(t,
207 +                         TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
208 +            assertEquals(t,
209 +                         TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
210 +        }
211 +    }
212  
213 <            assertEquals(t,
214 <                         TimeUnit.MILLISECONDS.toSeconds(t * 1000));
215 <            assertEquals(t,
216 <                         TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
217 <            assertEquals(t,
218 <                         TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
213 >    /**
214 >     * toMinutes correctly converts sample values in different units to
215 >     * minutes
216 >     */
217 >    public void testToMinutes() {
218 >        for (long t = 0; t < 88888; ++t) {
219 >            assertEquals(t*60*24,
220 >                         TimeUnit.DAYS.toMinutes(t));
221 >            assertEquals(t*60,
222 >                         TimeUnit.HOURS.toMinutes(t));
223 >            assertEquals(t,
224 >                         TimeUnit.MINUTES.toMinutes(t));
225 >            assertEquals(t,
226 >                         TimeUnit.SECONDS.toMinutes(t*60));
227 >            assertEquals(t,
228 >                         TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
229 >            assertEquals(t,
230 >                         TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
231 >            assertEquals(t,
232 >                         TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
233 >        }
234 >    }
235 >
236 >    /**
237 >     * toHours correctly converts sample values in different units to
238 >     * hours
239 >     */
240 >    public void testToHours() {
241 >        for (long t = 0; t < 88888; ++t) {
242 >            assertEquals(t*24,
243 >                         TimeUnit.DAYS.toHours(t));
244 >            assertEquals(t,
245 >                         TimeUnit.HOURS.toHours(t));
246 >            assertEquals(t,
247 >                         TimeUnit.MINUTES.toHours(t*60));
248 >            assertEquals(t,
249 >                         TimeUnit.SECONDS.toHours(t*60*60));
250 >            assertEquals(t,
251 >                         TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
252 >            assertEquals(t,
253 >                         TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
254 >            assertEquals(t,
255 >                         TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
256 >        }
257 >    }
258 >
259 >    /**
260 >     * toDays correctly converts sample values in different units to
261 >     * days
262 >     */
263 >    public void testToDays() {
264 >        for (long t = 0; t < 88888; ++t) {
265 >            assertEquals(t,
266 >                         TimeUnit.DAYS.toDays(t));
267 >            assertEquals(t,
268 >                         TimeUnit.HOURS.toDays(t*24));
269 >            assertEquals(t,
270 >                         TimeUnit.MINUTES.toDays(t*60*24));
271 >            assertEquals(t,
272 >                         TimeUnit.SECONDS.toDays(t*60*60*24));
273 >            assertEquals(t,
274 >                         TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275 >            assertEquals(t,
276 >                         TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277 >            assertEquals(t,
278 >                         TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279          }
280      }
281  
282  
283      /**
284 <     * convert saturates positive too-large values to Long.MAX_VALUE
284 >     * convert saturates positive too-large values to Long.MAX_VALUE
285       * and negative to LONG.MIN_VALUE
286       */
287      public void testConvertSaturate() {
# Line 160 | Line 291 | public class TimeUnitTest extends JSR166
291          assertEquals(Long.MIN_VALUE,
292                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293                                                    TimeUnit.SECONDS));
294 +        assertEquals(Long.MAX_VALUE,
295 +                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
296 +                                                  TimeUnit.MINUTES));
297 +        assertEquals(Long.MIN_VALUE,
298 +                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
299 +                                                  TimeUnit.MINUTES));
300 +        assertEquals(Long.MAX_VALUE,
301 +                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
302 +                                                  TimeUnit.HOURS));
303 +        assertEquals(Long.MIN_VALUE,
304 +                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
305 +                                                  TimeUnit.HOURS));
306 +        assertEquals(Long.MAX_VALUE,
307 +                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
308 +                                                  TimeUnit.DAYS));
309 +        assertEquals(Long.MIN_VALUE,
310 +                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
311 +                                                  TimeUnit.DAYS));
312 +
313      }
314  
315      /**
316 <     * toNanos saturates positive too-large values to Long.MAX_VALUE
316 >     * toNanos saturates positive too-large values to Long.MAX_VALUE
317       * and negative to LONG.MIN_VALUE
318       */
319      public void testToNanosSaturate() {
# Line 182 | Line 332 | public class TimeUnitTest extends JSR166
332          assertTrue(s.indexOf("ECOND") >= 0);
333      }
334  
335 <    
335 >
336      /**
337       *  Timed wait without holding lock throws
338       *  IllegalMonitorStateException
# Line 200 | Line 350 | public class TimeUnitTest extends JSR166
350                      }
351                      catch (InterruptedException ie) {
352                          threadUnexpectedException();
203 –                    }
204 –                    catch(IllegalMonitorStateException success) {
353                      }
354 <                    
354 >                    catch (IllegalMonitorStateException success) {
355 >                    }
356 >
357                  }
358              });
359          t.start();
# Line 211 | Line 361 | public class TimeUnitTest extends JSR166
361              Thread.sleep(SHORT_DELAY_MS);
362              t.interrupt();
363              t.join();
364 <        } catch(Exception e) {
364 >        } catch (Exception e) {
365              unexpectedException();
366          }
367      }
368 <    
368 >
369      /**
370       * timedWait throws InterruptedException when interrupted
371       */
# Line 223 | Line 373 | public class TimeUnitTest extends JSR166
373          Thread t = new Thread(new Runnable() {
374                  public void run() {
375                      Object o = new Object();
376 <                    
376 >
377                      TimeUnit tu = TimeUnit.MILLISECONDS;
378                      try {
379                          synchronized(o) {
# Line 231 | Line 381 | public class TimeUnitTest extends JSR166
381                          }
382                          threadShouldThrow();
383                      }
384 <                    catch(InterruptedException success) {}
385 <                    catch(IllegalMonitorStateException failure) {
384 >                    catch (InterruptedException success) {}
385 >                    catch (IllegalMonitorStateException failure) {
386                          threadUnexpectedException();
387                      }
388                  }
# Line 242 | Line 392 | public class TimeUnitTest extends JSR166
392              Thread.sleep(SHORT_DELAY_MS);
393              t.interrupt();
394              t.join();
395 <        } catch(Exception e) {
395 >        } catch (Exception e) {
396              unexpectedException();
397          }
398      }
399 <    
400 <    
399 >
400 >
401      /**
402       * timedJoin throws InterruptedException when interrupted
403       */
404      public void testTimedJoin() {
405          Thread t = new Thread(new Runnable() {
406                  public void run() {
407 <                    TimeUnit tu = TimeUnit.MILLISECONDS;        
407 >                    TimeUnit tu = TimeUnit.MILLISECONDS;
408                      try {
409                          Thread s = new Thread(new Runnable() {
410                                  public void run() {
411                                      try {
412                                          Thread.sleep(MEDIUM_DELAY_MS);
413 <                                    } catch(InterruptedException success){}
413 >                                    } catch (InterruptedException success) {}
414                                  }
415                              });
416                          s.start();
417                          tu.timedJoin(s,MEDIUM_DELAY_MS);
418                          threadShouldThrow();
419                      }
420 <                    catch(Exception e) {}
420 >                    catch (Exception e) {}
421                  }
422              });
423          t.start();
# Line 275 | Line 425 | public class TimeUnitTest extends JSR166
425              Thread.sleep(SHORT_DELAY_MS);
426              t.interrupt();
427              t.join();
428 <        } catch(Exception e) {
428 >        } catch (Exception e) {
429              unexpectedException();
430          }
431      }
432 <    
432 >
433      /**
434       *  timedSleep throws InterruptedException when interrupted
435       */
# Line 293 | Line 443 | public class TimeUnitTest extends JSR166
443                          tu.sleep(MEDIUM_DELAY_MS);
444                          threadShouldThrow();
445                      }
446 <                    catch(InterruptedException success) {}
446 >                    catch (InterruptedException success) {}
447                  }
448              });
449          t.start();
# Line 301 | Line 451 | public class TimeUnitTest extends JSR166
451              Thread.sleep(SHORT_DELAY_MS);
452              t.interrupt();
453              t.join();
454 <        } catch(Exception e) {
454 >        } catch (Exception e) {
455              unexpectedException();
456          }
457      }
458  
459      /**
460 <     * a deserialized serialized unit is equal
460 >     * a deserialized serialized unit is equal
461       */
462      public void testSerialization() {
463          TimeUnit q = TimeUnit.MILLISECONDS;
# Line 321 | Line 471 | public class TimeUnitTest extends JSR166
471              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
472              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
473              TimeUnit r = (TimeUnit)in.readObject();
474 <            
474 >
475              assertEquals(q.toString(), r.toString());
476 <        } catch(Exception e){
476 >        } catch (Exception e) {
477              e.printStackTrace();
478              unexpectedException();
479          }

Diff Legend

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