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 * @modules java.base/java.lang.module:open
27 * java.base/jdk.internal.module
28 * @run testng ModuleDescriptorTest
29 * @summary Basic test for java.lang.module.ModuleDescriptor and its builder
30 */
31
32 import java.io.ByteArrayOutputStream;
33 import java.io.IOException;
34 import java.io.InputStream;
35 import java.lang.module.InvalidModuleDescriptorException;
36 import java.lang.module.ModuleDescriptor;
37 import java.lang.module.ModuleDescriptor.Builder;
38 import java.lang.module.ModuleDescriptor.Exports;
39 import java.lang.module.ModuleDescriptor.Opens;
40 import java.lang.module.ModuleDescriptor.Requires;
41 import java.lang.module.ModuleDescriptor.Provides;
42 import java.lang.module.ModuleDescriptor.Requires.Modifier;
43 import java.lang.module.ModuleDescriptor.Version;
44 import java.lang.reflect.Constructor;
45 import java.lang.reflect.Module;
46 import java.nio.ByteBuffer;
47 import java.util.Collections;
48 import java.util.EnumSet;
49 import java.util.HashSet;
50 import java.util.List;
51 import java.util.Map;
52 import java.util.Set;
53 import java.util.stream.Collectors;
54
55 import static java.lang.module.ModuleDescriptor.Requires.Modifier.*;
56
57 import jdk.internal.module.ModuleInfoWriter;
58 import org.testng.annotations.DataProvider;
59 import org.testng.annotations.Test;
60 import static org.testng.Assert.*;
61
62 @Test
63 public class ModuleDescriptorTest {
64
65 @DataProvider(name = "invalidjavaidentifiers")
66 public Object[][] invalidJavaIdentifiers() {
67 return new Object[][]{
68
69 { null, null },
70 { ".foo", null },
71 { "foo.", null },
72 { "[foo]", null },
73
74 };
75 }
76
77
78 // requires
79
80 private Requires requires(Set<Modifier> mods, String mn) {
81 return ModuleDescriptor.module("m")
82 .requires(mods, mn)
83 .build()
84 .requires()
85 .iterator()
86 .next();
87 }
88
89 private Requires requires(String mn) {
90 return requires(Collections.emptySet(), mn);
91 }
92
93 public void testRequiresWithRequires() {
94 Requires r1 = requires("foo");
95 ModuleDescriptor descriptor = ModuleDescriptor.module("m").requires(r1).build();
96 Requires r2 = descriptor.requires().iterator().next();
97 assertEquals(r1, r2);
98 }
99
100 public void testRequiresWithNoModifiers() {
101 Requires r = requires(EnumSet.noneOf(Requires.Modifier.class), "foo");
102 assertEquals(r, r);
103 assertTrue(r.compareTo(r) == 0);
104 assertTrue(r.modifiers().isEmpty());
105 assertEquals(r.name(), "foo");
106 }
107
108 public void testRequiresWithOneModifier() {
109 Requires r = requires(EnumSet.of(TRANSITIVE), "foo");
110 assertEquals(r, r);
111 assertTrue(r.compareTo(r) == 0);
112 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE));
113 assertEquals(r.name(), "foo");
114 }
115
116 public void testRequiresWithTwoModifiers() {
117 Requires r = requires(EnumSet.of(TRANSITIVE, SYNTHETIC), "foo");
118 assertEquals(r, r);
119 assertTrue(r.compareTo(r) == 0);
120 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, SYNTHETIC));
121 assertEquals(r.name(), "foo");
122 }
123
124 public void testRequiresWithAllModifiers() {
125 Requires r = requires(EnumSet.allOf(Modifier.class), "foo");
126 assertEquals(r, r);
127 assertTrue(r.compareTo(r) == 0);
128 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, STATIC, SYNTHETIC, MANDATED));
129 assertEquals(r.name(), "foo");
130 }
131
132 @Test(expectedExceptions = IllegalStateException.class)
133 public void testRequiresWithDuplicatesRequires() {
134 Requires r = requires("foo");
135 ModuleDescriptor.module("m").requires(r).requires(r);
136 }
137
138 @Test(expectedExceptions = IllegalArgumentException.class)
139 public void testRequiresSelfWithRequires() {
140 Requires r = requires("foo");
141 ModuleDescriptor.module("foo").requires(r);
142 }
143
144 @Test(expectedExceptions = IllegalArgumentException.class)
145 public void testRequiresSelfWithNoModifier() {
146 ModuleDescriptor.module("m").requires("m");
147 }
148
149 @Test(expectedExceptions = IllegalArgumentException.class)
150 public void testRequiresSelfWithOneModifier() {
151 ModuleDescriptor.module("m").requires(Set.of(TRANSITIVE), "m");
152 }
153
154 @Test(expectedExceptions = IllegalArgumentException.class)
155 public void testRequiresSelfWithAllModifiers() {
156 ModuleDescriptor.module("m").requires(EnumSet.allOf(Modifier.class), "m");
157 }
158
159 @Test(dataProvider = "invalidjavaidentifiers",
160 expectedExceptions = IllegalArgumentException.class )
161 public void testRequiresWithBadModuleName(String mn, String ignore) {
162 requires(EnumSet.noneOf(Modifier.class), mn);
163 }
164
165 @Test(expectedExceptions = NullPointerException.class)
166 public void testRequiresWithNullRequires() {
167 ModuleDescriptor.module("m").requires((Requires) null);
168 }
169
170 public void testRequiresCompare() {
171 Requires r1 = requires(EnumSet.noneOf(Modifier.class), "foo");
172 Requires r2 = requires(EnumSet.noneOf(Modifier.class), "bar");
173 int n = "foo".compareTo("bar");
174 assertTrue(r1.compareTo(r2) == n);
175 assertTrue(r2.compareTo(r1) == -n);
176 }
177
178 public void testRequiresCompareWithDifferentModifiers() {
179 Requires r1 = requires(EnumSet.of(TRANSITIVE), "foo");
180 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
181 int n = Integer.compare(1 << TRANSITIVE.ordinal(), 1 << SYNTHETIC.ordinal());
182 assertTrue(r1.compareTo(r2) == n);
183 assertTrue(r2.compareTo(r1) == -n);
184 }
185
186 public void testRequiresCompareWithSameModifiers() {
187 Requires r1 = requires(EnumSet.of(SYNTHETIC), "foo");
188 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
189 assertTrue(r1.compareTo(r2) == 0);
190 assertTrue(r2.compareTo(r1) == 0);
191 }
192
193 public void testRequiresEqualsAndHashCode() {
194 Requires r1 = requires("foo");
195 Requires r2 = requires("foo");
196 assertEquals(r1, r2);
197 assertTrue(r1.hashCode() == r2.hashCode());
198
199 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
200 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
201 assertEquals(r1, r2);
202 assertTrue(r1.hashCode() == r2.hashCode());
203
204 r1 = requires("foo");
205 r2 = requires("bar");
206 assertNotEquals(r1, r2);
207
208 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
209 r2 = requires(Set.of(), "foo");
210 assertNotEquals(r1, r2);
211 }
212
213 public void testRequiresToString() {
214 Requires r = requires(EnumSet.noneOf(Modifier.class), "foo");
215 assertTrue(r.toString().contains("foo"));
216 }
217
218
219 // exports
220
221 private Exports exports(Set<Exports.Modifier> mods, String pn) {
222 return ModuleDescriptor.module("foo")
223 .exports(mods, pn)
224 .build()
225 .exports()
226 .iterator()
227 .next();
228 }
229
230 private Exports exports(String pn) {
921 ModuleDescriptor.module("foo").osVersion("");
922 }
923
924 // reads
925
926 private static InputStream EMPTY_INPUT_STREAM = new InputStream() {
927 @Override
928 public int read() {
929 return -1;
930 }
931 };
932
933 private static InputStream FAILING_INPUT_STREAM = new InputStream() {
934 @Override
935 public int read() throws IOException {
936 throw new IOException();
937 }
938 };
939
940 // basic test reading module-info.class
941 public void testRead1() throws Exception {
942 Module base = Object.class.getModule();
943
944 try (InputStream in = base.getResourceAsStream("module-info.class")) {
945 ModuleDescriptor descriptor = ModuleDescriptor.read(in);
946 assertTrue(in.read() == -1); // all bytes read
947 assertEquals(descriptor.name(), "java.base");
948 }
949
950 try (InputStream in = base.getResourceAsStream("module-info.class")) {
951 ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
952 ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
953 assertFalse(bb.hasRemaining()); // no more remaining bytes
954 assertEquals(descriptor.name(), "java.base");
955 }
956 }
957
958 /**
959 * Test reading a module-info.class that has a module name, requires,
960 * and qualified exports with module names that are not supported in the
961 * Java Language.
962 */
963 public void testRead2() throws Exception {
964 // use non-public constructor to create a Builder that is not strict
965 Constructor<?> ctor = Builder.class.getDeclaredConstructor(String.class, boolean.class);
966 ctor.setAccessible(true);
967
968 Builder builder = (ModuleDescriptor.Builder) ctor.newInstance("m?1", false);
969 ModuleDescriptor descriptor = builder
970 .requires("java.base")
971 .requires("-m1")
972 .exports("p", Set.of("m2-"))
973 .build();
974
975 ByteArrayOutputStream baos = new ByteArrayOutputStream();
976 ModuleInfoWriter.write(descriptor, baos);
977 ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
978
979 descriptor = ModuleDescriptor.read(bb);
980 assertEquals(descriptor.name(), "m?1");
981
982 Set<String> requires = descriptor.requires()
983 .stream()
984 .map(Requires::name)
985 .collect(Collectors.toSet());
986 assertTrue(requires.size() == 2);
987 assertTrue(requires.contains("java.base"));
988 assertTrue(requires.contains("-m1"));
989
990 assertTrue(descriptor.exports().size() == 1);
991 Exports e = descriptor.exports().iterator().next();
992 assertTrue(e.targets().size() == 1);
993 assertTrue(e.targets().contains("m2-"));
994 }
995
996 /**
997 * Test ModuleDescriptor with a packager finder
998 */
999 public void testReadsWithPackageFinder() throws Exception {
1000 ModuleDescriptor descriptor = ModuleDescriptor.module("foo")
1001 .requires("java.base")
1002 .build();
1003
1004 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1005 ModuleInfoWriter.write(descriptor, baos);
1006 ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
1007
1008 descriptor = ModuleDescriptor.read(bb, () -> Set.of("p", "q"));
1009
1010 assertTrue(descriptor.packages().size() == 2);
1011 assertTrue(descriptor.packages().contains("p"));
1012 assertTrue(descriptor.packages().contains("q"));
1013 }
1014
1015 /**
|
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 * @modules java.base/jdk.internal.module
27 * @run testng ModuleDescriptorTest
28 * @summary Basic test for java.lang.module.ModuleDescriptor and its builder
29 */
30
31 import java.io.ByteArrayOutputStream;
32 import java.io.IOException;
33 import java.io.InputStream;
34 import java.lang.module.InvalidModuleDescriptorException;
35 import java.lang.module.ModuleDescriptor;
36 import java.lang.module.ModuleDescriptor.Builder;
37 import java.lang.module.ModuleDescriptor.Exports;
38 import java.lang.module.ModuleDescriptor.Opens;
39 import java.lang.module.ModuleDescriptor.Requires;
40 import java.lang.module.ModuleDescriptor.Provides;
41 import java.lang.module.ModuleDescriptor.Requires.Modifier;
42 import java.lang.module.ModuleDescriptor.Version;
43 import java.lang.reflect.Module;
44 import java.nio.ByteBuffer;
45 import java.util.Collections;
46 import java.util.EnumSet;
47 import java.util.HashSet;
48 import java.util.List;
49 import java.util.Set;
50
51 import static java.lang.module.ModuleDescriptor.Requires.Modifier.*;
52
53 import jdk.internal.module.ModuleInfoWriter;
54 import org.testng.annotations.DataProvider;
55 import org.testng.annotations.Test;
56 import static org.testng.Assert.*;
57
58 @Test
59 public class ModuleDescriptorTest {
60
61 @DataProvider(name = "invalidjavaidentifiers")
62 public Object[][] invalidJavaIdentifiers() {
63 return new Object[][]{
64
65 { null, null },
66 { "1", null },
67 { "1foo", null },
68 { ".foo", null },
69 { "foo.", null },
70 { "[foo]", null },
71 { "foo.1", null },
72 { "1foo.bar", null },
73 { "foo.1bar", null },
74 { "foo.[bar]", null },
75 { "foo..bar", null },
76 { "foo.bar.1", null },
77 { "foo.bar.1gus", null },
78 { "foo.bar.[gus]", null },
79
80 };
81 }
82
83
84 // requires
85
86 private Requires requires(Set<Modifier> mods, String mn) {
87 return ModuleDescriptor.module("m")
88 .requires(mods, mn)
89 .build()
90 .requires()
91 .iterator()
92 .next();
93 }
94
95 private Requires requires(Set<Modifier> mods, String mn, Version v) {
96 return ModuleDescriptor.module("m")
97 .requires(mods, mn, v)
98 .build()
99 .requires()
100 .iterator()
101 .next();
102 }
103
104 private Requires requires(String mn) {
105 return requires(Collections.emptySet(), mn);
106 }
107
108 public void testRequiresWithRequires() {
109 Requires r1 = requires("foo");
110 ModuleDescriptor descriptor = ModuleDescriptor.module("m").requires(r1).build();
111 Requires r2 = descriptor.requires().iterator().next();
112 assertEquals(r1, r2);
113 }
114
115 public void testRequiresWithNoModifiers() {
116 Requires r = requires(EnumSet.noneOf(Requires.Modifier.class), "foo");
117 assertEquals(r, r);
118 assertTrue(r.compareTo(r) == 0);
119 assertTrue(r.modifiers().isEmpty());
120 assertEquals(r.name(), "foo");
121 assertFalse(r.compiledVersion().isPresent());
122 }
123
124 public void testRequiresWithOneModifier() {
125 Requires r = requires(EnumSet.of(TRANSITIVE), "foo");
126 assertEquals(r, r);
127 assertTrue(r.compareTo(r) == 0);
128 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE));
129 assertEquals(r.name(), "foo");
130 assertFalse(r.compiledVersion().isPresent());
131 }
132
133 public void testRequiresWithTwoModifiers() {
134 Requires r = requires(EnumSet.of(TRANSITIVE, SYNTHETIC), "foo");
135 assertEquals(r, r);
136 assertTrue(r.compareTo(r) == 0);
137 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, SYNTHETIC));
138 assertEquals(r.name(), "foo");
139 assertFalse(r.compiledVersion().isPresent());
140 }
141
142 public void testRequiresWithAllModifiers() {
143 Requires r = requires(EnumSet.allOf(Modifier.class), "foo");
144 assertEquals(r, r);
145 assertTrue(r.compareTo(r) == 0);
146 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, STATIC, SYNTHETIC, MANDATED));
147 assertEquals(r.name(), "foo");
148 assertFalse(r.compiledVersion().isPresent());
149 }
150
151 public void testRequiresWithCompiledVersion() {
152 Version v = Version.parse("1.0");
153 Requires r = requires(Set.of(), "foo", v);
154 assertEquals(r, r);
155 assertTrue(r.compareTo(r) == 0);
156 assertEquals(r.modifiers(), Set.of());
157 assertEquals(r.name(), "foo");
158 assertTrue(r.compiledVersion().isPresent());
159 assertEquals(r.compiledVersion().get().toString(), "1.0");
160 }
161
162 @Test(expectedExceptions = IllegalStateException.class)
163 public void testRequiresWithDuplicatesRequires() {
164 Requires r = requires("foo");
165 ModuleDescriptor.module("m").requires(r).requires(r);
166 }
167
168 @Test(expectedExceptions = IllegalArgumentException.class)
169 public void testRequiresSelfWithRequires() {
170 Requires r = requires("foo");
171 ModuleDescriptor.module("foo").requires(r);
172 }
173
174 @Test(expectedExceptions = IllegalArgumentException.class)
175 public void testRequiresSelfWithNoModifier() {
176 ModuleDescriptor.module("m").requires("m");
177 }
178
179 @Test(expectedExceptions = IllegalArgumentException.class)
180 public void testRequiresSelfWithOneModifier() {
181 ModuleDescriptor.module("m").requires(Set.of(TRANSITIVE), "m");
182 }
183
184 @Test(expectedExceptions = IllegalArgumentException.class)
185 public void testRequiresSelfWithAllModifiers() {
186 ModuleDescriptor.module("m").requires(EnumSet.allOf(Modifier.class), "m");
187 }
188
189 @Test(dataProvider = "invalidjavaidentifiers",
190 expectedExceptions = IllegalArgumentException.class )
191 public void testRequiresWithBadModuleName(String mn, String ignore) {
192 requires(EnumSet.noneOf(Modifier.class), mn);
193 }
194
195 @Test(expectedExceptions = NullPointerException.class)
196 public void testRequiresWithNullRequires() {
197 ModuleDescriptor.module("m").requires((Requires) null);
198 }
199
200 @Test(expectedExceptions = NullPointerException.class)
201 public void testRequiresWithNullModifiers() {
202 ModuleDescriptor.module("m").requires(null, "foo");
203 }
204
205 @Test(expectedExceptions = NullPointerException.class)
206 public void testRequiresWithNullVersion() {
207 ModuleDescriptor.module("m").requires(Set.of(), "foo", null);
208 }
209
210 public void testRequiresCompare() {
211 Requires r1 = requires(EnumSet.noneOf(Modifier.class), "foo");
212 Requires r2 = requires(EnumSet.noneOf(Modifier.class), "bar");
213 int n = "foo".compareTo("bar");
214 assertTrue(r1.compareTo(r2) == n);
215 assertTrue(r2.compareTo(r1) == -n);
216 }
217
218 public void testRequiresCompareWithDifferentModifiers() {
219 Requires r1 = requires(EnumSet.of(TRANSITIVE), "foo");
220 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
221 int n = Integer.compare(1 << TRANSITIVE.ordinal(), 1 << SYNTHETIC.ordinal());
222 assertTrue(r1.compareTo(r2) == n);
223 assertTrue(r2.compareTo(r1) == -n);
224 }
225
226 public void testRequiresCompareWithSameModifiers() {
227 Requires r1 = requires(EnumSet.of(SYNTHETIC), "foo");
228 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
229 assertTrue(r1.compareTo(r2) == 0);
230 assertTrue(r2.compareTo(r1) == 0);
231 }
232
233 public void testRequiresCompareWithSameCompiledVersion() {
234 Requires r1 = requires(Set.of(), "foo", Version.parse("2.0"));
235 Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));
236 assertTrue(r1.compareTo(r2) == 0);
237 assertTrue(r2.compareTo(r1) == 0);
238 }
239
240 public void testRequiresCompareWithDifferentCompiledVersion() {
241 Requires r1 = requires(Set.of(), "foo", Version.parse("1.0"));
242 Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));
243 assertTrue(r1.compareTo(r2) < 0);
244 assertTrue(r2.compareTo(r1) > 0);
245 }
246
247 public void testRequiresEqualsAndHashCode() {
248 Requires r1 = requires("foo");
249 Requires r2 = requires("foo");
250 assertEquals(r1, r2);
251 assertTrue(r1.hashCode() == r2.hashCode());
252
253 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
254 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
255 assertEquals(r1, r2);
256 assertTrue(r1.hashCode() == r2.hashCode());
257
258 r1 = requires("foo");
259 r2 = requires("bar");
260 assertNotEquals(r1, r2);
261
262 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
263 r2 = requires(Set.of(), "foo");
264 assertNotEquals(r1, r2);
265
266 Version v1 = Version.parse("1.0");
267 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
268 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
269 assertEquals(r1, r2);
270 assertTrue(r1.hashCode() == r2.hashCode());
271
272 Version v2 = Version.parse("2.0");
273 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
274 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v2);
275 assertNotEquals(r1, r2);
276 }
277
278 public void testRequiresToString() {
279 Requires r = requires(EnumSet.noneOf(Modifier.class), "foo");
280 assertTrue(r.toString().contains("foo"));
281 }
282
283
284 // exports
285
286 private Exports exports(Set<Exports.Modifier> mods, String pn) {
287 return ModuleDescriptor.module("foo")
288 .exports(mods, pn)
289 .build()
290 .exports()
291 .iterator()
292 .next();
293 }
294
295 private Exports exports(String pn) {
986 ModuleDescriptor.module("foo").osVersion("");
987 }
988
989 // reads
990
991 private static InputStream EMPTY_INPUT_STREAM = new InputStream() {
992 @Override
993 public int read() {
994 return -1;
995 }
996 };
997
998 private static InputStream FAILING_INPUT_STREAM = new InputStream() {
999 @Override
1000 public int read() throws IOException {
1001 throw new IOException();
1002 }
1003 };
1004
1005 // basic test reading module-info.class
1006 public void testRead() throws Exception {
1007 Module base = Object.class.getModule();
1008
1009 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1010 ModuleDescriptor descriptor = ModuleDescriptor.read(in);
1011 assertTrue(in.read() == -1); // all bytes read
1012 assertEquals(descriptor.name(), "java.base");
1013 }
1014
1015 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1016 ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
1017 ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
1018 assertFalse(bb.hasRemaining()); // no more remaining bytes
1019 assertEquals(descriptor.name(), "java.base");
1020 }
1021 }
1022 /**
1023 * Test ModuleDescriptor with a packager finder
1024 */
1025 public void testReadsWithPackageFinder() throws Exception {
1026 ModuleDescriptor descriptor = ModuleDescriptor.module("foo")
1027 .requires("java.base")
1028 .build();
1029
1030 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1031 ModuleInfoWriter.write(descriptor, baos);
1032 ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
1033
1034 descriptor = ModuleDescriptor.read(bb, () -> Set.of("p", "q"));
1035
1036 assertTrue(descriptor.packages().size() == 2);
1037 assertTrue(descriptor.packages().contains("p"));
1038 assertTrue(descriptor.packages().contains("q"));
1039 }
1040
1041 /**
|