1 /*
2 * Copyright (c) 2016, 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 import java.lang.module.ModuleDescriptor;
25 import java.lang.module.ModuleDescriptor.*;
26 import java.lang.module.ModuleFinder;
27 import java.lang.module.ModuleReference;
28 import java.io.IOException;
29 import java.io.UncheckedIOException;
30 import java.nio.file.Files;
31 import java.nio.file.Path;
32 import java.nio.file.Paths;
33 import java.util.List;
34 import java.util.Map;
35 import java.util.Set;
36
37 import jdk.internal.misc.JavaLangModuleAccess;
38 import jdk.internal.misc.SharedSecrets;
39 import org.testng.annotations.Test;
40 import static org.testng.Assert.*;
41
42 /**
43 * @test
44 * @bug 8142968 8173381
45 * @library /lib/testlibrary
46 * @modules java.base/jdk.internal.misc
47 * @modules java.base/jdk.internal.module
48 * @modules java.base/jdk.internal.org.objectweb.asm
49 * @build ModuleTargetHelper
50 * @run testng SystemModulesTest
51 * @summary Verify the properties of ModuleDescriptor created
52 * by SystemModules
53 */
54
55 public class SystemModulesTest {
56 private static final JavaLangModuleAccess JLMA =
57 SharedSecrets.getJavaLangModuleAccess();
58 private static final String OS_NAME = System.getProperty("os.name");
59 private static final String OS_ARCH = System.getProperty("os.arch");
60 // system modules containing no package
61 private static final Set<String> EMPTY_MODULES =
62 Set.of("java.se", "java.se.ee", "jdk.jdwp.agent", "jdk.pack");
63
64 @Test
65 public void testSystemModules() {
66 Path jimage = Paths.get(System.getProperty("java.home"), "lib", "modules");
67 if (Files.notExists(jimage))
68 return;
69
70 ModuleFinder.ofSystem().findAll().stream()
71 .forEach(this::checkAttributes);
72 }
73
74 // JMOD files are created with osName and osArch that may be different
75 // than os.name and os.arch system property
76 private boolean checkOSName(String name) {
77 if (name.equals(OS_NAME))
78 return true;
79
80 if (OS_NAME.startsWith("Windows")) {
81 return name.startsWith("Windows");
82 } else {
83 System.err.println("ERROR: " + name + " but expected: " + OS_NAME);
84 return false;
85 }
86 }
87
88 private boolean checkOSArch(String name) {
89 if (name.equals(OS_ARCH))
90 return true;
91
92 switch (OS_ARCH) {
93 case "i386":
94 case "x86":
95 return name.equals("x86");
96 case "amd64":
97 return name.equals("x86_64");
98 default:
99 System.err.println("ERROR: " + name + " but expected: " + OS_ARCH);
100 return false;
101 }
102 }
103
104 private void checkAttributes(ModuleReference modRef) {
105 try {
106 if (modRef.descriptor().name().equals("java.base")) {
107 ModuleTargetHelper.ModuleTarget mt = ModuleTargetHelper.read(modRef);
108 assertTrue(checkOSName(mt.osName()));
109 assertTrue(checkOSArch(mt.osArch()));
110 } else {
111 // target platform attribute is dropped by jlink plugin for other modules
112 ModuleTargetHelper.ModuleTarget mt = ModuleTargetHelper.read(modRef);
113 assertTrue(mt == null || (mt.osName() == null && mt.osArch() == null));
114 }
115 } catch (IOException exp) {
116 throw new UncheckedIOException(exp);
117 }
118 }
119
120 /**
121 * Verify ModuleDescriptor contains unmodifiable sets
122 */
123 @Test
124 public void testUnmodifableDescriptors() throws Exception {
125 ModuleFinder.ofSystem().findAll()
126 .stream()
127 .map(ModuleReference::descriptor)
128 .forEach(this::testModuleDescriptor);
129 }
130
131 private void testModuleDescriptor(ModuleDescriptor md) {
132 assertUnmodifiable(md.packages(), "package");
133 assertUnmodifiable(md.requires(),
134 JLMA.newRequires(Set.of(Requires.Modifier.TRANSITIVE),
135 "require", null));
136 for (Requires req : md.requires()) {
137 assertUnmodifiable(req.modifiers(), Requires.Modifier.TRANSITIVE);
138 }
139
140 assertUnmodifiable(md.exports(), JLMA.newExports(Set.of(), "export", Set.of()));
141 for (Exports exp : md.exports()) {
142 assertUnmodifiable(exp.modifiers(), Exports.Modifier.SYNTHETIC);
143 assertUnmodifiable(exp.targets(), "target");
144 }
145
146 assertUnmodifiable(md.opens(), JLMA.newOpens(Set.of(), "open", Set.of()));
147 for (Opens opens : md.opens()) {
148 assertUnmodifiable(opens.modifiers(), Opens.Modifier.SYNTHETIC);
149 assertUnmodifiable(opens.targets(), "target");
150 }
151
152 assertUnmodifiable(md.uses(), "use");
153
154 assertUnmodifiable(md.provides(),
155 JLMA.newProvides("provide", List.of("provide")));
156 for (Provides provides : md.provides()) {
157 assertUnmodifiable(provides.providers(), "provide");
158 }
159
160 }
161
162 private <T> void assertUnmodifiable(Set<T> set, T dummy) {
163 try {
164 set.add(dummy);
165 fail("Should throw UnsupportedOperationException");
166 } catch (UnsupportedOperationException e) {
167 // pass
168 } catch (Exception e) {
169 fail("Should throw UnsupportedOperationException");
170 }
171 }
172
173 private <T> void assertUnmodifiable(List<T> list, T dummy) {
174 try {
175 list.add(dummy);
176 fail("Should throw UnsupportedOperationException");
177 } catch (UnsupportedOperationException e) {
178 // pass
179 } catch (Exception e) {
180 fail("Should throw UnsupportedOperationException");
181 }
182 }
183
184 private <T, V> void assertUnmodifiable(Map<T, V> set, T dummyKey, V dummyValue) {
185 try {
186 set.put(dummyKey, dummyValue);
187 fail("Should throw UnsupportedOperationException");
188 } catch (UnsupportedOperationException e) {
189 // pass
190 } catch (Exception e) {
191 fail("Should throw UnsupportedOperationException");
192 }
193 }
194
195 }