1 /*
   2  * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /*
  25  * @test
  26  * @bug 8144355 8144062 8176709
  27  * @summary Test aliasing additions to ZipFileSystem for multi-release jar files
  28  * @library /lib/testlibrary/java/util/jar
  29  * @build Compiler JarBuilder CreateMultiReleaseTestJars
  30  * @run testng MultiReleaseJarTest
  31  * @modules jdk.compiler
  32  *          jdk.jartool
  33  *          jdk.zipfs
  34  */
  35 
  36 import java.io.IOException;
  37 import java.lang.invoke.MethodHandle;
  38 import java.lang.invoke.MethodHandles;
  39 import java.lang.invoke.MethodType;
  40 import java.lang.Runtime.Version;
  41 import java.net.URI;
  42 import java.nio.file.*;
  43 import java.util.HashMap;
  44 import java.util.Map;
  45 import java.util.concurrent.atomic.AtomicInteger;
  46 
  47 import org.testng.Assert;
  48 import org.testng.annotations.*;
  49 
  50 public class MultiReleaseJarTest {
  51     final private int MAJOR_VERSION = Runtime.version().major();
  52 
  53     final private String userdir = System.getProperty("user.dir",".");
  54     final private CreateMultiReleaseTestJars creator =  new CreateMultiReleaseTestJars();
  55     final private Map<String,String> stringEnv = new HashMap<>();
  56     final private Map<String,Integer> integerEnv = new HashMap<>();
  57     final private Map<String,Version> versionEnv = new HashMap<>();
  58     final private String className = "version.Version";
  59     final private MethodType mt = MethodType.methodType(int.class);
  60 
  61     private String entryName;
  62     private URI uvuri;
  63     private URI mruri;
  64     private URI smruri;
  65 
  66     @BeforeClass
  67     public void initialize() throws Exception {
  68         creator.compileEntries();
  69         creator.buildUnversionedJar();
  70         creator.buildMultiReleaseJar();
  71         creator.buildShortMultiReleaseJar();
  72         String ssp = Paths.get(userdir, "unversioned.jar").toUri().toString();
  73         uvuri = new URI("jar", ssp , null);
  74         ssp = Paths.get(userdir, "multi-release.jar").toUri().toString();
  75         mruri = new URI("jar", ssp, null);
  76         ssp = Paths.get(userdir, "short-multi-release.jar").toUri().toString();
  77         smruri = new URI("jar", ssp, null);
  78         entryName = className.replace('.', '/') + ".class";
  79     }
  80 
  81     public void close() throws IOException {
  82         Files.delete(Paths.get(userdir, "unversioned.jar"));
  83         Files.delete(Paths.get(userdir, "multi-release.jar"));
  84         Files.delete(Paths.get(userdir, "short-multi-release.jar"));
  85     }
  86 
  87     @DataProvider(name="strings")
  88     public Object[][] createStrings() {
  89         return new Object[][]{
  90                 {"runtime", MAJOR_VERSION},
  91                 {"-20", 8},
  92                 {"0", 8},
  93                 {"8", 8},
  94                 {"9", 9},
  95                 {"10", 10},
  96                 {"11", 10},
  97                 {"50", 10}
  98         };
  99     }
 100 
 101     @DataProvider(name="integers")
 102     public Object[][] createIntegers() {
 103         return new Object[][] {
 104                 {new Integer(-5), 8},
 105                 {new Integer(0), 8},
 106                 {new Integer(8), 8},
 107                 {new Integer(9), 9},
 108                 {new Integer(10), 10},
 109                 {new Integer(11), 10},
 110                 {new Integer(100), 10}
 111         };
 112     }
 113 
 114     @DataProvider(name="versions")
 115     public Object[][] createVersions() {
 116         return new Object[][] {
 117                 {Version.parse("8"),    8},
 118                 {Version.parse("9"),    9},
 119                 {Version.parse("10"),  10},
 120                 {Version.parse("11"),  10},
 121                 {Version.parse("100"), 10}
 122         };
 123     }
 124 
 125     // Not the best test but all I can do since ZipFileSystem and JarFileSystem
 126     // are not public, so I can't use (fs instanceof ...)
 127     @Test
 128     public void testNewFileSystem() throws Exception {
 129         Map<String,String> env = new HashMap<>();
 130         // no configuration, treat multi-release jar as unversioned
 131         try (FileSystem fs = FileSystems.newFileSystem(mruri, env)) {
 132             Assert.assertTrue(readAndCompare(fs, 8));
 133         }
 134         env.put("multi-release", "runtime");
 135         // a configuration and jar file is multi-release
 136         try (FileSystem fs = FileSystems.newFileSystem(mruri, env)) {
 137             Assert.assertTrue(readAndCompare(fs, MAJOR_VERSION));
 138         }
 139         // a configuration but jar file is unversioned
 140         try (FileSystem fs = FileSystems.newFileSystem(uvuri, env)) {
 141             Assert.assertTrue(readAndCompare(fs, 8));
 142         }
 143     }
 144 
 145     private boolean readAndCompare(FileSystem fs, int expected) throws IOException {
 146         Path path = fs.getPath("version/Version.java");
 147         String src = new String(Files.readAllBytes(path));
 148         return src.contains("return " + expected);
 149     }
 150 
 151     @Test(dataProvider="strings")
 152     public void testStrings(String value, int expected) throws Throwable {
 153         stringEnv.put("multi-release", value);
 154         runTest(stringEnv, expected);
 155     }
 156 
 157     @Test(dataProvider="integers")
 158     public void testIntegers(Integer value, int expected) throws Throwable {
 159         integerEnv.put("multi-release", value);
 160         runTest(integerEnv, expected);
 161     }
 162 
 163     @Test(dataProvider="versions")
 164     public void testVersions(Version value, int expected) throws Throwable {
 165         versionEnv.put("multi-release", value);
 166         runTest(versionEnv, expected);
 167     }
 168 
 169     @Test
 170     public void testShortJar() throws Throwable {
 171         integerEnv.put("multi-release", Integer.valueOf(10));
 172         runTest(smruri, integerEnv, 10);
 173         integerEnv.put("multi-release", Integer.valueOf(9));
 174         runTest(smruri, integerEnv, 8);
 175     }
 176 
 177     private void runTest(Map<String,?> env, int expected) throws Throwable {
 178         runTest(mruri, env, expected);
 179     }
 180 
 181     private void runTest(URI uri, Map<String,?> env, int expected) throws Throwable {
 182         try (FileSystem fs = FileSystems.newFileSystem(uri, env)) {
 183             Path version = fs.getPath(entryName);
 184             byte [] bytes = Files.readAllBytes(version);
 185             Class<?> vcls = (new ByteArrayClassLoader(fs)).defineClass(className, bytes);
 186             MethodHandle mh = MethodHandles.lookup().findVirtual(vcls, "getVersion", mt);
 187             Assert.assertEquals((int)mh.invoke(vcls.newInstance()), expected);
 188         }
 189     }
 190 
 191     @Test
 192     public void testIsMultiReleaseJar() throws Exception {
 193         // Re-examine commented out tests as part of JDK-8176843
 194         testCustomMultiReleaseValue("true", true);
 195         testCustomMultiReleaseValue("true\r\nOther: value", true);
 196         testCustomMultiReleaseValue("true\nOther: value", true);
 197         //testCustomMultiReleaseValue("true\rOther: value", true);
 198 
 199         testCustomMultiReleaseValue("false", false);
 200         testCustomMultiReleaseValue(" true", false);
 201         testCustomMultiReleaseValue("true ", false);
 202         //testCustomMultiReleaseValue("true\n ", false);
 203         //testCustomMultiReleaseValue("true\r ", false);
 204         //testCustomMultiReleaseValue("true\n true", false);
 205         //testCustomMultiReleaseValue("true\r\n true", false);
 206     }
 207 
 208     private static final AtomicInteger JAR_COUNT = new AtomicInteger(0);
 209 
 210     private void testCustomMultiReleaseValue(String value, boolean expected)
 211             throws Exception {
 212         String fileName = "custom-mr" + JAR_COUNT.incrementAndGet() + ".jar";
 213         creator.buildCustomMultiReleaseJar(fileName, value, Map.of(),
 214                 /*addEntries*/true);
 215 
 216         Map<String,String> env = Map.of("multi-release", "runtime");
 217         Path filePath = Paths.get(userdir, fileName);
 218         String ssp = filePath.toUri().toString();
 219         URI customJar = new URI("jar", ssp , null);
 220         try (FileSystem fs = FileSystems.newFileSystem(customJar, env)) {
 221             if (expected) {
 222                 Assert.assertTrue(readAndCompare(fs, MAJOR_VERSION));
 223             } else {
 224                 Assert.assertTrue(readAndCompare(fs, 8));
 225             }
 226         }
 227         Files.delete(filePath);
 228     }
 229 
 230     private static class ByteArrayClassLoader extends ClassLoader {
 231         final private FileSystem fs;
 232 
 233         ByteArrayClassLoader(FileSystem fs) {
 234             super(null);
 235             this.fs = fs;
 236         }
 237 
 238         @Override
 239         public Class<?> loadClass(String name) throws ClassNotFoundException {
 240             try {
 241                 return super.loadClass(name);
 242             } catch (ClassNotFoundException x) {}
 243             Path cls = fs.getPath(name.replace('.', '/') + ".class");
 244             try {
 245                 byte[] bytes = Files.readAllBytes(cls);
 246                 return defineClass(name, bytes);
 247             } catch (IOException x) {
 248                 throw new ClassNotFoundException(x.getMessage());
 249             }
 250         }
 251 
 252         public Class<?> defineClass(String name, byte[] bytes) throws ClassNotFoundException {
 253             if (bytes == null) throw new ClassNotFoundException("No bytes for " + name);
 254             return defineClass(name, bytes, 0, bytes.length);
 255         }
 256     }
 257 }