[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.5, Thu Sep 25 11:02:42 2003 UTC revision 1.14, Sat Nov 21 02:07:27 2009 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
# Line 19  Line 20 
20          return new TestSuite(TimeUnitTest.class);          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       * convert correctly converts sample values across the units
27       */       */
28      public void testConvert() {      public void testConvert() {
29          for (long t = 0; t < 10; ++t) {          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,              assertEquals(t,
40                           TimeUnit.SECONDS.convert(t,                           TimeUnit.SECONDS.convert(t,
41                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
42              assertEquals(t,              assertEquals(t,
43                           TimeUnit.SECONDS.convert(1000 * t,                           TimeUnit.SECONDS.convert(1000L*t,
44                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
45              assertEquals(t,              assertEquals(t,
46                           TimeUnit.SECONDS.convert(1000000 * t,                           TimeUnit.SECONDS.convert(1000000L*t,
47                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
48              assertEquals(t,              assertEquals(t,
49                           TimeUnit.SECONDS.convert(1000000000 * t,                           TimeUnit.SECONDS.convert(1000000000L*t,
50                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
51              assertEquals(1000 * t,  
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,                           TimeUnit.MILLISECONDS.convert(t,
64                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
65              assertEquals(t,              assertEquals(t,
66                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
67                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
68              assertEquals(t,              assertEquals(t,
69                           TimeUnit.MILLISECONDS.convert(1000 * t,                           TimeUnit.MILLISECONDS.convert(1000L*t,
70                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
71              assertEquals(t,              assertEquals(t,
72                           TimeUnit.MILLISECONDS.convert(1000000 * t,                           TimeUnit.MILLISECONDS.convert(1000000L*t,
73                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
74              assertEquals(1000000 * t,  
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,                           TimeUnit.MICROSECONDS.convert(t,
86                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
87              assertEquals(1000 * t,              assertEquals(1000L*t,
88                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
89                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
90              assertEquals(t,              assertEquals(t,
91                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
92                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
93              assertEquals(t,              assertEquals(t,
94                           TimeUnit.MICROSECONDS.convert(1000 * t,                           TimeUnit.MICROSECONDS.convert(1000L*t,
95                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
96              assertEquals(1000000000 * t,  
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,                           TimeUnit.NANOSECONDS.convert(t,
108                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
109              assertEquals(1000000 * t,              assertEquals(1000000L*t,
110                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
111                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
112              assertEquals(1000 * t,              assertEquals(1000L*t,
113                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
114                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
115              assertEquals(t,              assertEquals(t,
# Line 80  Line 123 
123       * nanoseconds       * nanoseconds
124       */       */
125      public void testToNanos() {      public void testToNanos() {
126          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
127              assertEquals(1000000000 * t,              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));                           TimeUnit.SECONDS.toNanos(t));
135                assertEquals(1000000L*t,
             assertEquals(1000000 * t,  
136                           TimeUnit.MILLISECONDS.toNanos(t));                           TimeUnit.MILLISECONDS.toNanos(t));
137              assertEquals(1000 * t,              assertEquals(1000L*t,
138                           TimeUnit.MICROSECONDS.toNanos(t));                           TimeUnit.MICROSECONDS.toNanos(t));
139              assertEquals(t,              assertEquals(t,
140                           TimeUnit.NANOSECONDS.toNanos(t));                           TimeUnit.NANOSECONDS.toNanos(t));
# Line 98  Line 146 
146       * microseconds       * microseconds
147       */       */
148      public void testToMicros() {      public void testToMicros() {
149          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
150              assertEquals(1000000 * t,              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));                           TimeUnit.SECONDS.toMicros(t));
158                assertEquals(1000L*t,
             assertEquals(1000 * t,  
159                           TimeUnit.MILLISECONDS.toMicros(t));                           TimeUnit.MILLISECONDS.toMicros(t));
160              assertEquals(t,              assertEquals(t,
161                           TimeUnit.MICROSECONDS.toMicros(t));                           TimeUnit.MICROSECONDS.toMicros(t));
162              assertEquals(t,              assertEquals(t,
163                           TimeUnit.NANOSECONDS.toMicros(t * 1000));                           TimeUnit.NANOSECONDS.toMicros(t*1000L));
164          }          }
165      }      }
166    
# Line 116  Line 169 
169       * milliseconds       * milliseconds
170       */       */
171      public void testToMillis() {      public void testToMillis() {
172          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
173              assertEquals(1000 * t,              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));                           TimeUnit.SECONDS.toMillis(t));
   
181              assertEquals(t,              assertEquals(t,
182                           TimeUnit.MILLISECONDS.toMillis(t));                           TimeUnit.MILLISECONDS.toMillis(t));
183              assertEquals(t,              assertEquals(t,
184                           TimeUnit.MICROSECONDS.toMillis(t * 1000));                           TimeUnit.MICROSECONDS.toMillis(t*1000L));
185              assertEquals(t,              assertEquals(t,
186                           TimeUnit.NANOSECONDS.toMillis(t * 1000000));                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187          }          }
188      }      }
189    
# Line 134  Line 192 
192       * seconds       * seconds
193       */       */
194      public void testToSeconds() {      public void testToSeconds() {
195          for (long t = 0; t < 10; ++t) {          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,              assertEquals(t,
203                           TimeUnit.SECONDS.toSeconds(t));                           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        /**
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,              assertEquals(t,
272                           TimeUnit.MILLISECONDS.toSeconds(t * 1000));                           TimeUnit.SECONDS.toDays(t*60*60*24));
273              assertEquals(t,              assertEquals(t,
274                           TimeUnit.MICROSECONDS.toSeconds(t * 1000000));                           TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275              assertEquals(t,              assertEquals(t,
276                           TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));                           TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277                assertEquals(t,
278                             TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279          }          }
280      }      }
281    
# Line 159  Line 291 
291          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
292                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293                                                    TimeUnit.SECONDS));                                                    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      /**      /**
# Line 174  Line 325 
325    
326    
327      /**      /**
328       * toString returns string containing commn name of unit       * toString returns string containing common name of unit
329       */       */
330      public void testToString() {      public void testToString() {
331          String s = TimeUnit.SECONDS.toString();          String s = TimeUnit.SECONDS.toString();
332          assertTrue(s.indexOf("econd") >= 0);          assertTrue(s.indexOf("ECOND") >= 0);
333      }      }
334    
335    
# Line 186  Line 337 
337       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
338       *  IllegalMonitorStateException       *  IllegalMonitorStateException
339       */       */
340      public void testTimedWait_IllegalMonitorException() {      public void testTimedWait_IllegalMonitorException() throws Exception {
341          //created a new thread with anonymous runnable          Thread t = new Thread(new CheckedRunnable() {
342                public void realRun() throws InterruptedException {
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
343                      Object o = new Object();                      Object o = new Object();
344                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
345                      try {                      try {
346                          tu.timedWait(o,LONG_DELAY_MS);                          tu.timedWait(o,LONG_DELAY_MS);
347                          threadShouldThrow();                          threadShouldThrow();
348                      }                  } catch (IllegalMonitorStateException success) {}}});
                     catch (InterruptedException ie) {  
                         threadUnexpectedException();  
                     }  
                     catch(IllegalMonitorStateException success) {  
                     }  
349    
                 }  
             });  
350          t.start();          t.start();
         try {  
351              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
352              t.interrupt();              t.interrupt();
353              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
354      }      }
355    
356      /**      /**
357       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
358       */       */
359      public void testTimedWait() {      public void testTimedWait() throws InterruptedException {
360          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
361                  public void run() {              public void realRun() throws InterruptedException {
362                      Object o = new Object();                      Object o = new Object();
363    
364                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
                     try {  
365                          synchronized(o) {                          synchronized(o) {
366                              tu.timedWait(o,MEDIUM_DELAY_MS);                              tu.timedWait(o,MEDIUM_DELAY_MS);
367                          }                          }
368                          threadShouldThrow();              }});
                     }  
                     catch(InterruptedException success) {}  
                     catch(IllegalMonitorStateException failure) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
369          t.start();          t.start();
         try {  
370              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
371              t.interrupt();              t.interrupt();
372              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
373      }      }
374    
375    
376      /**      /**
377       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
378       */       */
379      public void testTimedJoin() {      public void testTimedJoin() throws InterruptedException {
380          Thread t = new Thread(new Runnable() {          final Thread s = new Thread(new CheckedInterruptedRunnable() {
381                  public void run() {              public void realRun() throws InterruptedException {
                     TimeUnit tu = TimeUnit.MILLISECONDS;  
                     try {  
                         Thread s = new Thread(new Runnable() {  
                                 public void run() {  
                                     try {  
382                                          Thread.sleep(MEDIUM_DELAY_MS);                                          Thread.sleep(MEDIUM_DELAY_MS);
383                                      } catch(InterruptedException success){}              }});
384                                  }          final Thread t = new Thread(new CheckedInterruptedRunnable() {
385                              });              public void realRun() throws InterruptedException {
386                          s.start();                  TimeUnit tu = TimeUnit.MILLISECONDS;
387                          tu.timedJoin(s,MEDIUM_DELAY_MS);                          tu.timedJoin(s,MEDIUM_DELAY_MS);
388                          threadShouldThrow();              }});;
389                      }          s.start();
                     catch(Exception e) {}  
                 }  
             });  
390          t.start();          t.start();
         try {  
391              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
392              t.interrupt();              t.interrupt();
393              t.join();              t.join();
394          } catch(Exception e) {          s.interrupt();
395              unexpectedException();          s.join();
         }  
396      }      }
397    
398      /**      /**
399       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
400       */       */
401      public void testTimedSleep() {      public void testTimedSleep() throws InterruptedException {
402          //created a new thread with anonymous runnable          Thread t = new Thread(new CheckedInterruptedRunnable() {
403                public void realRun() throws InterruptedException {
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
404                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
                     try {  
405                          tu.sleep(MEDIUM_DELAY_MS);                          tu.sleep(MEDIUM_DELAY_MS);
406                          threadShouldThrow();              }});
407                      }  
                     catch(InterruptedException success) {}  
                 }  
             });  
408          t.start();          t.start();
         try {  
409              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
410              t.interrupt();              t.interrupt();
411              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
412      }      }
413    
414      /**      /**
415       * a deserialized serialized unit is equal       * a deserialized serialized unit is the same instance
416       */       */
417      public void testSerialization() {      public void testSerialization() throws Exception {
418          TimeUnit q = TimeUnit.MILLISECONDS;          TimeUnit q = TimeUnit.MILLISECONDS;
419    
         try {  
420              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
421              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
422              out.writeObject(q);              out.writeObject(q);
# Line 320  Line 425 
425              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
426              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
427              TimeUnit r = (TimeUnit)in.readObject();              TimeUnit r = (TimeUnit)in.readObject();
428            assertSame(q, r);
             assertEquals(q.toString(), r.toString());  
         } catch(Exception e){  
             e.printStackTrace();  
             unexpectedException();  
         }  
429      }      }
430    
431  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8