/* * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. * 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. */ import java.util.Objects; import sun.misc.VM; /** * @test * @bug 8068730 * @summary tests that VM.getgetNanoTimeAdjustment() works as expected. * @run main GetNanoTimeAdjustment * @author danielfuchs */ public class GetNanoTimeAdjustment { static final int MILLIS_IN_SECOND = 1000; static final int NANOS_IN_MILLI = 1000_000; static final int NANOS_IN_MICRO = 1000; static final int NANOS_IN_SECOND = 1000_000_000; static final boolean verbose = true; static final class TestAssertException extends RuntimeException { TestAssertException(String msg) { super(msg); } } private static void assertEquals(long expected, long received, String msg) { if (expected != received) { throw new TestAssertException("Unexpected result for " + msg + ".\n\texpected: " + expected + "\n\tactual: " + received); } else if (verbose) { System.out.println("Got expected " + msg + ": " + received); } } private static void assertEquals(Object expected, Object received, String msg) { if (!Objects.equals(expected, received)) { throw new TestAssertException("Unexpected result for " + msg + ".\n\texpected: " + expected + "\n\tactual: " + received); } else if (verbose) { System.out.println("Got expected " + msg + ": " + received); } } static final long MAX_OFFSET = 0x0100000000L; static final long MIN_OFFSET = -MAX_OFFSET; static enum Answer { YES, // isOffLimit = YES: we must get -1 NO, // isOffLimit = NO: we must not not get -1 MAYBE // isOffLimit = MAYBE: we might get -1 or a valid adjustment. }; static long distance(long one, long two) { return one > two ? Math.subtractExact(one, two) : Math.subtractExact(two, one); } static Answer isOffLimits(long before, long after, long offset) { long relativeDistanceBefore = distance(before, offset); long relativeDistanceAfter = distance(after, offset); if (relativeDistanceBefore >= MAX_OFFSET && relativeDistanceAfter >= MAX_OFFSET) { return Answer.YES; } if (relativeDistanceBefore < MAX_OFFSET && relativeDistanceAfter < MAX_OFFSET) { if (relativeDistanceBefore == 0 || relativeDistanceAfter == 0) { return Answer.MAYBE; // unlucky case where } return Answer.NO; } return Answer.MAYBE; } static void testWithOffset(String name, long offset) { System.out.println("Testing with offset: " + name); long beforeMillis = System.currentTimeMillis(); long adjustment = VM.getNanoTimeAdjustment(offset); long afterMillis = System.currentTimeMillis(); if (offset >= beforeMillis/MILLIS_IN_SECOND && offset <= afterMillis/MILLIS_IN_SECOND) { if (adjustment == -1) { // it's possible that we have fallen in the unlucky case // where -1 was the genuine result. let's go backward a bit. offset = offset - 10; beforeMillis = System.currentTimeMillis(); adjustment = VM.getNanoTimeAdjustment(offset); afterMillis = System.currentTimeMillis(); if (adjustment == -1) { throw new RuntimeException(name + ": VM says " + offset + " secs is too far off, " + " when time in seconds is in [" + beforeMillis/MILLIS_IN_SECOND + ", " + afterMillis/MILLIS_IN_SECOND + "]"); } } } Answer isOffLimit = isOffLimits(beforeMillis/MILLIS_IN_SECOND, afterMillis/MILLIS_IN_SECOND, offset); switch (isOffLimit) { case YES: if (adjustment != -1) { throw new RuntimeException(name + ": VM should have returned -1 for " + offset + " when time in seconds is in [" + beforeMillis/MILLIS_IN_SECOND + ", " + afterMillis/MILLIS_IN_SECOND + "]"); } System.out.println("Got expected exception value: " + adjustment); break; case NO: if (adjustment == -1) { throw new RuntimeException(name + "VM says " + offset + " secs is too far off, " + " when time in seconds is in [" + beforeMillis/MILLIS_IN_SECOND + ", " + afterMillis/MILLIS_IN_SECOND + "]"); } break; case MAYBE: System.out.println("Adjustment: " + adjustment); System.out.println("Can't assert for -1 with offset " + offset + "(" + name + ")" + " when time in seconds is in [" + beforeMillis/MILLIS_IN_SECOND + ", " + afterMillis/MILLIS_IN_SECOND + "]"); // not conclusive } if (isOffLimit == Answer.NO || adjustment != -1) { System.out.println("Validating adjustment: " + adjustment); long expectedMax = distance(offset, beforeMillis/MILLIS_IN_SECOND) * NANOS_IN_SECOND + (beforeMillis % MILLIS_IN_SECOND) * NANOS_IN_MILLI + (afterMillis - beforeMillis + 1) * NANOS_IN_MILLI; long absoluteAdjustment = distance(0, adjustment); if (absoluteAdjustment > expectedMax) { long adjSec = absoluteAdjustment / NANOS_IN_SECOND; long adjMil = (absoluteAdjustment % NANOS_IN_SECOND) / NANOS_IN_MILLI; long adjMic = (absoluteAdjustment % NANOS_IN_MILLI) / NANOS_IN_MICRO; long adjNan = (absoluteAdjustment % NANOS_IN_MICRO); long expSec = expectedMax / NANOS_IN_SECOND; long expMil = (expectedMax % NANOS_IN_SECOND) / NANOS_IN_MILLI; long expMic = (expectedMax % NANOS_IN_MILLI) / NANOS_IN_MICRO; long expNan = (expectedMax % NANOS_IN_MICRO); System.err.println("Excessive adjustment: " + adjSec + "s, " + adjMil + "ms, " + adjMic + "mics, " + adjNan + "ns"); System.err.println("Epected max: " + expSec + "s, " + expMil + "ms, " + expMic + "mics, " + expNan + "ns"); throw new RuntimeException(name + ": Excessive adjustment: " + adjustment + " when time in millis is in [" + beforeMillis + ", " + afterMillis + "] and offset in seconds is " + offset); } } } static void regular() { System.out.println("*** Testing regular cases ***"); final long start = System.currentTimeMillis(); long offset = start/1000; long adjustment = VM.getNanoTimeAdjustment(offset); if (start != offset*1000) { if (adjustment == -1) { throw new RuntimeException("VM says " + offset + " secs is too far off, but time millis is " + System.currentTimeMillis()); } } if (adjustment == -1) { offset = System.currentTimeMillis()/1000 - 1024; adjustment = VM.getNanoTimeAdjustment(offset); if (adjustment == -1) { throw new RuntimeException("VM says " + offset + " secs is too far off, but time millis is " + System.currentTimeMillis()); } } if (adjustment > (start/1000 - offset + 20)*NANOS_IN_SECOND) { throw new RuntimeException("Excessive adjustment: " + adjustment); } testWithOffset("System.currentTimeMillis()/1000", System.currentTimeMillis()/1000); testWithOffset("System.currentTimeMillis()/1000 - 1024", System.currentTimeMillis()/1000 - 1024); testWithOffset("System.currentTimeMillis()/1000 + 1024", System.currentTimeMillis()/1000 + 1024); } static void testLimits() { System.out.println("*** Testing limits ***"); testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET + 1", System.currentTimeMillis()/1000 - MAX_OFFSET + 1); testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET - 1", System.currentTimeMillis()/1000 + MAX_OFFSET - 1); testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET", System.currentTimeMillis()/1000 - MAX_OFFSET); testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET", System.currentTimeMillis()/1000 + MAX_OFFSET); testWithOffset("System.currentTimeMillis()/1000 - MAX_OFFSET - 1024", System.currentTimeMillis()/1000 - MAX_OFFSET - 1024); testWithOffset("System.currentTimeMillis()/1000 + MAX_OFFSET + 1024", System.currentTimeMillis()/1000 + MAX_OFFSET + 1024); testWithOffset("0", 0); testWithOffset("-1", -1); testWithOffset("Integer.MAX_VALUE + System.currentTimeMillis()/1000", ((long)Integer.MAX_VALUE) + System.currentTimeMillis()/1000); testWithOffset("System.currentTimeMillis()/1000 - Integer.MIN_VALUE", System.currentTimeMillis()/1000 - Integer.MIN_VALUE); testWithOffset("Long.MAX_VALUE", Long.MAX_VALUE); testWithOffset("System.currentTimeMillis()/1000 - Long.MIN_VALUE", (Long.MIN_VALUE + System.currentTimeMillis()/1000)*-1); } public static void main(String[] args) throws Exception { regular(); testLimits(); } }