--- jsr166/src/test/tck/TimeUnitTest.java 2004/12/30 13:04:50 1.9 +++ jsr166/src/test/tck/TimeUnitTest.java 2013/09/24 16:48:52 1.23 @@ -1,23 +1,23 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain - * Other contributors include Andrew Wright, Jeffrey Hayes, - * Pat Fisher, Mike Judd. + * http://creativecommons.org/publicdomain/zero/1.0/ + * Other contributors include Andrew Wright, Jeffrey Hayes, + * Pat Fisher, Mike Judd. */ - import junit.framework.*; -import java.util.concurrent.*; -import java.io.*; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import static java.util.concurrent.TimeUnit.*; public class TimeUnitTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run(suite()); + junit.textui.TestRunner.run(suite()); } - + public static Test suite() { - return new TestSuite(TimeUnitTest.class); + return new TestSuite(TimeUnitTest.class); } // (loops to 88888 check increments at all time divisions.) @@ -27,94 +27,65 @@ public class TimeUnitTest extends JSR166 */ public void testConvert() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*60*60*24, - TimeUnit.SECONDS.convert(t, - TimeUnit.DAYS)); - assertEquals(t*60*60, - TimeUnit.SECONDS.convert(t, - TimeUnit.HOURS)); - assertEquals(t*60, - TimeUnit.SECONDS.convert(t, - TimeUnit.MINUTES)); - assertEquals(t, - TimeUnit.SECONDS.convert(t, - TimeUnit.SECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000L*t, - TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000000L*t, - TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.SECONDS.convert(1000000000L*t, - TimeUnit.NANOSECONDS)); - - - assertEquals(1000L*t*60*60*24, - TimeUnit.MILLISECONDS.convert(t, - TimeUnit.DAYS)); - assertEquals(1000L*t*60*60, - TimeUnit.MILLISECONDS.convert(t, - TimeUnit.HOURS)); - assertEquals(1000L*t*60, - TimeUnit.MILLISECONDS.convert(t, - TimeUnit.MINUTES)); - assertEquals(1000L*t, - TimeUnit.MILLISECONDS.convert(t, - TimeUnit.SECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(t, - TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(1000L*t, - TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.MILLISECONDS.convert(1000000L*t, - TimeUnit.NANOSECONDS)); - - assertEquals(1000000L*t*60*60*24, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.DAYS)); - assertEquals(1000000L*t*60*60, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.HOURS)); - assertEquals(1000000L*t*60, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.MINUTES)); - assertEquals(1000000L*t, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.SECONDS)); - assertEquals(1000L*t, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.MILLISECONDS)); - assertEquals(t, - TimeUnit.MICROSECONDS.convert(t, - TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.MICROSECONDS.convert(1000L*t, - TimeUnit.NANOSECONDS)); - - assertEquals(1000000000L*t*60*60*24, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.DAYS)); - assertEquals(1000000000L*t*60*60, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.HOURS)); - assertEquals(1000000000L*t*60, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.MINUTES)); - assertEquals(1000000000L*t, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.SECONDS)); - assertEquals(1000000L*t, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.MILLISECONDS)); - assertEquals(1000L*t, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.MICROSECONDS)); - assertEquals(t, - TimeUnit.NANOSECONDS.convert(t, - TimeUnit.NANOSECONDS)); + assertEquals(t*60*60*24, + SECONDS.convert(t, DAYS)); + assertEquals(t*60*60, + SECONDS.convert(t, HOURS)); + assertEquals(t*60, + SECONDS.convert(t, MINUTES)); + assertEquals(t, + SECONDS.convert(t, SECONDS)); + assertEquals(t, + SECONDS.convert(1000L*t, MILLISECONDS)); + assertEquals(t, + SECONDS.convert(1000000L*t, MICROSECONDS)); + assertEquals(t, + SECONDS.convert(1000000000L*t, NANOSECONDS)); + + assertEquals(1000L*t*60*60*24, + MILLISECONDS.convert(t, DAYS)); + assertEquals(1000L*t*60*60, + MILLISECONDS.convert(t, HOURS)); + assertEquals(1000L*t*60, + MILLISECONDS.convert(t, MINUTES)); + assertEquals(1000L*t, + MILLISECONDS.convert(t, SECONDS)); + assertEquals(t, + MILLISECONDS.convert(t, MILLISECONDS)); + assertEquals(t, + MILLISECONDS.convert(1000L*t, MICROSECONDS)); + assertEquals(t, + MILLISECONDS.convert(1000000L*t, NANOSECONDS)); + + assertEquals(1000000L*t*60*60*24, + MICROSECONDS.convert(t, DAYS)); + assertEquals(1000000L*t*60*60, + MICROSECONDS.convert(t, HOURS)); + assertEquals(1000000L*t*60, + MICROSECONDS.convert(t, MINUTES)); + assertEquals(1000000L*t, + MICROSECONDS.convert(t, SECONDS)); + assertEquals(1000L*t, + MICROSECONDS.convert(t, MILLISECONDS)); + assertEquals(t, + MICROSECONDS.convert(t, MICROSECONDS)); + assertEquals(t, + MICROSECONDS.convert(1000L*t, NANOSECONDS)); + + assertEquals(1000000000L*t*60*60*24, + NANOSECONDS.convert(t, DAYS)); + assertEquals(1000000000L*t*60*60, + NANOSECONDS.convert(t, HOURS)); + assertEquals(1000000000L*t*60, + NANOSECONDS.convert(t, MINUTES)); + assertEquals(1000000000L*t, + NANOSECONDS.convert(t, SECONDS)); + assertEquals(1000000L*t, + NANOSECONDS.convert(t, MILLISECONDS)); + assertEquals(1000L*t, + NANOSECONDS.convert(t, MICROSECONDS)); + assertEquals(t, + NANOSECONDS.convert(t, NANOSECONDS)); } } @@ -124,20 +95,20 @@ public class TimeUnitTest extends JSR166 */ public void testToNanos() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*1000000000L*60*60*24, - TimeUnit.DAYS.toNanos(t)); - assertEquals(t*1000000000L*60*60, - TimeUnit.HOURS.toNanos(t)); - assertEquals(t*1000000000L*60, - TimeUnit.MINUTES.toNanos(t)); - assertEquals(1000000000L*t, - TimeUnit.SECONDS.toNanos(t)); - assertEquals(1000000L*t, - TimeUnit.MILLISECONDS.toNanos(t)); - assertEquals(1000L*t, - TimeUnit.MICROSECONDS.toNanos(t)); - assertEquals(t, - TimeUnit.NANOSECONDS.toNanos(t)); + assertEquals(t*1000000000L*60*60*24, + DAYS.toNanos(t)); + assertEquals(t*1000000000L*60*60, + HOURS.toNanos(t)); + assertEquals(t*1000000000L*60, + MINUTES.toNanos(t)); + assertEquals(1000000000L*t, + SECONDS.toNanos(t)); + assertEquals(1000000L*t, + MILLISECONDS.toNanos(t)); + assertEquals(1000L*t, + MICROSECONDS.toNanos(t)); + assertEquals(t, + NANOSECONDS.toNanos(t)); } } @@ -147,20 +118,20 @@ public class TimeUnitTest extends JSR166 */ public void testToMicros() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*1000000L*60*60*24, - TimeUnit.DAYS.toMicros(t)); - assertEquals(t*1000000L*60*60, - TimeUnit.HOURS.toMicros(t)); - assertEquals(t*1000000L*60, - TimeUnit.MINUTES.toMicros(t)); - assertEquals(1000000L*t, - TimeUnit.SECONDS.toMicros(t)); - assertEquals(1000L*t, - TimeUnit.MILLISECONDS.toMicros(t)); - assertEquals(t, - TimeUnit.MICROSECONDS.toMicros(t)); - assertEquals(t, - TimeUnit.NANOSECONDS.toMicros(t*1000L)); + assertEquals(t*1000000L*60*60*24, + DAYS.toMicros(t)); + assertEquals(t*1000000L*60*60, + HOURS.toMicros(t)); + assertEquals(t*1000000L*60, + MINUTES.toMicros(t)); + assertEquals(1000000L*t, + SECONDS.toMicros(t)); + assertEquals(1000L*t, + MILLISECONDS.toMicros(t)); + assertEquals(t, + MICROSECONDS.toMicros(t)); + assertEquals(t, + NANOSECONDS.toMicros(t*1000L)); } } @@ -170,20 +141,20 @@ public class TimeUnitTest extends JSR166 */ public void testToMillis() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*1000L*60*60*24, - TimeUnit.DAYS.toMillis(t)); - assertEquals(t*1000L*60*60, - TimeUnit.HOURS.toMillis(t)); - assertEquals(t*1000L*60, - TimeUnit.MINUTES.toMillis(t)); - assertEquals(1000L*t, - TimeUnit.SECONDS.toMillis(t)); - assertEquals(t, - TimeUnit.MILLISECONDS.toMillis(t)); - assertEquals(t, - TimeUnit.MICROSECONDS.toMillis(t*1000L)); - assertEquals(t, - TimeUnit.NANOSECONDS.toMillis(t*1000000L)); + assertEquals(t*1000L*60*60*24, + DAYS.toMillis(t)); + assertEquals(t*1000L*60*60, + HOURS.toMillis(t)); + assertEquals(t*1000L*60, + MINUTES.toMillis(t)); + assertEquals(1000L*t, + SECONDS.toMillis(t)); + assertEquals(t, + MILLISECONDS.toMillis(t)); + assertEquals(t, + MICROSECONDS.toMillis(t*1000L)); + assertEquals(t, + NANOSECONDS.toMillis(t*1000000L)); } } @@ -193,20 +164,20 @@ public class TimeUnitTest extends JSR166 */ public void testToSeconds() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*60*60*24, - TimeUnit.DAYS.toSeconds(t)); - assertEquals(t*60*60, - TimeUnit.HOURS.toSeconds(t)); - assertEquals(t*60, - TimeUnit.MINUTES.toSeconds(t)); - assertEquals(t, - TimeUnit.SECONDS.toSeconds(t)); - assertEquals(t, - TimeUnit.MILLISECONDS.toSeconds(t*1000L)); - assertEquals(t, - TimeUnit.MICROSECONDS.toSeconds(t*1000000L)); - assertEquals(t, - TimeUnit.NANOSECONDS.toSeconds(t*1000000000L)); + assertEquals(t*60*60*24, + DAYS.toSeconds(t)); + assertEquals(t*60*60, + HOURS.toSeconds(t)); + assertEquals(t*60, + MINUTES.toSeconds(t)); + assertEquals(t, + SECONDS.toSeconds(t)); + assertEquals(t, + MILLISECONDS.toSeconds(t*1000L)); + assertEquals(t, + MICROSECONDS.toSeconds(t*1000000L)); + assertEquals(t, + NANOSECONDS.toSeconds(t*1000000000L)); } } @@ -216,20 +187,20 @@ public class TimeUnitTest extends JSR166 */ public void testToMinutes() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*60*24, - TimeUnit.DAYS.toMinutes(t)); - assertEquals(t*60, - TimeUnit.HOURS.toMinutes(t)); - assertEquals(t, - TimeUnit.MINUTES.toMinutes(t)); - assertEquals(t, - TimeUnit.SECONDS.toMinutes(t*60)); - assertEquals(t, - TimeUnit.MILLISECONDS.toMinutes(t*1000L*60)); - assertEquals(t, - TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60)); - assertEquals(t, - TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60)); + assertEquals(t*60*24, + DAYS.toMinutes(t)); + assertEquals(t*60, + HOURS.toMinutes(t)); + assertEquals(t, + MINUTES.toMinutes(t)); + assertEquals(t, + SECONDS.toMinutes(t*60)); + assertEquals(t, + MILLISECONDS.toMinutes(t*1000L*60)); + assertEquals(t, + MICROSECONDS.toMinutes(t*1000000L*60)); + assertEquals(t, + NANOSECONDS.toMinutes(t*1000000000L*60)); } } @@ -239,20 +210,20 @@ public class TimeUnitTest extends JSR166 */ public void testToHours() { for (long t = 0; t < 88888; ++t) { - assertEquals(t*24, - TimeUnit.DAYS.toHours(t)); - assertEquals(t, - TimeUnit.HOURS.toHours(t)); - assertEquals(t, - TimeUnit.MINUTES.toHours(t*60)); - assertEquals(t, - TimeUnit.SECONDS.toHours(t*60*60)); - assertEquals(t, - TimeUnit.MILLISECONDS.toHours(t*1000L*60*60)); - assertEquals(t, - TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60)); - assertEquals(t, - TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60)); + assertEquals(t*24, + DAYS.toHours(t)); + assertEquals(t, + HOURS.toHours(t)); + assertEquals(t, + MINUTES.toHours(t*60)); + assertEquals(t, + SECONDS.toHours(t*60*60)); + assertEquals(t, + MILLISECONDS.toHours(t*1000L*60*60)); + assertEquals(t, + MICROSECONDS.toHours(t*1000000L*60*60)); + assertEquals(t, + NANOSECONDS.toHours(t*1000000000L*60*60)); } } @@ -262,221 +233,195 @@ public class TimeUnitTest extends JSR166 */ public void testToDays() { for (long t = 0; t < 88888; ++t) { - assertEquals(t, - TimeUnit.DAYS.toDays(t)); - assertEquals(t, - TimeUnit.HOURS.toDays(t*24)); - assertEquals(t, - TimeUnit.MINUTES.toDays(t*60*24)); - assertEquals(t, - TimeUnit.SECONDS.toDays(t*60*60*24)); - assertEquals(t, - TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24)); - assertEquals(t, - TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24)); - assertEquals(t, - TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24)); + assertEquals(t, + DAYS.toDays(t)); + assertEquals(t, + HOURS.toDays(t*24)); + assertEquals(t, + MINUTES.toDays(t*60*24)); + assertEquals(t, + SECONDS.toDays(t*60*60*24)); + assertEquals(t, + MILLISECONDS.toDays(t*1000L*60*60*24)); + assertEquals(t, + MICROSECONDS.toDays(t*1000000L*60*60*24)); + assertEquals(t, + NANOSECONDS.toDays(t*1000000000L*60*60*24)); } } - /** - * convert saturates positive too-large values to Long.MAX_VALUE + * convert saturates positive too-large values to Long.MAX_VALUE * and negative to LONG.MIN_VALUE */ public void testConvertSaturate() { assertEquals(Long.MAX_VALUE, - TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, - TimeUnit.SECONDS)); + NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS)); assertEquals(Long.MIN_VALUE, - TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, - TimeUnit.SECONDS)); + NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS)); assertEquals(Long.MAX_VALUE, - TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, - TimeUnit.MINUTES)); + NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES)); assertEquals(Long.MIN_VALUE, - TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, - TimeUnit.MINUTES)); + NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES)); assertEquals(Long.MAX_VALUE, - TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, - TimeUnit.HOURS)); + NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS)); assertEquals(Long.MIN_VALUE, - TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, - TimeUnit.HOURS)); + NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS)); assertEquals(Long.MAX_VALUE, - TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2, - TimeUnit.DAYS)); + NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS)); assertEquals(Long.MIN_VALUE, - TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4, - TimeUnit.DAYS)); - + NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS)); } /** - * toNanos saturates positive too-large values to Long.MAX_VALUE + * toNanos saturates positive too-large values to Long.MAX_VALUE * and negative to LONG.MIN_VALUE */ public void testToNanosSaturate() { - assertEquals(Long.MAX_VALUE, - TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2)); - assertEquals(Long.MIN_VALUE, - TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3)); + assertEquals(Long.MAX_VALUE, + MILLISECONDS.toNanos(Long.MAX_VALUE / 2)); + assertEquals(Long.MIN_VALUE, + MILLISECONDS.toNanos(-Long.MAX_VALUE / 3)); } - /** - * toString returns string containing common name of unit + * toString returns name of unit */ public void testToString() { - String s = TimeUnit.SECONDS.toString(); - assertTrue(s.indexOf("ECOND") >= 0); + assertEquals("SECONDS", SECONDS.toString()); } - /** - * Timed wait without holding lock throws - * IllegalMonitorStateException + * name returns name of unit */ - public void testTimedWait_IllegalMonitorException() { - //created a new thread with anonymous runnable - - Thread t = new Thread(new Runnable() { - public void run() { - Object o = new Object(); - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - tu.timedWait(o,LONG_DELAY_MS); - threadShouldThrow(); - } - catch (InterruptedException ie) { - threadUnexpectedException(); - } - catch(IllegalMonitorStateException success) { - } - - } - }); - t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + public void testName() { + assertEquals("SECONDS", SECONDS.name()); } - - /** - * timedWait throws InterruptedException when interrupted - */ - public void testTimedWait() { - Thread t = new Thread(new Runnable() { - public void run() { - Object o = new Object(); - - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - synchronized(o) { - tu.timedWait(o,MEDIUM_DELAY_MS); - } - threadShouldThrow(); - } - catch(InterruptedException success) {} - catch(IllegalMonitorStateException failure) { - threadUnexpectedException(); - } - } - }); - t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } - } - - + /** - * timedJoin throws InterruptedException when interrupted + * Timed wait without holding lock throws + * IllegalMonitorStateException */ - 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 { - Thread.sleep(MEDIUM_DELAY_MS); - } catch(InterruptedException success){} - } - }); - s.start(); - tu.timedJoin(s,MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(Exception e) {} - } - }); - t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + public void testTimedWait_IllegalMonitorException() { + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Object o = new Object(); + TimeUnit tu = MILLISECONDS; + + try { + tu.timedWait(o, LONG_DELAY_MS); + threadShouldThrow(); + } catch (IllegalMonitorStateException success) {} + }}); + + awaitTermination(t); } - + /** - * timedSleep throws InterruptedException when interrupted + * timedWait throws InterruptedException when interrupted */ - public void testTimedSleep() { - //created a new thread with anonymous runnable - - Thread t = new Thread(new Runnable() { - public void run() { - TimeUnit tu = TimeUnit.MILLISECONDS; - try { - tu.sleep(MEDIUM_DELAY_MS); - threadShouldThrow(); - } - catch(InterruptedException success) {} - } - }); - t.start(); - try { - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - } catch(Exception e) { - unexpectedException(); - } + public void testTimedWait_Interruptible() { + final CountDownLatch pleaseInterrupt = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + Object o = new Object(); + TimeUnit tu = MILLISECONDS; + + Thread.currentThread().interrupt(); + try { + synchronized (o) { + tu.timedWait(o, LONG_DELAY_MS); + } + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + + pleaseInterrupt.countDown(); + try { + synchronized (o) { + tu.timedWait(o, LONG_DELAY_MS); + } + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + }}); + + await(pleaseInterrupt); + assertThreadStaysAlive(t); + t.interrupt(); + awaitTermination(t); } /** - * a deserialized serialized unit is equal + * timedJoin throws InterruptedException when interrupted */ - public void testSerialization() { - TimeUnit q = TimeUnit.MILLISECONDS; - - try { - 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(); - - assertEquals(q.toString(), r.toString()); - } catch(Exception e){ - e.printStackTrace(); - unexpectedException(); - } + public void testTimedJoin_Interruptible() { + final CountDownLatch pleaseInterrupt = new CountDownLatch(1); + final Thread s = newStartedThread(new CheckedInterruptedRunnable() { + public void realRun() throws InterruptedException { + Thread.sleep(LONG_DELAY_MS); + }}); + final Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + TimeUnit tu = MILLISECONDS; + Thread.currentThread().interrupt(); + try { + tu.timedJoin(s, LONG_DELAY_MS); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + + pleaseInterrupt.countDown(); + try { + tu.timedJoin(s, LONG_DELAY_MS); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + }}); + + await(pleaseInterrupt); + assertThreadStaysAlive(t); + t.interrupt(); + awaitTermination(t); + s.interrupt(); + awaitTermination(s); + } + + /** + * timedSleep throws InterruptedException when interrupted + */ + public void testTimedSleep_Interruptible() { + final CountDownLatch pleaseInterrupt = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + TimeUnit tu = MILLISECONDS; + Thread.currentThread().interrupt(); + try { + tu.sleep(LONG_DELAY_MS); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + + pleaseInterrupt.countDown(); + try { + tu.sleep(LONG_DELAY_MS); + shouldThrow(); + } catch (InterruptedException success) {} + assertFalse(Thread.interrupted()); + }}); + + await(pleaseInterrupt); + assertThreadStaysAlive(t); + t.interrupt(); + awaitTermination(t); + } + + /** + * a deserialized serialized unit is the same instance + */ + public void testSerialization() throws Exception { + TimeUnit x = MILLISECONDS; + assertSame(x, serialClone(x)); } }