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.20 by jsr166, Fri May 27 19:12:09 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.*;
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 –    
329      /**
330 <     *  Timed wait without holding lock throws
338 <     *  IllegalMonitorStateException
330 >     * name returns name of unit
331       */
332 <    public void testTimedWait_IllegalMonitorException() {
333 <        //created a new thread with anonymous runnable
334 <
335 <        Thread t = new Thread(new Runnable() {
336 <                public void run() {
337 <                    Object o = new Object();
338 <                    TimeUnit tu = TimeUnit.MILLISECONDS;
339 <                    try {
340 <                        tu.timedWait(o,LONG_DELAY_MS);
341 <                        threadShouldThrow();
342 <                    }
343 <                    catch (InterruptedException ie) {
344 <                        threadUnexpectedException();
345 <                    }
346 <                    catch(IllegalMonitorStateException success) {
347 <                    }
348 <                    
349 <                }
358 <            });
332 >    public void testName() {
333 >        assertEquals("SECONDS", TimeUnit.SECONDS.name());
334 >    }
335 >
336 >    /**
337 >     * Timed wait without holding lock throws
338 >     * IllegalMonitorStateException
339 >     */
340 >    public void testTimedWait_IllegalMonitorException() throws Exception {
341 >        Thread t = new Thread(new CheckedRunnable() {
342 >            public void realRun() throws InterruptedException {
343 >                Object o = new Object();
344 >                TimeUnit tu = TimeUnit.MILLISECONDS;
345 >                try {
346 >                    tu.timedWait(o,LONG_DELAY_MS);
347 >                    threadShouldThrow();
348 >                } catch (IllegalMonitorStateException success) {}}});
349 >
350          t.start();
351 <        try {
352 <            Thread.sleep(SHORT_DELAY_MS);
353 <            t.interrupt();
363 <            t.join();
364 <        } catch(Exception e) {
365 <            unexpectedException();
366 <        }
351 >        Thread.sleep(SHORT_DELAY_MS);
352 >        t.interrupt();
353 >        t.join();
354      }
355 <    
355 >
356      /**
357       * timedWait throws InterruptedException when interrupted
358       */
359 <    public void testTimedWait() {
360 <        Thread t = new Thread(new Runnable() {
361 <                public void run() {
362 <                    Object o = new Object();
363 <                    
364 <                    TimeUnit tu = TimeUnit.MILLISECONDS;
365 <                    try {
366 <                        synchronized(o) {
367 <                            tu.timedWait(o,MEDIUM_DELAY_MS);
368 <                        }
369 <                        threadShouldThrow();
370 <                    }
371 <                    catch(InterruptedException success) {}
372 <                    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 <        }
359 >    public void testTimedWait() throws InterruptedException {
360 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
361 >            public void realRun() throws InterruptedException {
362 >                Object o = new Object();
363 >
364 >                TimeUnit tu = TimeUnit.MILLISECONDS;
365 >                synchronized (o) {
366 >                    tu.timedWait(o,MEDIUM_DELAY_MS);
367 >                }
368 >            }});
369 >        t.start();
370 >        Thread.sleep(SHORT_DELAY_MS);
371 >        t.interrupt();
372 >        t.join();
373      }
374 <    
400 <    
374 >
375      /**
376       * timedJoin throws InterruptedException when interrupted
377       */
378 <    public void testTimedJoin() {
379 <        Thread t = new Thread(new Runnable() {
380 <                public void run() {
381 <                    TimeUnit tu = TimeUnit.MILLISECONDS;        
382 <                    try {
383 <                        Thread s = new Thread(new Runnable() {
384 <                                public void run() {
385 <                                    try {
386 <                                        Thread.sleep(MEDIUM_DELAY_MS);
387 <                                    } catch(InterruptedException success){}
388 <                                }
389 <                            });
390 <                        s.start();
391 <                        tu.timedJoin(s,MEDIUM_DELAY_MS);
392 <                        threadShouldThrow();
393 <                    }
394 <                    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 <        }
378 >    public void testTimedJoin() throws InterruptedException {
379 >        final Thread s = new Thread(new CheckedInterruptedRunnable() {
380 >            public void realRun() throws InterruptedException {
381 >                Thread.sleep(MEDIUM_DELAY_MS);
382 >            }});
383 >        final Thread t = new Thread(new CheckedInterruptedRunnable() {
384 >            public void realRun() throws InterruptedException {
385 >                TimeUnit tu = TimeUnit.MILLISECONDS;
386 >                tu.timedJoin(s, MEDIUM_DELAY_MS);
387 >            }});
388 >        s.start();
389 >        t.start();
390 >        Thread.sleep(SHORT_DELAY_MS);
391 >        t.interrupt();
392 >        t.join();
393 >        s.interrupt();
394 >        s.join();
395      }
396 <    
396 >
397      /**
398 <     *  timedSleep throws InterruptedException when interrupted
399 <     */
400 <    public void testTimedSleep() {
401 <        //created a new thread with anonymous runnable
398 >     * timedSleep throws InterruptedException when interrupted
399 >     */
400 >    public void testTimedSleep() throws InterruptedException {
401 >        Thread t = new Thread(new CheckedInterruptedRunnable() {
402 >            public void realRun() throws InterruptedException {
403 >                TimeUnit tu = TimeUnit.MILLISECONDS;
404 >                tu.sleep(MEDIUM_DELAY_MS);
405 >            }});
406  
407 <        Thread t = new Thread(new Runnable() {
408 <                public void run() {
409 <                    TimeUnit tu = TimeUnit.MILLISECONDS;
410 <                    try {
443 <                        tu.sleep(MEDIUM_DELAY_MS);
444 <                        threadShouldThrow();
445 <                    }
446 <                    catch(InterruptedException success) {}
447 <                }
448 <            });
449 <        t.start();
450 <        try {
451 <            Thread.sleep(SHORT_DELAY_MS);
452 <            t.interrupt();
453 <            t.join();
454 <        } catch(Exception e) {
455 <            unexpectedException();
456 <        }
407 >        t.start();
408 >        Thread.sleep(SHORT_DELAY_MS);
409 >        t.interrupt();
410 >        t.join();
411      }
412  
413      /**
414 <     * a deserialized serialized unit is equal
414 >     * a deserialized serialized unit is the same instance
415       */
416 <    public void testSerialization() {
416 >    public void testSerialization() throws Exception {
417          TimeUnit q = TimeUnit.MILLISECONDS;
418  
419 <        try {
420 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
421 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
422 <            out.writeObject(q);
423 <            out.close();
424 <
425 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
426 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
427 <            TimeUnit r = (TimeUnit)in.readObject();
474 <            
475 <            assertEquals(q.toString(), r.toString());
476 <        } catch(Exception e){
477 <            e.printStackTrace();
478 <            unexpectedException();
479 <        }
419 >        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
420 >        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
421 >        out.writeObject(q);
422 >        out.close();
423 >
424 >        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
425 >        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
426 >        TimeUnit r = (TimeUnit)in.readObject();
427 >        assertSame(q, r);
428      }
429  
430   }

Diff Legend

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