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

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

Diff Legend

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