changeset 14552:3976fadb091d

8144062: Move jdk.Version to java.lang.Runtime.Version Reviewed-by: abuckley, alanb, forax, jjg, mchung, psandoz
author iris
date Thu, 19 May 2016 12:04:54 -0700
parents e53f8c34880e
children f0c1d4d90df6
files src/java.base/share/classes/java/lang/Runtime.java src/java.base/share/classes/java/lang/System.java src/java.base/share/classes/java/util/jar/JarFile.java src/java.base/share/classes/jdk/Version.java src/java.base/share/classes/module-info.java src/jdk.jconsole/share/classes/sun/tools/jconsole/AboutDialog.java src/jdk.zipfs/share/classes/jdk/nio/zipfs/JarFileSystem.java test/java/lang/Runtime/Version/Basic.java test/java/util/jar/JarFile/mrjar/MultiReleaseJarAPI.java test/java/util/jar/JarFile/mrjar/MultiReleaseJarIterators.java test/java/util/jar/JarFile/mrjar/MultiReleaseJarProperties.java test/java/util/jar/JarFile/mrjar/MultiReleaseJarSecurity.java test/jdk/Version/Basic.java test/jdk/nio/zipfs/MultiReleaseJarTest.java test/sun/net/www/protocol/jar/MultiReleaseJarURLConnection.java
diffstat 15 files changed, 1041 insertions(+), 1047 deletions(-) [+]
line wrap: on
line diff
--- a/src/java.base/share/classes/java/lang/Runtime.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/java.base/share/classes/java/lang/Runtime.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2016, 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
@@ -26,9 +26,21 @@
 package java.lang;
 
 import java.io.*;
+import java.math.BigInteger;
+import java.util.AbstractList;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.RandomAccess;
 import java.util.StringTokenizer;
 import jdk.internal.reflect.CallerSensitive;
 import jdk.internal.reflect.Reflection;
+import sun.security.action.GetPropertyAction;
 
 /**
  * Every Java application has a single instance of class
@@ -46,6 +58,8 @@
 public class Runtime {
     private static final Runtime currentRuntime = new Runtime();
 
+    private static Version version;
+
     /**
      * Returns the runtime object associated with the current Java application.
      * Most of the methods of class {@code Runtime} are instance
@@ -917,4 +931,591 @@
         return out;
     }
 
+    /**
+     * Returns the version of the Java Runtime Environment as a {@link
+     * Runtime.Version}.
+     *
+     * @return  the {@link Runtime.Version} of the Java Runtime Environment
+     *
+     * @since  9
+     */
+    public static Version version() {
+        if (version == null) {
+            version = Version.parse(
+                GetPropertyAction.privilegedGetProperty("java.runtime.version"));
+        }
+        return version;
+    }
+
+    /**
+     * A representation of a version string for an implemenation of the
+     * Java SE Platform.  A version string contains a version number
+     * optionally followed by pre-release and build information.
+     *
+     * <h2><a name="verNum">Version numbers</a></h2>
+     *
+     * <p> A <em>version number</em>, {@code $VNUM}, is a non-empty sequence
+     * of elements separated by period characters (U+002E).  An element is
+     * either zero, or a unsigned integer numeral without leading zeros.  The
+     * final element in a version number must not be zero.  The format is:
+     * </p>
+     *
+     * <blockquote><pre>
+     *     ^[1-9][0-9]*(((\.0)*\.[1-9][0-9]*)*)*$
+     * </pre></blockquote>
+     *
+     * <p> The sequence may be of arbitrary length but the first three
+     * elements are assigned specific meanings, as follows:</p>
+     *
+     * <blockquote><pre>
+     *     $MAJOR.$MINOR.$SECURITY
+     * </pre></blockquote>
+     *
+     * <ul>
+     *
+     * <li><p> <a name="major">{@code $MAJOR}</a> --- The major version
+     * number, incremented for a major release that contains significant new
+     * features as specified in a new edition of the Java&#160;SE Platform
+     * Specification, <em>e.g.</em>, <a
+     * href="https://jcp.org/en/jsr/detail?id=337">JSR 337</a> for
+     * Java&#160;SE&#160;8.  Features may be removed in a major release, given
+     * advance notice at least one major release ahead of time, and
+     * incompatible changes may be made when justified. The {@code $MAJOR}
+     * version number of JDK&#160;8 is {@code 8}; the {@code $MAJOR} version
+     * number of JDK&#160;9 is {@code 9}.  When {@code $MAJOR} is incremented,
+     * all subsequent elements are removed. </p></li>
+     *
+     * <li><p> <a name="minor">{@code $MINOR}</a> --- The minor version
+     * number, incremented for a minor update release that may contain
+     * compatible bug fixes, revisions to standard APIs mandated by a
+     * <a href="https://jcp.org/en/procedures/jcp2#5.3">Maintenance Release</a>
+     * of the relevant Platform Specification, and implementation features
+     * outside the scope of that Specification such as new JDK-specific APIs,
+     * additional service providers, new garbage collectors, and ports to new
+     * hardware architectures. </p></li>
+     *
+     * <li><p> <a name="security">{@code $SECURITY}</a> --- The security
+     * level, incremented for a security update release that contains critical
+     * fixes including those necessary to improve security.  {@code $SECURITY}
+     * is <strong>not</strong> reset when {@code $MINOR} is incremented.  A
+     * higher value of {@code $SECURITY} for a given {@code $MAJOR} value,
+     * therefore, always indicates a more secure release, regardless of the
+     * value of {@code $MINOR}. </p></li>
+     *
+     * </ul>
+     *
+     * <p> The fourth and later elements of a version number are free for use
+     * by downstream consumers of this code base.  Such a consumer may,
+     * <em>e.g.</em>, use the fourth element to identify patch releases which
+     * contain a small number of critical non-security fixes in addition to
+     * the security fixes in the corresponding security release. </p>
+     *
+     * <p> The version number does not include trailing zero elements;
+     * <em>i.e.</em>, {@code $SECURITY} is omitted if it has the value zero,
+     * and {@code $MINOR} is omitted if both {@code $MINOR} and {@code
+     * $SECURITY} have the value zero. </p>
+     *
+     * <p> The sequence of numerals in a version number is compared to another
+     * such sequence in numerical, pointwise fashion; <em>e.g.</em>, {@code
+     * 9.9.1} is less than {@code 9.10.3}. If one sequence is shorter than
+     * another then the missing elements of the shorter sequence are
+     * considered to be less than the corresponding elements of the longer
+     * sequence; <em>e.g.</em>, {@code 9.1.2} is less than {@code 9.1.2.1}.
+     * </p>
+     *
+     * <h2><a name="verStr">Version strings</a></h2>
+     *
+     * <p> A <em>version string</em>, {@code $VSTR}, consists of a version
+     * number {@code $VNUM}, as described above, optionally followed by
+     * pre-release and build information, in the format </p>
+     *
+     * <blockquote><pre>
+     *     $VNUM(-$PRE)?(\+($BUILD)?(-$OPT)?)?
+     * </pre></blockquote>
+     *
+     * <p> where: </p>
+     *
+     * <ul>
+     *
+     * <li><p> <a name="pre">{@code $PRE}</a>, matching {@code ([a-zA-Z0-9]+)}
+     * --- A pre-release identifier.  Typically {@code ea}, for a
+     * potentially unstable early-access release under active development,
+     * or {@code internal}, for an internal developer build.
+     *
+     * <li><p> <a name="build">{@code $BUILD}</a>, matching {@code
+     * (0|[1-9][0-9]*)} --- The build number, incremented for each promoted
+     * build.  {@code $BUILD} is reset to {@code 1} when any portion of {@code
+     * $VNUM} is incremented. </p>
+     *
+     * <li><p> <a name="opt">{@code $OPT}</a>, matching {@code
+     * ([-a-zA-Z0-9\.]+)} --- Additional build information, if desired.  In
+     * the case of an {@code internal} build this will often contain the date
+     * and time of the build. </p>
+     *
+     * </ul>
+     *
+     * <p> A version number {@code 10-ea} matches {@code $VNUM = "10"} and
+     * {@code $PRE = "ea"}.  The version number {@code 10+-ea} matches
+     * {@code $VNUM = "10"} and {@code $OPT = "ea"}. </p>
+     *
+     * <p> When comparing two version strings, the value of {@code $OPT}, if
+     * present, may or may not be significant depending on the chosen
+     * comparison method.  The comparison methods {@link #compareTo(Version)
+     * compareTo()} and {@link #compareToIgnoreOpt(Version)
+     * compareToIgnoreOpt()} should be used consistently with the
+     * corresponding methods {@link #equals(Object) equals()} and {@link
+     * #equalsIgnoreOpt(Object) equalsIgnoreOpt()}.  </p>
+     *
+     * <p> A <em>short version string</em>, {@code $SVSTR}, often useful in
+     * less formal contexts, is a version number optionally followed by a
+     * pre-release identifier:
+     *
+     * <blockquote><pre>
+     *     $VNUM(-$PRE)?
+     * </pre></blockquote>
+     *
+     * @since  9
+     */
+    public static class Version
+        implements Comparable<Version>
+    {
+        private final List<Integer>     version;
+        private final Optional<String>  pre;
+        private final Optional<Integer> build;
+        private final Optional<String>  optional;
+
+
+        // $VNUM(-$PRE)?(\+($BUILD)?(\-$OPT)?)?
+        // RE limits the format of version strings
+        // ([1-9][0-9]*(?:(?:\.0)*\.[1-9][0-9]*)*)(?:-([a-zA-Z0-9]+))?(?:(\+)(0|[1-9][0-9]*)?)?(?:-([-a-zA-Z0-9.]+))?
+
+        private static final String VNUM
+            = "(?<VNUM>[1-9][0-9]*(?:(?:\\.0)*\\.[1-9][0-9]*)*)";
+        private static final String VNUM_GROUP  = "VNUM";
+
+        private static final String PRE      = "(?:-(?<PRE>[a-zA-Z0-9]+))?";
+        private static final String PRE_GROUP   = "PRE";
+
+        private static final String BUILD
+            = "(?:(?<PLUS>\\+)(?<BUILD>0|[1-9][0-9]*)?)?";
+        private static final String PLUS_GROUP  = "PLUS";
+        private static final String BUILD_GROUP = "BUILD";
+
+        private static final String OPT      = "(?:-(?<OPT>[-a-zA-Z0-9.]+))?";
+        private static final String OPT_GROUP   = "OPT";
+
+        private static final String VSTR_FORMAT
+            = "^" + VNUM + PRE + BUILD + OPT + "$";
+        private static final Pattern VSTR_PATTERN = Pattern.compile(VSTR_FORMAT);
+
+        /**
+         * Constructs a valid <a href="verStr">version string</a> containing
+         * a <a href="#verNum">version number</a> followed by pre-release and
+         * build information.
+         *
+         * @param  s
+         *         A string to be interpreted as a version
+         *
+         * @throws  IllegalArgumentException
+         *          If the given string cannot be interpreted as a valid
+         *          version
+         *
+         * @throws  NullPointerException
+         *          If {@code s} is {@code null}
+         *
+         * @throws  NumberFormatException
+         *          If an element of the version number or the build number
+         *          cannot be represented as an {@link Integer}
+         */
+        private Version(String s) {
+            if (s == null)
+                throw new NullPointerException();
+
+            Matcher m = VSTR_PATTERN.matcher(s);
+            if (!m.matches())
+                throw new IllegalArgumentException("Invalid version string: '"
+                                                   + s + "'");
+
+            // $VNUM is a dot-separated list of integers of arbitrary length
+            List<Integer> list = new ArrayList<>();
+            for (String i : m.group(VNUM_GROUP).split("\\."))
+                list.add(Integer.parseInt(i));
+            version = Collections.unmodifiableList(list);
+
+            pre = Optional.ofNullable(m.group(PRE_GROUP));
+
+            String b = m.group(BUILD_GROUP);
+            // $BUILD is an integer
+            build = (b == null)
+                ? Optional.<Integer>empty()
+                : Optional.ofNullable(Integer.parseInt(b));
+
+            optional = Optional.ofNullable(m.group(OPT_GROUP));
+
+            // empty '+'
+            if ((m.group(PLUS_GROUP) != null) && !build.isPresent()) {
+                if (optional.isPresent()) {
+                    if (pre.isPresent())
+                        throw new IllegalArgumentException("'+' found with"
+                            + " pre-release and optional components:'" + s
+                            + "'");
+                } else {
+                    throw new IllegalArgumentException("'+' found with neither"
+                        + " build or optional components: '" + s + "'");
+                }
+            }
+        }
+
+        /**
+         * Parses the given string as a valid
+         * <a href="#verStr">version string</a> containing a
+         * <a href="#verNum">version number</a> followed by pre-release and
+         * build information.
+         *
+         * @param  s
+         *         A string to interpret as a version
+         *
+         * @throws  IllegalArgumentException
+         *          If the given string cannot be interpreted as a valid
+         *          version
+         *
+         * @throws  NullPointerException
+         *          If the given string is {@code null}
+         *
+         * @throws  NumberFormatException
+         *          If an element of the version number or the build number
+         *          cannot be represented as an {@link Integer}
+         *
+         * @return  The Version of the given string
+         */
+        public static Version parse(String s) {
+            return new Version(s);
+        }
+
+        /**
+         * Returns the <a href="#major">major</a> version number.
+         *
+         * @return  The major version number
+         */
+        public int major() {
+            return version.get(0);
+        }
+
+        /**
+         * Returns the <a href="#minor">minor</a> version number or zero if it
+         * was not set.
+         *
+         * @return  The minor version number or zero if it was not set
+         */
+        public int minor() {
+            return (version.size() > 1 ? version.get(1) : 0);
+        }
+
+        /**
+         * Returns the <a href="#security">security</a> version number or zero
+         * if it was not set.
+         *
+         * @return  The security version number or zero if it was not set
+         */
+        public int security() {
+            return (version.size() > 2 ? version.get(2) : 0);
+        }
+
+        /**
+         * Returns an unmodifiable {@link java.util.List List} of the
+         * integer numerals contained in the <a href="#verNum">version
+         * number</a>.  The {@code List} always contains at least one
+         * element corresponding to the <a href="#major">major version
+         * number</a>.
+         *
+         * @return  An unmodifiable list of the integer numerals
+         *          contained in the version number
+         */
+        public List<Integer> version() {
+            return version;
+        }
+
+        /**
+         * Returns the optional <a href="#pre">pre-release</a> information.
+         *
+         * @return  The optional pre-release information as a String
+         */
+        public Optional<String> pre() {
+            return pre;
+        }
+
+        /**
+         * Returns the <a href="#build">build number</a>.
+         *
+         * @return  The optional build number.
+         */
+        public Optional<Integer> build() {
+            return build;
+        }
+
+        /**
+         * Returns <a href="#opt">optional</a> additional identifying build
+         * information.
+         *
+         * @return  Additional build information as a String
+         */
+        public Optional<String> optional() {
+            return optional;
+        }
+
+        /**
+         * Compares this version to another.
+         *
+         * <p> Each of the components in the <a href="#verStr">version</a> is
+         * compared in the follow order of precedence: version numbers,
+         * pre-release identifiers, build numbers, optional build information.
+         * </p>
+         *
+         * <p> Comparison begins by examining the sequence of version numbers.
+         * If one sequence is shorter than another, then the missing elements
+         * of the shorter sequence are considered to be less than the
+         * corresponding elements of the longer sequence. </p>
+         *
+         * <p> A version with a pre-release identifier is always considered to
+         * be less than a version without one.  Pre-release identifiers are
+         * compared numerically when they consist only of digits, and
+         * lexicographically otherwise.  Numeric identifiers are considered to
+         * be less than non-numeric identifiers.  </p>
+         *
+         * <p> A version without a build number is always less than one with a
+         * build number; otherwise build numbers are compared numerically. </p>
+         *
+         * <p> The optional build information is compared lexicographically.
+         * During this comparison, a version with optional build information is
+         * considered to be greater than a version without one. </p>
+         *
+         * <p> A version is not comparable to any other type of object.
+         *
+         * @param  ob
+         *         The object to be compared
+         *
+         * @return  A negative integer, zero, or a positive integer if this
+         *          {@code Version} is less than, equal to, or greater than the
+         *          given {@code Version}
+         *
+         * @throws  NullPointerException
+         *          If the given object is {@code null}
+         */
+        @Override
+        public int compareTo(Version ob) {
+            return compare(ob, false);
+        }
+
+        /**
+         * Compares this version to another disregarding optional build
+         * information.
+         *
+         * <p> Two versions are compared by examining the version string as
+         * described in {@link #compareTo(Version)} with the exception that the
+         * optional build information is always ignored. </p>
+         *
+         * <p> A version is not comparable to any other type of object.
+         *
+         * @param  ob
+         *         The object to be compared
+         *
+         * @return  A negative integer, zero, or a positive integer if this
+         *          {@code Version} is less than, equal to, or greater than the
+         *          given {@code Version}
+         *
+         * @throws  NullPointerException
+         *          If the given object is {@code null}
+         */
+        public int compareToIgnoreOpt(Version ob) {
+            return compare(ob, true);
+        }
+
+        private int compare(Version ob, boolean ignoreOpt) {
+            if (ob == null)
+                throw new NullPointerException("Invalid argument");
+
+            int ret = compareVersion(ob);
+            if (ret != 0)
+                return ret;
+
+            ret = comparePre(ob);
+            if (ret != 0)
+                return ret;
+
+            ret = compareBuild(ob);
+            if (ret != 0)
+                return ret;
+
+            if (!ignoreOpt)
+                return compareOpt(ob);
+
+            return 0;
+        }
+
+        private int compareVersion(Version ob) {
+            int size = version.size();
+            int oSize = ob.version().size();
+            int min = Math.min(size, oSize);
+            for (int i = 0; i < min; i++) {
+                Integer val = version.get(i);
+                Integer oVal = ob.version().get(i);
+                if (val != oVal)
+                    return val - oVal;
+            }
+            if (size != oSize)
+                return size - oSize;
+            return 0;
+        }
+
+        private int comparePre(Version ob) {
+            Optional<String> oPre = ob.pre();
+            if (!pre.isPresent()) {
+                if (oPre.isPresent())
+                    return 1;
+            } else {
+                if (!oPre.isPresent())
+                    return -1;
+                String val = pre.get();
+                String oVal = oPre.get();
+                if (val.matches("\\d+")) {
+                    return (oVal.matches("\\d+")
+                        ? (new BigInteger(val)).compareTo(new BigInteger(oVal))
+                        : -1);
+                } else {
+                    return (oVal.matches("\\d+")
+                        ? 1
+                        : val.compareTo(oVal));
+                }
+            }
+            return 0;
+        }
+
+        private int compareBuild(Version ob) {
+            Optional<Integer> oBuild = ob.build();
+            if (oBuild.isPresent()) {
+                return (build.isPresent()
+                        ? build.get().compareTo(oBuild.get())
+                        : 1);
+            } else if (build.isPresent()) {
+                return -1;
+            }
+            return 0;
+        }
+
+        private int compareOpt(Version ob) {
+            Optional<String> oOpt = ob.optional();
+            if (!optional.isPresent()) {
+                if (oOpt.isPresent())
+                    return -1;
+            } else {
+                if (!oOpt.isPresent())
+                    return 1;
+                return optional.get().compareTo(oOpt.get());
+            }
+            return 0;
+        }
+
+        /**
+         * Returns a string representation of this version.
+         *
+         * @return  The version string
+         */
+        @Override
+        public String toString() {
+            StringBuilder sb
+                = new StringBuilder(version.stream()
+                    .map(Object::toString)
+                    .collect(Collectors.joining(".")));
+
+            pre.ifPresent(v -> sb.append("-").append(v));
+
+            if (build.isPresent()) {
+                sb.append("+").append(build.get());
+                if (optional.isPresent())
+                    sb.append("-").append(optional.get());
+            } else {
+                if (optional.isPresent()) {
+                    sb.append(pre.isPresent() ? "-" : "+-");
+                    sb.append(optional.get());
+                }
+            }
+
+            return sb.toString();
+        }
+
+        /**
+         * Determines whether this {@code Version} is equal to another object.
+         *
+         * <p> Two {@code Version}s are equal if and only if they represent the
+         * same version string.
+         *
+         * <p> This method satisfies the general contract of the {@link
+         * Object#equals(Object) Object.equals} method. </p>
+         *
+         * @param  ob
+         *         The object to which this {@code Version} is to be compared
+         *
+         * @return  {@code true} if, and only if, the given object is a {@code
+         *          Version} that is identical to this {@code Version}
+         *
+         */
+        @Override
+        public boolean equals(Object ob) {
+            boolean ret = equalsIgnoreOpt(ob);
+            if (!ret)
+                return false;
+
+            Version that = (Version)ob;
+            return (this.optional().equals(that.optional()));
+        }
+
+        /**
+         * Determines whether this {@code Version} is equal to another
+         * disregarding optional build information.
+         *
+         * <p> Two {@code Version}s are equal if and only if they represent the
+         * same version string disregarding the optional build information.
+         *
+         * @param  ob
+         *         The object to which this {@code Version} is to be compared
+         *
+         * @return  {@code true} if, and only if, the given object is a {@code
+         *          Version} that is identical to this {@code Version}
+         *          ignoring the optinal build information
+         *
+         */
+        public boolean equalsIgnoreOpt(Object ob) {
+            if (this == ob)
+                return true;
+            if (!(ob instanceof Version))
+                return false;
+
+            Version that = (Version)ob;
+            return (this.version().equals(that.version())
+                && this.pre().equals(that.pre())
+                && this.build().equals(that.build()));
+        }
+
+        /**
+         * Returns the hash code of this version.
+         *
+         * <p> This method satisfies the general contract of the {@link
+         * Object#hashCode Object.hashCode} method.
+         *
+         * @return  The hashcode of this version
+         */
+        @Override
+        public int hashCode() {
+            int h = 1;
+            int p = 17;
+
+            h = p * h + version.hashCode();
+            h = p * h + pre.hashCode();
+            h = p * h + build.hashCode();
+            h = p * h + optional.hashCode();
+
+            return h;
+        }
+    }
+
 }
--- a/src/java.base/share/classes/java/lang/System.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/java.base/share/classes/java/lang/System.java	Thu May 19 12:04:54 2016 -0700
@@ -576,7 +576,8 @@
      * <tr><th>Key</th>
      *     <th>Description of Associated Value</th></tr>
      * <tr><td><code>java.version</code></td>
-     *     <td>Java Runtime Environment version</td></tr>
+     *     <td>Java Runtime Environment version which may be interpreted
+     *     as a {@link Runtime.Version}</td></tr>
      * <tr><td><code>java.vendor</code></td>
      *     <td>Java Runtime Environment vendor</td></tr>
      * <tr><td><code>java.vendor.url</code></td>
@@ -584,19 +585,22 @@
      * <tr><td><code>java.home</code></td>
      *     <td>Java installation directory</td></tr>
      * <tr><td><code>java.vm.specification.version</code></td>
-     *     <td>Java Virtual Machine specification version</td></tr>
+     *     <td>Java Virtual Machine specification version which may be
+     *     interpreted as a {@link Runtime.Version}</td></tr>
      * <tr><td><code>java.vm.specification.vendor</code></td>
      *     <td>Java Virtual Machine specification vendor</td></tr>
      * <tr><td><code>java.vm.specification.name</code></td>
      *     <td>Java Virtual Machine specification name</td></tr>
      * <tr><td><code>java.vm.version</code></td>
-     *     <td>Java Virtual Machine implementation version</td></tr>
+     *     <td>Java Virtual Machine implementation version which may be
+     *     interpreted as a {@link Runtime.Version}</td></tr>
      * <tr><td><code>java.vm.vendor</code></td>
      *     <td>Java Virtual Machine implementation vendor</td></tr>
      * <tr><td><code>java.vm.name</code></td>
      *     <td>Java Virtual Machine implementation name</td></tr>
      * <tr><td><code>java.specification.version</code></td>
-     *     <td>Java Runtime Environment specification  version</td></tr>
+     *     <td>Java Runtime Environment specification version which may be
+     *     interpreted as a {@link Runtime.Version}</td></tr>
      * <tr><td><code>java.specification.vendor</code></td>
      *     <td>Java Runtime Environment specification  vendor</td></tr>
      * <tr><td><code>java.specification.name</code></td>
--- a/src/java.base/share/classes/java/util/jar/JarFile.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/java.base/share/classes/java/util/jar/JarFile.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2016, 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
@@ -153,7 +153,7 @@
         SharedSecrets.setJavaUtilJarAccess(new JavaUtilJarAccessImpl());
 
         BASE_VERSION = 8;  // one less than lowest version for versioned entries
-        int runtimeVersion = jdk.Version.current().major();
+        int runtimeVersion = Runtime.version().major();
         String jarVersion =
                 GetPropertyAction.privilegedGetProperty("jdk.util.jar.version");
         if (jarVersion != null) {
@@ -357,7 +357,7 @@
     }
 
     private boolean runtimeVersionExists() {
-        int version = jdk.Version.current().major();
+        int version = Runtime.version().major();
         try {
             Release.valueOf(version);
             return true;
--- a/src/java.base/share/classes/jdk/Version.java	Thu May 19 11:17:35 2016 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,603 +0,0 @@
-/*
- * Copyright (c) 2015, 2016, 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.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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.
- */
-
-package jdk;
-
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-import java.util.Collections;
-import java.util.List;
-import java.util.Optional;
-import sun.security.action.GetPropertyAction;
-
-/**
- * A representation of the JDK version-string which contains a version
- * number optionally followed by pre-release and build information.
- *
- * <h2><a name="verNum">Version numbers</a></h2>
- *
- * A <em>version number</em>, {@code $VNUM}, is a non-empty sequence of
- * non-negative integer numerals, without leading or trailing zeroes,
- * separated by period characters (U+002E); i.e., it matches the regular
- * expression {@code ^[1-9][0-9]*(((\.0)*\.[1-9][0-9]*)*)*$}. The sequence may
- * be of arbitrary length but the first three elements are assigned specific
- * meanings, as follows:
- *
- * <blockquote><pre>
- *     $MAJOR.$MINOR.$SECURITY
- * </pre></blockquote>
- *
- * <ul>
- *
- * <li><p> <a name="major">{@code $MAJOR}</a> --- The major version number,
- * incremented for a major release that contains significant new features as
- * specified in a new edition of the Java&#160;SE Platform Specification,
- * <em>e.g.</em>, <a href="https://jcp.org/en/jsr/detail?id=337">JSR 337</a>
- * for Java&#160;SE&#160;8. Features may be removed in a major release, given
- * advance notice at least one major release ahead of time, and incompatible
- * changes may be made when justified. The {@code $MAJOR} version number of
- * JDK&#160;8 was {@code 8}; the {@code $MAJOR} version number of JDK&#160;9
- * is {@code 9}. </p></li>
- *
- * <li><p> <a name="minor">{@code $MINOR}</a> --- The minor version number,
- * incremented for a minor update release that may contain compatible bug
- * fixes, revisions to standard APIs mandated by a <a
- * href="https://jcp.org/en/procedures/jcp2#5.3">Maintenance Release</a> of
- * the relevant Platform Specification, and implementation features outside
- * the scope of that Specification such as new JDK-specific APIs, additional
- * service providers, new garbage collectors, and ports to new hardware
- * architectures. {@code $MINOR} is reset to zero when {@code $MAJOR} is
- * incremented. </p></li>
- *
- * <li><p> <a name="security">{@code $SECURITY}</a> --- The security level,
- * incremented for a security-update release that contains critical fixes
- * including those necessary to improve security. {@code $SECURITY} is reset
- * to zero <strong>only</strong> when {@code $MAJOR} is incremented. A higher
- * value of {@code $SECURITY} for a given {@code $MAJOR} value, therefore,
- * always indicates a more secure release, regardless of the value of {@code
- * $MINOR}. </p></li>
- *
- * </ul>
- *
- * <p> The fourth and later elements of a version number are free for use by
- * downstream consumers of the JDK code base.  Such a consumer may,
- * <em>e.g.</em>, use the fourth element to identify patch releases which
- * contain a small number of critical non-security fixes in addition to the
- * security fixes in the corresponding security release. </p>
- *
- * <p> The version number does not include trailing zero elements;
- * <em>i.e.</em>, {@code $SECURITY} is omitted if it has the value zero, and
- * {@code $MINOR} is omitted if both {@code $MINOR} and {@code $SECURITY} have
- * the value zero. </p>
- *
- * <p> The sequence of numerals in a version number is compared to another
- * such sequence in numerical, pointwise fashion; <em>e.g.</em>, {@code 9.9.1}
- * is less than {@code 9.10.0}. If one sequence is shorter than another then
- * the missing elements of the shorter sequence are considered to be zero;
- * <em>e.g.</em>, {@code 9.1.2} is equal to {@code 9.1.2.0} but less than
- * {@code 9.1.2.1}. </p>
- *
- * <h2><a name="verStr">Version strings</a></h2>
- *
- * <p> A <em>version string</em> {@code $VSTR} consists of a version number
- * {@code $VNUM}, as described above, optionally followed by pre-release and
- * build information, in the format </p>
- *
- * <blockquote><pre>
- *     $VNUM(-$PRE)?(\+($BUILD)?(-$OPT)?)?
- * </pre></blockquote>
- *
- * <p> where: </p>
- *
- * <ul>
- *
- * <li><p> <a name="pre">{@code $PRE}</a>, matching {@code ([a-zA-Z0-9]+)} ---
- * A pre-release identifier.  Typically {@code ea}, for an early-access
- * release that's under active development and potentially unstable, or {@code
- * internal}, for an internal developer build.
- *
- * <li><p> <a name="build">{@code $BUILD}</a>, matching {@code
- * (0|[1-9][0-9]*)} --- The build number, incremented for each promoted build.
- * {@code $BUILD} is reset to {@code 1} when any portion of {@code $VNUM} is
- * incremented. </p>
- *
- * <li><p> <a name="opt">{@code $OPT}</a>, matching {@code ([-a-zA-Z0-9\.]+)}
- * --- Additional build information, if desired.  In the case of an {@code
- * internal} build this will often contain the date and time of the
- * build. </p>
- *
- * </ul>
- *
- * <p> When comparing two version strings the value of {@code $OPT}, if
- * present, may or may not be significant depending on the chosen comparison
- * method.  The comparison methods {@link #compareTo(Version) compareTo()} and
- * {@link #compareToIgnoreOpt(Version) compareToIgnoreOpt{}} should be used
- * consistently with the corresponding methods {@link #equals(Object) equals()}
- * and {@link #equalsIgnoreOpt(Object) equalsIgnoreOpt()}.  </p>
- *
- * <p> A <em>short version string</em> ({@code $SVSTR}), often useful in less
- * formal contexts, is simply {@code $VNUM} optionally ended with {@code
- * -$PRE}. </p>
- *
- * @since  9
- */
-public final class Version
-    implements Comparable<Version>
-{
-    private final List<Integer>     version;
-    private final Optional<String>  pre;
-    private final Optional<Integer> build;
-    private final Optional<String>  optional;
-
-    private static Version current;
-
-    // $VNUM(-$PRE)?(\+($BUILD)?(\-$OPT)?)?
-    // RE limits the format of version strings
-    // ([1-9][0-9]*(?:(?:\.0)*\.[1-9][0-9]*)*)(?:-([a-zA-Z0-9]+))?(?:(\+)(0|[1-9][0-9]*)?)?(?:-([-a-zA-Z0-9.]+))?
-
-    private static final String VNUM
-        = "(?<VNUM>[1-9][0-9]*(?:(?:\\.0)*\\.[1-9][0-9]*)*)";
-    private static final String VNUM_GROUP  = "VNUM";
-
-    private static final String PRE      = "(?:-(?<PRE>[a-zA-Z0-9]+))?";
-    private static final String PRE_GROUP   = "PRE";
-
-    private static final String BUILD
-        = "(?:(?<PLUS>\\+)(?<BUILD>0|[1-9][0-9]*)?)?";
-    private static final String PLUS_GROUP  = "PLUS";
-    private static final String BUILD_GROUP = "BUILD";
-
-    private static final String OPT      = "(?:-(?<OPT>[-a-zA-Z0-9.]+))?";
-    private static final String OPT_GROUP   = "OPT";
-
-    private static final String VSTR_FORMAT
-        = "^" + VNUM + PRE + BUILD + OPT + "$";
-    private static final Pattern VSTR_PATTERN = Pattern.compile(VSTR_FORMAT);
-
-    /**
-     * Constructs a valid JDK <a href="verStr">version string</a> containing a
-     * <a href="#verNum">version number</a> followed by pre-release and build
-     * information.
-     *
-     * @param  s
-     *         A string to be interpreted as a version
-     *
-     * @throws  IllegalArgumentException
-     *          If the given string cannot be interpreted a valid version
-     *
-     * @throws  NullPointerException
-     *          If {@code s} is {@code null}
-     *
-     * @throws  NumberFormatException
-     *          If an element of the version number or the build number cannot
-     *          be represented as an {@link Integer}
-     */
-    private Version(String s) {
-        if (s == null)
-            throw new NullPointerException();
-
-        Matcher m = VSTR_PATTERN.matcher(s);
-        if (!m.matches())
-            throw new IllegalArgumentException("Invalid version string: '"
-                                               + s + "'");
-
-        // $VNUM is a dot-separated list of integers of arbitrary length
-        List<Integer> list = new ArrayList<>();
-        for (String i : m.group(VNUM_GROUP).split("\\."))
-            list.add(Integer.parseInt(i));
-        version = Collections.unmodifiableList(list);
-
-        pre = Optional.ofNullable(m.group(PRE_GROUP));
-
-        String b = m.group(BUILD_GROUP);
-        // $BUILD is an integer
-        build = (b == null)
-             ? Optional.<Integer>empty()
-             : Optional.ofNullable(Integer.parseInt(b));
-
-        optional = Optional.ofNullable(m.group(OPT_GROUP));
-
-        // empty '+'
-        if ((m.group(PLUS_GROUP) != null) && !build.isPresent()) {
-            if (optional.isPresent()) {
-                if (pre.isPresent())
-                    throw new IllegalArgumentException("'+' found with"
-                        + " pre-release and optional components:'" + s + "'");
-            } else {
-                throw new IllegalArgumentException("'+' found with neither"
-                    + " build or optional components: '" + s + "'");
-            }
-        }
-    }
-
-    /**
-     * Parses the given string as a valid JDK <a
-     * href="#verStr">version string</a> containing a <a
-     * href="#verNum">version number</a> followed by pre-release and
-     * build information.
-     *
-     * @param  s
-     *         A string to interpret as a version
-     *
-     * @throws  IllegalArgumentException
-     *          If the given string cannot be interpreted a valid version
-     *
-     * @throws  NullPointerException
-     *          If the given string is {@code null}
-     *
-     * @throws  NumberFormatException
-     *          If an element of the version number or the build number cannot
-     *          be represented as an {@link Integer}
-     *
-     * @return  This version
-     */
-    public static Version parse(String s) {
-        return new Version(s);
-    }
-
-    /**
-     * Returns {@code System.getProperty("java.version")} as a Version.
-     *
-     * @throws  SecurityException
-     *          If a security manager exists and its {@link
-     *          SecurityManager#checkPropertyAccess(String)
-     *          checkPropertyAccess} method does not allow access to the
-     *          system property "java.version"
-     *
-     * @return  {@code System.getProperty("java.version")} as a Version
-     */
-    public static Version current() {
-        if (current == null) {
-            current = parse(
-                    GetPropertyAction.privilegedGetProperty("java.version"));
-        }
-        return current;
-    }
-
-    /**
-     * Returns the <a href="#major">major</a> version number.
-     *
-     * @return  The major version number
-     */
-    public int major() {
-        return version.get(0);
-    }
-
-    /**
-     * Returns the <a href="#minor">minor</a> version number or zero if it was
-     * not set.
-     *
-     * @return  The minor version number or zero if it was not set
-     */
-    public int minor() {
-        return (version.size() > 1 ? version.get(1) : 0);
-    }
-
-    /**
-     * Returns the <a href="#security">security</a> version number or zero if
-     * it was not set.
-     *
-     * @return  The security version number or zero if it was not set
-     */
-    public int security() {
-        return (version.size() > 2 ? version.get(2) : 0);
-    }
-
-    /**
-     * Returns an unmodifiable {@link java.util.List List} of the
-     * integer numerals contained in the <a href="#verNum">version
-     * number</a>.  The {@code List} always contains at least one
-     * element corresponding to the <a href="#major">major version
-     * number</a>.
-     *
-     * @return  An unmodifiable list of the integer numerals
-     *          contained in the version number
-     */
-    public List<Integer> version() {
-        return version;
-    }
-
-    /**
-     * Returns the optional <a href="#pre">pre-release</a> information.
-     *
-     * @return  The optional pre-release information as a String
-     */
-    public Optional<String> pre() {
-        return pre;
-    }
-
-    /**
-     * Returns the <a href="#build">build number</a>.
-     *
-     * @return The optional build number.
-     */
-    public Optional<Integer> build() {
-        return build;
-    }
-
-    /**
-     * Returns <a href="#opt">optional</a> additional identifying build
-     * information.
-     *
-     * @return  Additional build information as a String
-     */
-    public Optional<String> optional() {
-        return optional;
-    }
-
-    /**
-     * Compares this version to another.
-     *
-     * <p> Each of the components in the <a href="#verStr">version</a> is
-     * compared in the follow order of precedence: version numbers,
-     * pre-release identifiers, build numbers, optional build information. </p>
-     *
-     * <p> Comparison begins by examining the sequence of version numbers.  If
-     * one sequence is shorter than another, then the missing elements of the
-     * shorter sequence are considered to be zero. </p>
-     *
-     * <p> A version with a pre-release identifier is always considered to be
-     * less than a version without one.  Pre-release identifiers are compared
-     * numerically when they consist only of digits, and lexicographically
-     * otherwise.  Numeric identifiers are considered to be less than
-     * non-numeric identifiers.  </p>
-     *
-     * <p> A version without a build number is always less than one with a
-     * build number; otherwise build numbers are compared numerically. </p>
-     *
-     * <p> The optional build information is compared lexicographically.
-     * During this comparison, a version with optional build information is
-     * considered to be greater than a version without one. </p>
-     *
-     * <p> A version is not comparable to any other type of object.
-     *
-     * @param  ob
-     *         The object to be compared
-     *
-     * @return  A negative integer, zero, or a positive integer if this
-     *          {@code Version} is less than, equal to, or greater than the
-     *          given {@code Version}
-     *
-     * @throws  NullPointerException
-     *          If the given object is {@code null}
-     */
-    @Override
-    public int compareTo(Version ob) {
-        return compare(ob, false);
-    }
-
-    /**
-     * Compares this version to another disregarding optional build
-     * information.
-     *
-     * <p> Two versions are compared by examining the version string as
-     * described in {@link #compareTo(Version)} with the exception that the
-     * optional build information is always ignored. </p>
-     *
-     * <p> A version is not comparable to any other type of object.
-     *
-     * @param  ob
-     *         The object to be compared
-     *
-     * @return  A negative integer, zero, or a positive integer if this
-     *          {@code Version} is less than, equal to, or greater than the
-     *          given {@code Version}
-     *
-     * @throws  NullPointerException
-     *          If the given object is {@code null}
-     */
-    public int compareToIgnoreOpt(Version ob) {
-        return compare(ob, true);
-    }
-
-    private int compare(Version ob, boolean ignoreOpt) {
-        if (ob == null)
-            throw new NullPointerException("Invalid argument");
-
-        int ret = compareVersion(ob);
-        if (ret != 0)
-            return ret;
-
-        ret = comparePre(ob);
-        if (ret != 0)
-            return ret;
-
-        ret = compareBuild(ob);
-        if (ret != 0)
-            return ret;
-
-        if (!ignoreOpt)
-            return compareOpt(ob);
-
-        return 0;
-    }
-
-    private int compareVersion(Version ob) {
-        int size = version.size();
-        int oSize = ob.version().size();
-        int min = Math.min(size, oSize);
-        for (int i = 0; i < min; i++) {
-            Integer val = version.get(i);
-            Integer oVal = ob.version().get(i);
-            if (val != oVal)
-                return val - oVal;
-        }
-        if (size != oSize)
-            return size - oSize;
-        return 0;
-    }
-
-    private int comparePre(Version ob) {
-        Optional<String> oPre = ob.pre();
-        if (!pre.isPresent()) {
-            if (oPre.isPresent())
-                return 1;
-        } else {
-            if (!oPre.isPresent())
-                return -1;
-            String val = pre.get();
-            String oVal = oPre.get();
-            if (val.matches("\\d+")) {
-                return (oVal.matches("\\d+")
-                        ? (new BigInteger(val)).compareTo(new BigInteger(oVal))
-                        : -1);
-            } else {
-                return (oVal.matches("\\d+")
-                        ? 1
-                        : val.compareTo(oVal));
-            }
-        }
-        return 0;
-    }
-
-    private int compareBuild(Version ob) {
-        Optional<Integer> oBuild = ob.build();
-        if (oBuild.isPresent()) {
-            return (build.isPresent()
-                   ? build.get().compareTo(oBuild.get())
-                   : 1);
-        } else if (build.isPresent()) {
-            return -1;
-        }
-        return 0;
-    }
-
-    private int compareOpt(Version ob) {
-        Optional<String> oOpt = ob.optional();
-        if (!optional.isPresent()) {
-            if (oOpt.isPresent())
-                return -1;
-        } else {
-            if (!oOpt.isPresent())
-                return 1;
-            return optional.get().compareTo(oOpt.get());
-        }
-        return 0;
-    }
-
-    /**
-     * Returns a string representation of this version.
-     *
-     * @return  The version string
-     */
-    @Override
-    public String toString() {
-        StringBuilder sb
-            = new StringBuilder(version.stream()
-                                .map(Object::toString)
-                                .collect(Collectors.joining(".")));
-        pre.ifPresent(v -> sb.append("-").append(v));
-
-        if (build.isPresent()) {
-            sb.append("+").append(build.get());
-            if (optional.isPresent())
-                sb.append("-").append(optional.get());
-        } else {
-            if (optional.isPresent()) {
-                sb.append(pre.isPresent() ? "-" : "+-");
-                sb.append(optional.get());
-            }
-        }
-
-        return sb.toString();
-    }
-
-    /**
-     * Determines whether this {@code Version} is equal to another object.
-     *
-     * <p> Two {@code Version}s are equal if and only if they represent the
-     * same version string.
-     *
-     * <p> This method satisfies the general contract of the {@link
-     * Object#equals(Object) Object.equals} method. </p>
-     *
-     * @param  ob
-     *         The object to which this {@code Version} is to be compared
-     *
-     * @return  {@code true} if, and only if, the given object is a {@code
-     *          Version} that is identical to this {@code Version}
-     *
-     */
-    @Override
-    public boolean equals(Object ob) {
-        boolean ret = equalsIgnoreOpt(ob);
-        if (!ret)
-            return false;
-
-        Version that = (Version)ob;
-        return (this.optional().equals(that.optional()));
-    }
-
-    /**
-     * Determines whether this {@code Version} is equal to another
-     * disregarding optional build information.
-     *
-     * <p> Two {@code Version}s are equal if and only if they represent the
-     * same version string disregarding the optional build information.
-     *
-     * @param  ob
-     *         The object to which this {@code Version} is to be compared
-     *
-     * @return  {@code true} if, and only if, the given object is a {@code
-     *          Version} that is identical to this {@code Version}
-     *          ignoring the optinal build information
-     *
-     */
-    public boolean equalsIgnoreOpt(Object ob) {
-        if (this == ob)
-            return true;
-        if (!(ob instanceof Version))
-            return false;
-
-        Version that = (Version)ob;
-        return (this.version().equals(that.version())
-                && this.pre().equals(that.pre())
-                && this.build().equals(that.build()));
-    }
-
-    /**
-     * Returns the hash code of this version.
-     *
-     * <p> This method satisfies the general contract of the {@link
-     * Object#hashCode Object.hashCode} method.
-     *
-     * @return  The hashcode of this version
-     */
-    @Override
-    public int hashCode() {
-        int h = 1;
-        int p = 17;
-
-        h = p * h + version.hashCode();
-        h = p * h + pre.hashCode();
-        h = p * h + build.hashCode();
-        h = p * h + optional.hashCode();
-
-        return h;
-    }
-}
--- a/src/java.base/share/classes/module-info.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/java.base/share/classes/module-info.java	Thu May 19 12:04:54 2016 -0700
@@ -81,9 +81,6 @@
     exports javax.security.auth.x500;
     exports javax.security.cert;
 
-    // see JDK-8144062
-    exports jdk;
-
 
     // the service types defined by the APIs in this module
 
--- a/src/jdk.jconsole/share/classes/sun/tools/jconsole/AboutDialog.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/jdk.jconsole/share/classes/sun/tools/jconsole/AboutDialog.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2016, 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
@@ -181,7 +181,7 @@
     }
 
     private static String getOnlineDocUrl() {
-        String version = Integer.toString(jdk.Version.current().major());
+        String version = Integer.toString(Runtime.version().major());
         return Resources.format(Messages.HELP_ABOUT_DIALOG_USER_GUIDE_LINK_URL,
                                 version);
     }
--- a/src/jdk.zipfs/share/classes/jdk/nio/zipfs/JarFileSystem.java	Thu May 19 11:17:35 2016 -0700
+++ b/src/jdk.zipfs/share/classes/jdk/nio/zipfs/JarFileSystem.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -27,6 +27,7 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.Runtime.Version;
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -36,7 +37,6 @@
 import java.util.function.Function;
 import java.util.jar.Attributes;
 import java.util.jar.Manifest;
-import jdk.Version;
 
 /**
  * Adds aliasing to ZipFileSystem to support multi-release jar files.  An alias map
@@ -69,7 +69,7 @@
             if (o instanceof String) {
                 String s = (String)o;
                 if (s.equals("runtime")) {
-                    version = jdk.Version.current().major();
+                    version = Runtime.version().major();
                 } else {
                     version = Integer.parseInt(s);
                 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/java/lang/Runtime/Version/Basic.java	Thu May 19 12:04:54 2016 -0700
@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 2015, 2016, 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
+ * @summary Unit test for java.lang.Runtime.Version.
+ * @bug 8072379 8144062
+ */
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.Runtime.Version;
+import java.math.BigInteger;
+import java.util.stream.Collectors;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static java.lang.System.out;
+
+public class Basic {
+    private static final Class<? extends Throwable> IAE
+        = IllegalArgumentException.class;
+    private static final Class<? extends Throwable> NPE
+        = NullPointerException.class;
+    private static final Class<? extends Throwable> NFE
+        = NumberFormatException.class;
+    private static final Class<?> VERSION = Version.class;
+
+    private static final BigInteger TOO_BIG
+        = (BigInteger.valueOf(Integer.MAX_VALUE)).add(BigInteger.ONE);
+    private static final String TOO_BIG_STR = TOO_BIG.toString();
+
+    public static void main(String ... args) {
+
+        //// Tests for parse(), major(), minor(), security(), pre(),
+        //// build(), opt(), version(), toString()
+        //   v                          M     m sec pre bld opt
+
+        // $VNUM
+        test("9",                       9,    0, 0, "", 0, "");
+        test("9.1",                     9,    1, 0, "", 0, "");
+        test("9.0.1",                   9,    0, 1, "", 0, "");
+        test("404.1.2",                 404,  1, 2, "", 0, "");
+        test("9.1.2.3",                 9,    1, 2, "", 0, "");
+        test("1000.0.0.0.0.0.99999999", 1000, 0, 0, "", 0, "");
+
+        tryCatch(null,    NPE);
+        tryCatch("",      IAE);
+        tryCatch("foo",   IAE);
+        tryCatch("7a",    IAE);
+        tryCatch("0",     IAE);
+        tryCatch("09",    IAE);
+        tryCatch("9.0",   IAE);
+        tryCatch("9.0.",  IAE);
+        tryCatch("1.9,1", IAE);
+        tryCatch(TOO_BIG_STR, NFE);
+
+        // $PRE
+        test("9-ea",       9, 0, 0, "ea",       0, "");
+        test("9-internal", 9, 0, 0, "internal", 0, "");
+        test("9-0",        9, 0, 0, "0",        0, "");
+        test("9.2.7-8",    9, 2, 7, "8",        0, "");
+        test("1-ALL",      1, 0, 0, "ALL",      0, "");
+        test("2.3.4.5-1a", 2, 3, 4, "1a",       0, "");
+        test("1-" + TOO_BIG_STR, 1, 0, 0, TOO_BIG_STR, 0, "");
+
+        tryCatch("9:-ea",     IAE);
+        tryCatch("3.14159-",  IAE);
+        tryCatch("3.14159-%", IAE);
+
+        // $BUILD
+        test("9+0",            9, 0,  0,  "",      0,       "");
+        test("3.14+9999900",   3, 14, 0,  "",      9999900, "");
+        test("9-pre+105",      9, 0,  0,  "pre",   105,     "");
+        test("6.0.42-8beta+4", 6, 0,  42, "8beta", 4,       "");
+
+        tryCatch("9+",     IAE);
+        tryCatch("7+a",    IAE);
+        tryCatch("9+00",   IAE);
+        tryCatch("4.2+01", IAE);
+        tryCatch("4.2+1a", IAE);
+        tryCatch("1+" + TOO_BIG_STR, NFE);
+
+        // $OPT
+        test("9+-foo",          9,   0, 0, "",       0,  "foo");
+        test("9-pre-opt",       9,   0, 0, "pre",    0,  "opt");
+        test("42+---bar",       42,  0, 0, "",       0,  "--bar");
+        test("2.91+-8061493-",  2,  91, 0, "",       0,  "8061493-");
+        test("24+-foo.bar",     24,  0, 0, "",       0,  "foo.bar");
+        test("9-ribbit+17-...", 9,   0, 0, "ribbit", 17, "...");
+        test("7+1-" + TOO_BIG_STR, 7,0, 0, "",       1,  TOO_BIG_STR);
+
+        tryCatch("9-pre+-opt", IAE);
+        tryCatch("1.4142+-",   IAE);
+        tryCatch("2.9979+-%",  IAE);
+
+        //// Test for Runtime.version()
+        testVersion();
+
+        //// Test for equals{IgnoreOpt}?(), hashCode(), compareTo{IgnoreOpt}?()
+        // compare: after "<" == -1, equal == 0, before ">" == 1
+        //      v0            v1                  eq     eqNO  cmp  cmpNO
+        testEHC("9",          "9",                true,  true,   0,    0);
+
+        testEHC("8",          "9",                false, false, -1,   -1);
+        testEHC("9",          "10",               false, false, -1,   -1);
+        testEHC("9",          "8",                false, false,  1,    1);
+
+        // $OPT comparison
+        testEHC("9",          "9+-oink",          false, true,  -1,    0);
+        testEHC("9+-ribbit",  "9+-moo",           false, true,   1,    0);
+        testEHC("9-quack+3-ribbit",
+                              "9-quack+3-moo",    false, true,   1,    0);
+        testEHC("9.1+7",      "9.1+7-moo-baa-la", false, true,  -1,    0);
+
+        // numeric vs. non-numeric $PRE
+        testEHC("9.1.1.2-2a", "9.1.1.2-12",       false, false,  1,    1);
+        testEHC("9.1.1.2-12", "9.1.1.2-4",        false, false,  1,    1);
+
+        testEHC("27.16",      "27.16+120",        false, false,  1,    1);
+        testEHC("10",         "10-ea",            false, false,  1,    1);
+        testEHC("10.1+1",     "10.1-ea+1",        false, false,  1,    1);
+        testEHC("10.0.1+22",  "10.0.1+21",        false, false,  1,    1);
+
+        // numeric vs. non-numeric $PRE
+        testEHC("9.1.1.2-12", "9.1.1.2-a2",       false, false, -1,   -1);
+        testEHC("9.1.1.2-1",  "9.1.1.2-4",        false, false, -1,   -1);
+
+        testEHC("9-internal", "9",                false, false, -1,   -1);
+        testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
+        testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
+        testEHC("9+101",      "9",                false, false, -1,   -1);
+        testEHC("9+101",      "9+102",            false, false, -1,   -1);
+        testEHC("1.9-ea",     "9-ea",             false, false, -1,   -1);
+
+        if (fail != 0)
+            throw new RuntimeException((fail + pass) + " tests: "
+                                       + fail + " failure(s), first", first);
+        else
+            out.println("all " + (fail + pass) + " tests passed");
+
+    }
+
+    private static void test(String s, Integer major, Integer minor,
+                             Integer sec, String pre, Integer build,
+                             String opt)
+    {
+        Version v = testParse(s);
+
+        testStr(v.toString(), s);
+
+        testInt(v.major(), major);
+        testInt(v.minor(), minor);
+        testInt(v.security(), sec);
+        testStr((v.pre().isPresent() ? v.pre().get() : ""), pre);
+        testInt((v.build().isPresent() ? v.build().get() : 0), build);
+        testStr((v.optional().isPresent() ? v.optional().get() : ""), opt);
+
+        testVersion(v.version(), s);
+    }
+
+    private static Version testParse(String s) {
+        Version v = Version.parse(s);
+        pass();
+        return v;
+    }
+
+    private static void testInt(int got, int exp) {
+        if (got != exp) {
+            fail("testInt()", Integer.toString(exp), Integer.toString(got));
+        } else {
+            pass();
+        }
+     }
+
+    private static void testStr(String got, String exp) {
+        if (!got.equals(exp)) {
+            fail("testStr()", exp, got);
+        } else {
+            pass();
+        }
+    }
+
+    private static void tryCatch(String s, Class<? extends Throwable> ex) {
+        Throwable t = null;
+        try {
+            Version.parse(s);
+        } catch (Throwable x) {
+            if (ex.isAssignableFrom(x.getClass())) {
+                t = x;
+            } else
+                x.printStackTrace();
+        }
+        if ((t == null) && (ex != null))
+            fail(s, ex);
+        else
+            pass();
+    }
+
+    private static void testVersion() {
+        Version current = Runtime.version();
+        String javaVer = System.getProperty("java.runtime.version");
+
+        // java.runtime.version == $VNUM(\-$PRE)?(\+$BUILD)?(-$OPT)?
+        String [] jv  = javaVer.split("\\+");
+        String [] ver = jv[0].split("-");
+        List<Integer> javaVerVNum
+            = Arrays.stream(ver[0].split("\\."))
+            .map(v -> Integer.parseInt(v))
+            .collect(Collectors.toList());
+        if (!javaVerVNum.equals(current.version())) {
+            fail("Runtime.version()", javaVerVNum.toString(),
+                 current.version().toString());
+        } else {
+            pass();
+        }
+
+        Optional<String> javaVerPre
+            = (ver.length == 2)
+            ? Optional.ofNullable(ver[1])
+            : Optional.empty();
+        if (!javaVerPre.equals(current.pre())) {
+            fail("testCurrent() pre()", javaVerPre.toString(),
+                 current.pre().toString());
+        } else {
+            pass();
+        }
+
+        testEHC(current.toString(), javaVer, true, true, 0, 0);
+    }
+
+    private static void testVersion(List<Integer> vnum, String s) {
+        List<Integer> svnum = new ArrayList<Integer>();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < s.length(); i++) {
+            Character c = s.charAt(i);
+            if (Character.isDigit(c)) {
+                sb.append(c);
+            } else {
+                svnum.add(Integer.parseInt(sb.toString()));
+                sb = new StringBuilder();
+                if (c == '+' || c == '-') {
+                    break;
+                }
+            }
+        }
+        if (sb.length() > 0) {
+            svnum.add(Integer.parseInt(sb.toString()));
+        }
+
+        if (!svnum.equals(vnum)) {
+            fail("testVersion() equals()", svnum.toString(), vnum.toString());
+        } else {
+            pass();
+        }
+    }
+
+    private static void testEHC(String s0, String s1, boolean eq, boolean eqNO,
+                                int cmp, int cmpNO)
+    {
+        Version v0 = Version.parse(s0);
+        Version v1 = Version.parse(s1);
+
+        testEquals(v0, v1, eq);
+        testEqualsNO(v0, v1, eqNO);
+
+        testHashCode(v0, v1, eq);
+
+        testCompare(v0, v1, cmp);
+        testCompareNO(v0, v1, cmpNO);
+    }
+
+    private static void testEqualsNO(Version v0, Version v1, boolean eq) {
+        if ((eq && !v0.equalsIgnoreOpt(v1))
+            || (!eq && v0.equalsIgnoreOpt(v1))) {
+            fail("equalsIgnoreOpt() " + Boolean.toString(eq),
+                 v0.toString(), v1.toString());
+        } else {
+            pass();
+        }
+    }
+
+    private static void testEquals(Version v0, Version v1, boolean eq) {
+        if ((eq && !v0.equals(v1)) || (!eq && v0.equals(v1))) {
+            fail("equals() " + Boolean.toString(eq),
+                 v0.toString(), v1.toString());
+        } else {
+            pass();
+        }
+    }
+
+    private static void testHashCode(Version v0, Version v1, boolean eq) {
+        int h0 = v0.hashCode();
+        int h1 = v1.hashCode();
+        if (eq) {
+            testInt(h0, h1);
+        } else if (h0 == h1) {
+            fail(String.format("hashCode() %s", h0),
+                 Integer.toString(h0),
+                 Integer.toString(h1));
+        } else { // !eq && (h0 != h1)
+            pass();
+        }
+    }
+
+    private static void testCompareNO(Version v0, Version v1, int compare)
+    {
+        try {
+            Method m = VERSION.getMethod("compareToIgnoreOpt", VERSION);
+            int cmp = (int) m.invoke(v0, v1);
+            checkCompare(v0, v1, compare, cmp);
+        } catch (IllegalAccessException | InvocationTargetException |
+                 NoSuchMethodException ex) {
+            fail(String.format("compareToIgnoreOpt() invocation: %s",
+                               ex.getClass()),
+                 null);
+        }
+    }
+
+    private static void testCompare(Version v0, Version v1, int compare) {
+        try {
+            Method m = VERSION.getMethod("compareTo", VERSION);
+            int cmp = (int) m.invoke(v0, v1);
+            checkCompare(v0, v1, compare, cmp);
+        } catch (IllegalAccessException | InvocationTargetException |
+                 NoSuchMethodException ex) {
+            fail(String.format("compareTo() invocation: %s", ex.getClass()),
+                 null);
+        }
+    }
+
+    private static void checkCompare(Version v0, Version v1,
+                                     int compare, int cmp)
+    {
+        if (((cmp == 0) && (compare == 0))
+            || (compare == (cmp / Math.abs(cmp == 0 ? 1 : cmp)))) {
+            pass();
+        } else {
+            fail(String.format("compare() (cmp = %s) (compare = %s)",
+                               cmp, compare),
+                 v0.toString(), v1.toString());
+        }
+    }
+
+    private static int fail = 0;
+    private static int pass = 0;
+
+    private static Throwable first;
+
+    static void pass() {
+        pass++;
+    }
+
+    static void fail(String fs, Class ex) {
+        String s = "'" + fs + "'";
+        if (ex != null)
+            s += ": " + ex.getName() + " not thrown";
+        if (first == null)
+            setFirst(s);
+        System.err.println("FAILED: " + s);
+        fail++;
+    }
+
+    static void fail(String t, String exp, String got) {
+        String s = t + ": Expected '" + exp + "', got '" + got + "'";
+        if (first == null)
+            setFirst(s);
+        System.err.println("FAILED: " + s);
+        fail++;
+     }
+
+    private static void setFirst(String s) {
+        try {
+            throw new RuntimeException(s);
+        } catch (RuntimeException x) {
+            first = x;
+        }
+    }
+}
--- a/test/java/util/jar/JarFile/mrjar/MultiReleaseJarAPI.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/java/util/jar/JarFile/mrjar/MultiReleaseJarAPI.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8132734
+ * @bug 8132734 8144062
  * @summary Test the extended API and the aliasing additions in JarFile that
  *          support multi-release jar files
  * @library /lib/testlibrary/java/util/jar
@@ -39,7 +39,6 @@
 import java.util.jar.JarFile;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
-import jdk.Version;
 
 import static java.util.jar.JarFile.Release;
 
@@ -51,7 +50,7 @@
 
 public class MultiReleaseJarAPI {
 
-    static final int MAJOR_VERSION = Version.current().major();
+    static final int MAJOR_VERSION = Runtime.version().major();
 
     String userdir = System.getProperty("user.dir",".");
     CreateMultiReleaseTestJars creator =  new CreateMultiReleaseTestJars();
--- a/test/java/util/jar/JarFile/mrjar/MultiReleaseJarIterators.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/java/util/jar/JarFile/mrjar/MultiReleaseJarIterators.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8132734
+ * @bug 8132734 8144062
  * @summary Test the extended API and the aliasing additions in JarFile that
  *          support multi-release jar files
  * @library /lib/testlibrary/java/util/jar
@@ -42,7 +42,6 @@
 import java.util.jar.JarFile;
 import java.util.stream.Collectors;
 import java.util.zip.ZipFile;
-import jdk.Version;
 
 import static java.util.jar.JarFile.Release;
 
@@ -54,7 +53,7 @@
 
 public class MultiReleaseJarIterators {
 
-    static final int MAJOR_VERSION = Version.current().major();
+    static final int MAJOR_VERSION = Runtime.version().major();
 
     String userdir = System.getProperty("user.dir", ".");
     File unversioned = new File(userdir, "unversioned.jar");
--- a/test/java/util/jar/JarFile/mrjar/MultiReleaseJarProperties.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/java/util/jar/JarFile/mrjar/MultiReleaseJarProperties.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8132734
+ * @bug 8132734 8144062
  * @summary Test the System properties for JarFile that support multi-release jar files
  * @library /lib/testlibrary/java/util/jar
  * @build Compiler JarBuilder CreateMultiReleaseTestJars
@@ -54,7 +54,6 @@
 import java.nio.file.Files;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
-import jdk.Version;
 
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
@@ -63,7 +62,7 @@
 
 public class MultiReleaseJarProperties {
 
-    static final int MAJOR_VERSION = Version.current().major();
+    static final int MAJOR_VERSION = Runtime.version().major();
 
     final static int ROOTVERSION = 8; // magic number from knowledge of internals
     final static String userdir = System.getProperty("user.dir", ".");
--- a/test/java/util/jar/JarFile/mrjar/MultiReleaseJarSecurity.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/java/util/jar/JarFile/mrjar/MultiReleaseJarSecurity.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8132734
+ * @bug 8132734 8144062
  * @summary Test potential security related issues
  * @library /lib/testlibrary/java/util/jar
  * @build Compiler JarBuilder CreateMultiReleaseTestJars
@@ -40,7 +40,6 @@
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
 import java.util.zip.ZipFile;
-import jdk.Version;
 
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
@@ -49,7 +48,7 @@
 
 public class MultiReleaseJarSecurity {
 
-    static final int MAJOR_VERSION = Version.current().major();
+    static final int MAJOR_VERSION = Runtime.version().major();
 
     String userdir = System.getProperty("user.dir",".");
     File multirelease = new File(userdir, "multi-release.jar");
--- a/test/jdk/Version/Basic.java	Thu May 19 11:17:35 2016 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,400 +0,0 @@
-/*
- * Copyright (c) 2015, 2016, 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
- * @summary Unit test for jdk.Version.
- * @bug 8072379
- */
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.math.BigInteger;
-import java.util.stream.Collectors;
-import java.util.Arrays;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import jdk.Version;
-import static java.lang.System.out;
-
-public class Basic {
-    private static final Class<? extends Throwable> IAE
-        = IllegalArgumentException.class;
-    private static final Class<? extends Throwable> NPE
-        = NullPointerException.class;
-    private static final Class<? extends Throwable> NFE
-        = NumberFormatException.class;
-    private static final Class<?> VERSION = Version.class;
-
-    private static final BigInteger TOO_BIG
-        = (BigInteger.valueOf(Integer.MAX_VALUE)).add(BigInteger.ONE);
-    private static final String TOO_BIG_STR = TOO_BIG.toString();
-
-    public static void main(String ... args) {
-
-        //// Tests for parse(), major(), minor(), security(), pre(),
-        //// build(), opt(), version(), toString()
-        //   v                          M     m sec pre bld opt
-
-        // $VNUM
-        test("9",                       9,    0, 0, "", 0, "");
-        test("9.1",                     9,    1, 0, "", 0, "");
-        test("9.0.1",                   9,    0, 1, "", 0, "");
-        test("404.1.2",                 404,  1, 2, "", 0, "");
-        test("9.1.2.3",                 9,    1, 2, "", 0, "");
-        test("1000.0.0.0.0.0.99999999", 1000, 0, 0, "", 0, "");
-
-        tryCatch(null,    NPE);
-        tryCatch("",      IAE);
-        tryCatch("foo",   IAE);
-        tryCatch("7a",    IAE);
-        tryCatch("0",     IAE);
-        tryCatch("09",    IAE);
-        tryCatch("9.0",   IAE);
-        tryCatch("9.0.",  IAE);
-        tryCatch("1.9,1", IAE);
-        tryCatch(TOO_BIG_STR, NFE);
-
-        // $PRE
-        test("9-ea",       9, 0, 0, "ea",       0, "");
-        test("9-internal", 9, 0, 0, "internal", 0, "");
-        test("9-0",        9, 0, 0, "0",        0, "");
-        test("9.2.7-8",    9, 2, 7, "8",        0, "");
-        test("1-ALL",      1, 0, 0, "ALL",      0, "");
-        test("2.3.4.5-1a", 2, 3, 4, "1a",       0, "");
-        test("1-" + TOO_BIG_STR, 1, 0, 0, TOO_BIG_STR, 0, "");
-
-        tryCatch("9:-ea",     IAE);
-        tryCatch("3.14159-",  IAE);
-        tryCatch("3.14159-%", IAE);
-
-        // $BUILD
-        test("9+0",            9, 0,  0,  "",      0,       "");
-        test("3.14+9999900",   3, 14, 0,  "",      9999900, "");
-        test("9-pre+105",      9, 0,  0,  "pre",   105,     "");
-        test("6.0.42-8beta+4", 6, 0,  42, "8beta", 4,       "");
-
-        tryCatch("9+",     IAE);
-        tryCatch("7+a",    IAE);
-        tryCatch("9+00",   IAE);
-        tryCatch("4.2+01", IAE);
-        tryCatch("4.2+1a", IAE);
-        tryCatch("1+" + TOO_BIG_STR, NFE);
-
-        // $OPT
-        test("9+-foo",          9,   0, 0, "",       0,  "foo");
-        test("9-pre-opt",       9,   0, 0, "pre",    0,  "opt");
-        test("42+---bar",       42,  0, 0, "",       0,  "--bar");
-        test("2.91+-8061493-",  2,  91, 0, "",       0,  "8061493-");
-        test("24+-foo.bar",     24,  0, 0, "",       0,  "foo.bar");
-        test("9-ribbit+17-...", 9,   0, 0, "ribbit", 17, "...");
-        test("7+1-" + TOO_BIG_STR, 7,0, 0, "",       1,  TOO_BIG_STR);
-
-        tryCatch("9-pre+-opt", IAE);
-        tryCatch("1.4142+-",   IAE);
-        tryCatch("2.9979+-%",  IAE);
-
-        //// Test for current()
-        testCurrent();
-
-        //// Test for equals{IgnoreOpt}?(), hashCode(), compareTo{IgnoreOpt}?()
-        // compare: after "<" == -1, equal == 0, before ">" == 1
-        //      v0            v1                  eq     eqNO  cmp  cmpNO
-        testEHC("9",          "9",                true,  true,   0,    0);
-
-        testEHC("8",          "9",                false, false, -1,   -1);
-        testEHC("9",          "10",               false, false, -1,   -1);
-        testEHC("9",          "8",                false, false,  1,    1);
-
-        // $OPT comparison
-        testEHC("9",          "9+-oink",          false, true,  -1,    0);
-        testEHC("9+-ribbit",  "9+-moo",           false, true,   1,    0);
-        testEHC("9-quack+3-ribbit",
-                              "9-quack+3-moo",    false, true,   1,    0);
-        testEHC("9.1+7",      "9.1+7-moo-baa-la", false, true,  -1,    0);
-
-        // numeric vs. non-numeric $PRE
-        testEHC("9.1.1.2-2a", "9.1.1.2-12",       false, false,  1,    1);
-        testEHC("9.1.1.2-12", "9.1.1.2-4",        false, false,  1,    1);
-
-        testEHC("27.16",      "27.16+120",        false, false,  1,    1);
-        testEHC("10",         "10-ea",            false, false,  1,    1);
-        testEHC("10.1+1",     "10.1-ea+1",        false, false,  1,    1);
-        testEHC("10.0.1+22",  "10.0.1+21",        false, false,  1,    1);
-
-        // numeric vs. non-numeric $PRE
-        testEHC("9.1.1.2-12", "9.1.1.2-a2",       false, false, -1,   -1);
-        testEHC("9.1.1.2-1",  "9.1.1.2-4",        false, false, -1,   -1);
-
-        testEHC("9-internal", "9",                false, false, -1,   -1);
-        testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
-        testEHC("9-ea+120",   "9+120",            false, false, -1,   -1);
-        testEHC("9+101",      "9",                false, false, -1,   -1);
-        testEHC("9+101",      "9+102",            false, false, -1,   -1);
-        testEHC("1.9-ea",     "9-ea",             false, false, -1,   -1);
-
-        if (fail != 0)
-            throw new RuntimeException((fail + pass) + " tests: "
-                                       + fail + " failure(s), first", first);
-        else
-            out.println("all " + (fail + pass) + " tests passed");
-
-    }
-
-    private static void test(String s, Integer major, Integer minor,
-                             Integer sec, String pre, Integer build,
-                             String opt)
-    {
-        Version v = testParse(s);
-
-        testStr(v.toString(), s);
-
-        testInt(v.major(), major);
-        testInt(v.minor(), minor);
-        testInt(v.security(), sec);
-        testStr((v.pre().isPresent() ? v.pre().get() : ""), pre);
-        testInt((v.build().isPresent() ? v.build().get() : 0), build);
-        testStr((v.optional().isPresent() ? v.optional().get() : ""), opt);
-
-        testVersion(v.version(), s);
-    }
-
-    private static Version testParse(String s) {
-        Version v = Version.parse(s);
-        pass();
-        return v;
-    }
-
-    private static void testInt(int got, int exp) {
-        if (got != exp) {
-            fail("testInt()", Integer.toString(exp), Integer.toString(got));
-        } else {
-            pass();
-        }
-     }
-
-    private static void testStr(String got, String exp) {
-        if (!got.equals(exp)) {
-            fail("testStr()", exp, got);
-        } else {
-            pass();
-        }
-    }
-
-    private static void tryCatch(String s, Class<? extends Throwable> ex) {
-        Throwable t = null;
-        try {
-            Version.parse(s);
-        } catch (Throwable x) {
-            if (ex.isAssignableFrom(x.getClass())) {
-                t = x;
-            } else
-                x.printStackTrace();
-        }
-        if ((t == null) && (ex != null))
-            fail(s, ex);
-        else
-            pass();
-    }
-
-    private static void testCurrent() {
-        Version current = Version.current();
-        String javaVer = System.getProperty("java.version");
-
-        // java.version == $VNUM(\-$PRE)
-        String [] ver = javaVer.split("-");
-        List<Integer> javaVerVNum
-            = Arrays.stream(ver[0].split("\\."))
-            .map(v -> Integer.parseInt(v))
-            .collect(Collectors.toList());
-        if (!javaVerVNum.equals(current.version())) {
-            fail("testCurrent() version()", javaVerVNum.toString(),
-                 current.version().toString());
-        } else {
-            pass();
-        }
-
-        Optional<String> javaVerPre
-            = (ver.length == 2)
-            ? Optional.ofNullable(ver[1])
-            : Optional.empty();
-        if (!javaVerPre.equals(current.pre())) {
-            fail("testCurrent() pre()", javaVerPre.toString(),
-                 current.pre().toString());
-        } else {
-            pass();
-        }
-
-        testEHC(current.toString(), javaVer, true, true, 0, 0);
-    }
-
-    private static void testVersion(List<Integer> vnum, String s) {
-        List<Integer> svnum = new ArrayList<Integer>();
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < s.length(); i++) {
-            Character c = s.charAt(i);
-            if (Character.isDigit(c)) {
-                sb.append(c);
-            } else {
-                svnum.add(Integer.parseInt(sb.toString()));
-                sb = new StringBuilder();
-                if (c == '+' || c == '-') {
-                    break;
-                }
-            }
-        }
-        if (sb.length() > 0) {
-            svnum.add(Integer.parseInt(sb.toString()));
-        }
-
-        if (!svnum.equals(vnum)) {
-            fail("testVersion() equals()", svnum.toString(), vnum.toString());
-        } else {
-            pass();
-        }
-    }
-
-    private static void testEHC(String s0, String s1, boolean eq, boolean eqNO,
-                                int cmp, int cmpNO)
-    {
-        Version v0 = Version.parse(s0);
-        Version v1 = Version.parse(s1);
-
-        testEquals(v0, v1, eq);
-        testEqualsNO(v0, v1, eqNO);
-
-        testHashCode(v0, v1, eq);
-
-        testCompare(v0, v1, cmp);
-        testCompareNO(v0, v1, cmpNO);
-    }
-
-    private static void testEqualsNO(Version v0, Version v1, boolean eq) {
-        if ((eq && !v0.equalsIgnoreOpt(v1))
-            || (!eq && v0.equalsIgnoreOpt(v1))) {
-            fail("equalsIgnoreOpt() " + Boolean.toString(eq),
-                 v0.toString(), v1.toString());
-        } else {
-            pass();
-        }
-    }
-
-    private static void testEquals(Version v0, Version v1, boolean eq) {
-        if ((eq && !v0.equals(v1)) || (!eq && v0.equals(v1))) {
-            fail("equals() " + Boolean.toString(eq),
-                 v0.toString(), v1.toString());
-        } else {
-            pass();
-        }
-    }
-
-    private static void testHashCode(Version v0, Version v1, boolean eq) {
-        int h0 = v0.hashCode();
-        int h1 = v1.hashCode();
-        if (eq) {
-            testInt(h0, h1);
-        } else if (h0 == h1) {
-            fail(String.format("hashCode() %s", h0),
-                 Integer.toString(h0),
-                 Integer.toString(h1));
-        } else { // !eq && (h0 != h1)
-            pass();
-        }
-    }
-
-    private static void testCompareNO(Version v0, Version v1, int compare)
-    {
-        try {
-            Method m = VERSION.getMethod("compareToIgnoreOpt", VERSION);
-            int cmp = (int) m.invoke(v0, v1);
-            checkCompare(v0, v1, compare, cmp);
-        } catch (IllegalAccessException | InvocationTargetException |
-                 NoSuchMethodException ex) {
-            fail(String.format("compareToIgnoreOpt() invocation: %s",
-                               ex.getClass()),
-                 null);
-        }
-    }
-
-    private static void testCompare(Version v0, Version v1, int compare) {
-        try {
-            Method m = VERSION.getMethod("compareTo", VERSION);
-            int cmp = (int) m.invoke(v0, v1);
-            checkCompare(v0, v1, compare, cmp);
-        } catch (IllegalAccessException | InvocationTargetException |
-                 NoSuchMethodException ex) {
-            fail(String.format("compareTo() invocation: %s", ex.getClass()),
-                 null);
-        }
-    }
-
-    private static void checkCompare(Version v0, Version v1,
-                                     int compare, int cmp)
-    {
-        if (((cmp == 0) && (compare == 0))
-            || (compare == (cmp / Math.abs(cmp == 0 ? 1 : cmp)))) {
-            pass();
-        } else {
-            fail(String.format("compare() (cmp = %s) (compare = %s)",
-                               cmp, compare),
-                 v0.toString(), v1.toString());
-        }
-    }
-
-    private static int fail = 0;
-    private static int pass = 0;
-
-    private static Throwable first;
-
-    static void pass() {
-        pass++;
-    }
-
-    static void fail(String fs, Class ex) {
-        String s = "'" + fs + "'";
-        if (ex != null)
-            s += ": " + ex.getName() + " not thrown";
-        if (first == null)
-            setFirst(s);
-        System.err.println("FAILED: " + s);
-        fail++;
-    }
-
-    static void fail(String t, String exp, String got) {
-        String s = t + ": Expected '" + exp + "', got '" + got + "'";
-        if (first == null)
-            setFirst(s);
-        System.err.println("FAILED: " + s);
-        fail++;
-     }
-
-    private static void setFirst(String s) {
-        try {
-            throw new RuntimeException(s);
-        } catch (RuntimeException x) {
-            first = x;
-        }
-    }
-}
--- a/test/jdk/nio/zipfs/MultiReleaseJarTest.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/jdk/nio/zipfs/MultiReleaseJarTest.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8144355
+ * @bug 8144355 8144062
  * @summary Test aliasing additions to ZipFileSystem for multi-release jar files
  * @library /lib/testlibrary/java/util/jar
  * @build Compiler JarBuilder CreateMultiReleaseTestJars
@@ -34,17 +34,17 @@
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
+import java.lang.Runtime.Version;
 import java.net.URI;
 import java.nio.file.*;
 import java.util.HashMap;
 import java.util.Map;
-import jdk.Version;
 
 import org.testng.Assert;
 import org.testng.annotations.*;
 
 public class MultiReleaseJarTest {
-    final private int MAJOR_VERSION = Version.current().major();
+    final private int MAJOR_VERSION = Runtime.version().major();
 
     final private String userdir = System.getProperty("user.dir",".");
     final private Map<String,String> stringEnv = new HashMap<>();
--- a/test/sun/net/www/protocol/jar/MultiReleaseJarURLConnection.java	Thu May 19 11:17:35 2016 -0700
+++ b/test/sun/net/www/protocol/jar/MultiReleaseJarURLConnection.java	Thu May 19 12:04:54 2016 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2016, 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
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug 8132734
+ * @bug 8132734 8144062
  * @summary Test that URL connections to multi-release jars can be runtime versioned
  * @library /lib/testlibrary/java/util/jar
  * @build Compiler JarBuilder CreateMultiReleaseTestJars SimpleHttpServer
@@ -43,8 +43,6 @@
 import java.nio.file.Paths;
 import java.util.jar.JarFile;
 
-import jdk.Version;
-
 import org.testng.Assert;
 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
@@ -94,7 +92,7 @@
     public void testRuntimeVersioning(String style, String file) throws Exception {
         String urlFile = "jar:file:" + file + "!/";
         String baseUrlEntry = urlFile + "version/Version.java";
-        String rtreturn = "return " + Version.current().major();
+        String rtreturn = "return " + Runtime.version().major();
 
         Assert.assertTrue(readAndCompare(new URL(baseUrlEntry), "return 8"));
         // #runtime is "magic" for a multi-release jar, but not for unversioned jar
@@ -109,7 +107,7 @@
         if (style.equals("unversioned")) return;
 
         // direct access to versioned entry
-        String versUrlEntry = urlFile + "META-INF/versions/" + Version.current().major()
+        String versUrlEntry = urlFile + "META-INF/versions/" + Runtime.version().major()
                 + "/version/Version.java";
         Assert.assertTrue(readAndCompare(new URL(versUrlEntry), rtreturn));
         // adding any fragment does not change things
@@ -187,7 +185,7 @@
         MethodType mt = MethodType.methodType(int.class);
         MethodHandle mh = MethodHandles.lookup().findVirtual(vcls, "getVersion", mt);
         Assert.assertEquals((int)mh.invoke(vcls.newInstance()),
-                style.equals("unversioned") ? 8 : Version.current().major());
+                style.equals("unversioned") ? 8 : Runtime.version().major());
 
         // now get a resource and verify that we don't have a fragment attached
         URL vclsUrl = vcls.getResource("/version/Version.class");
@@ -206,7 +204,7 @@
         if (style.equals("unversioned")) {
             suffix = ".jar!/version/Version.class";
         } else {
-            suffix = ".jar!/META-INF/versions/" + Version.current().major()
+            suffix = ".jar!/META-INF/versions/" + Runtime.version().major()
                     + "/version/Version.class";
         }
         Assert.assertTrue(rep.endsWith(suffix));