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
36import java.io.IOException;
37import java.lang.invoke.MethodHandle;
38import java.lang.invoke.MethodHandles;
39import java.lang.invoke.MethodType;
40import java.lang.Runtime.Version;
41import java.net.URI;
42import java.nio.file.*;
43import java.util.HashMap;
44import java.util.Map;
45import java.util.concurrent.atomic.AtomicInteger;
46
47import org.testng.Assert;
48import org.testng.annotations.*;
49
50public 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}
258