< prev index next >

test/tools/javac/modules/ModulesAndClassPathTest.java

Print this page




  41 import javax.annotation.processing.AbstractProcessor;
  42 import javax.annotation.processing.RoundEnvironment;
  43 import javax.annotation.processing.SupportedAnnotationTypes;
  44 import javax.lang.model.element.TypeElement;
  45 
  46 import toolbox.JarTask;
  47 import toolbox.JavacTask;
  48 import toolbox.Task;
  49 
  50 public class ModulesAndClassPathTest extends ModuleTestBase {
  51 
  52     public static void main(String... args) throws Exception {
  53         new ModulesAndClassPathTest().runTests();
  54     }
  55 
  56     @Test
  57     public void testModulesAndClassPath(Path base) throws Exception {
  58         Path jar = prepareTestJar(base);
  59 
  60         Path moduleSrc = base.resolve("module-src");
  61         Path m1 = moduleSrc.resolve("m1");
  62 
  63         Path classes = base.resolve("classes");
  64 
  65         Files.createDirectories(classes);
  66 
  67         tb.writeJavaFiles(m1,
  68                           "module m1 { }",
  69                           "package impl; public class Impl { api.Api api; }");
  70 
  71         List<String> modLog = new JavacTask(tb)
  72                                 .options("--class-path", jar.toString(),
  73                                          "-XDrawDiagnostics")
  74                                 .outdir(classes)
  75                                 .files(findJavaFiles(moduleSrc))
  76                                 .run(Task.Expect.FAIL)
  77                                 .writeAll()
  78                                 .getOutputLines(Task.OutputKind.DIRECT);
  79 
  80         List<String> expected = Arrays.asList("Impl.java:1:38: compiler.err.doesnt.exist: api",
  81                                               "1 error");
  82 
  83         if (!expected.equals(modLog)) {
  84             throw new Exception("unexpected output: " + modLog);
  85         }
  86 
  87         new JavacTask(tb)
  88           .options("--class-path", jar.toString(),
  89                    "--add-reads", "m1=ALL-UNNAMED")
  90           .outdir(classes)
  91           .files(findJavaFiles(moduleSrc))
  92           .run()
  93           .writeAll()
  94           .getOutputLines(Task.OutputKind.DIRECT);
  95 
  96         new JavacTask(tb)
  97           .options("--class-path", jar.toString() + File.pathSeparator + System.getProperty("test.classes"),
  98                    "--add-reads", "m1=ALL-UNNAMED",
  99                    "-processor", ProcessorImpl.class.getName())
 100           .outdir(classes)
 101           .files(findJavaFiles(moduleSrc))
 102           .run()
 103           .writeAll()
 104           .getOutputLines(Task.OutputKind.DIRECT);
 105     }
 106 
 107     @Test
 108     public void testImplicitSourcePathModuleInfo(Path base) throws Exception {
 109         Path jar = prepareTestJar(base);
 110 
 111         Path moduleSrc = base.resolve("module-src");
 112         Path m1 = moduleSrc.resolve("m1");
 113 
 114         Path classes = base.resolve("classes");
 115 
 116         Files.createDirectories(classes);
 117 
 118         tb.writeJavaFiles(m1,
 119                           "module m1 { }",
 120                           "package impl; public class Impl { api.Api api; }");
 121 
 122         List<String> modLog = new JavacTask(tb)
 123                                 .options("--class-path", jar.toString(),
 124                                          "-sourcepath", m1.toString(),
 125                                          "-XDrawDiagnostics")
 126                                 .outdir(classes)
 127                                 .files(m1.resolve("impl").resolve("Impl.java"))
 128                                 .run(Task.Expect.FAIL)
 129                                 .writeAll()
 130                                 .getOutputLines(Task.OutputKind.DIRECT);
 131 
 132         List<String> expected = Arrays.asList("Impl.java:1:38: compiler.err.doesnt.exist: api",
 133                                               "1 error");
 134 
 135         if (!expected.equals(modLog)) {
 136             throw new Exception("unexpected output: " + modLog);
 137         }
 138     }
 139 
 140     @Test
 141     public void testModuleInfoFromOutput(Path base) throws Exception {
 142         Path jar = prepareTestJar(base);
 143 
 144         Path moduleSrc = base.resolve("module-src");
 145         Path m1 = moduleSrc.resolve("m1");
 146 
 147         Path classes = base.resolve("classes");
 148 
 149         Files.createDirectories(classes);
 150 
 151         tb.writeJavaFiles(m1,
 152                           "module m1 { }",
 153                           "package impl; public class Impl { api.Api api; }");
 154 
 155         new JavacTask(tb)
 156           .options("--class-path", jar.toString(),
 157                    "-XDrawDiagnostics")
 158           .outdir(classes)
 159           .files(m1.resolve("module-info.java"))
 160           .run()
 161           .writeAll()
 162           .getOutputLines(Task.OutputKind.DIRECT);
 163 
 164         List<String> modLog = new JavacTask(tb)
 165                                 .options("--class-path", jar.toString(),
 166                                          "-XDrawDiagnostics")
 167                                 .outdir(classes)
 168                                 .files(m1.resolve("impl").resolve("Impl.java"))
 169                                 .run(Task.Expect.FAIL)
 170                                 .writeAll()
 171                                 .getOutputLines(Task.OutputKind.DIRECT);
 172 


 205 
 206         new JarTask(tb, jar)
 207           .baseDir(legacyClasses)
 208           .files("api/Api.class")
 209           .run();
 210 
 211         return jar;
 212     }
 213 
 214     @SupportedAnnotationTypes("*")
 215     public static class ProcessorImpl extends AbstractProcessor {
 216         @Override
 217         public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 218             return false;
 219         }
 220     }
 221 
 222     @Test
 223     public void testClassOutputVisibleForIncrementalCompilation(Path base) throws Exception {
 224         Path moduleSrc = base.resolve("module-src");
 225         Path m1 = moduleSrc.resolve("m1");
 226 
 227         Path classes = base.resolve("classes");
 228 
 229         Files.createDirectories(classes);
 230 
 231         tb.writeJavaFiles(m1,
 232                           "module m1 { exports impl; }",
 233                           "package impl; public class Impl { }",
 234                           "package src; public class Src { }",
 235                           "package test; public class TestCP extends impl.Impl { }",
 236                           "package test; public class TestSP extends src.Src { }");
 237 
 238         new JavacTask(tb)
 239           .outdir(classes)
 240           .files(m1.resolve("impl").resolve("Impl.java"))
 241           .run()
 242           .writeAll()
 243           .getOutputLines(Task.OutputKind.DIRECT);
 244 
 245         new JavacTask(tb)
 246           .outdir(classes)
 247           .files(m1.resolve("module-info.java"))
 248           .run()
 249           .writeAll()
 250           .getOutputLines(Task.OutputKind.DIRECT);
 251 
 252         new JavacTask(tb)


  41 import javax.annotation.processing.AbstractProcessor;
  42 import javax.annotation.processing.RoundEnvironment;
  43 import javax.annotation.processing.SupportedAnnotationTypes;
  44 import javax.lang.model.element.TypeElement;
  45 
  46 import toolbox.JarTask;
  47 import toolbox.JavacTask;
  48 import toolbox.Task;
  49 
  50 public class ModulesAndClassPathTest extends ModuleTestBase {
  51 
  52     public static void main(String... args) throws Exception {
  53         new ModulesAndClassPathTest().runTests();
  54     }
  55 
  56     @Test
  57     public void testModulesAndClassPath(Path base) throws Exception {
  58         Path jar = prepareTestJar(base);
  59 
  60         Path moduleSrc = base.resolve("module-src");
  61         Path m1 = moduleSrc.resolve("m");
  62 
  63         Path classes = base.resolve("classes");
  64 
  65         Files.createDirectories(classes);
  66 
  67         tb.writeJavaFiles(m1,
  68                           "module m { }",
  69                           "package impl; public class Impl { api.Api api; }");
  70 
  71         List<String> modLog = new JavacTask(tb)
  72                                 .options("--class-path", jar.toString(),
  73                                          "-XDrawDiagnostics")
  74                                 .outdir(classes)
  75                                 .files(findJavaFiles(moduleSrc))
  76                                 .run(Task.Expect.FAIL)
  77                                 .writeAll()
  78                                 .getOutputLines(Task.OutputKind.DIRECT);
  79 
  80         List<String> expected = Arrays.asList("Impl.java:1:38: compiler.err.doesnt.exist: api",
  81                                               "1 error");
  82 
  83         if (!expected.equals(modLog)) {
  84             throw new Exception("unexpected output: " + modLog);
  85         }
  86 
  87         new JavacTask(tb)
  88           .options("--class-path", jar.toString(),
  89                    "--add-reads", "m=ALL-UNNAMED")
  90           .outdir(classes)
  91           .files(findJavaFiles(moduleSrc))
  92           .run()
  93           .writeAll()
  94           .getOutputLines(Task.OutputKind.DIRECT);
  95 
  96         new JavacTask(tb)
  97           .options("--class-path", jar.toString() + File.pathSeparator + System.getProperty("test.classes"),
  98                    "--add-reads", "m=ALL-UNNAMED",
  99                    "-processor", ProcessorImpl.class.getName())
 100           .outdir(classes)
 101           .files(findJavaFiles(moduleSrc))
 102           .run()
 103           .writeAll()
 104           .getOutputLines(Task.OutputKind.DIRECT);
 105     }
 106 
 107     @Test
 108     public void testImplicitSourcePathModuleInfo(Path base) throws Exception {
 109         Path jar = prepareTestJar(base);
 110 
 111         Path moduleSrc = base.resolve("module-src");
 112         Path m1 = moduleSrc.resolve("m");
 113 
 114         Path classes = base.resolve("classes");
 115 
 116         Files.createDirectories(classes);
 117 
 118         tb.writeJavaFiles(m1,
 119                           "module m { }",
 120                           "package impl; public class Impl { api.Api api; }");
 121 
 122         List<String> modLog = new JavacTask(tb)
 123                                 .options("--class-path", jar.toString(),
 124                                          "-sourcepath", m1.toString(),
 125                                          "-XDrawDiagnostics")
 126                                 .outdir(classes)
 127                                 .files(m1.resolve("impl").resolve("Impl.java"))
 128                                 .run(Task.Expect.FAIL)
 129                                 .writeAll()
 130                                 .getOutputLines(Task.OutputKind.DIRECT);
 131 
 132         List<String> expected = Arrays.asList("Impl.java:1:38: compiler.err.doesnt.exist: api",
 133                                               "1 error");
 134 
 135         if (!expected.equals(modLog)) {
 136             throw new Exception("unexpected output: " + modLog);
 137         }
 138     }
 139 
 140     @Test
 141     public void testModuleInfoFromOutput(Path base) throws Exception {
 142         Path jar = prepareTestJar(base);
 143 
 144         Path moduleSrc = base.resolve("module-src");
 145         Path m1 = moduleSrc.resolve("m");
 146 
 147         Path classes = base.resolve("classes");
 148 
 149         Files.createDirectories(classes);
 150 
 151         tb.writeJavaFiles(m1,
 152                           "module m { }",
 153                           "package impl; public class Impl { api.Api api; }");
 154 
 155         new JavacTask(tb)
 156           .options("--class-path", jar.toString(),
 157                    "-XDrawDiagnostics")
 158           .outdir(classes)
 159           .files(m1.resolve("module-info.java"))
 160           .run()
 161           .writeAll()
 162           .getOutputLines(Task.OutputKind.DIRECT);
 163 
 164         List<String> modLog = new JavacTask(tb)
 165                                 .options("--class-path", jar.toString(),
 166                                          "-XDrawDiagnostics")
 167                                 .outdir(classes)
 168                                 .files(m1.resolve("impl").resolve("Impl.java"))
 169                                 .run(Task.Expect.FAIL)
 170                                 .writeAll()
 171                                 .getOutputLines(Task.OutputKind.DIRECT);
 172 


 205 
 206         new JarTask(tb, jar)
 207           .baseDir(legacyClasses)
 208           .files("api/Api.class")
 209           .run();
 210 
 211         return jar;
 212     }
 213 
 214     @SupportedAnnotationTypes("*")
 215     public static class ProcessorImpl extends AbstractProcessor {
 216         @Override
 217         public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 218             return false;
 219         }
 220     }
 221 
 222     @Test
 223     public void testClassOutputVisibleForIncrementalCompilation(Path base) throws Exception {
 224         Path moduleSrc = base.resolve("module-src");
 225         Path m1 = moduleSrc.resolve("m");
 226 
 227         Path classes = base.resolve("classes");
 228 
 229         Files.createDirectories(classes);
 230 
 231         tb.writeJavaFiles(m1,
 232                           "module m { exports impl; }",
 233                           "package impl; public class Impl { }",
 234                           "package src; public class Src { }",
 235                           "package test; public class TestCP extends impl.Impl { }",
 236                           "package test; public class TestSP extends src.Src { }");
 237 
 238         new JavacTask(tb)
 239           .outdir(classes)
 240           .files(m1.resolve("impl").resolve("Impl.java"))
 241           .run()
 242           .writeAll()
 243           .getOutputLines(Task.OutputKind.DIRECT);
 244 
 245         new JavacTask(tb)
 246           .outdir(classes)
 247           .files(m1.resolve("module-info.java"))
 248           .run()
 249           .writeAll()
 250           .getOutputLines(Task.OutputKind.DIRECT);
 251 
 252         new JavacTask(tb)
< prev index next >