[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.4, Sat Sep 20 18:20:08 2003 UTC revision 1.14, Sat Nov 21 02:07:27 2009 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9    
# Line 19  Line 20 
20          return new TestSuite(TimeUnitTest.class);          return new TestSuite(TimeUnitTest.class);
21      }      }
22    
23        // (loops to 88888 check increments at all time divisions.)
24    
25      /**      /**
26       *       * convert correctly converts sample values across the units
27       */       */
28      public void testConvert() {      public void testConvert() {
29          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
30                assertEquals(t*60*60*24,
31                             TimeUnit.SECONDS.convert(t,
32                                                      TimeUnit.DAYS));
33                assertEquals(t*60*60,
34                             TimeUnit.SECONDS.convert(t,
35                                                      TimeUnit.HOURS));
36                assertEquals(t*60,
37                             TimeUnit.SECONDS.convert(t,
38                                                      TimeUnit.MINUTES));
39              assertEquals(t,              assertEquals(t,
40                           TimeUnit.SECONDS.convert(t,                           TimeUnit.SECONDS.convert(t,
41                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
42              assertEquals(t,              assertEquals(t,
43                           TimeUnit.SECONDS.convert(1000 * t,                           TimeUnit.SECONDS.convert(1000L*t,
44                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
45              assertEquals(t,              assertEquals(t,
46                           TimeUnit.SECONDS.convert(1000000 * t,                           TimeUnit.SECONDS.convert(1000000L*t,
47                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
48              assertEquals(t,              assertEquals(t,
49                           TimeUnit.SECONDS.convert(1000000000 * t,                           TimeUnit.SECONDS.convert(1000000000L*t,
50                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
51              assertEquals(1000 * t,  
52    
53                assertEquals(1000L*t*60*60*24,
54                             TimeUnit.MILLISECONDS.convert(t,
55                                                      TimeUnit.DAYS));
56                assertEquals(1000L*t*60*60,
57                             TimeUnit.MILLISECONDS.convert(t,
58                                                      TimeUnit.HOURS));
59                assertEquals(1000L*t*60,
60                             TimeUnit.MILLISECONDS.convert(t,
61                                                      TimeUnit.MINUTES));
62                assertEquals(1000L*t,
63                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
64                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
65              assertEquals(t,              assertEquals(t,
66                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
67                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
68              assertEquals(t,              assertEquals(t,
69                           TimeUnit.MILLISECONDS.convert(1000 * t,                           TimeUnit.MILLISECONDS.convert(1000L*t,
70                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
71              assertEquals(t,              assertEquals(t,
72                           TimeUnit.MILLISECONDS.convert(1000000 * t,                           TimeUnit.MILLISECONDS.convert(1000000L*t,
73                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
74              assertEquals(1000000 * t,  
75                assertEquals(1000000L*t*60*60*24,
76                             TimeUnit.MICROSECONDS.convert(t,
77                                                      TimeUnit.DAYS));
78                assertEquals(1000000L*t*60*60,
79                             TimeUnit.MICROSECONDS.convert(t,
80                                                      TimeUnit.HOURS));
81                assertEquals(1000000L*t*60,
82                             TimeUnit.MICROSECONDS.convert(t,
83                                                      TimeUnit.MINUTES));
84                assertEquals(1000000L*t,
85                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
86                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
87              assertEquals(1000 * t,              assertEquals(1000L*t,
88                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
89                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
90              assertEquals(t,              assertEquals(t,
91                           TimeUnit.MICROSECONDS.convert(t,                           TimeUnit.MICROSECONDS.convert(t,
92                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
93              assertEquals(t,              assertEquals(t,
94                           TimeUnit.MICROSECONDS.convert(1000 * t,                           TimeUnit.MICROSECONDS.convert(1000L*t,
95                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
96              assertEquals(1000000000 * t,  
97                assertEquals(1000000000L*t*60*60*24,
98                             TimeUnit.NANOSECONDS.convert(t,
99                                                      TimeUnit.DAYS));
100                assertEquals(1000000000L*t*60*60,
101                             TimeUnit.NANOSECONDS.convert(t,
102                                                      TimeUnit.HOURS));
103                assertEquals(1000000000L*t*60,
104                             TimeUnit.NANOSECONDS.convert(t,
105                                                      TimeUnit.MINUTES));
106                assertEquals(1000000000L*t,
107                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
108                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
109              assertEquals(1000000 * t,              assertEquals(1000000L*t,
110                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
111                                                    TimeUnit.MILLISECONDS));                                                    TimeUnit.MILLISECONDS));
112              assertEquals(1000 * t,              assertEquals(1000L*t,
113                           TimeUnit.NANOSECONDS.convert(t,                           TimeUnit.NANOSECONDS.convert(t,
114                                                    TimeUnit.MICROSECONDS));                                                    TimeUnit.MICROSECONDS));
115              assertEquals(t,              assertEquals(t,
# Line 76  Line 119 
119      }      }
120    
121      /**      /**
122       *       * toNanos correctly converts sample values in different units to
123         * nanoseconds
124       */       */
125      public void testToNanos() {      public void testToNanos() {
126          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
127              assertEquals(1000000000 * t,              assertEquals(t*1000000000L*60*60*24,
128                             TimeUnit.DAYS.toNanos(t));
129                assertEquals(t*1000000000L*60*60,
130                             TimeUnit.HOURS.toNanos(t));
131                assertEquals(t*1000000000L*60,
132                             TimeUnit.MINUTES.toNanos(t));
133                assertEquals(1000000000L*t,
134                           TimeUnit.SECONDS.toNanos(t));                           TimeUnit.SECONDS.toNanos(t));
135                assertEquals(1000000L*t,
             assertEquals(1000000 * t,  
136                           TimeUnit.MILLISECONDS.toNanos(t));                           TimeUnit.MILLISECONDS.toNanos(t));
137              assertEquals(1000 * t,              assertEquals(1000L*t,
138                           TimeUnit.MICROSECONDS.toNanos(t));                           TimeUnit.MICROSECONDS.toNanos(t));
139              assertEquals(t,              assertEquals(t,
140                           TimeUnit.NANOSECONDS.toNanos(t));                           TimeUnit.NANOSECONDS.toNanos(t));
# Line 93  Line 142 
142      }      }
143    
144      /**      /**
145       *       * toMicros correctly converts sample values in different units to
146         * microseconds
147       */       */
148      public void testToMicros() {      public void testToMicros() {
149          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
150              assertEquals(1000000 * t,              assertEquals(t*1000000L*60*60*24,
151                             TimeUnit.DAYS.toMicros(t));
152                assertEquals(t*1000000L*60*60,
153                             TimeUnit.HOURS.toMicros(t));
154                assertEquals(t*1000000L*60,
155                             TimeUnit.MINUTES.toMicros(t));
156                assertEquals(1000000L*t,
157                           TimeUnit.SECONDS.toMicros(t));                           TimeUnit.SECONDS.toMicros(t));
158                assertEquals(1000L*t,
             assertEquals(1000 * t,  
159                           TimeUnit.MILLISECONDS.toMicros(t));                           TimeUnit.MILLISECONDS.toMicros(t));
160              assertEquals(t,              assertEquals(t,
161                           TimeUnit.MICROSECONDS.toMicros(t));                           TimeUnit.MICROSECONDS.toMicros(t));
162              assertEquals(t,              assertEquals(t,
163                           TimeUnit.NANOSECONDS.toMicros(t * 1000));                           TimeUnit.NANOSECONDS.toMicros(t*1000L));
164          }          }
165      }      }
166    
167      /**      /**
168       *       * toMillis correctly converts sample values in different units to
169         * milliseconds
170       */       */
171      public void testToMillis() {      public void testToMillis() {
172          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
173              assertEquals(1000 * t,              assertEquals(t*1000L*60*60*24,
174                             TimeUnit.DAYS.toMillis(t));
175                assertEquals(t*1000L*60*60,
176                             TimeUnit.HOURS.toMillis(t));
177                assertEquals(t*1000L*60,
178                             TimeUnit.MINUTES.toMillis(t));
179                assertEquals(1000L*t,
180                           TimeUnit.SECONDS.toMillis(t));                           TimeUnit.SECONDS.toMillis(t));
   
181              assertEquals(t,              assertEquals(t,
182                           TimeUnit.MILLISECONDS.toMillis(t));                           TimeUnit.MILLISECONDS.toMillis(t));
183              assertEquals(t,              assertEquals(t,
184                           TimeUnit.MICROSECONDS.toMillis(t * 1000));                           TimeUnit.MICROSECONDS.toMillis(t*1000L));
185              assertEquals(t,              assertEquals(t,
186                           TimeUnit.NANOSECONDS.toMillis(t * 1000000));                           TimeUnit.NANOSECONDS.toMillis(t*1000000L));
187          }          }
188      }      }
189    
190      /**      /**
191       *       * toSeconds correctly converts sample values in different units to
192         * seconds
193       */       */
194      public void testToSeconds() {      public void testToSeconds() {
195          for (long t = 0; t < 10; ++t) {          for (long t = 0; t < 88888; ++t) {
196                assertEquals(t*60*60*24,
197                             TimeUnit.DAYS.toSeconds(t));
198                assertEquals(t*60*60,
199                             TimeUnit.HOURS.toSeconds(t));
200                assertEquals(t*60,
201                             TimeUnit.MINUTES.toSeconds(t));
202              assertEquals(t,              assertEquals(t,
203                           TimeUnit.SECONDS.toSeconds(t));                           TimeUnit.SECONDS.toSeconds(t));
204                assertEquals(t,
205                             TimeUnit.MILLISECONDS.toSeconds(t*1000L));
206                assertEquals(t,
207                             TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
208                assertEquals(t,
209                             TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
210            }
211        }
212    
213        /**
214         * toMinutes correctly converts sample values in different units to
215         * minutes
216         */
217        public void testToMinutes() {
218            for (long t = 0; t < 88888; ++t) {
219                assertEquals(t*60*24,
220                             TimeUnit.DAYS.toMinutes(t));
221                assertEquals(t*60,
222                             TimeUnit.HOURS.toMinutes(t));
223                assertEquals(t,
224                             TimeUnit.MINUTES.toMinutes(t));
225              assertEquals(t,              assertEquals(t,
226                           TimeUnit.MILLISECONDS.toSeconds(t * 1000));                           TimeUnit.SECONDS.toMinutes(t*60));
227              assertEquals(t,              assertEquals(t,
228                           TimeUnit.MICROSECONDS.toSeconds(t * 1000000));                           TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
229              assertEquals(t,              assertEquals(t,
230                           TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));                           TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
231                assertEquals(t,
232                             TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
233          }          }
234      }      }
235    
236        /**
237         * toHours correctly converts sample values in different units to
238         * hours
239         */
240        public void testToHours() {
241            for (long t = 0; t < 88888; ++t) {
242                assertEquals(t*24,
243                             TimeUnit.DAYS.toHours(t));
244                assertEquals(t,
245                             TimeUnit.HOURS.toHours(t));
246                assertEquals(t,
247                             TimeUnit.MINUTES.toHours(t*60));
248                assertEquals(t,
249                             TimeUnit.SECONDS.toHours(t*60*60));
250                assertEquals(t,
251                             TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
252                assertEquals(t,
253                             TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
254                assertEquals(t,
255                             TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
256            }
257        }
258    
259      /**      /**
260       *       * toDays correctly converts sample values in different units to
261         * days
262         */
263        public void testToDays() {
264            for (long t = 0; t < 88888; ++t) {
265                assertEquals(t,
266                             TimeUnit.DAYS.toDays(t));
267                assertEquals(t,
268                             TimeUnit.HOURS.toDays(t*24));
269                assertEquals(t,
270                             TimeUnit.MINUTES.toDays(t*60*24));
271                assertEquals(t,
272                             TimeUnit.SECONDS.toDays(t*60*60*24));
273                assertEquals(t,
274                             TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
275                assertEquals(t,
276                             TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
277                assertEquals(t,
278                             TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
279            }
280        }
281    
282    
283        /**
284         * convert saturates positive too-large values to Long.MAX_VALUE
285         * and negative to LONG.MIN_VALUE
286       */       */
287      public void testConvertSaturate() {      public void testConvertSaturate() {
288          assertEquals(Long.MAX_VALUE,          assertEquals(Long.MAX_VALUE,
# Line 154  Line 291 
291          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
292                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
293                                                    TimeUnit.SECONDS));                                                    TimeUnit.SECONDS));
294            assertEquals(Long.MAX_VALUE,
295                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
296                                                      TimeUnit.MINUTES));
297            assertEquals(Long.MIN_VALUE,
298                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
299                                                      TimeUnit.MINUTES));
300            assertEquals(Long.MAX_VALUE,
301                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
302                                                      TimeUnit.HOURS));
303            assertEquals(Long.MIN_VALUE,
304                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
305                                                      TimeUnit.HOURS));
306            assertEquals(Long.MAX_VALUE,
307                         TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
308                                                      TimeUnit.DAYS));
309            assertEquals(Long.MIN_VALUE,
310                         TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
311                                                      TimeUnit.DAYS));
312    
313      }      }
314    
315      /**      /**
316       *       * toNanos saturates positive too-large values to Long.MAX_VALUE
317         * and negative to LONG.MIN_VALUE
318       */       */
319      public void testToNanosSaturate() {      public void testToNanosSaturate() {
320              assertEquals(Long.MAX_VALUE,              assertEquals(Long.MAX_VALUE,
321                           TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));                           TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322              assertEquals(Long.MIN_VALUE,              assertEquals(Long.MIN_VALUE,
323                           TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                           TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
   
324      }      }
325    
326    
327      /**      /**
328       *       * toString returns string containing common name of unit
329       */       */
330      public void testToString() {      public void testToString() {
331          String s = TimeUnit.SECONDS.toString();          String s = TimeUnit.SECONDS.toString();
332          assertTrue(s.indexOf("econd") >= 0);          assertTrue(s.indexOf("ECOND") >= 0);
333      }      }
334    
335    
# Line 182  Line 337 
337       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
338       *  IllegalMonitorStateException       *  IllegalMonitorStateException
339       */       */
340      /**      public void testTimedWait_IllegalMonitorException() throws Exception {
341       *          Thread t = new Thread(new CheckedRunnable() {
342       */              public void realRun() throws InterruptedException {
     public void testTimedWait_IllegalMonitorException() {  
         //created a new thread with anonymous runnable  
   
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
343                      Object o = new Object();                      Object o = new Object();
344                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
345                      try {                      try {
346                          tu.timedWait(o,LONG_DELAY_MS);                          tu.timedWait(o,LONG_DELAY_MS);
347                          threadShouldThrow();                          threadShouldThrow();
348                      }                  } catch (IllegalMonitorStateException success) {}}});
                     catch (InterruptedException ie) {  
                         threadUnexpectedException();  
                     }  
                     catch(IllegalMonitorStateException success) {  
                     }  
349    
                 }  
             });  
350          t.start();          t.start();
         try {  
351              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
352              t.interrupt();              t.interrupt();
353              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
354      }      }
355    
356      /**      /**
357       *   timedWait will throw InterruptedException.       * timedWait throws InterruptedException when interrupted
      *  Thread t waits on timedWait while the main thread interrupts it.  
      *  Note:  This does not throw IllegalMonitorException since timeWait  
      *         is synchronized on o  
      */  
     /**  
      *  
358       */       */
359      public void testTimedWait() {      public void testTimedWait() throws InterruptedException {
360          Thread t = new Thread(new Runnable() {          Thread t = new Thread(new CheckedInterruptedRunnable() {
361                  public void run() {              public void realRun() throws InterruptedException {
362                      Object o = new Object();                      Object o = new Object();
363    
364                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
                     try {  
365                          synchronized(o) {                          synchronized(o) {
366                              tu.timedWait(o,MEDIUM_DELAY_MS);                              tu.timedWait(o,MEDIUM_DELAY_MS);
367                          }                          }
368                          threadShouldThrow();              }});
                     }  
                     catch(InterruptedException success) {}  
                     catch(IllegalMonitorStateException failure) {  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
369          t.start();          t.start();
         try {  
370              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
371              t.interrupt();              t.interrupt();
372              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
373      }      }
374    
375    
376      /**      /**
377       *   timedJoin will throw InterruptedException.       * timedJoin throws InterruptedException when interrupted
      *  Thread t waits on timedJoin while the main thread interrupts it.  
378       */       */
379      /**      public void testTimedJoin() throws InterruptedException {
380       *          final Thread s = new Thread(new CheckedInterruptedRunnable() {
381       */              public void realRun() throws InterruptedException {
     public void testTimedJoin() {  
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     TimeUnit tu = TimeUnit.MILLISECONDS;  
                     try {  
                         Thread s = new Thread(new Runnable() {  
                                 public void run() {  
                                     try {  
382                                          Thread.sleep(MEDIUM_DELAY_MS);                                          Thread.sleep(MEDIUM_DELAY_MS);
383                                      } catch(InterruptedException success){}              }});
384                                  }          final Thread t = new Thread(new CheckedInterruptedRunnable() {
385                              });              public void realRun() throws InterruptedException {
386                          s.start();                  TimeUnit tu = TimeUnit.MILLISECONDS;
387                          tu.timedJoin(s,MEDIUM_DELAY_MS);                          tu.timedJoin(s,MEDIUM_DELAY_MS);
388                          threadShouldThrow();              }});;
389                      }          s.start();
                     catch(Exception e) {}  
                 }  
             });  
390          t.start();          t.start();
         try {  
391              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
392              t.interrupt();              t.interrupt();
393              t.join();              t.join();
394          } catch(Exception e) {          s.interrupt();
395              unexpectedException();          s.join();
         }  
396      }      }
397    
398      /**      /**
399       *   timedSleep will throw InterruptedException.       *  timedSleep throws InterruptedException when interrupted
      *  Thread t waits on timedSleep while the main thread interrupts it.  
400       */       */
401      /**      public void testTimedSleep() throws InterruptedException {
402       *          Thread t = new Thread(new CheckedInterruptedRunnable() {
403       */              public void realRun() throws InterruptedException {
     public void testTimedSleep() {  
         //created a new thread with anonymous runnable  
   
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
404                      TimeUnit tu = TimeUnit.MILLISECONDS;                      TimeUnit tu = TimeUnit.MILLISECONDS;
                     try {  
405                          tu.sleep(MEDIUM_DELAY_MS);                          tu.sleep(MEDIUM_DELAY_MS);
406                          threadShouldThrow();              }});
407                      }  
                     catch(InterruptedException success) {}  
                 }  
             });  
408          t.start();          t.start();
         try {  
409              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
410              t.interrupt();              t.interrupt();
411              t.join();              t.join();
         } catch(Exception e) {  
             unexpectedException();  
         }  
412      }      }
413    
414      /**      /**
415       *       * a deserialized serialized unit is the same instance
416       */       */
417      public void testSerialization() {      public void testSerialization() throws Exception {
418          TimeUnit q = TimeUnit.MILLISECONDS;          TimeUnit q = TimeUnit.MILLISECONDS;
419    
         try {  
420              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);              ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
421              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));              ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
422              out.writeObject(q);              out.writeObject(q);
# Line 333  Line 425 
425              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());              ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
426              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));              ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
427              TimeUnit r = (TimeUnit)in.readObject();              TimeUnit r = (TimeUnit)in.readObject();
428            assertSame(q, r);
             assertEquals(q.toString(), r.toString());  
         } catch(Exception e){  
             e.printStackTrace();  
             unexpectedException();  
         }  
429      }      }
430    
431  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8