[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.23, Tue Sep 24 16:48:52 2013 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 junit.framework.*;  import junit.framework.*;
10  import java.util.concurrent.*;  import java.util.concurrent.CountDownLatch;
11  import java.io.*;  import java.util.concurrent.TimeUnit;
12    import static java.util.concurrent.TimeUnit.*;
13    
14  public class TimeUnitTest extends JSR166TestCase {  public class TimeUnitTest extends JSR166TestCase {
15      public static void main(String[] args) {      public static void main(String[] args) {
# Line 28  Line 28 
28      public void testConvert() {      public void testConvert() {
29          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
30              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
31                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
32              assertEquals(t*60*60,              assertEquals(t*60*60,
33                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
34              assertEquals(t*60,              assertEquals(t*60,
35                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
36              assertEquals(t,              assertEquals(t,
37                           TimeUnit.SECONDS.convert(t,                           SECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
38              assertEquals(t,              assertEquals(t,
39                           TimeUnit.SECONDS.convert(1000L*t,                           SECONDS.convert(1000L*t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
40              assertEquals(t,              assertEquals(t,
41                           TimeUnit.SECONDS.convert(1000000L*t,                           SECONDS.convert(1000000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
42              assertEquals(t,              assertEquals(t,
43                           TimeUnit.SECONDS.convert(1000000000L*t,                           SECONDS.convert(1000000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
   
44    
45              assertEquals(1000L*t*60*60*24,              assertEquals(1000L*t*60*60*24,
46                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
47              assertEquals(1000L*t*60*60,              assertEquals(1000L*t*60*60,
48                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
49              assertEquals(1000L*t*60,              assertEquals(1000L*t*60,
50                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
51              assertEquals(1000L*t,              assertEquals(1000L*t,
52                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
53              assertEquals(t,              assertEquals(t,
54                           TimeUnit.MILLISECONDS.convert(t,                           MILLISECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
55              assertEquals(t,              assertEquals(t,
56                           TimeUnit.MILLISECONDS.convert(1000L*t,                           MILLISECONDS.convert(1000L*t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
57              assertEquals(t,              assertEquals(t,
58                           TimeUnit.MILLISECONDS.convert(1000000L*t,                           MILLISECONDS.convert(1000000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
59    
60              assertEquals(1000000L*t*60*60*24,              assertEquals(1000000L*t*60*60*24,
61                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
62              assertEquals(1000000L*t*60*60,              assertEquals(1000000L*t*60*60,
63                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
64              assertEquals(1000000L*t*60,              assertEquals(1000000L*t*60,
65                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
66              assertEquals(1000000L*t,              assertEquals(1000000L*t,
67                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
68              assertEquals(1000L*t,              assertEquals(1000L*t,
69                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
70              assertEquals(t,              assertEquals(t,
71                           TimeUnit.MICROSECONDS.convert(t,                           MICROSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
72              assertEquals(t,              assertEquals(t,
73                           TimeUnit.MICROSECONDS.convert(1000L*t,                           MICROSECONDS.convert(1000L*t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
74    
75              assertEquals(1000000000L*t*60*60*24,              assertEquals(1000000000L*t*60*60*24,
76                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, DAYS));
                                                   TimeUnit.DAYS));  
77              assertEquals(1000000000L*t*60*60,              assertEquals(1000000000L*t*60*60,
78                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, HOURS));
                                                   TimeUnit.HOURS));  
79              assertEquals(1000000000L*t*60,              assertEquals(1000000000L*t*60,
80                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MINUTES));
                                                   TimeUnit.MINUTES));  
81              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
82                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, SECONDS));
                                                   TimeUnit.SECONDS));  
83              assertEquals(1000000L*t,              assertEquals(1000000L*t,
84                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MILLISECONDS));
                                                   TimeUnit.MILLISECONDS));  
85              assertEquals(1000L*t,              assertEquals(1000L*t,
86                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, MICROSECONDS));
                                                   TimeUnit.MICROSECONDS));  
87              assertEquals(t,              assertEquals(t,
88                           TimeUnit.NANOSECONDS.convert(t,                           NANOSECONDS.convert(t, NANOSECONDS));
                                                   TimeUnit.NANOSECONDS));  
89          }          }
90      }      }
91    
# Line 125  Line 96 
96      public void testToNanos() {      public void testToNanos() {
97          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
98              assertEquals(t*1000000000L*60*60*24,              assertEquals(t*1000000000L*60*60*24,
99                           TimeUnit.DAYS.toNanos(t));                           DAYS.toNanos(t));
100              assertEquals(t*1000000000L*60*60,              assertEquals(t*1000000000L*60*60,
101                           TimeUnit.HOURS.toNanos(t));                           HOURS.toNanos(t));
102              assertEquals(t*1000000000L*60,              assertEquals(t*1000000000L*60,
103                           TimeUnit.MINUTES.toNanos(t));                           MINUTES.toNanos(t));
104              assertEquals(1000000000L*t,              assertEquals(1000000000L*t,
105                           TimeUnit.SECONDS.toNanos(t));                           SECONDS.toNanos(t));
106              assertEquals(1000000L*t,              assertEquals(1000000L*t,
107                           TimeUnit.MILLISECONDS.toNanos(t));                           MILLISECONDS.toNanos(t));
108              assertEquals(1000L*t,              assertEquals(1000L*t,
109                           TimeUnit.MICROSECONDS.toNanos(t));                           MICROSECONDS.toNanos(t));
110              assertEquals(t,              assertEquals(t,
111                           TimeUnit.NANOSECONDS.toNanos(t));                           NANOSECONDS.toNanos(t));
112          }          }
113      }      }
114    
# Line 148  Line 119 
119      public void testToMicros() {      public void testToMicros() {
120          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
121              assertEquals(t*1000000L*60*60*24,              assertEquals(t*1000000L*60*60*24,
122                           TimeUnit.DAYS.toMicros(t));                           DAYS.toMicros(t));
123              assertEquals(t*1000000L*60*60,              assertEquals(t*1000000L*60*60,
124                           TimeUnit.HOURS.toMicros(t));                           HOURS.toMicros(t));
125              assertEquals(t*1000000L*60,              assertEquals(t*1000000L*60,
126                           TimeUnit.MINUTES.toMicros(t));                           MINUTES.toMicros(t));
127              assertEquals(1000000L*t,              assertEquals(1000000L*t,
128                           TimeUnit.SECONDS.toMicros(t));                           SECONDS.toMicros(t));
129              assertEquals(1000L*t,              assertEquals(1000L*t,
130                           TimeUnit.MILLISECONDS.toMicros(t));                           MILLISECONDS.toMicros(t));
131              assertEquals(t,              assertEquals(t,
132                           TimeUnit.MICROSECONDS.toMicros(t));                           MICROSECONDS.toMicros(t));
133              assertEquals(t,              assertEquals(t,
134                           TimeUnit.NANOSECONDS.toMicros(t*1000L));                           NANOSECONDS.toMicros(t*1000L));
135          }          }
136      }      }
137    
# Line 171  Line 142 
142      public void testToMillis() {      public void testToMillis() {
143          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
144              assertEquals(t*1000L*60*60*24,              assertEquals(t*1000L*60*60*24,
145                           TimeUnit.DAYS.toMillis(t));                           DAYS.toMillis(t));
146              assertEquals(t*1000L*60*60,              assertEquals(t*1000L*60*60,
147                           TimeUnit.HOURS.toMillis(t));                           HOURS.toMillis(t));
148              assertEquals(t*1000L*60,              assertEquals(t*1000L*60,
149                           TimeUnit.MINUTES.toMillis(t));                           MINUTES.toMillis(t));
150              assertEquals(1000L*t,              assertEquals(1000L*t,
151                           TimeUnit.SECONDS.toMillis(t));                           SECONDS.toMillis(t));
152              assertEquals(t,              assertEquals(t,
153                           TimeUnit.MILLISECONDS.toMillis(t));                           MILLISECONDS.toMillis(t));
154              assertEquals(t,              assertEquals(t,
155                           TimeUnit.MICROSECONDS.toMillis(t*1000L));                           MICROSECONDS.toMillis(t*1000L));
156              assertEquals(t,              assertEquals(t,
157                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));                           NANOSECONDS.toMillis(t*1000000L));
158          }          }
159      }      }
160    
# Line 194  Line 165 
165      public void testToSeconds() {      public void testToSeconds() {
166          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
167              assertEquals(t*60*60*24,              assertEquals(t*60*60*24,
168                           TimeUnit.DAYS.toSeconds(t));                           DAYS.toSeconds(t));
169              assertEquals(t*60*60,              assertEquals(t*60*60,
170                           TimeUnit.HOURS.toSeconds(t));                           HOURS.toSeconds(t));
171              assertEquals(t*60,              assertEquals(t*60,
172                           TimeUnit.MINUTES.toSeconds(t));                           MINUTES.toSeconds(t));
173              assertEquals(t,              assertEquals(t,
174                           TimeUnit.SECONDS.toSeconds(t));                           SECONDS.toSeconds(t));
175              assertEquals(t,              assertEquals(t,
176                           TimeUnit.MILLISECONDS.toSeconds(t*1000L));                           MILLISECONDS.toSeconds(t*1000L));
177              assertEquals(t,              assertEquals(t,
178                           TimeUnit.MICROSECONDS.toSeconds(t*1000000L));                           MICROSECONDS.toSeconds(t*1000000L));
179              assertEquals(t,              assertEquals(t,
180                           TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));                           NANOSECONDS.toSeconds(t*1000000000L));
181          }          }
182      }      }
183    
# Line 217  Line 188 
188      public void testToMinutes() {      public void testToMinutes() {
189          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
190              assertEquals(t*60*24,              assertEquals(t*60*24,
191                           TimeUnit.DAYS.toMinutes(t));                           DAYS.toMinutes(t));
192              assertEquals(t*60,              assertEquals(t*60,
193                           TimeUnit.HOURS.toMinutes(t));                           HOURS.toMinutes(t));
194              assertEquals(t,              assertEquals(t,
195                           TimeUnit.MINUTES.toMinutes(t));                           MINUTES.toMinutes(t));
196              assertEquals(t,              assertEquals(t,
197                           TimeUnit.SECONDS.toMinutes(t*60));                           SECONDS.toMinutes(t*60));
198              assertEquals(t,              assertEquals(t,
199                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));                           MILLISECONDS.toMinutes(t*1000L*60));
200              assertEquals(t,              assertEquals(t,
201                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));                           MICROSECONDS.toMinutes(t*1000000L*60));
202              assertEquals(t,              assertEquals(t,
203                           TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));                           NANOSECONDS.toMinutes(t*1000000000L*60));
204          }          }
205      }      }
206    
# Line 240  Line 211 
211      public void testToHours() {      public void testToHours() {
212          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
213              assertEquals(t*24,              assertEquals(t*24,
214                           TimeUnit.DAYS.toHours(t));                           DAYS.toHours(t));
215              assertEquals(t,              assertEquals(t,
216                           TimeUnit.HOURS.toHours(t));                           HOURS.toHours(t));
217              assertEquals(t,              assertEquals(t,
218                           TimeUnit.MINUTES.toHours(t*60));                           MINUTES.toHours(t*60));
219              assertEquals(t,              assertEquals(t,
220                           TimeUnit.SECONDS.toHours(t*60*60));                           SECONDS.toHours(t*60*60));
221              assertEquals(t,              assertEquals(t,
222                           TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));                           MILLISECONDS.toHours(t*1000L*60*60));
223              assertEquals(t,              assertEquals(t,
224                           TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));                           MICROSECONDS.toHours(t*1000000L*60*60));
225              assertEquals(t,              assertEquals(t,
226                           TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));                           NANOSECONDS.toHours(t*1000000000L*60*60));
227          }          }
228      }      }
229    
# Line 263  Line 234 
234      public void testToDays() {      public void testToDays() {
235          for (long t = 0; t < 88888; ++t) {          for (long t = 0; t < 88888; ++t) {
236              assertEquals(t,              assertEquals(t,
237                           TimeUnit.DAYS.toDays(t));                           DAYS.toDays(t));
238              assertEquals(t,              assertEquals(t,
239                           TimeUnit.HOURS.toDays(t*24));                           HOURS.toDays(t*24));
240              assertEquals(t,              assertEquals(t,
241                           TimeUnit.MINUTES.toDays(t*60*24));                           MINUTES.toDays(t*60*24));
242              assertEquals(t,              assertEquals(t,
243                           TimeUnit.SECONDS.toDays(t*60*60*24));                           SECONDS.toDays(t*60*60*24));
244              assertEquals(t,              assertEquals(t,
245                           TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));                           MILLISECONDS.toDays(t*1000L*60*60*24));
246              assertEquals(t,              assertEquals(t,
247                           TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));                           MICROSECONDS.toDays(t*1000000L*60*60*24));
248              assertEquals(t,              assertEquals(t,
249                           TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));                           NANOSECONDS.toDays(t*1000000000L*60*60*24));
250          }          }
251      }      }
252    
   
253      /**      /**
254       * convert saturates positive too-large values to Long.MAX_VALUE       * convert saturates positive too-large values to Long.MAX_VALUE
255       * and negative to LONG.MIN_VALUE       * and negative to LONG.MIN_VALUE
256       */       */
257      public void testConvertSaturate() {      public void testConvertSaturate() {
258          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
259                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
                                                   TimeUnit.SECONDS));  
260          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
261                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
                                                   TimeUnit.SECONDS));  
262          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
263                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
                                                   TimeUnit.MINUTES));  
264          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
265                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
                                                   TimeUnit.MINUTES));  
266          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
267                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
                                                   TimeUnit.HOURS));  
268          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
269                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
                                                   TimeUnit.HOURS));  
270          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
271                       TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,                       NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
                                                   TimeUnit.DAYS));  
272          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
273                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
                                                   TimeUnit.DAYS));  
   
274      }      }
275    
276      /**      /**
# Line 318  Line 279 
279       */       */
280      public void testToNanosSaturate() {      public void testToNanosSaturate() {
281          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
282                       TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));                       MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
283          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
284                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                       MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
285      }      }
286    
   
287      /**      /**
288       * toString returns string containing common name of unit       * toString returns name of unit
289       */       */
290      public void testToString() {      public void testToString() {
291          String s = TimeUnit.SECONDS.toString();          assertEquals("SECONDS", SECONDS.toString());
         assertTrue(s.indexOf("ECOND") >= 0);  
292      }      }
293    
294        /**
295         * name returns name of unit
296         */
297        public void testName() {
298            assertEquals("SECONDS", SECONDS.name());
299        }
300    
301      /**      /**
302       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
303       *  IllegalMonitorStateException       *  IllegalMonitorStateException
304       */       */
305      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
306          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
307              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
308                  Object o = new Object();                  Object o = new Object();
309                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
310    
311                  try {                  try {
312                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
313                      threadShouldThrow();                      threadShouldThrow();
314                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
315                }});
316    
317          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
318      }      }
319    
320      /**      /**
321       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
322       */       */
323      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
324          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
325            Thread t = newStartedThread(new CheckedRunnable() {
326              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
327                  Object o = new Object();                  Object o = new Object();
328                    TimeUnit tu = MILLISECONDS;
329    
330                  TimeUnit tu = TimeUnit.MILLISECONDS;                  Thread.currentThread().interrupt();
331                    try {
332                  synchronized(o) {                  synchronized(o) {
333                      tu.timedWait(o,MEDIUM_DELAY_MS);                          tu.timedWait(o, LONG_DELAY_MS);
334                  }                  }
335                        shouldThrow();
336                    } catch (InterruptedException success) {}
337                    assertFalse(Thread.interrupted());
338    
339                    pleaseInterrupt.countDown();
340                    try {
341                        synchronized (o) {
342                            tu.timedWait(o, LONG_DELAY_MS);
343                        }
344                        shouldThrow();
345                    } catch (InterruptedException success) {}
346                    assertFalse(Thread.interrupted());
347              }});              }});
348          t.start();  
349          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
350            assertThreadStaysAlive(t);
351          t.interrupt();          t.interrupt();
352          t.join();          awaitTermination(t);
353      }      }
354    
   
355      /**      /**
356       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
357       */       */
358      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
359          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
360            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
361              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
362                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
363              }});              }});
364          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
365              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
366                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
367                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
368              }});;                  try {
369          s.start();                      tu.timedJoin(s, LONG_DELAY_MS);
370          t.start();                      shouldThrow();
371          Thread.sleep(SHORT_DELAY_MS);                  } catch (InterruptedException success) {}
372                    assertFalse(Thread.interrupted());
373    
374                    pleaseInterrupt.countDown();
375                    try {
376                        tu.timedJoin(s, LONG_DELAY_MS);
377                        shouldThrow();
378                    } catch (InterruptedException success) {}
379                    assertFalse(Thread.interrupted());
380                }});
381    
382            await(pleaseInterrupt);
383            assertThreadStaysAlive(t);
384          t.interrupt();          t.interrupt();
385          t.join();          awaitTermination(t);
386          s.interrupt();          s.interrupt();
387          s.join();          awaitTermination(s);
388      }      }
389    
390      /**      /**
391       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
392       */       */
393      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
394          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
395            Thread t = newStartedThread(new CheckedRunnable() {
396              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
397                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = MILLISECONDS;
398                  tu.sleep(MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
399                    try {
400                        tu.sleep(LONG_DELAY_MS);
401                        shouldThrow();
402                    } catch (InterruptedException success) {}
403                    assertFalse(Thread.interrupted());
404    
405                    pleaseInterrupt.countDown();
406                    try {
407                        tu.sleep(LONG_DELAY_MS);
408                        shouldThrow();
409                    } catch (InterruptedException success) {}
410                    assertFalse(Thread.interrupted());
411              }});              }});
412    
413          t.start();          await(pleaseInterrupt);
414          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
415          t.interrupt();          t.interrupt();
416          t.join();          awaitTermination(t);
417      }      }
418    
419      /**      /**
420       * a deserialized serialized unit is the same instance       * a deserialized serialized unit is the same instance
421       */       */
422      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
423          TimeUnit q = TimeUnit.MILLISECONDS;          TimeUnit x = MILLISECONDS;
424            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);  
425      }      }
426    
427  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8