undefect. CWE-407 — 63 sites patched across 27 ecosystems

Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.

test/jdk/java/lang/management/RuntimeMXBean/UpTime.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2003, 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.
+ */
+
+/*
+ * @test
+ * @bug     4530538
+ * @summary Basic unit test of RuntimeMXBean.getUptime()
+ * @author  Alexei Guibadoulline
+ */
+
+import java.lang.management.*;
+
+public class UpTime {
+    static final long DELAY = 5; // Seconds
+    static final long TIMEOUT = 30; // Minutes
+    static final long MULTIPLIER = 1000; // millisecond ticks
+
+    private static final RuntimeMXBean metrics
+        = ManagementFactory.getRuntimeMXBean();
+
+    public static void main(String argv[]) throws Exception {
+        long jvmStartTime = metrics.getStartTime();
+        // this will get an aproximate JVM uptime before starting this test
+        long jvmUptime = System.currentTimeMillis() - jvmStartTime;
+        long systemStartOuter = System_milliTime();
+        long metricsStart = metrics.getUptime();
+        long systemStartInner = System_milliTime();
+
+        // This JVM might have been running for some time if this test runs
+        // in samevm mode.  The sanity check should apply to the test uptime.
+        long testUptime = metricsStart - jvmUptime;
+
+        // If uptime is more than 30 minutes then it looks like a bug in
+        // the method
+        if (testUptime > TIMEOUT * 60 * MULTIPLIER)
+            throw new RuntimeException("Uptime of the JVM is more than 30 "
+                                     + "minutes ("
+                                     + (metricsStart / 60 / MULTIPLIER)
+                                     + " minutes).");
+
+        // Wait for DELAY seconds
+        Object o = new Object();
+        while (System_milliTime() < systemStartInner + DELAY * MULTIPLIER) {
+            synchronized (o) {
+                try {
+                    o.wait(DELAY * 1000);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    throw e;
+                }
+            }
+        }
+
+        long systemEndInner = System_milliTime();
+        long metricsEnd = metrics.getUptime();
+        long systemEndOuter = System_milliTime();
+
+        long systemDifferenceInner = systemEndInner - systemStartInner;
+        long systemDifferenceOuter = systemEndOuter - systemStartOuter;
+        long metricsDifference = metricsEnd - metricsStart;
+
+        // Check the flow of time in RuntimeMXBean.getUptime(). See the
+        // picture below.
+        // The measured times can be off by 1 due to conversions from
+        // nanoseconds to milliseconds, using different channels to read the
+        // HR timer and rounding error. Bigger difference will make the test
+        // fail.
+        if (metricsDifference - systemDifferenceInner < -1)
+            throw new RuntimeException("Flow of the time in "
+                                     + "RuntimeMXBean.getUptime() ("
+                                     + metricsDifference + ") is slower than "
+                                     + " in system (" + systemDifferenceInner
+                                     + ")");
+        if (metricsDifference - systemDifferenceOuter > 1)
+            throw new RuntimeException("Flow of the time in "
+                                     + "RuntimeMXBean.getUptime() ("
+                                     + metricsDifference + ") is faster than "
+                                     + "in system (" + systemDifferenceOuter
+                                     + ")");
+
+        System.out.println("Test passed.");
+    }
+
+    private static long System_milliTime() {
+        return System.nanoTime() / 1000000; // nanoseconds / milliseconds;
+    }
+}
+
+/*
+
+   A picture to describe the second testcase that checks the flow of time in
+   RuntimeMXBean.getUptime()
+
+
+   start
+             o1  u1  i1    Sleep for DELAY minutes    i2  u2  o2
+     |-------|---|---|--------------------------------|---|---|---------------> time
+
+
+   The following inequality (checked by the test) must always be true:
+
+       o2-o1 >= u2-u1 >= i2-i1
+
+   In the test:
+
+   i1 - systemStartInner
+   i2 - systemEndInner
+   o1 - systemStartOuter
+   o2 - systemEndOuter
+   u1 - metricsStart
+   u2 - metricsEnd
+
+*/