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