--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/jar/JarFile/MultiReleaseJarProperties.java Mon Feb 15 17:47:53 2016 -0800
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 8132734
+ * @summary Test the System properties for JarFile that support multi-release jar files
+ * @library /lib/testlibrary/java/util/jar
+ * @build Compiler JarBuilder CreateMultiReleaseTestJars
+ * @run testng MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=0 MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=8 MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=9 MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=10 MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=100 MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=8 -Djdk.util.jar.enableMultiRelease=false MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=9 -Djdk.util.jar.enableMultiRelease=false MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=10 -Djdk.util.jar.enableMultiRelease=false MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=8 -Djdk.util.jar.enableMultiRelease=force MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=9 -Djdk.util.jar.enableMultiRelease=force MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.version=10 -Djdk.util.jar.enableMultiRelease=force MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.enableMultiRelease=false MultiReleaseJarProperties
+ * @run testng/othervm -Djdk.util.jar.enableMultiRelease=force MultiReleaseJarProperties
+ */
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import static sun.misc.Version.jdkMajorVersion; // fixme JEP 223 Version
+
+import org.testng.Assert;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+
+public class MultiReleaseJarProperties {
+ final static int ROOTVERSION = 8; // magic number from knowledge of internals
+ final static String userdir = System.getProperty("user.dir", ".");
+ final static File multirelease = new File(userdir, "multi-release.jar");
+ protected int rtVersion;
+ boolean force;
+ protected ClassLoader cldr;
+ protected Class<?> rootClass;
+
+ @BeforeClass
+ public void initialize() throws Exception {
+ CreateMultiReleaseTestJars creator = new CreateMultiReleaseTestJars();
+ creator.compileEntries();
+ creator.buildMultiReleaseJar();
+
+ rtVersion = Integer.getInteger("jdk.util.jar.version", jdkMajorVersion());
+ String mrprop = System.getProperty("jdk.util.jar.enableMultiRelease", "");
+ if (mrprop.equals("false")) {
+ rtVersion = ROOTVERSION;
+ } else if (rtVersion < ROOTVERSION) {
+ rtVersion = ROOTVERSION;
+ } else if (rtVersion > jdkMajorVersion()) {
+ rtVersion = jdkMajorVersion();
+ }
+ force = mrprop.equals("force");
+
+ initializeClassLoader();
+ }
+
+ protected void initializeClassLoader() throws Exception {
+ URL[] urls = new URL[]{multirelease.toURI().toURL()};
+ cldr = new URLClassLoader(urls);
+ // load any class, Main is convenient and in the root entries
+ rootClass = cldr.loadClass("version.Main");
+ }
+
+ @AfterClass
+ public void close() throws IOException {
+ ((URLClassLoader)cldr).close();
+ Files.delete(multirelease.toPath());
+ }
+
+ /*
+ * jdk.util.jar.enableMultiRelease=force is a no-op for URLClassLoader
+ */
+ @Test
+ public void testURLClassLoader() throws Throwable {
+ Class<?> vcls = cldr.loadClass("version.Version");
+ invokeMethod(vcls, rtVersion);
+ }
+
+ protected void invokeMethod(Class<?> vcls, int expected) throws Throwable {
+ MethodType mt = MethodType.methodType(int.class);
+ MethodHandle mh = MethodHandles.lookup().findVirtual(vcls, "getVersion", mt);
+ Assert.assertEquals(expected, (int) mh.invoke(vcls.newInstance()));
+ }
+
+ /*
+ * jdk.util.jar.enableMultiRelease=force should affect a custom class loader
+ */
+ @Test
+ public void testClassLoader() throws Throwable {
+ try (JarFile jf = new JarFile(multirelease)) { // do not set runtime versioning
+ ClassLoader cldr = new CustomClassLoader(jf);
+ Class<?> vcls = cldr.loadClass("version.Version");
+ if (rtVersion == 9) {
+ try {
+ cldr.loadClass("version.PackagePrivate");
+ } catch (ClassNotFoundException x) {
+ if (force) throw x;
+ }
+ }
+ invokeMethod(vcls, force ? rtVersion : ROOTVERSION);
+ }
+ }
+
+ private static class CustomClassLoader extends ClassLoader {
+ private final JarFile jf;
+
+ CustomClassLoader(JarFile jf) throws Exception {
+ super(null);
+ this.jf = jf;
+ }
+
+ protected Class<?> findClass(String name) throws ClassNotFoundException {
+ try {
+ byte[] b;
+ String entryName = name.replace(".", "/") + ".class";
+ JarEntry je = jf.getJarEntry(entryName);
+ if (je != null) {
+ try (InputStream is = jf.getInputStream(je)) {
+ b = new byte[(int) je.getSize()];
+ is.read(b);
+ }
+ return defineClass(name, b, 0, b.length);
+ }
+ throw new ClassNotFoundException(name);
+ } catch (IOException x) {
+ throw new ClassNotFoundException(x.getMessage());
+ }
+ }
+ }
+
+ @Test
+ public void testGetResourceAsStream() throws Exception {
+ String resource = rtVersion == 9 ? "/version/PackagePrivate.java" : "/version/Version.java";
+ // use fileRootClass as a base for getting resources
+ getResourceAsStream(rootClass, resource);
+ }
+
+ protected void getResourceAsStream(Class<?> rootClass, String resource) throws Exception {
+ try (InputStream is = rootClass.getResourceAsStream(resource)) {
+ byte[] bytes = is.readAllBytes();
+ resource = new String(bytes);
+ }
+ String match = "return " + rtVersion + ";";
+ Assert.assertTrue(resource.contains(match));
+ }
+
+ @Test
+ public void testGetResource() throws Exception {
+ String resource = rtVersion == 9 ? "/version/PackagePrivate.java" : "/version/Version.java";
+ // use rootClass as a base for getting resources
+ getResource(rootClass, resource);
+ }
+
+ protected void getResource(Class<?> rootClass, String resource) throws Exception {
+ URL url = rootClass.getResource(resource);
+ try (InputStream is = url.openStream()) {
+ byte[] bytes = is.readAllBytes();
+ resource = new String(bytes);
+ }
+ String match = "return " + rtVersion + ";";
+ Assert.assertTrue(resource.contains(match));
+ }
+}