[cvs] / jsr166 / src / test / tck / TimeUnitTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/TimeUnitTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.14, Sat Nov 21 02:07:27 2009 UTC revision 1.21, Sat May 28 12:13:08 2011 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain   * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
   
9  import junit.framework.*;  import junit.framework.*;
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11  import java.io.*;  import java.io.*;
# Line 49  Line 48 
48                           TimeUnit.SECONDS.convert(1000000000L*t,                           TimeUnit.SECONDS.convert(1000000000L*t,
49                                                    TimeUnit.NANOSECONDS));                                                    TimeUnit.NANOSECONDS));
50    
   
51              assertEquals(1000L*t*60*60*24,              assertEquals(1000L*t*60*60*24,
52                           TimeUnit.MILLISECONDS.convert(t,                           TimeUnit.MILLISECONDS.convert(t,
53                                                    TimeUnit.DAYS));                                                    TimeUnit.DAYS));
# Line 279  Line 277 
277          }          }
278      }      }
279    
   
280      /**      /**
281       * convert saturates positive too-large values to Long.MAX_VALUE       * convert saturates positive too-large values to Long.MAX_VALUE
282       * and negative to LONG.MIN_VALUE       * and negative to LONG.MIN_VALUE
# Line 309  Line 306 
306          assertEquals(Long.MIN_VALUE,          assertEquals(Long.MIN_VALUE,
307                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,                       TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
308                                                    TimeUnit.DAYS));                                                    TimeUnit.DAYS));
   
309      }      }
310    
311      /**      /**
# Line 323  Line 319 
319                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));                       TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
320      }      }
321    
   
322      /**      /**
323       * toString returns string containing common name of unit       * toString returns name of unit
324       */       */
325      public void testToString() {      public void testToString() {
326          String s = TimeUnit.SECONDS.toString();          assertEquals("SECONDS", TimeUnit.SECONDS.toString());
         assertTrue(s.indexOf("ECOND") >= 0);  
327      }      }
328    
329        /**
330         * name returns name of unit
331         */
332        public void testName() {
333            assertEquals("SECONDS", TimeUnit.SECONDS.name());
334        }
335    
336      /**      /**
337       *  Timed wait without holding lock throws       *  Timed wait without holding lock throws
338       *  IllegalMonitorStateException       *  IllegalMonitorStateException
339       */       */
340      public void testTimedWait_IllegalMonitorException() throws Exception {      public void testTimedWait_IllegalMonitorException() {
341          Thread t = new Thread(new CheckedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
342              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
343                  Object o = new Object();                  Object o = new Object();
344                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
345    
346                  try {                  try {
347                      tu.timedWait(o,LONG_DELAY_MS);                      tu.timedWait(o,LONG_DELAY_MS);
348                      threadShouldThrow();                      threadShouldThrow();
349                  } catch (IllegalMonitorStateException success) {}}});                  } catch (IllegalMonitorStateException success) {}
350                }});
351    
352          t.start();          awaitTermination(t);
         Thread.sleep(SHORT_DELAY_MS);  
         t.interrupt();  
         t.join();  
353      }      }
354    
355      /**      /**
356       * timedWait throws InterruptedException when interrupted       * timedWait throws InterruptedException when interrupted
357       */       */
358      public void testTimedWait() throws InterruptedException {      public void testTimedWait_Interruptible() {
359          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
360            Thread t = newStartedThread(new CheckedRunnable() {
361              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
362                  Object o = new Object();                  Object o = new Object();
   
363                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
364    
365                    Thread.currentThread().interrupt();
366                    try {
367                  synchronized(o) {                  synchronized(o) {
368                      tu.timedWait(o,MEDIUM_DELAY_MS);                          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          t.start();  
384          Thread.sleep(SHORT_DELAY_MS);          await(pleaseInterrupt);
385            assertThreadStaysAlive(t);
386          t.interrupt();          t.interrupt();
387          t.join();          awaitTermination(t);
388      }      }
389    
   
390      /**      /**
391       * timedJoin throws InterruptedException when interrupted       * timedJoin throws InterruptedException when interrupted
392       */       */
393      public void testTimedJoin() throws InterruptedException {      public void testTimedJoin_Interruptible() {
394          final Thread s = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
395            final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
396              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
397                  Thread.sleep(MEDIUM_DELAY_MS);                  Thread.sleep(LONG_DELAY_MS);
398              }});              }});
399          final Thread t = new Thread(new CheckedInterruptedRunnable() {          final Thread t = newStartedThread(new CheckedRunnable() {
400              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
401                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
402                  tu.timedJoin(s, MEDIUM_DELAY_MS);                  Thread.currentThread().interrupt();
403              }});;                  try {
404          s.start();                      tu.timedJoin(s, LONG_DELAY_MS);
405          t.start();                      shouldThrow();
406          Thread.sleep(SHORT_DELAY_MS);                  } 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();          t.interrupt();
420          t.join();          awaitTermination(t);
421          s.interrupt();          s.interrupt();
422          s.join();          awaitTermination(s);
423      }      }
424    
425      /**      /**
426       *  timedSleep throws InterruptedException when interrupted       *  timedSleep throws InterruptedException when interrupted
427       */       */
428      public void testTimedSleep() throws InterruptedException {      public void testTimedSleep_Interruptible() {
429          Thread t = new Thread(new CheckedInterruptedRunnable() {          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
430            Thread t = newStartedThread(new CheckedRunnable() {
431              public void realRun() throws InterruptedException {              public void realRun() throws InterruptedException {
432                  TimeUnit tu = TimeUnit.MILLISECONDS;                  TimeUnit tu = TimeUnit.MILLISECONDS;
433                  tu.sleep(MEDIUM_DELAY_MS);                  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          t.start();          await(pleaseInterrupt);
449          Thread.sleep(SHORT_DELAY_MS);          assertThreadStaysAlive(t);
450          t.interrupt();          t.interrupt();
451          t.join();          awaitTermination(t);
452      }      }
453    
454      /**      /**
# Line 416  Line 456 
456       */       */
457      public void testSerialization() throws Exception {      public void testSerialization() throws Exception {
458          TimeUnit q = TimeUnit.MILLISECONDS;          TimeUnit q = TimeUnit.MILLISECONDS;
459            assertSame(q, serialClone(q));
         ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);  
         ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));  
         out.writeObject(q);  
         out.close();  
   
         ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());  
         ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));  
         TimeUnit r = (TimeUnit)in.readObject();  
         assertSame(q, r);  
460      }      }
461    
462  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8