test/tck/TimeUnitTest.java

/*
 * 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/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import static java.util.concurrent.TimeUnit.DAYS;
import static java.util.concurrent.TimeUnit.HOURS;
import static java.util.concurrent.TimeUnit.MICROSECONDS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.MINUTES;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import junit.framework.Test;
import junit.framework.TestSuite;

public class TimeUnitTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }

    public static Test suite() {
        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));
        }
    }

    /**
     * toMinutes correctly converts sample values in different units to
     * minutes
     */
    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));
        }
    }

    /**
     * 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));
        }
    }

    /**
     * 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));
        }
    }

    /**
     * convert saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testConvertSaturate() {
        assertEquals(Long.MAX_VALUE,
                     NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
        assertEquals(Long.MIN_VALUE,
                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
        assertEquals(Long.MAX_VALUE,
                     NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
        assertEquals(Long.MIN_VALUE,
                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
        assertEquals(Long.MAX_VALUE,
                     NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
        assertEquals(Long.MIN_VALUE,
                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
        assertEquals(Long.MAX_VALUE,
                     NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
        assertEquals(Long.MIN_VALUE,
                     NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));

        for (TimeUnit x : TimeUnit.values())
            for (TimeUnit y : TimeUnit.values()) {
                long ratio = x.toNanos(1) / y.toNanos(1);
                if (ratio >= 1) {
                    assertEquals(ratio, y.convert(1, x));
                    assertEquals(1, x.convert(ratio, y));
                    long max = Long.MAX_VALUE/ratio;
                    assertEquals(max * ratio, y.convert(max, x));
                    assertEquals(-max * ratio, y.convert(-max, x));
                    assertEquals(max, x.convert(max * ratio, y));
                    assertEquals(-max, x.convert(-max * ratio, y));
                    if (max < Long.MAX_VALUE) {
                        assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
                        assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
                        assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
                    }
                    assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
                    assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
                }
            }
    }

    /**
     * toNanos saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToNanosSaturate() {
        assertEquals(Long.MAX_VALUE,
                     MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
        assertEquals(Long.MIN_VALUE,
                     MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));

        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
            if (ratio >= 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toNanos(z));
                if (max < Long.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
                    assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
                    assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
                }
                assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
                if (max < Integer.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
                    assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
                }
            }
        }
    }

    /**
     * toMicros saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToMicrosSaturate() {
        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
            if (ratio >= 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toMicros(z));
                if (max < Long.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
                    assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
                    assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
                }
                assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
                if (max < Integer.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
                    assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
                }
            }
        }
    }

    /**
     * toMillis saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToMillisSaturate() {
        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
            if (ratio >= 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toMillis(z));
                if (max < Long.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
                    assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
                    assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
                }
                assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
                if (max < Integer.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
                    assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
                }
            }
        }
    }

    /**
     * toSeconds saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToSecondsSaturate() {
        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / SECONDS.toNanos(1);
            if (ratio >= 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toSeconds(z));
                if (max < Long.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
                    assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
                    assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
                }
                assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
                if (max < Integer.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
                    assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
                }
            }
        }
    }

    /**
     * toMinutes saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToMinutesSaturate() {
        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / MINUTES.toNanos(1);
            if (ratio > 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toMinutes(z));
                assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
                assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
                assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
                assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
            }
        }
    }

    /**
     * toHours saturates positive too-large values to Long.MAX_VALUE
     * and negative to LONG.MIN_VALUE
     */
    public void testToHoursSaturate() {
        for (TimeUnit x : TimeUnit.values()) {
            long ratio = x.toNanos(1) / HOURS.toNanos(1);
            if (ratio >= 1) {
                long max = Long.MAX_VALUE/ratio;
                for (long z : new long[] {0, 1, -1, max, -max})
                    assertEquals(z * ratio, x.toHours(z));
                if (max < Long.MAX_VALUE) {
                    assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
                    assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
                    assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
                }
                assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
                assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
            }
        }
    }

    /**
     * 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() {
        for (TimeUnit x : TimeUnit.values())
            assertEquals(x.toString(), x.name());
    }

    /**
     * Timed wait without holding lock throws
     * IllegalMonitorStateException
     */
    public void testTimedWait_IllegalMonitorException() {
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Object o = new Object();
                try {
                    MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
                    threadShouldThrow();
                } catch (IllegalMonitorStateException success) {}
            }});

        awaitTermination(t);
    }

    /**
     * timedWait throws InterruptedException when interrupted
     */
    public void testTimedWait_Interruptible() {
        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Object o = new Object();

                Thread.currentThread().interrupt();
                try {
                    synchronized (o) {
                        MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
                    }
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();
                try {
                    synchronized (o) {
                        MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
                    }
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        await(pleaseInterrupt);
        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timedJoin throws InterruptedException when interrupted
     */
    public void testTimedJoin_Interruptible() {
        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
        final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.sleep(LONGER_DELAY_MS);
            }});
        final Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                Thread.currentThread().interrupt();
                try {
                    MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();
                try {
                    MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        await(pleaseInterrupt);
        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        t.interrupt();
        awaitTermination(t);
        s.interrupt();
        awaitTermination(s);
    }

    /**
     * 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 {
                Thread.currentThread().interrupt();
                try {
                    MILLISECONDS.sleep(LONGER_DELAY_MS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());

                pleaseInterrupt.countDown();
                try {
                    MILLISECONDS.sleep(LONGER_DELAY_MS);
                    shouldThrow();
                } catch (InterruptedException success) {}
                assertFalse(Thread.interrupted());
            }});

        await(pleaseInterrupt);
        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        t.interrupt();
        awaitTermination(t);
    }

    /**
     * timeUnit.sleep(x) for x <= 0 does not sleep at all.
     */
    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());
    }

    /**
     * a deserialized/reserialized unit is the same instance
     */
    public void testSerialization() throws Exception {
        for (TimeUnit x : TimeUnit.values())
            assertSame(x, serialClone(x));
    }

}
Revision:	1.36
Committed:	Thu Sep 5 21:55:17 2019 UTC (4 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.35:	+8 -23 lines
Log Message:	rely on awaitTermination together with LONGER_DELAY_MS
#	Content
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/publicdomain/zero/1.0/
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
8
9	import static java.util.concurrent.TimeUnit.DAYS;
10	import static java.util.concurrent.TimeUnit.HOURS;
11	import static java.util.concurrent.TimeUnit.MICROSECONDS;
12	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13	import static java.util.concurrent.TimeUnit.MINUTES;
14	import static java.util.concurrent.TimeUnit.NANOSECONDS;
15	import static java.util.concurrent.TimeUnit.SECONDS;
16
17	import java.util.concurrent.CountDownLatch;
18	import java.util.concurrent.TimeUnit;
19
20	import junit.framework.Test;
21	import junit.framework.TestSuite;
22
23	public class TimeUnitTest extends JSR166TestCase {
24	public static void main(String[] args) {
25	main(suite(), args);
26	}
27
28	public static Test suite() {
29	return new TestSuite(TimeUnitTest.class);
30	}
31
32	// (loops to 88888 check increments at all time divisions.)
33
34	/**
35	* convert correctly converts sample values across the units
36	*/
37	public void testConvert() {
38	for (long t = 0; t < 88888; ++t) {
39	assertEquals(t6060*24,
40	SECONDS.convert(t, DAYS));
41	assertEquals(t6060,
42	SECONDS.convert(t, HOURS));
43	assertEquals(t*60,
44	SECONDS.convert(t, MINUTES));
45	assertEquals(t,
46	SECONDS.convert(t, SECONDS));
47	assertEquals(t,
48	SECONDS.convert(1000L*t, MILLISECONDS));
49	assertEquals(t,
50	SECONDS.convert(1000000L*t, MICROSECONDS));
51	assertEquals(t,
52	SECONDS.convert(1000000000L*t, NANOSECONDS));
53
54	assertEquals(1000Lt606024,
55	MILLISECONDS.convert(t, DAYS));
56	assertEquals(1000Lt60*60,
57	MILLISECONDS.convert(t, HOURS));
58	assertEquals(1000Lt60,
59	MILLISECONDS.convert(t, MINUTES));
60	assertEquals(1000L*t,
61	MILLISECONDS.convert(t, SECONDS));
62	assertEquals(t,
63	MILLISECONDS.convert(t, MILLISECONDS));
64	assertEquals(t,
65	MILLISECONDS.convert(1000L*t, MICROSECONDS));
66	assertEquals(t,
67	MILLISECONDS.convert(1000000L*t, NANOSECONDS));
68
69	assertEquals(1000000Lt606024,
70	MICROSECONDS.convert(t, DAYS));
71	assertEquals(1000000Lt60*60,
72	MICROSECONDS.convert(t, HOURS));
73	assertEquals(1000000Lt60,
74	MICROSECONDS.convert(t, MINUTES));
75	assertEquals(1000000L*t,
76	MICROSECONDS.convert(t, SECONDS));
77	assertEquals(1000L*t,
78	MICROSECONDS.convert(t, MILLISECONDS));
79	assertEquals(t,
80	MICROSECONDS.convert(t, MICROSECONDS));
81	assertEquals(t,
82	MICROSECONDS.convert(1000L*t, NANOSECONDS));
83
84	assertEquals(1000000000Lt606024,
85	NANOSECONDS.convert(t, DAYS));
86	assertEquals(1000000000Lt60*60,
87	NANOSECONDS.convert(t, HOURS));
88	assertEquals(1000000000Lt60,
89	NANOSECONDS.convert(t, MINUTES));
90	assertEquals(1000000000L*t,
91	NANOSECONDS.convert(t, SECONDS));
92	assertEquals(1000000L*t,
93	NANOSECONDS.convert(t, MILLISECONDS));
94	assertEquals(1000L*t,
95	NANOSECONDS.convert(t, MICROSECONDS));
96	assertEquals(t,
97	NANOSECONDS.convert(t, NANOSECONDS));
98	}
99
100	for (TimeUnit x : TimeUnit.values()) {
101	long[] zs = {
102	0, 1, -1,
103	Integer.MAX_VALUE, Integer.MIN_VALUE,
104	Long.MAX_VALUE, Long.MIN_VALUE,
105	};
106	for (long z : zs) assertEquals(z, x.convert(z, x));
107	}
108	}
109
110	/**
111	* toNanos correctly converts sample values in different units to
112	* nanoseconds
113	*/
114	public void testToNanos() {
115	for (long t = 0; t < 88888; ++t) {
116	assertEquals(t1000000000L606024,
117	DAYS.toNanos(t));
118	assertEquals(t1000000000L60*60,
119	HOURS.toNanos(t));
120	assertEquals(t1000000000L60,
121	MINUTES.toNanos(t));
122	assertEquals(1000000000L*t,
123	SECONDS.toNanos(t));
124	assertEquals(1000000L*t,
125	MILLISECONDS.toNanos(t));
126	assertEquals(1000L*t,
127	MICROSECONDS.toNanos(t));
128	assertEquals(t,
129	NANOSECONDS.toNanos(t));
130	}
131	}
132
133	/**
134	* toMicros correctly converts sample values in different units to
135	* microseconds
136	*/
137	public void testToMicros() {
138	for (long t = 0; t < 88888; ++t) {
139	assertEquals(t1000000L606024,
140	DAYS.toMicros(t));
141	assertEquals(t1000000L60*60,
142	HOURS.toMicros(t));
143	assertEquals(t1000000L60,
144	MINUTES.toMicros(t));
145	assertEquals(1000000L*t,
146	SECONDS.toMicros(t));
147	assertEquals(1000L*t,
148	MILLISECONDS.toMicros(t));
149	assertEquals(t,
150	MICROSECONDS.toMicros(t));
151	assertEquals(t,
152	NANOSECONDS.toMicros(t*1000L));
153	}
154	}
155
156	/**
157	* toMillis correctly converts sample values in different units to
158	* milliseconds
159	*/
160	public void testToMillis() {
161	for (long t = 0; t < 88888; ++t) {
162	assertEquals(t1000L606024,
163	DAYS.toMillis(t));
164	assertEquals(t1000L60*60,
165	HOURS.toMillis(t));
166	assertEquals(t1000L60,
167	MINUTES.toMillis(t));
168	assertEquals(1000L*t,
169	SECONDS.toMillis(t));
170	assertEquals(t,
171	MILLISECONDS.toMillis(t));
172	assertEquals(t,
173	MICROSECONDS.toMillis(t*1000L));
174	assertEquals(t,
175	NANOSECONDS.toMillis(t*1000000L));
176	}
177	}
178
179	/**
180	* toSeconds correctly converts sample values in different units to
181	* seconds
182	*/
183	public void testToSeconds() {
184	for (long t = 0; t < 88888; ++t) {
185	assertEquals(t6060*24,
186	DAYS.toSeconds(t));
187	assertEquals(t6060,
188	HOURS.toSeconds(t));
189	assertEquals(t*60,
190	MINUTES.toSeconds(t));
191	assertEquals(t,
192	SECONDS.toSeconds(t));
193	assertEquals(t,
194	MILLISECONDS.toSeconds(t*1000L));
195	assertEquals(t,
196	MICROSECONDS.toSeconds(t*1000000L));
197	assertEquals(t,
198	NANOSECONDS.toSeconds(t*1000000000L));
199	}
200	}
201
202	/**
203	* toMinutes correctly converts sample values in different units to
204	* minutes
205	*/
206	public void testToMinutes() {
207	for (long t = 0; t < 88888; ++t) {
208	assertEquals(t6024,
209	DAYS.toMinutes(t));
210	assertEquals(t*60,
211	HOURS.toMinutes(t));
212	assertEquals(t,
213	MINUTES.toMinutes(t));
214	assertEquals(t,
215	SECONDS.toMinutes(t*60));
216	assertEquals(t,
217	MILLISECONDS.toMinutes(t1000L60));
218	assertEquals(t,
219	MICROSECONDS.toMinutes(t1000000L60));
220	assertEquals(t,
221	NANOSECONDS.toMinutes(t1000000000L60));
222	}
223	}
224
225	/**
226	* toHours correctly converts sample values in different units to
227	* hours
228	*/
229	public void testToHours() {
230	for (long t = 0; t < 88888; ++t) {
231	assertEquals(t*24,
232	DAYS.toHours(t));
233	assertEquals(t,
234	HOURS.toHours(t));
235	assertEquals(t,
236	MINUTES.toHours(t*60));
237	assertEquals(t,
238	SECONDS.toHours(t6060));
239	assertEquals(t,
240	MILLISECONDS.toHours(t1000L60*60));
241	assertEquals(t,
242	MICROSECONDS.toHours(t1000000L60*60));
243	assertEquals(t,
244	NANOSECONDS.toHours(t1000000000L60*60));
245	}
246	}
247
248	/**
249	* toDays correctly converts sample values in different units to
250	* days
251	*/
252	public void testToDays() {
253	for (long t = 0; t < 88888; ++t) {
254	assertEquals(t,
255	DAYS.toDays(t));
256	assertEquals(t,
257	HOURS.toDays(t*24));
258	assertEquals(t,
259	MINUTES.toDays(t6024));
260	assertEquals(t,
261	SECONDS.toDays(t6060*24));
262	assertEquals(t,
263	MILLISECONDS.toDays(t1000L606024));
264	assertEquals(t,
265	MICROSECONDS.toDays(t1000000L606024));
266	assertEquals(t,
267	NANOSECONDS.toDays(t1000000000L606024));
268	}
269	}
270
271	/**
272	* convert saturates positive too-large values to Long.MAX_VALUE
273	* and negative to LONG.MIN_VALUE
274	*/
275	public void testConvertSaturate() {
276	assertEquals(Long.MAX_VALUE,
277	NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
278	assertEquals(Long.MIN_VALUE,
279	NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
280	assertEquals(Long.MAX_VALUE,
281	NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
282	assertEquals(Long.MIN_VALUE,
283	NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
284	assertEquals(Long.MAX_VALUE,
285	NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
286	assertEquals(Long.MIN_VALUE,
287	NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
288	assertEquals(Long.MAX_VALUE,
289	NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
290	assertEquals(Long.MIN_VALUE,
291	NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
292
293	for (TimeUnit x : TimeUnit.values())
294	for (TimeUnit y : TimeUnit.values()) {
295	long ratio = x.toNanos(1) / y.toNanos(1);
296	if (ratio >= 1) {
297	assertEquals(ratio, y.convert(1, x));
298	assertEquals(1, x.convert(ratio, y));
299	long max = Long.MAX_VALUE/ratio;
300	assertEquals(max * ratio, y.convert(max, x));
301	assertEquals(-max * ratio, y.convert(-max, x));
302	assertEquals(max, x.convert(max * ratio, y));
303	assertEquals(-max, x.convert(-max * ratio, y));
304	if (max < Long.MAX_VALUE) {
305	assertEquals(Long.MAX_VALUE, y.convert(max + 1, x));
306	assertEquals(Long.MIN_VALUE, y.convert(-max - 1, x));
307	assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE + 1, x));
308	}
309	assertEquals(Long.MAX_VALUE, y.convert(Long.MAX_VALUE, x));
310	assertEquals(Long.MIN_VALUE, y.convert(Long.MIN_VALUE, x));
311	}
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() {
320	assertEquals(Long.MAX_VALUE,
321	MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
322	assertEquals(Long.MIN_VALUE,
323	MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
324
325	for (TimeUnit x : TimeUnit.values()) {
326	long ratio = x.toNanos(1) / NANOSECONDS.toNanos(1);
327	if (ratio >= 1) {
328	long max = Long.MAX_VALUE/ratio;
329	for (long z : new long[] {0, 1, -1, max, -max})
330	assertEquals(z * ratio, x.toNanos(z));
331	if (max < Long.MAX_VALUE) {
332	assertEquals(Long.MAX_VALUE, x.toNanos(max + 1));
333	assertEquals(Long.MIN_VALUE, x.toNanos(-max - 1));
334	assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE + 1));
335	}
336	assertEquals(Long.MAX_VALUE, x.toNanos(Long.MAX_VALUE));
337	assertEquals(Long.MIN_VALUE, x.toNanos(Long.MIN_VALUE));
338	if (max < Integer.MAX_VALUE) {
339	assertEquals(Long.MAX_VALUE, x.toNanos(Integer.MAX_VALUE));
340	assertEquals(Long.MIN_VALUE, x.toNanos(Integer.MIN_VALUE));
341	}
342	}
343	}
344	}
345
346	/**
347	* toMicros saturates positive too-large values to Long.MAX_VALUE
348	* and negative to LONG.MIN_VALUE
349	*/
350	public void testToMicrosSaturate() {
351	for (TimeUnit x : TimeUnit.values()) {
352	long ratio = x.toNanos(1) / MICROSECONDS.toNanos(1);
353	if (ratio >= 1) {
354	long max = Long.MAX_VALUE/ratio;
355	for (long z : new long[] {0, 1, -1, max, -max})
356	assertEquals(z * ratio, x.toMicros(z));
357	if (max < Long.MAX_VALUE) {
358	assertEquals(Long.MAX_VALUE, x.toMicros(max + 1));
359	assertEquals(Long.MIN_VALUE, x.toMicros(-max - 1));
360	assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE + 1));
361	}
362	assertEquals(Long.MAX_VALUE, x.toMicros(Long.MAX_VALUE));
363	assertEquals(Long.MIN_VALUE, x.toMicros(Long.MIN_VALUE));
364	if (max < Integer.MAX_VALUE) {
365	assertEquals(Long.MAX_VALUE, x.toMicros(Integer.MAX_VALUE));
366	assertEquals(Long.MIN_VALUE, x.toMicros(Integer.MIN_VALUE));
367	}
368	}
369	}
370	}
371
372	/**
373	* toMillis saturates positive too-large values to Long.MAX_VALUE
374	* and negative to LONG.MIN_VALUE
375	*/
376	public void testToMillisSaturate() {
377	for (TimeUnit x : TimeUnit.values()) {
378	long ratio = x.toNanos(1) / MILLISECONDS.toNanos(1);
379	if (ratio >= 1) {
380	long max = Long.MAX_VALUE/ratio;
381	for (long z : new long[] {0, 1, -1, max, -max})
382	assertEquals(z * ratio, x.toMillis(z));
383	if (max < Long.MAX_VALUE) {
384	assertEquals(Long.MAX_VALUE, x.toMillis(max + 1));
385	assertEquals(Long.MIN_VALUE, x.toMillis(-max - 1));
386	assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE + 1));
387	}
388	assertEquals(Long.MAX_VALUE, x.toMillis(Long.MAX_VALUE));
389	assertEquals(Long.MIN_VALUE, x.toMillis(Long.MIN_VALUE));
390	if (max < Integer.MAX_VALUE) {
391	assertEquals(Long.MAX_VALUE, x.toMillis(Integer.MAX_VALUE));
392	assertEquals(Long.MIN_VALUE, x.toMillis(Integer.MIN_VALUE));
393	}
394	}
395	}
396	}
397
398	/**
399	* toSeconds saturates positive too-large values to Long.MAX_VALUE
400	* and negative to LONG.MIN_VALUE
401	*/
402	public void testToSecondsSaturate() {
403	for (TimeUnit x : TimeUnit.values()) {
404	long ratio = x.toNanos(1) / SECONDS.toNanos(1);
405	if (ratio >= 1) {
406	long max = Long.MAX_VALUE/ratio;
407	for (long z : new long[] {0, 1, -1, max, -max})
408	assertEquals(z * ratio, x.toSeconds(z));
409	if (max < Long.MAX_VALUE) {
410	assertEquals(Long.MAX_VALUE, x.toSeconds(max + 1));
411	assertEquals(Long.MIN_VALUE, x.toSeconds(-max - 1));
412	assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE + 1));
413	}
414	assertEquals(Long.MAX_VALUE, x.toSeconds(Long.MAX_VALUE));
415	assertEquals(Long.MIN_VALUE, x.toSeconds(Long.MIN_VALUE));
416	if (max < Integer.MAX_VALUE) {
417	assertEquals(Long.MAX_VALUE, x.toSeconds(Integer.MAX_VALUE));
418	assertEquals(Long.MIN_VALUE, x.toSeconds(Integer.MIN_VALUE));
419	}
420	}
421	}
422	}
423
424	/**
425	* toMinutes saturates positive too-large values to Long.MAX_VALUE
426	* and negative to LONG.MIN_VALUE
427	*/
428	public void testToMinutesSaturate() {
429	for (TimeUnit x : TimeUnit.values()) {
430	long ratio = x.toNanos(1) / MINUTES.toNanos(1);
431	if (ratio > 1) {
432	long max = Long.MAX_VALUE/ratio;
433	for (long z : new long[] {0, 1, -1, max, -max})
434	assertEquals(z * ratio, x.toMinutes(z));
435	assertEquals(Long.MAX_VALUE, x.toMinutes(max + 1));
436	assertEquals(Long.MIN_VALUE, x.toMinutes(-max - 1));
437	assertEquals(Long.MAX_VALUE, x.toMinutes(Long.MAX_VALUE));
438	assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE));
439	assertEquals(Long.MIN_VALUE, x.toMinutes(Long.MIN_VALUE + 1));
440	}
441	}
442	}
443
444	/**
445	* toHours saturates positive too-large values to Long.MAX_VALUE
446	* and negative to LONG.MIN_VALUE
447	*/
448	public void testToHoursSaturate() {
449	for (TimeUnit x : TimeUnit.values()) {
450	long ratio = x.toNanos(1) / HOURS.toNanos(1);
451	if (ratio >= 1) {
452	long max = Long.MAX_VALUE/ratio;
453	for (long z : new long[] {0, 1, -1, max, -max})
454	assertEquals(z * ratio, x.toHours(z));
455	if (max < Long.MAX_VALUE) {
456	assertEquals(Long.MAX_VALUE, x.toHours(max + 1));
457	assertEquals(Long.MIN_VALUE, x.toHours(-max - 1));
458	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE + 1));
459	}
460	assertEquals(Long.MAX_VALUE, x.toHours(Long.MAX_VALUE));
461	assertEquals(Long.MIN_VALUE, x.toHours(Long.MIN_VALUE));
462	}
463	}
464	}
465
466	/**
467	* toString returns name of unit
468	*/
469	public void testToString() {
470	assertEquals("NANOSECONDS", NANOSECONDS.toString());
471	assertEquals("MICROSECONDS", MICROSECONDS.toString());
472	assertEquals("MILLISECONDS", MILLISECONDS.toString());
473	assertEquals("SECONDS", SECONDS.toString());
474	assertEquals("MINUTES", MINUTES.toString());
475	assertEquals("HOURS", HOURS.toString());
476	assertEquals("DAYS", DAYS.toString());
477	}
478
479	/**
480	* name returns name of unit
481	*/
482	public void testName() {
483	for (TimeUnit x : TimeUnit.values())
484	assertEquals(x.toString(), x.name());
485	}
486
487	/**
488	* Timed wait without holding lock throws
489	* IllegalMonitorStateException
490	*/
491	public void testTimedWait_IllegalMonitorException() {
492	Thread t = newStartedThread(new CheckedRunnable() {
493	public void realRun() throws InterruptedException {
494	Object o = new Object();
495	try {
496	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
497	threadShouldThrow();
498	} catch (IllegalMonitorStateException success) {}
499	}});
500
501	awaitTermination(t);
502	}
503
504	/**
505	* timedWait throws InterruptedException when interrupted
506	*/
507	public void testTimedWait_Interruptible() {
508	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
509	Thread t = newStartedThread(new CheckedRunnable() {
510	public void realRun() throws InterruptedException {
511	Object o = new Object();
512
513	Thread.currentThread().interrupt();
514	try {
515	synchronized (o) {
516	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
517	}
518	shouldThrow();
519	} catch (InterruptedException success) {}
520	assertFalse(Thread.interrupted());
521
522	pleaseInterrupt.countDown();
523	try {
524	synchronized (o) {
525	MILLISECONDS.timedWait(o, LONGER_DELAY_MS);
526	}
527	shouldThrow();
528	} catch (InterruptedException success) {}
529	assertFalse(Thread.interrupted());
530	}});
531
532	await(pleaseInterrupt);
533	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
534	t.interrupt();
535	awaitTermination(t);
536	}
537
538	/**
539	* timedJoin throws InterruptedException when interrupted
540	*/
541	public void testTimedJoin_Interruptible() {
542	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
543	final Thread s = newStartedThread(new CheckedInterruptedRunnable() {
544	public void realRun() throws InterruptedException {
545	Thread.sleep(LONGER_DELAY_MS);
546	}});
547	final Thread t = newStartedThread(new CheckedRunnable() {
548	public void realRun() throws InterruptedException {
549	Thread.currentThread().interrupt();
550	try {
551	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
552	shouldThrow();
553	} catch (InterruptedException success) {}
554	assertFalse(Thread.interrupted());
555
556	pleaseInterrupt.countDown();
557	try {
558	MILLISECONDS.timedJoin(s, LONGER_DELAY_MS);
559	shouldThrow();
560	} catch (InterruptedException success) {}
561	assertFalse(Thread.interrupted());
562	}});
563
564	await(pleaseInterrupt);
565	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
566	t.interrupt();
567	awaitTermination(t);
568	s.interrupt();
569	awaitTermination(s);
570	}
571
572	/**
573	* timeUnit.sleep throws InterruptedException when interrupted
574	*/
575	public void testTimedSleep_Interruptible() {
576	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
577	Thread t = newStartedThread(new CheckedRunnable() {
578	public void realRun() throws InterruptedException {
579	Thread.currentThread().interrupt();
580	try {
581	MILLISECONDS.sleep(LONGER_DELAY_MS);
582	shouldThrow();
583	} catch (InterruptedException success) {}
584	assertFalse(Thread.interrupted());
585
586	pleaseInterrupt.countDown();
587	try {
588	MILLISECONDS.sleep(LONGER_DELAY_MS);
589	shouldThrow();
590	} catch (InterruptedException success) {}
591	assertFalse(Thread.interrupted());
592	}});
593
594	await(pleaseInterrupt);
595	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
596	t.interrupt();
597	awaitTermination(t);
598	}
599
600	/**
601	* timeUnit.sleep(x) for x <= 0 does not sleep at all.
602	*/
603	public void testTimedSleep_nonPositive() throws InterruptedException {
604	boolean interrupt = randomBoolean();
605	if (interrupt) Thread.currentThread().interrupt();
606	randomTimeUnit().sleep(0L);
607	randomTimeUnit().sleep(-1L);
608	randomTimeUnit().sleep(Long.MIN_VALUE);
609	if (interrupt) assertTrue(Thread.interrupted());
610	}
611
612	/**
613	* a deserialized/reserialized unit is the same instance
614	*/
615	public void testSerialization() throws Exception {
616	for (TimeUnit x : TimeUnit.values())
617	assertSame(x, serialClone(x));
618	}
619
620	}