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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8