test/jdk/java/util/concurrent/tck/TimeUnitTest.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * 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("SECONDS", SECONDS.toString());
    }

    /**
     * name returns name of unit
     */
    public void testName() {
        assertEquals("SECONDS", SECONDS.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();
                TimeUnit tu = MILLISECONDS;

                try {
                    tu.timedWait(o, LONG_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();
                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);
        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(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);
        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        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);
        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
        t.interrupt();
        awaitTermination(t);
    }

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

}