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

Diff Legend

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