[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.27, Sat Jan 30 22:24:32 2016 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
9    import static java.util.concurrent.TimeUnit.DAYS;
10    import static java.util.concurrent.TimeUnit.HOURS;
11    import static java.util.concurrent.TimeUnit.MICROSECONDS;
12    import static java.util.concurrent.TimeUnit.MILLISECONDS;
13    import static java.util.concurrent.TimeUnit.MINUTES;
14    import static java.util.concurrent.TimeUnit.NANOSECONDS;
15    import static java.util.concurrent.TimeUnit.SECONDS;
16    
17    import java.time.temporal.ChronoUnit;
18    import java.util.concurrent.CountDownLatch;
19    import java.util.concurrent.TimeUnit;
20    
21  import junit.framework.*;  import junit.framework.Test;
22  import java.util.concurrent.*;  import junit.framework.TestSuite;
 import java.io.*;  
23    
24  public class TimeUnitTest extends JSR166TestCase {  public class TimeUnitTest extends JSR166TestCase {
25      public static void main(String[] args) {      public static void main(String[] args) {
26          junit.textui.TestRunner.run(suite());          main(suite(), args);
27      }      }
28    
29      public static Test suite() {      public static Test suite() {
# Line 28  Line 38 
38      public void testConvert() {      public void testConvert() {
39          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
40              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
41                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
42              assertEquals(t*60*60,              assertEquals(t*60*60,
43                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
44              assertEquals(t*60,              assertEquals(t*60,
45                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
46              assertEquals(t,              assertEquals(t,
47                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
48              assertEquals(t,              assertEquals(t,
49                           TimeUnit.SECONDS.convert(1000L*t,                           SECONDS.convert(1000L*t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
50              assertEquals(t,              assertEquals(t,
51                           TimeUnit.SECONDS.convert(1000000L*t,                           SECONDS.convert(1000000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
52              assertEquals(t,              assertEquals(t,
53                           TimeUnit.SECONDS.convert(1000000000L*t,                           SECONDS.convert(1000000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
   
54    
55              assertEquals(1000L*t*60*60*24,              assertEquals(1000L*t*60*60*24,
56                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
57              assertEquals(1000L*t*60*60,              assertEquals(1000L*t*60*60,
58                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
59              assertEquals(1000L*t*60,              assertEquals(1000L*t*60,
60                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
61              assertEquals(1000L*t,              assertEquals(1000L*t,
62                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
63              assertEquals(t,              assertEquals(t,
64                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
65              assertEquals(t,              assertEquals(t,
66                           TimeUnit.MILLISECONDS.convert(1000L*t,                           MILLISECONDS.convert(1000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
67              assertEquals(t,              assertEquals(t,
68                           TimeUnit.MILLISECONDS.convert(1000000L*t,                           MILLISECONDS.convert(1000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
69    
70              assertEquals(1000000L*t*60*60*24,              assertEquals(1000000L*t*60*60*24,
71                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
72              assertEquals(1000000L*t*60*60,              assertEquals(1000000L*t*60*60,
73                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
74              assertEquals(1000000L*t*60,              assertEquals(1000000L*t*60,
75                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
76              assertEquals(1000000L*t,              assertEquals(1000000L*t,
77                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
78              assertEquals(1000L*t,              assertEquals(1000L*t,
79                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
80              assertEquals(t,              assertEquals(t,
81                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
82              assertEquals(t,              assertEquals(t,
83                           TimeUnit.MICROSECONDS.convert(1000L*t,                           MICROSECONDS.convert(1000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
84    
85              assertEquals(1000000000L*t*60*60*24,              assertEquals(1000000000L*t*60*60*24,
86                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
87              assertEquals(1000000000L*t*60*60,              assertEquals(1000000000L*t*60*60,
88                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
89              assertEquals(1000000000L*t*60,              assertEquals(1000000000L*t*60,
90                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
91              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
92                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
93              assertEquals(1000000L*t,              assertEquals(1000000L*t,
94                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
95              assertEquals(1000L*t,              assertEquals(1000L*t,
96                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
97              assertEquals(t,              assertEquals(t,
98                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
99          }          }
100      }      }
101    
# Line 125  Line 106 
106      public void testToNanos() {      public void testToNanos() {
107          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
108              assertEquals(t*1000000000L*60*60*24,              assertEquals(t*1000000000L*60*60*24,
109                           TimeUnit.DAYS.toNanos(t));                           DAYS.toNanos(t));
110              assertEquals(t*1000000000L*60*60,              assertEquals(t*1000000000L*60*60,
111                           TimeUnit.HOURS.toNanos(t));                           HOURS.toNanos(t));
112              assertEquals(t*1000000000L*60,              assertEquals(t*1000000000L*60,
113                           TimeUnit.MINUTES.toNanos(t));                           MINUTES.toNanos(t));
114              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
115                           TimeUnit.SECONDS.toNanos(t));                           SECONDS.toNanos(t));
116              assertEquals(1000000L*t,              assertEquals(1000000L*t,
117                           TimeUnit.MILLISECONDS.toNanos(t));                           MILLISECONDS.toNanos(t));
118              assertEquals(1000L*t,              assertEquals(1000L*t,
119                           TimeUnit.MICROSECONDS.toNanos(t));                           MICROSECONDS.toNanos(t));
120              assertEquals(t,              assertEquals(t,
121                           TimeUnit.NANOSECONDS.toNanos(t));                           NANOSECONDS.toNanos(t));
122          }          }
123      }      }
124    
# Line 148  Line 129 
129      public void testToMicros() {      public void testToMicros() {
130          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
131              assertEquals(t*1000000L*60*60*24,              assertEquals(t*1000000L*60*60*24,
132                           TimeUnit.DAYS.toMicros(t));                           DAYS.toMicros(t));
133              assertEquals(t*1000000L*60*60,              assertEquals(t*1000000L*60*60,
134                           TimeUnit.HOURS.toMicros(t));                           HOURS.toMicros(t));
135              assertEquals(t*1000000L*60,              assertEquals(t*1000000L*60,
136                           TimeUnit.MINUTES.toMicros(t));                           MINUTES.toMicros(t));
137              assertEquals(1000000L*t,              assertEquals(1000000L*t,
138                           TimeUnit.SECONDS.toMicros(t));                           SECONDS.toMicros(t));
139              assertEquals(1000L*t,              assertEquals(1000L*t,
140                           TimeUnit.MILLISECONDS.toMicros(t));                           MILLISECONDS.toMicros(t));
141              assertEquals(t,              assertEquals(t,
142                           TimeUnit.MICROSECONDS.toMicros(t));                           MICROSECONDS.toMicros(t));
143              assertEquals(t,              assertEquals(t,
144                           TimeUnit.NANOSECONDS.toMicros(t*1000L));                           NANOSECONDS.toMicros(t*1000L));
145          }          }
146      }      }
147    
# Line 171  Line 152 
152      public void testToMillis() {      public void testToMillis() {
153          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
154              assertEquals(t*1000L*60*60*24,              assertEquals(t*1000L*60*60*24,
155                           TimeUnit.DAYS.toMillis(t));                           DAYS.toMillis(t));
156              assertEquals(t*1000L*60*60,              assertEquals(t*1000L*60*60,
157                           TimeUnit.HOURS.toMillis(t));                           HOURS.toMillis(t));
158              assertEquals(t*1000L*60,              assertEquals(t*1000L*60,
159                           TimeUnit.MINUTES.toMillis(t));                           MINUTES.toMillis(t));
160              assertEquals(1000L*t,              assertEquals(1000L*t,
161                           TimeUnit.SECONDS.toMillis(t));                           SECONDS.toMillis(t));
162              assertEquals(t,              assertEquals(t,
163                           TimeUnit.MILLISECONDS.toMillis(t));                           MILLISECONDS.toMillis(t));
164              assertEquals(t,              assertEquals(t,
165                           TimeUnit.MICROSECONDS.toMillis(t*1000L));                           MICROSECONDS.toMillis(t*1000L));
166              assertEquals(t,              assertEquals(t,
167                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));                           NANOSECONDS.toMillis(t*1000000L));
168          }          }
169      }      }
170    
# Line 194  Line 175 
175      public void testToSeconds() {      public void testToSeconds() {
176          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
177              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
178                           TimeUnit.DAYS.toSeconds(t));                           DAYS.toSeconds(t));
179              assertEquals(t*60*60,              assertEquals(t*60*60,
180                           TimeUnit.HOURS.toSeconds(t));                           HOURS.toSeconds(t));
181              assertEquals(t*60,              assertEquals(t*60,
182                           TimeUnit.MINUTES.toSeconds(t));                           MINUTES.toSeconds(t));
183              assertEquals(t,              assertEquals(t,
184                           TimeUnit.SECONDS.toSeconds(t));                           SECONDS.toSeconds(t));
185              assertEquals(t,              assertEquals(t,
186                           TimeUnit.MILLISECONDS.toSeconds(t*1000L));                           MILLISECONDS.toSeconds(t*1000L));
187              assertEquals(t,              assertEquals(t,
188                           TimeUnit.MICROSECONDS.toSeconds(t*1000000L));                           MICROSECONDS.toSeconds(t*1000000L));
189              assertEquals(t,              assertEquals(t,
190                           TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));                           NANOSECONDS.toSeconds(t*1000000000L));
191          }          }
192      }      }
193    
# Line 217  Line 198 
198      public void testToMinutes() {      public void testToMinutes() {
199          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
200              assertEquals(t*60*24,              assertEquals(t*60*24,
201                           TimeUnit.DAYS.toMinutes(t));                           DAYS.toMinutes(t));
202              assertEquals(t*60,              assertEquals(t*60,
203                           TimeUnit.HOURS.toMinutes(t));                           HOURS.toMinutes(t));
204              assertEquals(t,              assertEquals(t,
205                           TimeUnit.MINUTES.toMinutes(t));                           MINUTES.toMinutes(t));
206              assertEquals(t,              assertEquals(t,
207                           TimeUnit.SECONDS.toMinutes(t*60));                           SECONDS.toMinutes(t*60));
208              assertEquals(t,              assertEquals(t,
209                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));                           MILLISECONDS.toMinutes(t*1000L*60));
210              assertEquals(t,              assertEquals(t,
211                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));                           MICROSECONDS.toMinutes(t*1000000L*60));
212              assertEquals(t,              assertEquals(t,
213                           TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));                           NANOSECONDS.toMinutes(t*1000000000L*60));
214          }          }
215      }      }
216    
# Line 240  Line 221 
221      public void testToHours() {      public void testToHours() {
222          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
223              assertEquals(t*24,              assertEquals(t*24,
224                           TimeUnit.DAYS.toHours(t));                           DAYS.toHours(t));
225              assertEquals(t,              assertEquals(t,
226                           TimeUnit.HOURS.toHours(t));                           HOURS.toHours(t));
227              assertEquals(t,              assertEquals(t,
228                           TimeUnit.MINUTES.toHours(t*60));                           MINUTES.toHours(t*60));
229              assertEquals(t,              assertEquals(t,
230                           TimeUnit.SECONDS.toHours(t*60*60));                           SECONDS.toHours(t*60*60));
231              assertEquals(t,              assertEquals(t,
232                           TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));                           MILLISECONDS.toHours(t*1000L*60*60));
233              assertEquals(t,              assertEquals(t,
234                           TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));                           MICROSECONDS.toHours(t*1000000L*60*60));
235              assertEquals(t,              assertEquals(t,
236                           TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));                           NANOSECONDS.toHours(t*1000000000L*60*60));
237          }          }
238      }      }
239    
# Line 263  Line 244 
244      public void testToDays() {      public void testToDays() {
245          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
246              assertEquals(t,              assertEquals(t,
247                           TimeUnit.DAYS.toDays(t));                           DAYS.toDays(t));
248              assertEquals(t,              assertEquals(t,
249                           TimeUnit.HOURS.toDays(t*24));                           HOURS.toDays(t*24));
250              assertEquals(t,              assertEquals(t,
251                           TimeUnit.MINUTES.toDays(t*60*24));                           MINUTES.toDays(t*60*24));
252              assertEquals(t,              assertEquals(t,
253                           TimeUnit.SECONDS.toDays(t*60*60*24));                           SECONDS.toDays(t*60*60*24));
254              assertEquals(t,              assertEquals(t,
255                           TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));                           MILLISECONDS.toDays(t*1000L*60*60*24));
256              assertEquals(t,              assertEquals(t,
257                           TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));                           MICROSECONDS.toDays(t*1000000L*60*60*24));
258              assertEquals(t,              assertEquals(t,
259                           TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));                           NANOSECONDS.toDays(t*1000000000L*60*60*24));
260          }          }
261      }      }
262    
   
263      /**      /**
264       * convert saturates positive too-large values to Long.MAX_VALUE       * convert saturates positive too-large values to Long.MAX_VALUE
265       * and negative to LONG.MIN_VALUE       * and negative to LONG.MIN_VALUE
266       */       */
267      public void testConvertSaturate() {      public void testConvertSaturate() {
268          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
269                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
                                                   TimeUnit.SECONDS));  
270          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
271                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
                                                   TimeUnit.SECONDS));  
272          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
273                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
                                                   TimeUnit.MINUTES));  
274          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
275                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
                                                   TimeUnit.MINUTES));  
276          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
277                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
                                                   TimeUnit.HOURS));  
278          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
279                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
                                                   TimeUnit.HOURS));  
280          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
281                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
                                                   TimeUnit.DAYS));  
282          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
283                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
                                                   TimeUnit.DAYS));  
   
284      }      }
285    
286      /**      /**
# Line 318  Line 289 
289       */       */
290      public void testToNanosSaturate() {      public void testToNanosSaturate() {
291          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
292                       TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
293          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
294                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                       MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
295      }      }
296    
   
297      /**      /**
298       * toString returns string containing common name of unit       * toString returns name of unit
299       */       */
300      public void testToString() {      public void testToString() {
301          String s = TimeUnit.SECONDS.toString();          assertEquals("SECONDS", SECONDS.toString());
         assertTrue(s.indexOf("ECOND") >= 0);  
302      }      }
303    
304        /**
305         * name returns name of unit
306         */
307        public void testName() {
308            assertEquals("SECONDS", SECONDS.name());
309        }
310    
311      /**      /**
312       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
313       *  IllegalMonitorStateException       *  IllegalMonitorStateException
314       */       */
315      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
316          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
317              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
318                  Object o = new Object();                  Object o = new Object();
319                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
320    
321                  try {                  try {
322                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
323                      threadShouldThrow();                      threadShouldThrow();
324                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
325                }});
326    
327          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
328      }      }
329    
330      /**      /**
331       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
332       */       */
333      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
334          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
335            Thread t = newStartedThread(new CheckedRunnable() {
336              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
337                  Object o = new Object();                  Object o = new Object();
338                    TimeUnit tu = MILLISECONDS;
339    
340                  TimeUnit tu = TimeUnit.MILLISECONDS;                  Thread.currentThread().interrupt();
341                    try {
342                        synchronized (o) {
343                            tu.timedWait(o, LONG_DELAY_MS);
344                        }
345                        shouldThrow();
346                    } catch (InterruptedException success) {}
347                    assertFalse(Thread.interrupted());
348    
349                    pleaseInterrupt.countDown();
350                    try {
351                  synchronized(o) {                  synchronized(o) {
352                      tu.timedWait(o,MEDIUM_DELAY_MS);                          tu.timedWait(o, LONG_DELAY_MS);
353                  }                  }
354                        shouldThrow();
355                    } catch (InterruptedException success) {}
356                    assertFalse(Thread.interrupted());
357              }});              }});
358          t.start();  
359          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
360            assertThreadStaysAlive(t);
361          t.interrupt();          t.interrupt();
362          t.join();          awaitTermination(t);
363      }      }
364    
   
365      /**      /**
366       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
367       */       */
368      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
369          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
370            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
371              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
372                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
373              }});              }});
374          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
375              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
376                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
377                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
378              }});;                  try {
379          s.start();                      tu.timedJoin(s, LONG_DELAY_MS);
380          t.start();                      shouldThrow();
381          Thread.sleep(SHORT_DELAY_MS);                  } catch (InterruptedException success) {}
382                    assertFalse(Thread.interrupted());
383    
384                    pleaseInterrupt.countDown();
385                    try {
386                        tu.timedJoin(s, LONG_DELAY_MS);
387                        shouldThrow();
388                    } catch (InterruptedException success) {}
389                    assertFalse(Thread.interrupted());
390                }});
391    
392            await(pleaseInterrupt);
393            assertThreadStaysAlive(t);
394          t.interrupt();          t.interrupt();
395          t.join();          awaitTermination(t);
396          s.interrupt();          s.interrupt();
397          s.join();          awaitTermination(s);
398      }      }
399    
400      /**      /**
401       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
402       */       */
403      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
404          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
405            Thread t = newStartedThread(new CheckedRunnable() {
406              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
407                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
408                  tu.sleep(MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
409                    try {
410                        tu.sleep(LONG_DELAY_MS);
411                        shouldThrow();
412                    } catch (InterruptedException success) {}
413                    assertFalse(Thread.interrupted());
414    
415                    pleaseInterrupt.countDown();
416                    try {
417                        tu.sleep(LONG_DELAY_MS);
418                        shouldThrow();
419                    } catch (InterruptedException success) {}
420                    assertFalse(Thread.interrupted());
421              }});              }});
422    
423          t.start();          await(pleaseInterrupt);
424          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
425          t.interrupt();          t.interrupt();
426          t.join();          awaitTermination(t);
427      }      }
428    
429      /**      /**
430       * a deserialized serialized unit is the same instance       * a deserialized serialized unit is the same instance
431       */       */
432      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
433          TimeUnit q = TimeUnit.MILLISECONDS;          for (TimeUnit x : TimeUnit.values())
434                assertSame(x, serialClone(x));
435        }
436    
437        /**
438         * tests for toChronoUnit.
439         */
440        public void testToChronoUnit() throws Exception {
441            assertSame(ChronoUnit.NANOS,   NANOSECONDS.toChronoUnit());
442            assertSame(ChronoUnit.MICROS,  MICROSECONDS.toChronoUnit());
443            assertSame(ChronoUnit.MILLIS,  MILLISECONDS.toChronoUnit());
444            assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit());
445            assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit());
446            assertSame(ChronoUnit.HOURS,   HOURS.toChronoUnit());
447            assertSame(ChronoUnit.DAYS,    DAYS.toChronoUnit());
448    
449            // Every TimeUnit has a defined ChronoUnit equivalent
450            for (TimeUnit x : TimeUnit.values())
451                assertSame(x, TimeUnit.of(x.toChronoUnit()));
452        }
453    
454        /**
455         * tests for TimeUnit.of(ChronoUnit).
456         */
457        public void testTimeUnitOf() throws Exception {
458            assertSame(NANOSECONDS,  TimeUnit.of(ChronoUnit.NANOS));
459            assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS));
460            assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS));
461            assertSame(SECONDS,      TimeUnit.of(ChronoUnit.SECONDS));
462            assertSame(MINUTES,      TimeUnit.of(ChronoUnit.MINUTES));
463            assertSame(HOURS,        TimeUnit.of(ChronoUnit.HOURS));
464            assertSame(DAYS,         TimeUnit.of(ChronoUnit.DAYS));
465    
466            assertThrows(NullPointerException.class,
467                         () -> TimeUnit.of((ChronoUnit)null));
468    
469          ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);          // ChronoUnits either round trip to their TimeUnit
470          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));          // equivalents, or throw IllegalArgumentException.
471          out.writeObject(q);          for (ChronoUnit cu : ChronoUnit.values()) {
472          out.close();              final TimeUnit tu;
473                try {
474          ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());                  tu = TimeUnit.of(cu);
475          ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              } catch (IllegalArgumentException acceptable) {
476          TimeUnit r = (TimeUnit)in.readObject();                  continue;
477          assertSame(q, r);              }
478                assertSame(cu, tu.toChronoUnit());
479            }
480      }      }
481    
482  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8