--- jsr166/src/test/tck/TimeUnitTest.java 2016/03/25 04:53:28 1.29 +++ jsr166/src/test/tck/TimeUnitTest.java 2019/09/08 23:45:54 1.37 @@ -14,7 +14,6 @@ import static java.util.concurrent.TimeU import static java.util.concurrent.TimeUnit.NANOSECONDS; import static java.util.concurrent.TimeUnit.SECONDS; -import java.time.temporal.ChronoUnit; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; @@ -30,243 +29,56 @@ public class TimeUnitTest extends JSR166 return new TestSuite(TimeUnitTest.class); } - // (loops to 88888 check increments at all time divisions.) - - /** - * convert correctly converts sample values across the units - */ - public void testConvert() { - for (long t = 0; t < 88888; ++t) { - 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)); - } - - for (TimeUnit x : TimeUnit.values()) { - long[] zs = { - 0, 1, -1, - Integer.MAX_VALUE, Integer.MIN_VALUE, - Long.MAX_VALUE, Long.MIN_VALUE, - }; - for (long z : zs) assertEquals(z, x.convert(z, x)); - } - } - - /** - * toNanos correctly converts sample values in different units to - * nanoseconds - */ - public void testToNanos() { - for (long t = 0; t < 88888; ++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)); - } - } - - /** - * toMicros correctly converts sample values in different units to - * microseconds - */ - public void testToMicros() { - for (long t = 0; t < 88888; ++t) { - 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)); - } - } - - /** - * toMillis correctly converts sample values in different units to - * milliseconds - */ - public void testToMillis() { - for (long t = 0; t < 88888; ++t) { - 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)); - } - } - - /** - * toSeconds correctly converts sample values in different units to - * seconds - */ - public void testToSeconds() { - for (long t = 0; t < 88888; ++t) { - 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)); + void testConversion(TimeUnit x, TimeUnit y, long n, long expected) { + assertEquals(expected, x.convert(n, y)); + switch (x) { + case NANOSECONDS: assertEquals(expected, y.toNanos(n)); break; + case MICROSECONDS: assertEquals(expected, y.toMicros(n)); break; + case MILLISECONDS: assertEquals(expected, y.toMillis(n)); break; + case SECONDS: assertEquals(expected, y.toSeconds(n)); break; + case MINUTES: assertEquals(expected, y.toMinutes(n)); break; + case HOURS: assertEquals(expected, y.toHours(n)); break; + case DAYS: assertEquals(expected, y.toDays(n)); break; + default: throw new AssertionError(); + } + + if (n > 0) testConversion(x, y, -n, -expected); + } + + void testConversion(TimeUnit x, TimeUnit y) { + long ratio = x.toNanos(1)/y.toNanos(1); + assertTrue(ratio > 0); + long[] ns = { 0, 1, 2, Long.MAX_VALUE/ratio, Long.MIN_VALUE/ratio }; + for (long n : ns) { + testConversion(y, x, n, n * ratio); + long[] ks = { n * ratio, n * ratio + 1, n * ratio - 1 }; + for (long k : ks) { + testConversion(x, y, k, k / ratio); + } } } /** - * toMinutes correctly converts sample values in different units to - * minutes + * Conversion methods correctly convert sample values */ - public void testToMinutes() { - for (long t = 0; t < 88888; ++t) { - 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)); - } - } + public void testConversions() { + // Sanity check + assertEquals(1, NANOSECONDS.toNanos(1)); + assertEquals(1000L * NANOSECONDS.toNanos(1), MICROSECONDS.toNanos(1)); + assertEquals(1000L * MICROSECONDS.toNanos(1), MILLISECONDS.toNanos(1)); + assertEquals(1000L * MILLISECONDS.toNanos(1), SECONDS.toNanos(1)); + assertEquals(60L * SECONDS.toNanos(1), MINUTES.toNanos(1)); + assertEquals(60L * MINUTES.toNanos(1), HOURS.toNanos(1)); + assertEquals(24L * HOURS.toNanos(1), DAYS.toNanos(1)); - /** - * toHours correctly converts sample values in different units to - * hours - */ - public void testToHours() { - for (long t = 0; t < 88888; ++t) { - 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)); + for (TimeUnit x : TimeUnit.values()) { + assertEquals(x.toNanos(1), NANOSECONDS.convert(1, x)); } - } - /** - * toDays correctly converts sample values in different units to - * days - */ - public void testToDays() { - for (long t = 0; t < 88888; ++t) { - 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)); - } + for (TimeUnit x : TimeUnit.values()) + for (TimeUnit y : TimeUnit.values()) + if (x.toNanos(1) >= y.toNanos(1)) + testConversion(x, y); } /** @@ -468,14 +280,21 @@ public class TimeUnitTest extends JSR166 * toString returns name of unit */ public void testToString() { + assertEquals("NANOSECONDS", NANOSECONDS.toString()); + assertEquals("MICROSECONDS", MICROSECONDS.toString()); + assertEquals("MILLISECONDS", MILLISECONDS.toString()); assertEquals("SECONDS", SECONDS.toString()); + assertEquals("MINUTES", MINUTES.toString()); + assertEquals("HOURS", HOURS.toString()); + assertEquals("DAYS", DAYS.toString()); } /** * name returns name of unit */ public void testName() { - assertEquals("SECONDS", SECONDS.name()); + for (TimeUnit x : TimeUnit.values()) + assertEquals(x.toString(), x.name()); } /** @@ -486,10 +305,8 @@ public class TimeUnitTest extends JSR166 Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { Object o = new Object(); - TimeUnit tu = MILLISECONDS; - try { - tu.timedWait(o, LONG_DELAY_MS); + MILLISECONDS.timedWait(o, LONGER_DELAY_MS); threadShouldThrow(); } catch (IllegalMonitorStateException success) {} }}); @@ -505,12 +322,11 @@ public class TimeUnitTest extends JSR166 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); + MILLISECONDS.timedWait(o, LONGER_DELAY_MS); } shouldThrow(); } catch (InterruptedException success) {} @@ -519,7 +335,7 @@ public class TimeUnitTest extends JSR166 pleaseInterrupt.countDown(); try { synchronized (o) { - tu.timedWait(o, LONG_DELAY_MS); + MILLISECONDS.timedWait(o, LONGER_DELAY_MS); } shouldThrow(); } catch (InterruptedException success) {} @@ -527,7 +343,7 @@ public class TimeUnitTest extends JSR166 }}); await(pleaseInterrupt); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } @@ -539,28 +355,27 @@ public class TimeUnitTest extends JSR166 final CountDownLatch pleaseInterrupt = new CountDownLatch(1); final Thread s = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { - Thread.sleep(LONG_DELAY_MS); + Thread.sleep(LONGER_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); + MILLISECONDS.timedJoin(s, LONGER_DELAY_MS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - tu.timedJoin(s, LONG_DELAY_MS); + MILLISECONDS.timedJoin(s, LONGER_DELAY_MS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); s.interrupt(); @@ -568,85 +383,51 @@ public class TimeUnitTest extends JSR166 } /** - * timedSleep throws InterruptedException when interrupted + * timeUnit.sleep 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); + MILLISECONDS.sleep(LONGER_DELAY_MS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); pleaseInterrupt.countDown(); try { - tu.sleep(LONG_DELAY_MS); + MILLISECONDS.sleep(LONGER_DELAY_MS); shouldThrow(); } catch (InterruptedException success) {} assertFalse(Thread.interrupted()); }}); await(pleaseInterrupt); - assertThreadStaysAlive(t); + if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING); t.interrupt(); awaitTermination(t); } /** - * a deserialized serialized unit is the same instance + * timeUnit.sleep(x) for x <= 0 does not sleep at all. */ - public void testSerialization() throws Exception { - for (TimeUnit x : TimeUnit.values()) - assertSame(x, serialClone(x)); + public void testTimedSleep_nonPositive() throws InterruptedException { + boolean interrupt = randomBoolean(); + if (interrupt) Thread.currentThread().interrupt(); + randomTimeUnit().sleep(0L); + randomTimeUnit().sleep(-1L); + randomTimeUnit().sleep(Long.MIN_VALUE); + if (interrupt) assertTrue(Thread.interrupted()); } /** - * tests for toChronoUnit. + * a deserialized/reserialized unit is the same instance */ - public void testToChronoUnit() throws Exception { - assertSame(ChronoUnit.NANOS, NANOSECONDS.toChronoUnit()); - assertSame(ChronoUnit.MICROS, MICROSECONDS.toChronoUnit()); - assertSame(ChronoUnit.MILLIS, MILLISECONDS.toChronoUnit()); - assertSame(ChronoUnit.SECONDS, SECONDS.toChronoUnit()); - assertSame(ChronoUnit.MINUTES, MINUTES.toChronoUnit()); - assertSame(ChronoUnit.HOURS, HOURS.toChronoUnit()); - assertSame(ChronoUnit.DAYS, DAYS.toChronoUnit()); - - // Every TimeUnit has a defined ChronoUnit equivalent + public void testSerialization() throws Exception { for (TimeUnit x : TimeUnit.values()) - assertSame(x, TimeUnit.of(x.toChronoUnit())); - } - - /** - * tests for TimeUnit.of(ChronoUnit). - */ - public void testTimeUnitOf() throws Exception { - assertSame(NANOSECONDS, TimeUnit.of(ChronoUnit.NANOS)); - assertSame(MICROSECONDS, TimeUnit.of(ChronoUnit.MICROS)); - assertSame(MILLISECONDS, TimeUnit.of(ChronoUnit.MILLIS)); - assertSame(SECONDS, TimeUnit.of(ChronoUnit.SECONDS)); - assertSame(MINUTES, TimeUnit.of(ChronoUnit.MINUTES)); - assertSame(HOURS, TimeUnit.of(ChronoUnit.HOURS)); - assertSame(DAYS, TimeUnit.of(ChronoUnit.DAYS)); - - assertThrows(NullPointerException.class, - () -> TimeUnit.of((ChronoUnit)null)); - - // ChronoUnits either round trip to their TimeUnit - // equivalents, or throw IllegalArgumentException. - for (ChronoUnit cu : ChronoUnit.values()) { - final TimeUnit tu; - try { - tu = TimeUnit.of(cu); - } catch (IllegalArgumentException acceptable) { - continue; - } - assertSame(cu, tu.toChronoUnit()); - } + assertSame(x, serialClone(x)); } }