Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/test/java/lang/module/AutomaticModulesTest.java
changeset 44545 83b611b88ac8
parent 44359 c6761862ca0b
child 45004 ea3137042a61
equal deleted inserted replaced
44480:2c33418a6d57 44545:83b611b88ac8 
    36 import java.lang.module.ModuleDescriptor.Requires.Modifier;
 
    36 import java.lang.module.ModuleDescriptor.Requires.Modifier;
 
    37 import java.lang.module.ModuleFinder;
 
    37 import java.lang.module.ModuleFinder;
 
    38 import java.lang.module.ModuleReference;
 
    38 import java.lang.module.ModuleReference;
 
    39 import java.lang.module.ResolutionException;
 
    39 import java.lang.module.ResolutionException;
 
    40 import java.lang.module.ResolvedModule;
 
    40 import java.lang.module.ResolvedModule;
 
    41 import java.lang.reflect.Layer;
 
       
    42 import java.lang.reflect.Module;
 
       
    43 import java.nio.file.Files;
 
    41 import java.nio.file.Files;
 
    44 import java.nio.file.Path;
 
    42 import java.nio.file.Path;
 
    45 import java.nio.file.Paths;
 
    43 import java.nio.file.Paths;
 
    46 import java.util.Optional;
 
    44 import java.util.Optional;
 
    47 import java.util.Set;
 
    45 import java.util.Set;
 
    67             // JAR file name                module-name[/version]
 
    65             // JAR file name                module-name[/version]
 
    68 
    66 
    69             { "foo.jar",                    "foo" },
 
    67             { "foo.jar",                    "foo" },
 
    70             { "foo4j.jar",                  "foo4j", },
 
    68             { "foo4j.jar",                  "foo4j", },
 
    71 
    69 
    72             { "foo1.jar",                   "foo" },
 
    70             { "foo1.jar",                   "foo1" },
 
    73             { "foo1.2.jar",                 "foo" },
 
    71             { "foo10.jar",                  "foo10" },
 
    74             { "foo1.2.3.jar",               "foo" },
 
       
    75 
       
    76             { "foo10.jar",                  "foo" },
 
       
    77             { "foo10.20.jar",               "foo" },
 
       
    78             { "foo10.20.30.jar",            "foo" },
 
       
    79 
    72 
    80             { "foo-1.jar",                  "foo/1" },
 
    73             { "foo-1.jar",                  "foo/1" },
 
    81             { "foo-1.2.jar",                "foo/1.2" },
 
    74             { "foo-1.2.jar",                "foo/1.2" },
 
    82             { "foo-1.2.3.jar",              "foo/1.2.3" },
 
    75             { "foo-1.2.3.jar",              "foo/1.2.3" },
 
    83             { "foo-1.2.3.4.jar",            "foo/1.2.3.4" },
 
    76             { "foo-1.2.3.4.jar",            "foo/1.2.3.4" },
 
    91             { "foo-bar-1.jar",              "foo.bar/1" },
 
    84             { "foo-bar-1.jar",              "foo.bar/1" },
 
    92             { "foo-bar-1.2.jar",            "foo.bar/1.2"},
 
    85             { "foo-bar-1.2.jar",            "foo.bar/1.2"},
 
    93             { "foo-bar-10.jar",             "foo.bar/10" },
 
    86             { "foo-bar-10.jar",             "foo.bar/10" },
 
    94             { "foo-bar-10.20.jar",          "foo.bar/10.20" },
 
    87             { "foo-bar-10.20.jar",          "foo.bar/10.20" },
 
    95 
    88 
       
    89             { "foo.bar1.jar",               "foo.bar1" },
 
       
    90             { "foo.bar10.jar",              "foo.bar10" },
 
       
    91 
    96             { "foo-1.2-SNAPSHOT.jar",       "foo/1.2-SNAPSHOT" },
 
    92             { "foo-1.2-SNAPSHOT.jar",       "foo/1.2-SNAPSHOT" },
 
    97             { "foo-bar-1.2-SNAPSHOT.jar",   "foo.bar/1.2-SNAPSHOT" },
 
    93             { "foo-bar-1.2-SNAPSHOT.jar",   "foo.bar/1.2-SNAPSHOT" },
 
    98 
    94 
    99             { "foo--bar-1.0.jar",           "foo.bar/1.0" },
 
    95             { "foo--bar-1.0.jar",           "foo.bar/1.0" },
 
   100             { "-foo-bar-1.0.jar",           "foo.bar/1.0" },
 
    96             { "-foo-bar-1.0.jar",           "foo.bar/1.0" },
 
   106     // JAR file names that do not map to a legal module name
 
   102     // JAR file names that do not map to a legal module name
 
   107     @DataProvider(name = "badnames")
 
   103     @DataProvider(name = "badnames")
 
   108     public Object[][] createBadNames() {
 
   104     public Object[][] createBadNames() {
 
   109         return new Object[][]{
 
   105         return new Object[][]{
 
   110 
   106 
   111             { ".jar",     null },
 
   107             { ".jar",          null },
 
   112             { "_.jar",    null }
 
   108             { "_.jar",         null },
 
       
   109 
       
   110             { "foo.1.jar",     null },
 
       
   111             { "1foo.jar",      null },
 
       
   112             { "foo.1bar.jar",  null },
 
   113 
   113 
   114         };
 
   114         };
 
   115     }
 
   115     }
 
   116 
   116 
   117     /**
 
   117     /**
 
   387         String entry = mainClass.replace('.', '/') + ".class";
 
   387         String entry = mainClass.replace('.', '/') + ".class";
 
   388         createDummyJarFile(dir.resolve("m.jar"), man, entry);
 
   388         createDummyJarFile(dir.resolve("m.jar"), man, entry);
 
   389 
   389 
   390         ModuleFinder finder = ModuleFinder.of(dir);
 
   390         ModuleFinder finder = ModuleFinder.of(dir);
 
   391 
   391 
   392         Configuration parent = Layer.boot().configuration();
 
   392         Configuration parent = ModuleLayer.boot().configuration();
 
   393         Configuration cf = resolve(parent, finder, "m");
 
   393         Configuration cf = resolve(parent, finder, "m");
 
   394 
   394 
   395         ModuleDescriptor descriptor = findDescriptor(cf, "m");
 
   395         ModuleDescriptor descriptor = findDescriptor(cf, "m");
 
   396 
   396 
   397         assertTrue(descriptor.mainClass().isPresent());
 
   397         assertTrue(descriptor.mainClass().isPresent());
 
   467         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   467         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   468         createDummyJarFile(dir.resolve("b.jar"), "p/T.class");
 
   468         createDummyJarFile(dir.resolve("b.jar"), "p/T.class");
 
   469         createDummyJarFile(dir.resolve("c.jar"), "q/T.class");
 
   469         createDummyJarFile(dir.resolve("c.jar"), "q/T.class");
 
   470 
   470 
   471         // module finder locates a and the modules in the directory
 
   471         // module finder locates a and the modules in the directory
 
   472         ModuleFinder finder
 
   472         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
 
   473             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor1),
 
   473         ModuleFinder finder2 = ModuleFinder.of(dir);
 
   474                 ModuleFinder.of(dir));
 
   474         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
   475 
   475 
   476         Configuration parent = Layer.boot().configuration();
 
   476         Configuration parent = ModuleLayer.boot().configuration();
 
   477         Configuration cf = resolve(parent, finder, "a");
 
   477         Configuration cf = resolve(parent, finder, "a");
 
   478 
   478 
   479         assertTrue(cf.modules().size() == 3);
 
   479         assertTrue(cf.modules().size() == 3);
 
   480         assertTrue(cf.findModule("a").isPresent());
 
   480         assertTrue(cf.findModule("a").isPresent());
 
   481         assertTrue(cf.findModule("b").isPresent());
 
   481         assertTrue(cf.findModule("b").isPresent());
 
   482         assertTrue(cf.findModule("c").isPresent());
 
   482         assertTrue(cf.findModule("c").isPresent());
 
   483 
   483 
   484         ResolvedModule base = cf.findModule("java.base").get();
 
   484         ResolvedModule base = cf.findModule("java.base").get();
 
   485         assertTrue(base.configuration() == Layer.boot().configuration());
 
   485         assertTrue(base.configuration() == ModuleLayer.boot().configuration());
 
   486         ResolvedModule a = cf.findModule("a").get();
 
   486         ResolvedModule a = cf.findModule("a").get();
 
   487         ResolvedModule b = cf.findModule("b").get();
 
   487         ResolvedModule b = cf.findModule("b").get();
 
   488         ResolvedModule c = cf.findModule("c").get();
 
   488         ResolvedModule c = cf.findModule("c").get();
 
   489 
   489 
   490         // b && c only require java.base
 
   490         // b && c only require java.base
 
   532         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   532         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   533         createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
 
   533         createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
 
   534         createDummyJarFile(dir.resolve("d.jar"), "q/T.class");
 
   534         createDummyJarFile(dir.resolve("d.jar"), "q/T.class");
 
   535 
   535 
   536         // module finder locates a and the modules in the directory
 
   536         // module finder locates a and the modules in the directory
 
   537         ModuleFinder finder
 
   537         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
 
   538             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor1, descriptor2),
 
   538         ModuleFinder finder2 = ModuleFinder.of(dir);
 
   539                                    ModuleFinder.of(dir));
 
   539         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
   540 
   540 
   541         Configuration parent = Layer.boot().configuration();
 
   541         Configuration parent = ModuleLayer.boot().configuration();
 
   542         Configuration cf = resolve(parent, finder, "a", "d");
 
   542         Configuration cf = resolve(parent, finder, "a", "d");
 
   543 
   543 
   544         assertTrue(cf.modules().size() == 4);
 
   544         assertTrue(cf.modules().size() == 4);
 
   545         assertTrue(cf.findModule("a").isPresent());
 
   545         assertTrue(cf.findModule("a").isPresent());
 
   546         assertTrue(cf.findModule("b").isPresent());
 
   546         assertTrue(cf.findModule("b").isPresent());
 
   552         assertTrue(findDescriptor(cf, "d").requires().size() == 1);
 
   552         assertTrue(findDescriptor(cf, "d").requires().size() == 1);
 
   553 
   553 
   554         // readability
 
   554         // readability
 
   555 
   555 
   556         ResolvedModule base = cf.findModule("java.base").get();
 
   556         ResolvedModule base = cf.findModule("java.base").get();
 
   557         assertTrue(base.configuration() == Layer.boot().configuration());
 
   557         assertTrue(base.configuration() == ModuleLayer.boot().configuration());
 
   558         ResolvedModule a = cf.findModule("a").get();
 
   558         ResolvedModule a = cf.findModule("a").get();
 
   559         ResolvedModule b = cf.findModule("b").get();
 
   559         ResolvedModule b = cf.findModule("b").get();
 
   560         ResolvedModule c = cf.findModule("c").get();
 
   560         ResolvedModule c = cf.findModule("c").get();
 
   561         ResolvedModule d = cf.findModule("d").get();
 
   561         ResolvedModule d = cf.findModule("d").get();
 
   562 
   562 
   605         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   605         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
   606         createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
 
   606         createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
 
   607         createDummyJarFile(dir.resolve("d.jar"), "q/T.class");
 
   607         createDummyJarFile(dir.resolve("d.jar"), "q/T.class");
 
   608 
   608 
   609         // module finder locates a and the modules in the directory
 
   609         // module finder locates a and the modules in the directory
 
   610         ModuleFinder finder
 
   610         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
 
   611             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor1, descriptor2),
 
   611         ModuleFinder finder2 = ModuleFinder.of(dir);
 
   612                 ModuleFinder.of(dir));
 
   612         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
   613 
   613 
   614         Configuration parent = Layer.boot().configuration();
 
   614         Configuration parent = ModuleLayer.boot().configuration();
 
   615         Configuration cf = resolve(parent, finder, "a", "d");
 
   615         Configuration cf = resolve(parent, finder, "a", "d");
 
   616 
   616 
   617         assertTrue(cf.modules().size() == 4);
 
   617         assertTrue(cf.modules().size() == 4);
 
   618         assertTrue(cf.findModule("a").isPresent());
 
   618         assertTrue(cf.findModule("a").isPresent());
 
   619         assertTrue(cf.findModule("b").isPresent());
 
   619         assertTrue(cf.findModule("b").isPresent());
 
   620         assertTrue(cf.findModule("c").isPresent());
 
   620         assertTrue(cf.findModule("c").isPresent());
 
   621         assertTrue(cf.findModule("d").isPresent());
 
   621         assertTrue(cf.findModule("d").isPresent());
 
   622 
   622 
   623         ResolvedModule base = cf.findModule("java.base").get();
 
   623         ResolvedModule base = cf.findModule("java.base").get();
 
   624         assertTrue(base.configuration() == Layer.boot().configuration());
 
   624         assertTrue(base.configuration() == ModuleLayer.boot().configuration());
 
   625         ResolvedModule a = cf.findModule("a").get();
 
   625         ResolvedModule a = cf.findModule("a").get();
 
   626         ResolvedModule b = cf.findModule("b").get();
 
   626         ResolvedModule b = cf.findModule("b").get();
 
   627         ResolvedModule c = cf.findModule("c").get();
 
   627         ResolvedModule c = cf.findModule("c").get();
 
   628         ResolvedModule d = cf.findModule("d").get();
 
   628         ResolvedModule d = cf.findModule("d").get();
 
   629 
   629 
   655 
   655 
   656         assertTrue(d.reads().contains(a));
 
   656         assertTrue(d.reads().contains(a));
 
   657         assertTrue(d.reads().contains(b));
 
   657         assertTrue(d.reads().contains(b));
 
   658         assertTrue(d.reads().contains(c));
 
   658         assertTrue(d.reads().contains(c));
 
   659         testReadAllBootModules(cf, "d");    // d reads all modules in boot layer
 
   659         testReadAllBootModules(cf, "d");    // d reads all modules in boot layer
 
       
   660     }
 
       
   661 
       
   662 
       
   663     /**
 
       
   664      * Basic test to ensure that no automatic modules are resolved when
 
       
   665      * an automatic module is not a root or required by other modules.
 
       
   666      */
 
       
   667     public void testInConfiguration4() throws IOException {
 
       
   668         ModuleDescriptor descriptor1
 
       
   669             = ModuleDescriptor.newModule("m1")
 
       
   670                 .requires("java.base")
 
       
   671                 .build();
 
       
   672 
       
   673         // automatic modules
 
       
   674         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
       
   675         createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
 
       
   676         createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
 
       
   677         createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");
 
       
   678 
       
   679         // module finder locates m1 and the modules in the directory
 
       
   680         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
 
       
   681         ModuleFinder finder2 =  ModuleFinder.of(dir);
 
       
   682         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
       
   683 
       
   684         Configuration parent = ModuleLayer.boot().configuration();
 
       
   685         Configuration cf = resolve(parent, finder, "m1");
 
       
   686 
       
   687         // ensure that no automatic module is resolved
 
       
   688         assertTrue(cf.modules().size() == 1);
 
       
   689         assertTrue(cf.findModule("m1").isPresent());
 
       
   690     }
 
       
   691 
       
   692 
       
   693     /**
 
       
   694      * Basic test to ensure that if an automatic module is resolved then
 
       
   695      * all observable automatic modules are resolved.
 
       
   696      */
 
       
   697     public void testInConfiguration5() throws IOException {
 
       
   698         // m1 requires m2
 
       
   699         ModuleDescriptor descriptor1
 
       
   700             = ModuleDescriptor.newModule("m1")
 
       
   701                 .requires("m2").build();
 
       
   702 
       
   703         // m2 requires automatic module
 
       
   704         ModuleDescriptor descriptor2
 
       
   705             = ModuleDescriptor.newModule("m2")
 
       
   706                 .requires("auto1")
 
       
   707                 .build();
 
       
   708 
       
   709         // automatic modules
 
       
   710         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
       
   711         createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
 
       
   712         createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
 
       
   713         createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");
 
       
   714 
       
   715         // module finder locates m1, m2, and the modules in the directory
 
       
   716         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
 
       
   717         ModuleFinder finder2 =  ModuleFinder.of(dir);
 
       
   718         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
       
   719 
       
   720         Configuration parent = ModuleLayer.boot().configuration();
 
       
   721         Configuration cf = resolve(parent, finder, "m1");
 
       
   722 
       
   723         // all automatic modules should be resolved
 
       
   724         assertTrue(cf.modules().size() == 5);
 
       
   725         assertTrue(cf.findModule("m1").isPresent());
 
       
   726         assertTrue(cf.findModule("m2").isPresent());
 
       
   727         assertTrue(cf.findModule("auto1").isPresent());
 
       
   728         assertTrue(cf.findModule("auto2").isPresent());
 
       
   729         assertTrue(cf.findModule("auto3").isPresent());
 
       
   730 
       
   731         ResolvedModule base = parent.findModule("java.base")
 
       
   732                                     .orElseThrow(() -> new RuntimeException());
 
       
   733         ResolvedModule m1 = cf.findModule("m1").get();
 
       
   734         ResolvedModule m2 = cf.findModule("m2").get();
 
       
   735         ResolvedModule auto1 = cf.findModule("auto1").get();
 
       
   736         ResolvedModule auto2 = cf.findModule("auto2").get();
 
       
   737         ResolvedModule auto3 = cf.findModule("auto3").get();
 
       
   738 
       
   739         // m1 does not read the automatic modules
 
       
   740         assertTrue(m1.reads().size() == 2);
 
       
   741         assertTrue(m1.reads().contains(m2));
 
       
   742         assertTrue(m1.reads().contains(base));
 
       
   743 
       
   744         // m2 should read all the automatic modules
 
       
   745         assertTrue(m2.reads().size() == 4);
 
       
   746         assertTrue(m2.reads().contains(auto1));
 
       
   747         assertTrue(m2.reads().contains(auto2));
 
       
   748         assertTrue(m2.reads().contains(auto3));
 
       
   749         assertTrue(m2.reads().contains(base));
 
       
   750 
       
   751         assertTrue(auto1.reads().contains(m1));
 
       
   752         assertTrue(auto1.reads().contains(m2));
 
       
   753         assertTrue(auto1.reads().contains(auto2));
 
       
   754         assertTrue(auto1.reads().contains(auto3));
 
       
   755         assertTrue(auto1.reads().contains(base));
 
       
   756 
       
   757         assertTrue(auto2.reads().contains(m1));
 
       
   758         assertTrue(auto2.reads().contains(m2));
 
       
   759         assertTrue(auto2.reads().contains(auto1));
 
       
   760         assertTrue(auto2.reads().contains(auto3));
 
       
   761         assertTrue(auto2.reads().contains(base));
 
       
   762 
       
   763         assertTrue(auto3.reads().contains(m1));
 
       
   764         assertTrue(auto3.reads().contains(m2));
 
       
   765         assertTrue(auto3.reads().contains(auto1));
 
       
   766         assertTrue(auto3.reads().contains(auto2));
 
       
   767         assertTrue(auto3.reads().contains(base));
 
       
   768     }
 
       
   769 
       
   770 
       
   771     /**
 
       
   772      * Basic test of automatic modules in a child configuration. All automatic
 
       
   773      * modules that are found with the before finder should be resolved. The
 
       
   774      * automatic modules that are found by the after finder and not shadowed
 
       
   775      * by the before finder, or parent configurations, should also be resolved.
 
       
   776      */
 
       
   777     public void testInConfiguration6() throws IOException {
 
       
   778         // m1 requires auto1
 
       
   779         ModuleDescriptor descriptor1
 
       
   780             = ModuleDescriptor.newModule("m1")
 
       
   781                 .requires("auto1")
 
       
   782                 .build();
 
       
   783 
       
   784         Path dir = Files.createTempDirectory(USER_DIR, "mods");
 
       
   785         createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
 
       
   786 
       
   787         // module finder locates m1 and auto1
 
       
   788         ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
 
       
   789         ModuleFinder finder2 =  ModuleFinder.of(dir);
 
       
   790         ModuleFinder finder = ModuleFinder.compose(finder1, finder2);
 
       
   791 
       
   792         Configuration parent = ModuleLayer.boot().configuration();
 
       
   793         Configuration cf1 = resolve(parent, finder, "m1");
 
       
   794 
       
   795         assertTrue(cf1.modules().size() == 2);
 
       
   796         assertTrue(cf1.findModule("m1").isPresent());
 
       
   797         assertTrue(cf1.findModule("auto1").isPresent());
 
       
   798 
       
   799         ResolvedModule base = parent.findModule("java.base")
 
       
   800                                     .orElseThrow(() -> new RuntimeException());
 
       
   801         ResolvedModule m1 = cf1.findModule("m1").get();
 
       
   802         ResolvedModule auto1 = cf1.findModule("auto1").get();
 
       
   803 
       
   804         assertTrue(m1.reads().size() == 2);
 
       
   805         assertTrue(m1.reads().contains(auto1));
 
       
   806         assertTrue(m1.reads().contains(base));
 
       
   807 
       
   808         assertTrue(auto1.reads().contains(m1));
 
       
   809         assertTrue(auto1.reads().contains(base));
 
       
   810 
       
   811 
       
   812         // create child configuration - the after finder locates auto1
 
       
   813 
       
   814         dir = Files.createTempDirectory(USER_DIR, "mods");
 
       
   815         createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
 
       
   816         ModuleFinder beforeFinder =  ModuleFinder.of(dir);
 
       
   817 
       
   818         dir = Files.createTempDirectory(USER_DIR, "mods");
 
       
   819         createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
 
       
   820         createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
 
       
   821         createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");
 
       
   822         ModuleFinder afterFinder =  ModuleFinder.of(dir);
 
       
   823 
       
   824         Configuration cf2 = cf1.resolve(beforeFinder, afterFinder, Set.of("auto2"));
 
       
   825 
       
   826         // auto1 should be found in parent and should not be in cf2
 
       
   827         assertTrue(cf2.modules().size() == 2);
 
       
   828         assertTrue(cf2.findModule("auto2").isPresent());
 
       
   829         assertTrue(cf2.findModule("auto3").isPresent());
 
       
   830 
       
   831         ResolvedModule auto2 = cf2.findModule("auto2").get();
 
       
   832         ResolvedModule auto3 = cf2.findModule("auto3").get();
 
       
   833 
       
   834         assertTrue(auto2.reads().contains(m1));
 
       
   835         assertTrue(auto2.reads().contains(auto1));
 
       
   836         assertTrue(auto2.reads().contains(auto3));
 
       
   837         assertTrue(auto2.reads().contains(base));
 
       
   838 
       
   839         assertTrue(auto3.reads().contains(m1));
 
       
   840         assertTrue(auto3.reads().contains(auto1));
 
       
   841         assertTrue(auto3.reads().contains(auto2));
 
       
   842         assertTrue(auto3.reads().contains(base));
 
   660     }
 
   843     }
 
   661 
   844 
   662 
   845 
   663     /**
 
   846     /**
 
   664      * Basic test of a configuration created with automatic modules
 
   847      * Basic test of a configuration created with automatic modules
 
   682         // module finder locates 'a' and the modules in the directory
 
   865         // module finder locates 'a' and the modules in the directory
 
   683         ModuleFinder finder
 
   866         ModuleFinder finder
 
   684             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   867             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   685                                    ModuleFinder.of(dir));
 
   868                                    ModuleFinder.of(dir));
 
   686 
   869 
   687         Configuration parent = Layer.boot().configuration();
 
   870         Configuration parent = ModuleLayer.boot().configuration();
 
   688         resolve(parent, finder, "a");
 
   871         resolve(parent, finder, "a");
 
   689     }
 
   872     }
 
   690 
   873 
   691 
   874 
   692     /**
 
   875     /**
 
   709         // module finder locates 'a' and the modules in the directory
 
   892         // module finder locates 'a' and the modules in the directory
 
   710         ModuleFinder finder
 
   893         ModuleFinder finder
 
   711             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   894             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   712                                    ModuleFinder.of(dir));
 
   895                                    ModuleFinder.of(dir));
 
   713 
   896 
   714         Configuration parent = Layer.boot().configuration();
 
   897         Configuration parent = ModuleLayer.boot().configuration();
 
   715         resolve(parent, finder, "a");
 
   898         resolve(parent, finder, "a");
 
   716     }
 
   899     }
 
   717 
   900 
   718 
   901 
   719     /**
 
   902     /**
 
   720      * Basic test of Layer containing automatic modules
 
   903      * Basic test of layer containing automatic modules
 
   721      */
 
   904      */
 
   722     public void testInLayer() throws IOException {
 
   905     public void testInLayer() throws IOException {
 
   723         ModuleDescriptor descriptor
 
   906         ModuleDescriptor descriptor
 
   724             = ModuleDescriptor.newModule("a")
 
   907             = ModuleDescriptor.newModule("a")
 
   725                 .requires("b")
 
   908                 .requires("b")
 
   734         // module finder locates a and the modules in the directory
 
   917         // module finder locates a and the modules in the directory
 
   735         ModuleFinder finder
 
   918         ModuleFinder finder
 
   736             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   919             = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
 
   737                 ModuleFinder.of(dir));
 
   920                 ModuleFinder.of(dir));
 
   738 
   921 
   739         Configuration parent = Layer.boot().configuration();
 
   922         Configuration parent = ModuleLayer.boot().configuration();
 
   740         Configuration cf = resolve(parent, finder, "a");
 
   923         Configuration cf = resolve(parent, finder, "a");
 
   741         assertTrue(cf.modules().size() == 3);
 
   924         assertTrue(cf.modules().size() == 3);
 
   742 
   925 
   743         // each module gets its own loader
 
   926         // each module gets its own loader
 
   744         Layer layer = Layer.boot().defineModules(cf, mn -> new ClassLoader() { });
 
   927         ModuleLayer layer = ModuleLayer.boot().defineModules(cf, mn -> new ClassLoader() { });
 
   745 
   928 
   746         // an unnamed module
 
   929         // an unnamed module
 
   747         Module unnamed = (new ClassLoader() { }).getUnnamedModule();
 
   930         Module unnamed = (new ClassLoader() { }).getUnnamedModule();
 
   748 
   931 
   749         Module b = layer.findModule("b").get();
 
   932         Module b = layer.findModule("b").get();
 
   802      * Test that a module in a configuration reads all modules in the boot
 
   985      * Test that a module in a configuration reads all modules in the boot
 
   803      * configuration.
 
   986      * configuration.
 
   804      */
 
   987      */
 
   805     static void testReadAllBootModules(Configuration cf, String mn) {
 
   988     static void testReadAllBootModules(Configuration cf, String mn) {
 
   806 
   989 
   807         Set<String> bootModules = Layer.boot().modules().stream()
 
   990         Set<String> bootModules = ModuleLayer.boot().modules().stream()
 
   808                 .map(Module::getName)
 
   991                 .map(Module::getName)
 
   809                 .collect(Collectors.toSet());
 
   992                 .collect(Collectors.toSet());
 
   810 
   993 
   811         bootModules.forEach(other -> assertTrue(reads(cf, mn, other)));
 
   994         bootModules.forEach(other -> assertTrue(reads(cf, mn, other)));
 
   812 
   995 
   813     }
 
   996     }
 
   814 
   997 
   815     /**
 
   998     /**
 
   816      * Test that the given Module reads all module in the given Layer
 
   999      * Test that the given Module reads all module in the given layer
 
   817      * and its parent Layers.
 
  1000      * and its parent layers.
 
   818      */
 
  1001      */
 
   819     static void testsReadsAll(Module m, Layer layer) {
 
  1002     static void testsReadsAll(Module m, ModuleLayer layer) {
 
   820         // check that m reads all modules in the layer
 
  1003         // check that m reads all modules in the layer
 
   821         layer.configuration().modules().stream()
 
  1004         layer.configuration().modules().stream()
 
   822             .map(ResolvedModule::name)
 
  1005             .map(ResolvedModule::name)
 
   823             .map(layer::findModule)
 
  1006             .map(layer::findModule)
 
   824             .map(Optional::get)
 
  1007             .map(Optional::get)
jdk-sandbox