1 /*
2 * Copyright (c) 2015, 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 8132734
27 * @summary Test the extended API and the aliasing additions in JarFile that
28 * support multi-release jar files
29 * @library /lib/testlibrary/java/util/jar
30 * @build Compiler JarBuilder CreateMultiReleaseTestJars
31 * @run testng MultiReleaseJarIterators
32 */
33
34 import java.io.File;
35 import java.io.IOException;
36 import java.io.InputStream;
37 import java.nio.file.Files;
38 import java.util.Enumeration;
39 import java.util.HashMap;
40 import java.util.Map;
41 import java.util.jar.JarEntry;
42 import java.util.jar.JarFile;
43 import java.util.stream.Collectors;
44 import java.util.zip.ZipFile;
45 import jdk.Version;
46
47 import static java.util.jar.JarFile.Release;
48
49 import org.testng.Assert;
50 import org.testng.annotations.AfterClass;
51 import org.testng.annotations.BeforeClass;
52 import org.testng.annotations.Test;
53
54
55 public class MultiReleaseJarIterators {
56
57 static final int MAJOR_VERSION = Version.current().major();
58
59 String userdir = System.getProperty("user.dir", ".");
60 File unversioned = new File(userdir, "unversioned.jar");
61 File multirelease = new File(userdir, "multi-release.jar");
62 Map<String,JarEntry> uvEntries = new HashMap<>();
63 Map<String,JarEntry> mrEntries = new HashMap<>();
64 Map<String,JarEntry> baseEntries = new HashMap<>();
65 Map<String,JarEntry> v9Entries = new HashMap<>();
66 Map<String, JarEntry> v10Entries = new HashMap<>();
67
68 @BeforeClass
69 public void initialize() throws Exception {
70 CreateMultiReleaseTestJars creator = new CreateMultiReleaseTestJars();
71 creator.compileEntries();
72 creator.buildUnversionedJar();
73 creator.buildMultiReleaseJar();
74
75 try (JarFile jf = new JarFile(multirelease)) {
76 for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements(); ) {
77 JarEntry je = e.nextElement();
78 String name = je.getName();
79 mrEntries.put(name, je);
80 if (name.startsWith("META-INF/versions/")) {
81 if (name.startsWith("META-INF/versions/9/")) {
82 v9Entries.put(name.substring(20), je);
83 } else if (name.startsWith("META-INF/versions/10/")) {
84 v10Entries.put(name.substring(21), je);
85 }
86 } else {
87 baseEntries.put(name, je);
88 }
89 }
90 }
91 Assert.assertEquals(mrEntries.size(), 14);
92 Assert.assertEquals(baseEntries.size(), 6);
93 Assert.assertEquals(v9Entries.size(), 5);
94 Assert.assertEquals(v10Entries.size(), 3);
95
96 try (JarFile jf = new JarFile(unversioned)) {
97 jf.entries().asIterator().forEachRemaining(je -> uvEntries.put(je.getName(), je));
98 }
99 Assert.assertEquals(uvEntries.size(), 6);
100 }
101
102 @AfterClass
103 public void close() throws IOException {
104 Files.delete(unversioned.toPath());
105 Files.delete(multirelease.toPath());
106 }
107
108 @Test
109 public void testMultiReleaseJar() throws IOException {
110 try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ)) {
111 testEnumeration(jf, mrEntries);
112 testStream(jf, mrEntries);
113 }
114
115 try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.BASE)) {
116 testEnumeration(jf, baseEntries);
117 testStream(jf, baseEntries);
118 }
119
120 try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.VERSION_9)) {
121 testEnumeration(jf, v9Entries);
122 testStream(jf, v9Entries);
123 }
124
125 try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.RUNTIME)) {
126 Map<String,JarEntry> expectedEntries;
127 switch (MAJOR_VERSION) {
128 case 9:
129 expectedEntries = v9Entries;
130 break;
131 case 10: // won't get here until JDK 10
132 expectedEntries = v10Entries;
133 break;
134 default:
135 expectedEntries = baseEntries;
136 break;
137 }
138
139 testEnumeration(jf, expectedEntries);
140 testStream(jf, expectedEntries);
141 }
142 }
143
144 @Test
145 public void testUnversionedJar() throws IOException {
146 try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ)) {
147 testEnumeration(jf, uvEntries);
148 testStream(jf, uvEntries);
149 }
150
151 try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.BASE)) {
152 testEnumeration(jf, uvEntries);
153 testStream(jf, uvEntries);
154 }
155
156 try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.VERSION_9)) {
157 testEnumeration(jf, uvEntries);
158 testStream(jf, uvEntries);
159 }
160
161 try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, Release.RUNTIME)) {
162 testEnumeration(jf, uvEntries);
163 testStream(jf, uvEntries);
164 }
165 }
166
167 private void testEnumeration(JarFile jf, Map<String,JarEntry> expectedEntries) {
168 Map<String, JarEntry> actualEntries = new HashMap<>();
169 for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements(); ) {
170 JarEntry je = e.nextElement();
171 actualEntries.put(je.getName(), je);
172 }
173
174 testEntries(jf, actualEntries, expectedEntries);
175 }
176
177
178 private void testStream(JarFile jf, Map<String,JarEntry> expectedEntries) {
179 Map<String,JarEntry> actualEntries = jf.stream().collect(Collectors.toMap(je -> je.getName(), je -> je));
180
181 testEntries(jf, actualEntries, expectedEntries);
182 }
183
184 private void testEntries(JarFile jf, Map<String,JarEntry> actualEntries, Map<String,JarEntry> expectedEntries) {
185 /* For multi-release jar files constructed with a Release object,
186 * actualEntries contain versionedEntries that are considered part of the
187 * public API. They have a 1-1 correspondence with baseEntries,
188 * so entries that are not part of the public API won't be present,
189 * i.e. those entries with a name that starts with version/PackagePrivate
190 * in this particular jar file (multi-release.jar)
191 */
192
193 Map<String,JarEntry> entries;
194 if (expectedEntries == mrEntries) {
195 Assert.assertEquals(actualEntries.size(), mrEntries.size());
196 entries = mrEntries;
197 } else if (expectedEntries == uvEntries) {
198 Assert.assertEquals(actualEntries.size(), uvEntries.size());
199 entries = uvEntries;
200 } else {
201 Assert.assertEquals(actualEntries.size(), baseEntries.size()); // this is correct
202 entries = baseEntries;
203 }
204
205 entries.keySet().forEach(name -> {
206 JarEntry ee = expectedEntries.get(name);
207 if (ee == null) ee = entries.get(name);
208 JarEntry ae = actualEntries.get(name);
209 try {
210 compare(jf, ae, ee);
211 } catch (IOException x) {
212 throw new RuntimeException(x);
213 }
214 });
215 }
216
217 private void compare(JarFile jf, JarEntry actual, JarEntry expected) throws IOException {
218 byte[] abytes;
219 byte[] ebytes;
220
221 try (InputStream is = jf.getInputStream(actual)) {
222 abytes = is.readAllBytes();
223 }
224
225 try (InputStream is = jf.getInputStream(expected)) {
226 ebytes = is.readAllBytes();
227 }
228
229 Assert.assertEquals(abytes, ebytes);
230 }
231 }