1 /*
2 * Copyright (c) 2013, 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 * @modules java.base/jdk.internal.access
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.nio.ByteBuffer;
45 import java.util.ArrayList;
46 import java.util.Collections;
47 import java.util.EnumSet;
48 import java.util.HashSet;
49 import java.util.Iterator;
50 import java.util.List;
51 import java.util.Objects;
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.access.JavaLangModuleAccess;
58 import jdk.internal.access.SharedSecrets;
59 import jdk.internal.module.ModuleInfoWriter;
60 import org.testng.annotations.DataProvider;
61 import org.testng.annotations.Test;
62 import static org.testng.Assert.*;
63
64 @Test
65 public class ModuleDescriptorTest {
66
67 @DataProvider(name = "invalidNames")
68 public Object[][] invalidNames() {
69 return new Object[][]{
70
71 { null, null },
72 { "1", null },
73 { "1foo", null },
74 { ".foo", null },
75 { "foo.", null },
76 { "[foo]", null },
77 { "foo.1", null },
78 { "1foo.bar", null },
79 { "foo.1bar", null },
80 { "foo.[bar]", null },
81 { "foo..bar", null },
82 { "foo.bar.1", null },
83 { "foo.bar.1gus", null },
84 { "foo.bar.[gus]", null },
85
86 { "class", null },
87 { "interface", null },
88 { "true", null },
89 { "false", null },
90 { "null", null },
91
92 { "x.class", null },
93 { "x.interface", null },
94 { "x.true", null },
95 { "x.false", null },
96 { "x.null", null },
97
98 { "class.x", null },
99 { "interface.x", null },
100 { "true.x", null },
101 { "false.x", null },
102 { "null.x", null },
103
104 { "x.class.x", null },
105 { "x.interface.x", null },
106 { "x.true.x", null },
107 { "x.false.x", null },
108 { "x.null.x", null },
109
110 { "_", null },
111
112 };
113 }
114
115
116 // requires
117
118 private Requires requires(Set<Modifier> mods, String mn) {
119 return requires(mods, mn, null);
120 }
121
122 private Requires requires(Set<Modifier> mods, String mn, Version v) {
123 Builder builder = ModuleDescriptor.newModule("m");
124 if (v == null) {
125 builder.requires(mods, mn);
126 } else {
127 builder.requires(mods, mn, v);
128 }
129 Set<Requires> requires = builder.build().requires();
130 assertTrue(requires.size() == 2);
131 Iterator<Requires> iterator = requires.iterator();
132 Requires r = iterator.next();
133 if (r.name().equals("java.base")) {
134 r = iterator.next();
135 } else {
136 Requires other = iterator.next();
137 assertEquals(other.name(), "java.base");
138 }
139 return r;
140 }
141
142 private Requires requires(String mn) {
143 return requires(Collections.emptySet(), mn);
144 }
145
146 public void testRequiresWithRequires() {
147 Requires r1 = requires("foo");
148 ModuleDescriptor descriptor = ModuleDescriptor.newModule("m").requires(r1).build();
149 assertEquals(descriptor.requires().size(), 2);
150 var iterator = descriptor.requires().iterator();
151 Requires r2 = iterator.next();
152 if (r2.name().equals("java.base")) {
153 r2 = iterator.next();
154 }
155 assertEquals(r1, r2);
156 }
157
158 public void testRequiresWithNoModifiers() {
159 Requires r = requires(EnumSet.noneOf(Requires.Modifier.class), "foo");
160 assertEquals(r, r);
161 assertTrue(r.compareTo(r) == 0);
162 assertTrue(r.modifiers().isEmpty());
163 assertEquals(r.name(), "foo");
164 assertFalse(r.compiledVersion().isPresent());
165 }
166
167 public void testRequiresWithOneModifier() {
168 Requires r = requires(EnumSet.of(TRANSITIVE), "foo");
169 assertEquals(r, r);
170 assertTrue(r.compareTo(r) == 0);
171 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE));
172 assertEquals(r.name(), "foo");
173 assertFalse(r.compiledVersion().isPresent());
174 }
175
176 public void testRequiresWithTwoModifiers() {
177 Requires r = requires(EnumSet.of(TRANSITIVE, SYNTHETIC), "foo");
178 assertEquals(r, r);
179 assertTrue(r.compareTo(r) == 0);
180 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, SYNTHETIC));
181 assertEquals(r.name(), "foo");
182 assertFalse(r.compiledVersion().isPresent());
183 }
184
185 public void testRequiresWithAllModifiers() {
186 Requires r = requires(EnumSet.allOf(Modifier.class), "foo");
187 assertEquals(r, r);
188 assertTrue(r.compareTo(r) == 0);
189 assertEquals(r.modifiers(), EnumSet.of(TRANSITIVE, STATIC, SYNTHETIC, MANDATED));
190 assertEquals(r.name(), "foo");
191 assertFalse(r.compiledVersion().isPresent());
192 }
193
194 public void testRequiresWithCompiledVersion() {
195 Version v = Version.parse("1.0");
196 Requires r = requires(Set.of(), "foo", v);
197 assertEquals(r, r);
198 assertTrue(r.compareTo(r) == 0);
199 assertEquals(r.modifiers(), Set.of());
200 assertEquals(r.name(), "foo");
201 assertTrue(r.compiledVersion().isPresent());
202 assertEquals(r.compiledVersion().get().toString(), "1.0");
203 }
204
205 @Test(expectedExceptions = IllegalStateException.class)
206 public void testRequiresWithDuplicatesRequires() {
207 Requires r = requires("foo");
208 ModuleDescriptor.newModule("m").requires(r).requires(r);
209 }
210
211 @Test(expectedExceptions = IllegalArgumentException.class)
212 public void testRequiresSelfWithRequires() {
213 Requires r = requires("foo");
214 ModuleDescriptor.newModule("foo").requires(r);
215 }
216
217 @Test(expectedExceptions = IllegalArgumentException.class)
218 public void testRequiresSelfWithNoModifier() {
219 ModuleDescriptor.newModule("m").requires("m");
220 }
221
222 @Test(expectedExceptions = IllegalArgumentException.class)
223 public void testRequiresSelfWithOneModifier() {
224 ModuleDescriptor.newModule("m").requires(Set.of(TRANSITIVE), "m");
225 }
226
227 @Test(expectedExceptions = IllegalArgumentException.class)
228 public void testRequiresSelfWithAllModifiers() {
229 ModuleDescriptor.newModule("m").requires(EnumSet.allOf(Modifier.class), "m");
230 }
231
232 @Test(dataProvider = "invalidNames",
233 expectedExceptions = IllegalArgumentException.class )
234 public void testRequiresWithBadModuleName(String mn, String ignore) {
235 requires(EnumSet.noneOf(Modifier.class), mn);
236 }
237
238 @Test(expectedExceptions = NullPointerException.class)
239 public void testRequiresWithNullRequires() {
240 ModuleDescriptor.newModule("m").requires((Requires) null);
241 }
242
243 @Test(expectedExceptions = NullPointerException.class)
244 public void testRequiresWithNullModifiers() {
245 ModuleDescriptor.newModule("m").requires(null, "foo");
246 }
247
248 @Test(expectedExceptions = NullPointerException.class)
249 public void testRequiresWithNullVersion() {
250 ModuleDescriptor.newModule("m").requires(Set.of(), "foo", null);
251 }
252
253 public void testRequiresCompare() {
254 Requires r1 = requires(EnumSet.noneOf(Modifier.class), "foo");
255 Requires r2 = requires(EnumSet.noneOf(Modifier.class), "bar");
256 int n = "foo".compareTo("bar");
257 assertTrue(r1.compareTo(r2) == n);
258 assertTrue(r2.compareTo(r1) == -n);
259 }
260
261 public void testRequiresCompareWithDifferentModifiers() {
262 Requires r1 = requires(EnumSet.of(TRANSITIVE), "foo");
263 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
264 int n = Integer.compare(1 << TRANSITIVE.ordinal(), 1 << SYNTHETIC.ordinal());
265 assertTrue(r1.compareTo(r2) == n);
266 assertTrue(r2.compareTo(r1) == -n);
267 }
268
269 public void testRequiresCompareWithSameModifiers() {
270 Requires r1 = requires(EnumSet.of(SYNTHETIC), "foo");
271 Requires r2 = requires(EnumSet.of(SYNTHETIC), "foo");
272 assertTrue(r1.compareTo(r2) == 0);
273 assertTrue(r2.compareTo(r1) == 0);
274 }
275
276 public void testRequiresCompareWithSameCompiledVersion() {
277 Requires r1 = requires(Set.of(), "foo", Version.parse("2.0"));
278 Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));
279 assertTrue(r1.compareTo(r2) == 0);
280 assertTrue(r2.compareTo(r1) == 0);
281 }
282
283 public void testRequiresCompareWithDifferentCompiledVersion() {
284 Requires r1 = requires(Set.of(), "foo", Version.parse("1.0"));
285 Requires r2 = requires(Set.of(), "foo", Version.parse("2.0"));
286 assertTrue(r1.compareTo(r2) < 0);
287 assertTrue(r2.compareTo(r1) > 0);
288 }
289
290 public void testRequiresEqualsAndHashCode() {
291 Requires r1 = requires("foo");
292 Requires r2 = requires("foo");
293 assertEquals(r1, r2);
294 assertTrue(r1.hashCode() == r2.hashCode());
295
296 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
297 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
298 assertEquals(r1, r2);
299 assertTrue(r1.hashCode() == r2.hashCode());
300
301 r1 = requires("foo");
302 r2 = requires("bar");
303 assertNotEquals(r1, r2);
304
305 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo");
306 r2 = requires(Set.of(), "foo");
307 assertNotEquals(r1, r2);
308
309 Version v1 = Version.parse("1.0");
310 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
311 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
312 assertEquals(r1, r2);
313 assertTrue(r1.hashCode() == r2.hashCode());
314
315 Version v2 = Version.parse("2.0");
316 r1 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v1);
317 r2 = requires(EnumSet.allOf(Requires.Modifier.class), "foo", v2);
318 assertNotEquals(r1, r2);
319 }
320
321 public void testRequiresToString() {
322 Requires r = requires(EnumSet.noneOf(Modifier.class), "foo");
323 assertTrue(r.toString().contains("foo"));
324 }
325
326
327 // exports
328
329 private Exports exports(Set<Exports.Modifier> mods, String pn) {
330 return ModuleDescriptor.newModule("foo")
331 .exports(mods, pn)
332 .build()
333 .exports()
334 .iterator()
335 .next();
336 }
337
338 private Exports exports(String pn) {
339 return exports(Set.of(), pn);
340 }
341
342 private Exports exports(Set<Exports.Modifier> mods, String pn, String target) {
343 return ModuleDescriptor.newModule("foo")
344 .exports(mods, pn, Set.of(target))
345 .build()
346 .exports()
347 .iterator()
348 .next();
349 }
350
351 private Exports exports(String pn, String target) {
352 return exports(Set.of(), pn, target);
353 }
354
355
356 public void testExportsExports() {
357 Exports e1 = exports("p");
358 ModuleDescriptor descriptor = ModuleDescriptor.newModule("m").exports(e1).build();
359 Exports e2 = descriptor.exports().iterator().next();
360 assertEquals(e1, e2);
361 }
362
363 public void testExportsToAll() {
364 Exports e = exports("p");
365 assertEquals(e, e);
366 assertTrue(e.modifiers().isEmpty());
367 assertEquals(e.source(), "p");
368 assertFalse(e.isQualified());
369 assertTrue(e.targets().isEmpty());
370 }
371
372 public void testExportsToTarget() {
373 Exports e = exports("p", "bar");
374 assertEquals(e, e);
375 assertTrue(e.modifiers().isEmpty());
376 assertEquals(e.source(), "p");
377 assertTrue(e.isQualified());
378 assertTrue(e.targets().size() == 1);
379 assertTrue(e.targets().contains("bar"));
380 }
381
382 public void testExportsToTargets() {
383 Set<String> targets = new HashSet<>();
384 targets.add("bar");
385 targets.add("gus");
386 Exports e
387 = ModuleDescriptor.newModule("foo")
388 .exports("p", targets)
389 .build()
390 .exports()
391 .iterator()
392 .next();
393 assertEquals(e, e);
394 assertTrue(e.modifiers().isEmpty());
395 assertEquals(e.source(), "p");
396 assertTrue(e.isQualified());
397 assertTrue(e.targets().size() == 2);
398 assertTrue(e.targets().contains("bar"));
399 assertTrue(e.targets().contains("gus"));
400 }
401
402 public void testExportsToAllWithModifier() {
403 Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
404 assertEquals(e, e);
405 assertTrue(e.modifiers().size() == 1);
406 assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));
407 assertEquals(e.source(), "p");
408 assertFalse(e.isQualified());
409 assertTrue(e.targets().isEmpty());
410 }
411
412 public void testExportsToTargetWithModifier() {
413 Exports e = exports(Set.of(Exports.Modifier.SYNTHETIC), "p", "bar");
414 assertEquals(e, e);
415 assertTrue(e.modifiers().size() == 1);
416 assertTrue(e.modifiers().contains(Exports.Modifier.SYNTHETIC));
417 assertEquals(e.source(), "p");
418 assertTrue(e.isQualified());
419 assertTrue(e.targets().size() == 1);
420 assertTrue(e.targets().contains("bar"));
421 }
422
423 @Test(expectedExceptions = IllegalStateException.class)
424 public void testExportsWithDuplicate1() {
425 Exports e = exports("p");
426 ModuleDescriptor.newModule("foo").exports(e).exports(e);
427 }
428
429 @Test(expectedExceptions = IllegalStateException.class)
430 public void testExportsWithDuplicate2() {
431 ModuleDescriptor.newModule("foo").exports("p").exports("p");
432 }
433
434 @Test(expectedExceptions = IllegalArgumentException.class )
435 public void testExportsWithEmptySet() {
436 ModuleDescriptor.newModule("foo").exports("p", Collections.emptySet());
437 }
438
439 @Test(dataProvider = "invalidNames",
440 expectedExceptions = IllegalArgumentException.class )
441 public void testExportsWithBadName(String pn, String ignore) {
442 ModuleDescriptor.newModule("foo").exports(pn);
443 }
444
445 @Test(expectedExceptions = NullPointerException.class )
446 public void testExportsWithNullExports() {
447 ModuleDescriptor.newModule("foo").exports((Exports) null);
448 }
449
450 @Test(expectedExceptions = NullPointerException.class )
451 public void testExportsWithNullTargets() {
452 ModuleDescriptor.newModule("foo").exports("p", (Set<String>) null);
453 }
454
455 public void testExportsCompare() {
456 Exports e1 = exports("p");
457 Exports e2 = exports("p");
458 assertEquals(e1, e2);
459 assertTrue(e1.hashCode() == e2.hashCode());
460 assertTrue(e1.compareTo(e2) == 0);
461 assertTrue(e2.compareTo(e1) == 0);
462 }
463
464 public void testExportsCompareWithSameModifiers() {
465 Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
466 Exports e2 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
467 assertEquals(e1, e2);
468 assertTrue(e1.hashCode() == e2.hashCode());
469 assertTrue(e1.compareTo(e2) == 0);
470 assertTrue(e2.compareTo(e1) == 0);
471 }
472
473 public void testExportsCompareWithDifferentModifiers() {
474 Exports e1 = exports(Set.of(Exports.Modifier.SYNTHETIC), "p");
475 Exports e2 = exports("p");
476 assertNotEquals(e1, e2);
477 assertTrue(e1.compareTo(e2) == 1);
478 assertTrue(e2.compareTo(e1) == -1);
479 }
480
481 public void testExportsCompareWithSameTargets() {
482 Exports e1 = exports("p", "x");
483 Exports e2 = exports("p", "x");
484 assertEquals(e1, e2);
485 assertTrue(e1.hashCode() == e2.hashCode());
486 assertTrue(e1.compareTo(e2) == 0);
487 assertTrue(e2.compareTo(e1) == 0);
488 }
489
490 public void testExportsCompareWithDifferentTargets() {
491 Exports e1 = exports("p", "y");
492 Exports e2 = exports("p", "x");
493 assertNotEquals(e1, e2);
494 assertTrue(e1.compareTo(e2) == 1);
495 assertTrue(e2.compareTo(e1) == -1);
496 }
497
498 public void testExportsToString() {
499 String s = ModuleDescriptor.newModule("foo")
500 .exports("p1", Set.of("bar"))
501 .build()
502 .exports()
503 .iterator()
504 .next()
505 .toString();
506 assertTrue(s.contains("p1"));
507 assertTrue(s.contains("bar"));
508 }
509
510
511 // opens
512
513 private Opens opens(Set<Opens.Modifier> mods, String pn) {
514 return ModuleDescriptor.newModule("foo")
515 .opens(mods, pn)
516 .build()
517 .opens()
518 .iterator()
519 .next();
520 }
521
522 private Opens opens(String pn) {
523 return opens(Set.of(), pn);
524 }
525
526 private Opens opens(Set<Opens.Modifier> mods, String pn, String target) {
527 return ModuleDescriptor.newModule("foo")
528 .opens(mods, pn, Set.of(target))
529 .build()
530 .opens()
531 .iterator()
532 .next();
533 }
534
535 private Opens opens(String pn, String target) {
536 return opens(Set.of(), pn, target);
537 }
538
539 public void testOpensOpens() {
540 Opens o1 = opens("p");
541 ModuleDescriptor descriptor = ModuleDescriptor.newModule("m").opens(o1).build();
542 Opens o2 = descriptor.opens().iterator().next();
543 assertEquals(o1, o2);
544 }
545
546 public void testOpensToAll() {
547 Opens o = opens("p");
548 assertEquals(o, o);
549 assertTrue(o.modifiers().isEmpty());
550 assertEquals(o.source(), "p");
551 assertFalse(o.isQualified());
552 assertTrue(o.targets().isEmpty());
553 }
554
555
556 public void testOpensToTarget() {
557 Opens o = opens("p", "bar");
558 assertEquals(o, o);
559 assertTrue(o.modifiers().isEmpty());
560 assertEquals(o.source(), "p");
561 assertTrue(o.isQualified());
562 assertTrue(o.targets().size() == 1);
563 assertTrue(o.targets().contains("bar"));
564 }
565
566 public void testOpensToTargets() {
567 Set<String> targets = new HashSet<>();
568 targets.add("bar");
569 targets.add("gus");
570 Opens o = ModuleDescriptor.newModule("foo")
571 .opens("p", targets)
572 .build()
573 .opens()
574 .iterator()
575 .next();
576 assertEquals(o, o);
577 assertTrue(o.modifiers().isEmpty());
578 assertEquals(o.source(), "p");
579 assertTrue(o.isQualified());
580 assertTrue(o.targets().size() == 2);
581 assertTrue(o.targets().contains("bar"));
582 assertTrue(o.targets().contains("gus"));
583 }
584
585 @Test(expectedExceptions = IllegalStateException.class)
586 public void testOpensWithDuplicate1() {
587 Opens o = opens("p");
588 ModuleDescriptor.newModule("foo").opens(o).opens(o);
589 }
590
591 @Test(expectedExceptions = IllegalStateException.class)
592 public void testOpensWithDuplicate2() {
593 ModuleDescriptor.newModule("foo").opens("p").opens("p");
594 }
595
596 @Test(expectedExceptions = IllegalArgumentException.class )
597 public void testOpensWithEmptySet() {
598 ModuleDescriptor.newModule("foo").opens("p", Collections.emptySet());
599 }
600
601 @Test(dataProvider = "invalidNames",
602 expectedExceptions = IllegalArgumentException.class )
603 public void testOpensWithBadName(String pn, String ignore) {
604 ModuleDescriptor.newModule("foo").opens(pn);
605 }
606
607 @Test(expectedExceptions = NullPointerException.class )
608 public void testOpensWithNullExports() {
609 ModuleDescriptor.newModule("foo").opens((Opens) null);
610 }
611
612 @Test(expectedExceptions = NullPointerException.class )
613 public void testOpensWithNullTargets() {
614 ModuleDescriptor.newModule("foo").opens("p", (Set<String>) null);
615 }
616
617 public void testOpensCompare() {
618 Opens o1 = opens("p");
619 Opens o2 = opens("p");
620 assertEquals(o1, o2);
621 assertTrue(o1.hashCode() == o2.hashCode());
622 assertTrue(o1.compareTo(o2) == 0);
623 assertTrue(o2.compareTo(o1) == 0);
624 }
625
626 public void testOpensCompareWithSameModifiers() {
627 Opens o1 = opens(Set.of(Opens.Modifier.SYNTHETIC), "p");
628 Opens o2 = opens(Set.of(Opens.Modifier.SYNTHETIC), "p");
629 assertEquals(o1, o2);
630 assertTrue(o1.hashCode() == o2.hashCode());
631 assertTrue(o1.compareTo(o2) == 0);
632 assertTrue(o2.compareTo(o1) == 0);
633 }
634
635 public void testOpensCompareWithDifferentModifiers() {
636 Opens o1 = opens(Set.of(Opens.Modifier.SYNTHETIC), "p");
637 Opens o2 = opens("p");
638 assertNotEquals(o1, o2);
639 assertTrue(o1.compareTo(o2) == 1);
640 assertTrue(o2.compareTo(o1) == -1);
641 }
642
643 public void testOpensCompareWithSameTargets() {
644 Opens o1 = opens("p", "x");
645 Opens o2 = opens("p", "x");
646 assertEquals(o1, o2);
647 assertTrue(o1.hashCode() == o2.hashCode());
648 assertTrue(o1.compareTo(o2) == 0);
649 assertTrue(o2.compareTo(o1) == 0);
650 }
651
652 public void testOpensCompareWithDifferentTargets() {
653 Opens o1 = opens("p", "y");
654 Opens o2 = opens("p", "x");
655 assertNotEquals(o1, o2);
656 assertTrue(o1.compareTo(o2) == 1);
657 assertTrue(o2.compareTo(o1) == -1);
658 }
659
660 public void testOpensToString() {
661 String s = ModuleDescriptor.newModule("foo")
662 .opens("p1", Set.of("bar"))
663 .build()
664 .opens()
665 .iterator()
666 .next()
667 .toString();
668 assertTrue(s.contains("p1"));
669 assertTrue(s.contains("bar"));
670 }
671
672
673 // uses
674
675 public void testUses() {
676 Set<String> uses
677 = ModuleDescriptor.newModule("foo")
678 .uses("p.S")
679 .uses("q.S")
680 .build()
681 .uses();
682 assertTrue(uses.size() == 2);
683 assertTrue(uses.contains("p.S"));
684 assertTrue(uses.contains("q.S"));
685 }
686
687 @Test(expectedExceptions = IllegalStateException.class)
688 public void testUsesWithDuplicate() {
689 ModuleDescriptor.newModule("foo").uses("p.S").uses("p.S");
690 }
691
692 @Test(expectedExceptions = IllegalArgumentException.class)
693 public void testUsesWithSimpleIdentifier() {
694 ModuleDescriptor.newModule("foo").uses("S");
695 }
696
697 @Test(dataProvider = "invalidNames",
698 expectedExceptions = IllegalArgumentException.class )
699 public void testUsesWithBadName(String service, String ignore) {
700 ModuleDescriptor.newModule("foo").uses(service);
701 }
702
703
704 // provides
705
706 private Provides provides(String st, String pc) {
707 return ModuleDescriptor.newModule("foo")
708 .provides(st, List.of(pc))
709 .build()
710 .provides()
711 .iterator()
712 .next();
713 }
714
715 private Provides provides(String st, List<String> pns) {
716 return ModuleDescriptor.newModule("foo")
717 .provides(st, pns)
718 .build()
719 .provides()
720 .iterator()
721 .next();
722 }
723
724 public void testProvidesWithProvides() {
725 Provides p1 = provides("p.S", "q.S1");
726 ModuleDescriptor descriptor = ModuleDescriptor.newModule("m")
727 .provides(p1)
728 .build();
729 Provides p2 = descriptor.provides().iterator().next();
730 assertEquals(p1, p2);
731 }
732
733
734 public void testProvides() {
735 Set<Provides> set = ModuleDescriptor.newModule("foo")
736 .provides("p.S", List.of("q.P1", "q.P2"))
737 .build()
738 .provides();
739 assertTrue(set.size() == 1);
740
741 Provides p = set.iterator().next();
742 assertEquals(p, p);
743 assertEquals(p.service(), "p.S");
744 assertTrue(p.providers().size() == 2);
745 assertEquals(p.providers().get(0), "q.P1");
746 assertEquals(p.providers().get(1), "q.P2");
747 }
748
749 @Test(expectedExceptions = IllegalStateException.class )
750 public void testProvidesWithDuplicateProvides() {
751 Provides p = provides("p.S", "q.S2");
752 ModuleDescriptor.newModule("m").provides("p.S", List.of("q.S1")).provides(p);
753 }
754
755 @Test(expectedExceptions = IllegalArgumentException.class )
756 public void testProvidesWithEmptySet() {
757 ModuleDescriptor.newModule("foo").provides("p.Service", Collections.emptyList());
758 }
759
760 @Test(expectedExceptions = IllegalArgumentException.class )
761 public void testProvidesWithSimpleIdentifier1() {
762 ModuleDescriptor.newModule("foo").provides("S", List.of("q.P"));
763 }
764
765 @Test(expectedExceptions = IllegalArgumentException.class )
766 public void testProvidesWithSimpleIdentifier2() {
767 ModuleDescriptor.newModule("foo").provides("p.S", List.of("P"));
768 }
769
770 @Test(dataProvider = "invalidNames",
771 expectedExceptions = IllegalArgumentException.class )
772 public void testProvidesWithBadService(String service, String ignore) {
773 ModuleDescriptor.newModule("foo").provides(service, List.of("p.Provider"));
774 }
775
776 @Test(dataProvider = "invalidNames",
777 expectedExceptions = IllegalArgumentException.class )
778 public void testProvidesWithBadProvider(String provider, String ignore) {
779 List<String> names = new ArrayList<>(); // allows nulls
780 names.add(provider);
781 ModuleDescriptor.newModule("foo").provides("p.Service", names);
782 }
783
784 @Test(expectedExceptions = NullPointerException.class )
785 public void testProvidesWithNullProvides() {
786 ModuleDescriptor.newModule("foo").provides((Provides) null);
787 }
788
789 @Test(expectedExceptions = NullPointerException.class )
790 public void testProvidesWithNullProviders() {
791 ModuleDescriptor.newModule("foo").provides("p.S", (List<String>) null);
792 }
793
794 public void testProvidesCompare() {
795 Provides p1 = provides("p.S", "q.S1");
796 Provides p2 = provides("p.S", "q.S1");
797 assertEquals(p1, p2);
798 assertTrue(p1.hashCode() == p2.hashCode());
799 assertTrue(p1.compareTo(p2) == 0);
800 assertTrue(p2.compareTo(p1) == 0);
801 }
802
803 public void testProvidesCompareWithDifferentService() {
804 Provides p1 = provides("p.S2", "q.S1");
805 Provides p2 = provides("p.S1", "q.S1");
806 assertNotEquals(p1, p2);
807 assertTrue(p1.compareTo(p2) == 1);
808 assertTrue(p2.compareTo(p1) == -1);
809 }
810
811 public void testProvidesCompareWithDifferentProviders1() {
812 Provides p1 = provides("p.S", "q.S2");
813 Provides p2 = provides("p.S", "q.S1");
814 assertNotEquals(p1, p2);
815 assertTrue(p1.compareTo(p2) == 1);
816 assertTrue(p2.compareTo(p1) == -1);
817 }
818
819 public void testProvidesCompareWithDifferentProviders2() {
820 Provides p1 = provides("p.S", List.of("q.S1", "q.S2"));
821 Provides p2 = provides("p.S", "q.S1");
822 assertNotEquals(p1, p2);
823 assertTrue(p1.compareTo(p2) == 1);
824 assertTrue(p2.compareTo(p1) == -1);
825 }
826
827 // packages
828
829 public void testPackages1() {
830 Set<String> packages = ModuleDescriptor.newModule("foo")
831 .packages(Set.of("p", "q"))
832 .build()
833 .packages();
834 assertTrue(packages.size() == 2);
835 assertTrue(packages.contains("p"));
836 assertTrue(packages.contains("q"));
837 }
838
839 public void testPackages2() {
840 Set<String> packages = ModuleDescriptor.newModule("foo")
841 .packages(Set.of("p"))
842 .packages(Set.of("q"))
843 .build()
844 .packages();
845 assertTrue(packages.size() == 2);
846 assertTrue(packages.contains("p"));
847 assertTrue(packages.contains("q"));
848 }
849
850
851 public void testPackagesWithEmptySet() {
852 Set<String> packages = ModuleDescriptor.newModule("foo")
853 .packages(Collections.emptySet())
854 .build()
855 .packages();
856 assertTrue(packages.size() == 0);
857 }
858
859 public void testPackagesDuplicate() {
860 Set<String> packages = ModuleDescriptor.newModule("foo")
861 .packages(Set.of("p"))
862 .packages(Set.of("p"))
863 .build()
864 .packages();
865 assertTrue(packages.size() == 1);
866 assertTrue(packages.contains("p"));
867 }
868
869 public void testPackagesAndExportsPackage1() {
870 Set<String> packages = ModuleDescriptor.newModule("foo")
871 .packages(Set.of("p"))
872 .exports("p")
873 .build()
874 .packages();
875 assertTrue(packages.size() == 1);
876 assertTrue(packages.contains("p"));
877 }
878
879 public void testPackagesAndExportsPackage2() {
880 Set<String> packages = ModuleDescriptor.newModule("foo")
881 .exports("p")
882 .packages(Set.of("p"))
883 .build()
884 .packages();
885 assertTrue(packages.size() == 1);
886 assertTrue(packages.contains("p"));
887 }
888
889 public void testPackagesAndOpensPackage1() {
890 Set<String> packages = ModuleDescriptor.newModule("foo")
891 .packages(Set.of("p"))
892 .opens("p")
893 .build()
894 .packages();
895 assertTrue(packages.size() == 1);
896 assertTrue(packages.contains("p"));
897 }
898
899 public void testPackagesAndOpensPackage2() {
900 Set<String> packages = ModuleDescriptor.newModule("foo")
901 .opens("p")
902 .packages(Set.of("p"))
903 .build()
904 .packages();
905 assertTrue(packages.size() == 1);
906 assertTrue(packages.contains("p"));
907 }
908
909 public void testPackagesAndProvides1() {
910 Set<String> packages = ModuleDescriptor.newModule("foo")
911 .packages(Set.of("p"))
912 .provides("q.S", List.of("p.T"))
913 .build()
914 .packages();
915 assertTrue(packages.size() == 1);
916 assertTrue(packages.contains("p"));
917 }
918
919 public void testPackagesAndProvides2() {
920 Set<String> packages = ModuleDescriptor.newModule("foo")
921 .provides("q.S", List.of("p.T"))
922 .packages(Set.of("p"))
923 .build()
924 .packages();
925 assertTrue(packages.size() == 1);
926 assertTrue(packages.contains("p"));
927 }
928
929 public void testPackagesAndMainClass1() {
930 Set<String> packages = ModuleDescriptor.newModule("foo")
931 .packages(Set.of("p"))
932 .mainClass("p.Main")
933 .build()
934 .packages();
935 assertTrue(packages.size() == 1);
936 assertTrue(packages.contains("p"));
937 }
938
939 public void testPackagesAndMainClass2() {
940 Set<String> packages = ModuleDescriptor.newModule("foo")
941 .mainClass("p.Main")
942 .packages(Set.of("p"))
943 .build()
944 .packages();
945 assertTrue(packages.size() == 1);
946 assertTrue(packages.contains("p"));
947 }
948
949 public void testPackagesAndAll() {
950 Set<String> packages = ModuleDescriptor.newModule("foo")
951 .exports("p1")
952 .opens("p2")
953 .packages(Set.of("p3"))
954 .provides("q.S", List.of("p4.T"))
955 .mainClass("p5.Main")
956 .build()
957 .packages();
958 assertTrue(Objects.equals(packages, Set.of("p1", "p2", "p3", "p4", "p5")));
959 }
960
961 @Test(dataProvider = "invalidNames",
962 expectedExceptions = IllegalArgumentException.class )
963 public void testPackagesWithBadName(String pn, String ignore) {
964 Set<String> pkgs = new HashSet<>(); // allows nulls
965 pkgs.add(pn);
966 ModuleDescriptor.newModule("foo").packages(pkgs);
967 }
968
969 // name
970
971 public void testModuleName() {
972 String mn = ModuleDescriptor.newModule("foo").build().name();
973 assertEquals(mn, "foo");
974 }
975
976 @Test(dataProvider = "invalidNames",
977 expectedExceptions = IllegalArgumentException.class )
978 public void testBadModuleName(String mn, String ignore) {
979 ModuleDescriptor.newModule(mn);
980 }
981
982
983 // version
984
985 public void testVersion1() {
986 Version v1 = Version.parse("1.0");
987 Version v2 = ModuleDescriptor.newModule("foo")
988 .version(v1)
989 .build()
990 .version()
991 .get();
992 assertEquals(v1, v2);
993 }
994
995 public void testVersion2() {
996 String vs = "1.0";
997 Version v1 = ModuleDescriptor.newModule("foo")
998 .version(vs)
999 .build()
1000 .version()
1001 .get();
1002 Version v2 = Version.parse(vs);
1003 assertEquals(v1, v2);
1004 }
1005
1006 @Test(expectedExceptions = NullPointerException.class )
1007 public void testNullVersion1() {
1008 ModuleDescriptor.newModule("foo").version((Version) null);
1009 }
1010
1011 @Test(expectedExceptions = IllegalArgumentException.class )
1012 public void testNullVersion2() {
1013 ModuleDescriptor.newModule("foo").version((String) null);
1014 }
1015
1016 @Test(expectedExceptions = IllegalArgumentException.class )
1017 public void testEmptyVersion() {
1018 ModuleDescriptor.newModule("foo").version("");
1019 }
1020
1021
1022 @DataProvider(name = "unparseableVersions")
1023 public Object[][] unparseableVersions() {
1024 return new Object[][]{
1025
1026 { null, "A1" }, // no version < unparseable
1027 { "A1", "A2" }, // unparseable < unparseable
1028 { "A1", "1.0" }, // unparseable < parseable
1029
1030 };
1031 }
1032
1033 /**
1034 * Basic test for unparseable module versions
1035 */
1036 @Test(dataProvider = "unparseableVersions")
1037 public void testUnparseableModuleVersion(String vs1, String vs2) {
1038 ModuleDescriptor descriptor1 = newModule("m", vs1);
1039 ModuleDescriptor descriptor2 = newModule("m", vs2);
1040
1041 if (vs1 != null && !isParsableVersion(vs1)) {
1042 assertFalse(descriptor1.version().isPresent());
1043 assertTrue(descriptor1.rawVersion().isPresent());
1044 assertEquals(descriptor1.rawVersion().get(), vs1);
1045 }
1046
1047 if (vs2 != null && !isParsableVersion(vs2)) {
1048 assertFalse(descriptor2.version().isPresent());
1049 assertTrue(descriptor2.rawVersion().isPresent());
1050 assertEquals(descriptor2.rawVersion().get(), vs2);
1051 }
1052
1053 assertFalse(descriptor1.equals(descriptor2));
1054 assertFalse(descriptor2.equals(descriptor1));
1055 assertTrue(descriptor1.compareTo(descriptor2) == -1);
1056 assertTrue(descriptor2.compareTo(descriptor1) == 1);
1057 }
1058
1059 /**
1060 * Basic test for requiring a module with an unparseable version recorded
1061 * at compile version.
1062 */
1063 @Test(dataProvider = "unparseableVersions")
1064 public void testUnparseableCompiledVersion(String vs1, String vs2) {
1065 Requires r1 = newRequires("m", vs1);
1066 Requires r2 = newRequires("m", vs2);
1067
1068 if (vs1 != null && !isParsableVersion(vs1)) {
1069 assertFalse(r1.compiledVersion().isPresent());
1070 assertTrue(r1.rawCompiledVersion().isPresent());
1071 assertEquals(r1.rawCompiledVersion().get(), vs1);
1072 }
1073
1074 if (vs2 != null && !isParsableVersion(vs2)) {
1075 assertFalse(r2.compiledVersion().isPresent());
1076 assertTrue(r2.rawCompiledVersion().isPresent());
1077 assertEquals(r2.rawCompiledVersion().get(), vs2);
1078 }
1079
1080 assertFalse(r1.equals(r2));
1081 assertFalse(r2.equals(r1));
1082 assertTrue(r1.compareTo(r2) == -1);
1083 assertTrue(r2.compareTo(r1) == 1);
1084 }
1085
1086 private ModuleDescriptor newModule(String name, String vs) {
1087 JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess();
1088 Builder builder = JLMA.newModuleBuilder(name, false, Set.of());
1089 if (vs != null)
1090 builder.version(vs);
1091 builder.requires("java.base");
1092 ByteBuffer bb = ModuleInfoWriter.toByteBuffer(builder.build());
1093 return ModuleDescriptor.read(bb);
1094 }
1095
1096 private Requires newRequires(String name, String vs) {
1097 JavaLangModuleAccess JLMA = SharedSecrets.getJavaLangModuleAccess();
1098 Builder builder = JLMA.newModuleBuilder("foo", false, Set.of());
1099 if (vs == null) {
1100 builder.requires(name);
1101 } else {
1102 JLMA.requires(builder, Set.of(), name, vs);
1103 }
1104 Set<ModuleDescriptor.Requires> requires = builder.build().requires();
1105 Iterator<ModuleDescriptor.Requires> iterator = requires.iterator();
1106 ModuleDescriptor.Requires r = iterator.next();
1107 if (r.name().equals("java.base")) {
1108 r = iterator.next();
1109 }
1110 return r;
1111 }
1112
1113 private boolean isParsableVersion(String vs) {
1114 try {
1115 Version.parse(vs);
1116 return true;
1117 } catch (IllegalArgumentException e) {
1118 return false;
1119 }
1120 }
1121
1122
1123 // toNameAndVersion
1124
1125 public void testToNameAndVersion() {
1126 ModuleDescriptor md1 = ModuleDescriptor.newModule("foo").build();
1127 assertEquals(md1.toNameAndVersion(), "foo");
1128
1129 ModuleDescriptor md2 = ModuleDescriptor.newModule("foo").version("1.0").build();
1130 assertEquals(md2.toNameAndVersion(), "foo@1.0");
1131 }
1132
1133
1134 // open modules
1135
1136 public void testOpenModule() {
1137 ModuleDescriptor descriptor = ModuleDescriptor.newOpenModule("foo")
1138 .requires("bar")
1139 .exports("p")
1140 .provides("p.Service", List.of("q.ServiceImpl"))
1141 .build();
1142
1143 // modifiers
1144 assertTrue(descriptor.modifiers().contains(ModuleDescriptor.Modifier.OPEN));
1145 assertTrue(descriptor.isOpen());
1146
1147 // requires
1148 assertTrue(descriptor.requires().size() == 2);
1149 Set<String> names = descriptor.requires()
1150 .stream()
1151 .map(Requires::name)
1152 .collect(Collectors.toSet());
1153 assertEquals(names, Set.of("bar", "java.base"));
1154
1155 // packages
1156 assertEquals(descriptor.packages(), Set.of("p", "q"));
1157
1158 // exports
1159 assertTrue(descriptor.exports().size() == 1);
1160 names = descriptor.exports()
1161 .stream()
1162 .map(Exports::source)
1163 .collect(Collectors.toSet());
1164 assertEquals(names, Set.of("p"));
1165
1166 // opens
1167 assertTrue(descriptor.opens().isEmpty());
1168 }
1169
1170 @Test(expectedExceptions = IllegalStateException.class)
1171 public void testOpensOnOpenModule1() {
1172 ModuleDescriptor.newOpenModule("foo").opens("p");
1173 }
1174
1175 @Test(expectedExceptions = IllegalStateException.class)
1176 public void testOpensOnOpenModule2() {
1177 ModuleDescriptor.newOpenModule("foo").opens("p", Set.of("bar"));
1178 }
1179
1180 public void testIsOpen() {
1181 assertFalse(ModuleDescriptor.newModule("m").build().isOpen());
1182 assertFalse(ModuleDescriptor.newAutomaticModule("m").build().isOpen());
1183 assertTrue(ModuleDescriptor.newOpenModule("m").build().isOpen());
1184 }
1185
1186
1187 // automatic modules
1188
1189 public void testAutomaticModule() {
1190 ModuleDescriptor descriptor = ModuleDescriptor.newAutomaticModule("foo")
1191 .packages(Set.of("p"))
1192 .provides("p.Service", List.of("q.ServiceImpl"))
1193 .build();
1194
1195 // modifiers
1196 assertTrue(descriptor.modifiers().contains(ModuleDescriptor.Modifier.AUTOMATIC));
1197 assertTrue(descriptor.isAutomatic());
1198
1199 // requires
1200 assertTrue(descriptor.requires().size() == 1);
1201 Set<String> names = descriptor.requires()
1202 .stream()
1203 .map(Requires::name)
1204 .collect(Collectors.toSet());
1205 assertEquals(names, Set.of("java.base"));
1206
1207 // packages
1208 assertEquals(descriptor.packages(), Set.of("p", "q"));
1209 assertTrue(descriptor.exports().isEmpty());
1210 assertTrue(descriptor.opens().isEmpty());
1211 }
1212
1213 @Test(expectedExceptions = IllegalStateException.class)
1214 public void testRequiresOnAutomaticModule() {
1215 ModuleDescriptor.newAutomaticModule("foo").requires("java.base");
1216 }
1217
1218 @Test(expectedExceptions = IllegalStateException.class)
1219 public void testExportsOnAutomaticModule1() {
1220 ModuleDescriptor.newAutomaticModule("foo").exports("p");
1221 }
1222
1223 @Test(expectedExceptions = IllegalStateException.class)
1224 public void testExportsOnAutomaticModule2() {
1225 ModuleDescriptor.newAutomaticModule("foo").exports("p", Set.of("bar"));
1226 }
1227
1228 @Test(expectedExceptions = IllegalStateException.class)
1229 public void testOpensOnAutomaticModule1() {
1230 ModuleDescriptor.newAutomaticModule("foo").opens("p");
1231 }
1232
1233 @Test(expectedExceptions = IllegalStateException.class)
1234 public void testOpensOnAutomaticModule2() {
1235 ModuleDescriptor.newAutomaticModule("foo").opens("p", Set.of("bar"));
1236 }
1237
1238 @Test(expectedExceptions = IllegalStateException.class)
1239 public void testUsesOnAutomaticModule() {
1240 ModuleDescriptor.newAutomaticModule("foo").uses("p.Service");
1241 }
1242
1243 public void testIsAutomatic() {
1244 ModuleDescriptor descriptor1 = ModuleDescriptor.newModule("foo").build();
1245 assertFalse(descriptor1.isAutomatic());
1246
1247 ModuleDescriptor descriptor2 = ModuleDescriptor.newOpenModule("foo").build();
1248 assertFalse(descriptor2.isAutomatic());
1249
1250 ModuleDescriptor descriptor3 = ModuleDescriptor.newAutomaticModule("foo").build();
1251 assertTrue(descriptor3.isAutomatic());
1252 }
1253
1254
1255 // newModule with modifiers
1256
1257 public void testNewModuleToBuildAutomaticModule() {
1258 Set<ModuleDescriptor.Modifier> ms = Set.of(ModuleDescriptor.Modifier.AUTOMATIC);
1259 ModuleDescriptor descriptor = ModuleDescriptor.newModule("foo", ms).build();
1260 assertTrue(descriptor.modifiers().equals(ms));
1261 assertTrue(descriptor.isAutomatic());
1262 }
1263
1264 public void testNewModuleToBuildOpenModule() {
1265 Set<ModuleDescriptor.Modifier> ms = Set.of(ModuleDescriptor.Modifier.OPEN);
1266 ModuleDescriptor descriptor = ModuleDescriptor.newModule("foo", ms).build();
1267 assertTrue(descriptor.modifiers().equals(ms));
1268 assertTrue(descriptor.isOpen());
1269
1270 ms = Set.of(ModuleDescriptor.Modifier.OPEN, ModuleDescriptor.Modifier.SYNTHETIC);
1271 descriptor = ModuleDescriptor.newModule("foo", ms).build();
1272 assertTrue(descriptor.modifiers().equals(ms));
1273 assertTrue(descriptor.isOpen());
1274 }
1275
1276 @Test(expectedExceptions = IllegalArgumentException.class)
1277 public void testNewModuleToBuildAutomaticAndOpenModule() {
1278 Set<ModuleDescriptor.Modifier> ms = Set.of(ModuleDescriptor.Modifier.AUTOMATIC,
1279 ModuleDescriptor.Modifier.OPEN);
1280 ModuleDescriptor.newModule("foo", ms);
1281 }
1282
1283
1284 // mainClass
1285
1286 public void testMainClass() {
1287 String mainClass
1288 = ModuleDescriptor.newModule("foo").mainClass("p.Main").build().mainClass().get();
1289 assertEquals(mainClass, "p.Main");
1290 }
1291
1292 @Test(expectedExceptions = IllegalArgumentException.class)
1293 public void testMainClassWithSimpleIdentifier() {
1294 ModuleDescriptor.newModule("foo").mainClass("Main");
1295 }
1296
1297 @Test(dataProvider = "invalidNames",
1298 expectedExceptions = IllegalArgumentException.class )
1299 public void testMainClassWithBadName(String mainClass, String ignore) {
1300 Builder builder = ModuleDescriptor.newModule("foo");
1301 builder.mainClass(mainClass);
1302 }
1303
1304
1305 // reads
1306
1307 private static InputStream EMPTY_INPUT_STREAM = new InputStream() {
1308 @Override
1309 public int read() {
1310 return -1;
1311 }
1312 };
1313
1314 private static InputStream FAILING_INPUT_STREAM = new InputStream() {
1315 @Override
1316 public int read() throws IOException {
1317 throw new IOException();
1318 }
1319 };
1320
1321 /**
1322 * Basic test reading module-info.class
1323 */
1324 public void testRead() throws Exception {
1325 Module base = Object.class.getModule();
1326
1327 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1328 ModuleDescriptor descriptor = ModuleDescriptor.read(in);
1329 assertTrue(in.read() == -1); // all bytes read
1330 assertEquals(descriptor.name(), "java.base");
1331 }
1332
1333 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1334 ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
1335 ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
1336 assertFalse(bb.hasRemaining()); // no more remaining bytes
1337 assertEquals(descriptor.name(), "java.base");
1338 }
1339 }
1340
1341 /**
1342 * Test ModuleDescriptor with a packager finder
1343 */
1344 public void testReadsWithPackageFinder() throws Exception {
1345 ModuleDescriptor descriptor = ModuleDescriptor.newModule("foo")
1346 .requires("java.base")
1347 .build();
1348
1349 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1350 ModuleInfoWriter.write(descriptor, baos);
1351 ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
1352
1353 descriptor = ModuleDescriptor.read(bb, () -> Set.of("p", "q"));
1354
1355 assertTrue(descriptor.packages().size() == 2);
1356 assertTrue(descriptor.packages().contains("p"));
1357 assertTrue(descriptor.packages().contains("q"));
1358 }
1359
1360 /**
1361 * Test ModuleDescriptor with a packager finder that doesn't return the
1362 * complete set of packages.
1363 */
1364 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1365 public void testReadsWithBadPackageFinder() throws Exception {
1366 ModuleDescriptor descriptor = ModuleDescriptor.newModule("foo")
1367 .requires("java.base")
1368 .exports("p")
1369 .build();
1370
1371 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1372 ModuleInfoWriter.write(descriptor, baos);
1373 ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());
1374
1375 // package finder returns a set that doesn't include p
1376 ModuleDescriptor.read(bb, () -> Set.of("q"));
1377 }
1378
1379 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1380 public void testReadFromEmptyInputStream() throws Exception {
1381 ModuleDescriptor.read(EMPTY_INPUT_STREAM);
1382 }
1383
1384 @Test(expectedExceptions = IOException.class)
1385 public void testReadFromFailingInputStream() throws Exception {
1386 ModuleDescriptor.read(FAILING_INPUT_STREAM);
1387 }
1388
1389 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1390 public void testReadFromEmptyBuffer() {
1391 ByteBuffer bb = ByteBuffer.allocate(0);
1392 ModuleDescriptor.read(bb);
1393 }
1394
1395 // The requires table for java.base must be 0 length
1396 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1397 public void testReadOfJavaBaseWithRequires() {
1398 ModuleDescriptor descriptor
1399 = ModuleDescriptor.newModule("java.base")
1400 .requires("other")
1401 .build();
1402 ByteBuffer bb = ModuleInfoWriter.toByteBuffer(descriptor);
1403 ModuleDescriptor.read(bb);
1404 }
1405
1406 // The requires table must have an entry for java.base
1407 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1408 public void testReadWithEmptyRequires() {
1409 ModuleDescriptor descriptor = SharedSecrets.getJavaLangModuleAccess()
1410 .newModuleBuilder("m1", false, Set.of()).build();
1411 ByteBuffer bb = ModuleInfoWriter.toByteBuffer(descriptor);
1412 ModuleDescriptor.read(bb);
1413 }
1414
1415 // The requires table must have an entry for java.base
1416 @Test(expectedExceptions = InvalidModuleDescriptorException.class)
1417 public void testReadWithNoRequiresBase() {
1418 ModuleDescriptor descriptor = SharedSecrets.getJavaLangModuleAccess()
1419 .newModuleBuilder("m1", false, Set.of()).requires("m2").build();
1420 ByteBuffer bb = ModuleInfoWriter.toByteBuffer(descriptor);
1421 ModuleDescriptor.read(bb);
1422 }
1423
1424 public void testReadWithNull() throws Exception {
1425 Module base = Object.class.getModule();
1426
1427 try {
1428 ModuleDescriptor.read((InputStream)null);
1429 assertTrue(false);
1430 } catch (NullPointerException expected) { }
1431
1432
1433 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1434 try {
1435 ModuleDescriptor.read(in, null);
1436 assertTrue(false);
1437 } catch (NullPointerException expected) { }
1438 }
1439
1440 try {
1441 ModuleDescriptor.read((ByteBuffer)null);
1442 assertTrue(false);
1443 } catch (NullPointerException expected) { }
1444
1445
1446 try (InputStream in = base.getResourceAsStream("module-info.class")) {
1447 ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
1448 try {
1449 ModuleDescriptor.read(bb, null);
1450 assertTrue(false);
1451 } catch (NullPointerException expected) { }
1452 }
1453 }
1454
1455
1456 // equals/hashCode/compareTo/toString
1457
1458 public void testEqualsAndHashCode() {
1459 ModuleDescriptor md1 = ModuleDescriptor.newModule("m").build();
1460 ModuleDescriptor md2 = ModuleDescriptor.newModule("m").build();
1461 assertEquals(md1, md1);
1462 assertEquals(md1.hashCode(), md2.hashCode());
1463 assertTrue(md1.compareTo(md2) == 0);
1464 assertTrue(md2.compareTo(md1) == 0);
1465 }
1466
1467 @DataProvider(name = "sortedModuleDescriptors")
1468 public Object[][] sortedModuleDescriptors() {
1469 return new Object[][]{
1470
1471 { ModuleDescriptor.newModule("m2").build(),
1472 ModuleDescriptor.newModule("m1").build()
1473 },
1474
1475 { ModuleDescriptor.newModule("m").version("2").build(),
1476 ModuleDescriptor.newModule("m").version("1").build()
1477 },
1478
1479 { ModuleDescriptor.newModule("m").version("1").build(),
1480 ModuleDescriptor.newModule("m").build()
1481 },
1482
1483 { ModuleDescriptor.newOpenModule("m").build(),
1484 ModuleDescriptor.newModule("m").build()
1485 },
1486
1487 };
1488 }
1489
1490 @Test(dataProvider = "sortedModuleDescriptors")
1491 public void testCompare(ModuleDescriptor md1, ModuleDescriptor md2) {
1492 assertNotEquals(md1, md2);
1493 assertTrue(md1.compareTo(md2) == 1);
1494 assertTrue(md2.compareTo(md1) == -1);
1495 }
1496
1497 public void testToString() {
1498 String s = ModuleDescriptor.newModule("m1")
1499 .requires("m2")
1500 .exports("p1")
1501 .build()
1502 .toString();
1503 assertTrue(s.contains("m1"));
1504 assertTrue(s.contains("m2"));
1505 assertTrue(s.contains("p1"));
1506 }
1507
1508 }