< prev index next >

langtools/test/tools/jdeps/modules/CheckModuleTest.java

Print this page




  61     /**
  62      * Compiles classes used by the test
  63      */
  64     @BeforeTest
  65     public void compileAll() throws Exception {
  66         CompilerUtils.cleanDir(MODS_DIR);
  67         modules.forEach(mn ->
  68             assertTrue(CompilerUtils.compileModule(SRC_DIR, MODS_DIR, mn)));
  69     }
  70 
  71     @DataProvider(name = "javaBase")
  72     public Object[][] base() {
  73         return new Object[][] {
  74             { JAVA_BASE, new ModuleMetaData(JAVA_BASE)
  75             },
  76         };
  77     };
  78 
  79     @Test(dataProvider = "javaBase")
  80     public void testJavaBase(String name, ModuleMetaData data) throws Exception {
  81         String cmd = String.format("jdeps -check %s -mp %s%n", name, MODS_DIR);
  82         try (JdepsUtil.Command jdeps = JdepsUtil.newCommand(cmd)) {
  83             jdeps.appModulePath(MODS_DIR.toString());
  84 
  85             ModuleAnalyzer analyzer = jdeps.getModuleAnalyzer(Set.of(name));
  86             assertTrue(analyzer.run());
  87             jdeps.dumpOutput(System.err);
  88 
  89             ModuleDescriptor[] descriptors = analyzer.descriptors(name);
  90             for (int i = 0; i < 3; i++) {
  91                 descriptors[i].requires().stream()
  92                     .forEach(req -> data.checkRequires(req));
  93             }
  94         }
  95     }
  96 
  97     @DataProvider(name = "modules")
  98     public Object[][] unnamed() {
  99         return new Object[][]{
 100             { "m4", new ModuleMetaData[] {
 101                         // original


 120                             .requires("java.sql")
 121                             .requiresPublic("m4"),
 122                         // suggested version
 123                         new ModuleMetaData("m5")
 124                             .requiresPublic("java.compiler")
 125                             .requires("java.logging")
 126                             .requiresPublic("java.sql")
 127                             .requiresPublic("m4"),
 128                         // reduced version
 129                         new ModuleMetaData("m5")
 130                             .requiresPublic("java.compiler")
 131                             .requiresPublic("java.sql")
 132                             .requiresPublic("m4"),
 133                     }
 134             },
 135         };
 136     }
 137 
 138     @Test(dataProvider = "modules")
 139     public void modularTest(String name, ModuleMetaData[] data) throws Exception {
 140         String cmd = String.format("jdeps -check %s -mp %s%n", name, MODS_DIR);
 141 
 142         try (JdepsUtil.Command jdeps = JdepsUtil.newCommand(cmd)) {
 143             jdeps.appModulePath(MODS_DIR.toString());
 144 
 145             ModuleAnalyzer analyzer = jdeps.getModuleAnalyzer(Set.of(name));
 146             assertTrue(analyzer.run());
 147             jdeps.dumpOutput(System.err);
 148 
 149             // compare the module descriptors and the suggested versions
 150             ModuleDescriptor[] descriptors = analyzer.descriptors(name);
 151             for (int i = 0; i < 3; i++) {
 152                 ModuleMetaData metaData = data[i];
 153                 descriptors[i].requires().stream()
 154                     .forEach(req -> metaData.checkRequires(req));
 155             }
 156 
 157             Map<String, Set<String>> unused = analyzer.unusedQualifiedExports(name);
 158             // verify unuused qualified exports
 159             assertEquals(unused, data[0].exports);
 160         }


  61     /**
  62      * Compiles classes used by the test
  63      */
  64     @BeforeTest
  65     public void compileAll() throws Exception {
  66         CompilerUtils.cleanDir(MODS_DIR);
  67         modules.forEach(mn ->
  68             assertTrue(CompilerUtils.compileModule(SRC_DIR, MODS_DIR, mn)));
  69     }
  70 
  71     @DataProvider(name = "javaBase")
  72     public Object[][] base() {
  73         return new Object[][] {
  74             { JAVA_BASE, new ModuleMetaData(JAVA_BASE)
  75             },
  76         };
  77     };
  78 
  79     @Test(dataProvider = "javaBase")
  80     public void testJavaBase(String name, ModuleMetaData data) throws Exception {
  81         String cmd = String.format("jdeps --check %s --module-path %s%n", name, MODS_DIR);
  82         try (JdepsUtil.Command jdeps = JdepsUtil.newCommand(cmd)) {
  83             jdeps.appModulePath(MODS_DIR.toString());
  84 
  85             ModuleAnalyzer analyzer = jdeps.getModuleAnalyzer(Set.of(name));
  86             assertTrue(analyzer.run());
  87             jdeps.dumpOutput(System.err);
  88 
  89             ModuleDescriptor[] descriptors = analyzer.descriptors(name);
  90             for (int i = 0; i < 3; i++) {
  91                 descriptors[i].requires().stream()
  92                     .forEach(req -> data.checkRequires(req));
  93             }
  94         }
  95     }
  96 
  97     @DataProvider(name = "modules")
  98     public Object[][] unnamed() {
  99         return new Object[][]{
 100             { "m4", new ModuleMetaData[] {
 101                         // original


 120                             .requires("java.sql")
 121                             .requiresPublic("m4"),
 122                         // suggested version
 123                         new ModuleMetaData("m5")
 124                             .requiresPublic("java.compiler")
 125                             .requires("java.logging")
 126                             .requiresPublic("java.sql")
 127                             .requiresPublic("m4"),
 128                         // reduced version
 129                         new ModuleMetaData("m5")
 130                             .requiresPublic("java.compiler")
 131                             .requiresPublic("java.sql")
 132                             .requiresPublic("m4"),
 133                     }
 134             },
 135         };
 136     }
 137 
 138     @Test(dataProvider = "modules")
 139     public void modularTest(String name, ModuleMetaData[] data) throws Exception {
 140         String cmd = String.format("jdeps --check %s --module-path %s%n", name, MODS_DIR);
 141 
 142         try (JdepsUtil.Command jdeps = JdepsUtil.newCommand(cmd)) {
 143             jdeps.appModulePath(MODS_DIR.toString());
 144 
 145             ModuleAnalyzer analyzer = jdeps.getModuleAnalyzer(Set.of(name));
 146             assertTrue(analyzer.run());
 147             jdeps.dumpOutput(System.err);
 148 
 149             // compare the module descriptors and the suggested versions
 150             ModuleDescriptor[] descriptors = analyzer.descriptors(name);
 151             for (int i = 0; i < 3; i++) {
 152                 ModuleMetaData metaData = data[i];
 153                 descriptors[i].requires().stream()
 154                     .forEach(req -> metaData.checkRequires(req));
 155             }
 156 
 157             Map<String, Set<String>> unused = analyzer.unusedQualifiedExports(name);
 158             // verify unuused qualified exports
 159             assertEquals(unused, data[0].exports);
 160         }
< prev index next >