langtools/test/tools/javac/modules/ModulePathTest.java
changeset 40308 274367a99f98
parent 39103 91a64ec5b970
child 41521 9f45ffccd1c8
equal deleted inserted replaced
40306:1a0fcaf3f2ed 40308:274367a99f98
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 
    23 
    24 /*
    24 /*
    25  * @test
    25  * @test
    26  * @summary tests for -modulepath
    26  * @summary tests for --module-path
    27  * @library /tools/lib
    27  * @library /tools/lib
    28  * @modules
    28  * @modules
    29  *      jdk.compiler/com.sun.tools.javac.api
    29  *      jdk.compiler/com.sun.tools.javac.api
    30  *      jdk.compiler/com.sun.tools.javac.main
    30  *      jdk.compiler/com.sun.tools.javac.main
    31  *      jdk.jdeps/com.sun.tools.javap
    31  *      jdk.jdeps/com.sun.tools.javap
    60         Path src = base.resolve("src");
    60         Path src = base.resolve("src");
    61         tb.writeJavaFiles(src, "class C { }");
    61         tb.writeJavaFiles(src, "class C { }");
    62 
    62 
    63         String log = new JavacTask(tb, Task.Mode.CMDLINE)
    63         String log = new JavacTask(tb, Task.Mode.CMDLINE)
    64                 .options("-XDrawDiagnostics",
    64                 .options("-XDrawDiagnostics",
    65                         "-modulepath", "doesNotExist")
    65                         "--module-path", "doesNotExist")
    66                 .files(findJavaFiles(src))
    66                 .files(findJavaFiles(src))
    67                 .run(Task.Expect.FAIL)
    67                 .run(Task.Expect.FAIL)
    68                 .writeAll()
    68                 .writeAll()
    69                 .getOutput(Task.OutputKind.DIRECT);
    69                 .getOutput(Task.OutputKind.DIRECT);
    70 
    70 
    71         if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, doesNotExist"))
    71         if (!log.contains("- compiler.err.illegal.argument.for.option: --module-path, doesNotExist"))
    72             throw new Exception("expected output not found");
    72             throw new Exception("expected output not found");
    73     }
    73     }
    74 
    74 
    75     @Test
    75     @Test
    76     public void testNotADirOnPath_1(Path base) throws Exception {
    76     public void testNotADirOnPath_1(Path base) throws Exception {
    78         tb.writeJavaFiles(src, "class C { }");
    78         tb.writeJavaFiles(src, "class C { }");
    79         tb.writeFile("dummy.txt", "");
    79         tb.writeFile("dummy.txt", "");
    80 
    80 
    81         String log = new JavacTask(tb, Task.Mode.CMDLINE)
    81         String log = new JavacTask(tb, Task.Mode.CMDLINE)
    82                 .options("-XDrawDiagnostics",
    82                 .options("-XDrawDiagnostics",
    83                         "-modulepath", "dummy.txt")
    83                         "--module-path", "dummy.txt")
    84                 .files(findJavaFiles(src))
    84                 .files(findJavaFiles(src))
    85                 .run(Task.Expect.FAIL)
    85                 .run(Task.Expect.FAIL)
    86                 .writeAll()
    86                 .writeAll()
    87                 .getOutput(Task.OutputKind.DIRECT);
    87                 .getOutput(Task.OutputKind.DIRECT);
    88 
    88 
    89         if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.txt"))
    89         if (!log.contains("- compiler.err.illegal.argument.for.option: --module-path, dummy.txt"))
    90             throw new Exception("expected output not found");
    90             throw new Exception("expected output not found");
    91     }
    91     }
    92 
    92 
    93     @Test
    93     @Test
    94     public void testNotADirOnPath_2(Path base) throws Exception {
    94     public void testNotADirOnPath_2(Path base) throws Exception {
    96         tb.writeJavaFiles(src, "class C { }");
    96         tb.writeJavaFiles(src, "class C { }");
    97         tb.writeFile("dummy.jimage", "");
    97         tb.writeFile("dummy.jimage", "");
    98 
    98 
    99         String log = new JavacTask(tb, Task.Mode.CMDLINE)
    99         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   100                 .options("-XDrawDiagnostics",
   100                 .options("-XDrawDiagnostics",
   101                         "-modulepath", "dummy.jimage")
   101                         "--module-path", "dummy.jimage")
   102                 .files(findJavaFiles(src))
   102                 .files(findJavaFiles(src))
   103                 .run(Task.Expect.FAIL)
   103                 .run(Task.Expect.FAIL)
   104                 .writeAll()
   104                 .writeAll()
   105                 .getOutput(Task.OutputKind.DIRECT);
   105                 .getOutput(Task.OutputKind.DIRECT);
   106 
   106 
   107         if (!log.contains("- compiler.err.illegal.argument.for.option: -modulepath, dummy.jimage"))
   107         if (!log.contains("- compiler.err.illegal.argument.for.option: --module-path, dummy.jimage"))
   108             throw new Exception("expected output not found");
   108             throw new Exception("expected output not found");
   109     }
   109     }
   110 
   110 
   111     @Test
   111     @Test
   112     public void testExplodedModuleOnPath(Path base) throws Exception {
   112     public void testExplodedModuleOnPath(Path base) throws Exception {
   130         Path classes = base.resolve("classes");
   130         Path classes = base.resolve("classes");
   131         Files.createDirectories(classes);
   131         Files.createDirectories(classes);
   132 
   132 
   133         new JavacTask(tb, Task.Mode.CMDLINE)
   133         new JavacTask(tb, Task.Mode.CMDLINE)
   134                 .outdir(classes)
   134                 .outdir(classes)
   135                 .options("-modulepath", modClasses.toString())
   135                 .options("--module-path", modClasses.toString())
   136                 .files(findJavaFiles(src))
   136                 .files(findJavaFiles(src))
   137                 .run()
   137                 .run()
   138                 .writeAll();
   138                 .writeAll();
   139     }
   139     }
   140 
   140 
   151         Files.createDirectories(classes);
   151         Files.createDirectories(classes);
   152 
   152 
   153         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   153         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   154                 .outdir(classes)
   154                 .outdir(classes)
   155                 .options("-XDrawDiagnostics",
   155                 .options("-XDrawDiagnostics",
   156                         "-modulepath", modClasses.toString())
   156                         "--module-path", modClasses.toString())
   157                 .files(findJavaFiles(src))
   157                 .files(findJavaFiles(src))
   158                 .run(Task.Expect.FAIL)
   158                 .run(Task.Expect.FAIL)
   159                 .writeAll()
   159                 .writeAll()
   160                 .getOutput(Task.OutputKind.DIRECT);
   160                 .getOutput(Task.OutputKind.DIRECT);
   161 
   161 
   188         Path classes = base.resolve("classes");
   188         Path classes = base.resolve("classes");
   189         Files.createDirectories(classes);
   189         Files.createDirectories(classes);
   190 
   190 
   191         new JavacTask(tb, Task.Mode.CMDLINE)
   191         new JavacTask(tb, Task.Mode.CMDLINE)
   192                 .outdir(classes)
   192                 .outdir(classes)
   193                 .options("-modulepath", moduleJar.toString(), "-addmods", "m1")
   193                 .options("--module-path", moduleJar.toString(), "--add-modules", "m1")
   194                 .files(findJavaFiles(src))
   194                 .files(findJavaFiles(src))
   195                 .run()
   195                 .run()
   196                 .writeAll();
   196                 .writeAll();
   197     }
   197     }
   198 
   198 
   224         Path classes = base.resolve("classes");
   224         Path classes = base.resolve("classes");
   225         Files.createDirectories(classes);
   225         Files.createDirectories(classes);
   226 
   226 
   227         new JavacTask(tb, Task.Mode.CMDLINE)
   227         new JavacTask(tb, Task.Mode.CMDLINE)
   228                 .outdir(classes)
   228                 .outdir(classes)
   229                 .options("-modulepath", moduleJar.toString())
   229                 .options("--module-path", moduleJar.toString())
   230                 .files(findJavaFiles(src))
   230                 .files(findJavaFiles(src))
   231                 .run()
   231                 .run()
   232                 .writeAll();
   232                 .writeAll();
   233     }
   233     }
   234 
   234 
   238         tb.writeJavaFiles(src, "class C { }");
   238         tb.writeJavaFiles(src, "class C { }");
   239         tb.writeFile("dummy.jar", "");
   239         tb.writeFile("dummy.jar", "");
   240 
   240 
   241         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   241         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   242                 .options("-XDrawDiagnostics",
   242                 .options("-XDrawDiagnostics",
   243                         "-modulepath", "dummy.jar")
   243                         "--module-path", "dummy.jar")
   244                 .files(findJavaFiles(src))
   244                 .files(findJavaFiles(src))
   245                 .run(Task.Expect.FAIL)
   245                 .run(Task.Expect.FAIL)
   246                 .writeAll()
   246                 .writeAll()
   247                 .getOutput(Task.OutputKind.DIRECT);
   247                 .getOutput(Task.OutputKind.DIRECT);
   248 
   248 
   275         Path classes = base.resolve("classes");
   275         Path classes = base.resolve("classes");
   276         Files.createDirectories(classes);
   276         Files.createDirectories(classes);
   277 
   277 
   278         new JavacTask(tb, Task.Mode.CMDLINE)
   278         new JavacTask(tb, Task.Mode.CMDLINE)
   279                 .outdir(classes)
   279                 .outdir(classes)
   280                 .options("-modulepath", jmod.toString())
   280                 .options("--module-path", jmod.toString())
   281                 .files(findJavaFiles(src))
   281                 .files(findJavaFiles(src))
   282                 .run()
   282                 .run()
   283                 .writeAll();
   283                 .writeAll();
   284     }
   284     }
   285 
   285 
   289         tb.writeJavaFiles(src, "class C { }");
   289         tb.writeJavaFiles(src, "class C { }");
   290         tb.writeFile("dummy.jmod", "");
   290         tb.writeFile("dummy.jmod", "");
   291 
   291 
   292         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   292         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   293                 .options("-XDrawDiagnostics",
   293                 .options("-XDrawDiagnostics",
   294                         "-modulepath", "dummy.jmod")
   294                         "--module-path", "dummy.jmod")
   295                 .files(findJavaFiles(src))
   295                 .files(findJavaFiles(src))
   296                 .run(Task.Expect.FAIL)
   296                 .run(Task.Expect.FAIL)
   297                 .writeAll()
   297                 .writeAll()
   298                 .getOutput(Task.OutputKind.DIRECT);
   298                 .getOutput(Task.OutputKind.DIRECT);
   299 
   299 
   309         Path src = base.resolve("src");
   309         Path src = base.resolve("src");
   310         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   310         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   311 
   311 
   312         new JavacTask(tb, Task.Mode.CMDLINE)
   312         new JavacTask(tb, Task.Mode.CMDLINE)
   313                 .options("-XDrawDiagnostics",
   313                 .options("-XDrawDiagnostics",
   314                         "-modulepath", modules + "/./../modules")
   314                         "--module-path", modules + "/./../modules")
   315                 .files(findJavaFiles(src))
   315                 .files(findJavaFiles(src))
   316                 .run()
   316                 .run()
   317                 .writeAll();
   317                 .writeAll();
   318     }
   318     }
   319 
   319 
   325         Path src = base.resolve("src");
   325         Path src = base.resolve("src");
   326         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   326         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   327 
   327 
   328         new JavacTask(tb, Task.Mode.CMDLINE)
   328         new JavacTask(tb, Task.Mode.CMDLINE)
   329                 .options("-XDrawDiagnostics",
   329                 .options("-XDrawDiagnostics",
   330                         "-modulepath", modules + "/./../modules" + PATH_SEP + modules)
   330                         "--module-path", modules + "/./../modules" + PATH_SEP + modules)
   331                 .files(findJavaFiles(src))
   331                 .files(findJavaFiles(src))
   332                 .run()
   332                 .run()
   333                 .writeAll();
   333                 .writeAll();
   334     }
   334     }
   335 
   335 
   341         Path src = base.resolve("src");
   341         Path src = base.resolve("src");
   342         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   342         tb.writeJavaFiles(src, "module m2 { requires m1; }", "class A { }");
   343 
   343 
   344         new JavacTask(tb, Task.Mode.CMDLINE)
   344         new JavacTask(tb, Task.Mode.CMDLINE)
   345                 .options("-XDrawDiagnostics",
   345                 .options("-XDrawDiagnostics",
   346                         "-modulepath", modules.toString(),
   346                         "--module-path", modules.toString(),
   347                         "-modulepath", modules.toString())
   347                         "--module-path", modules.toString())
   348                 .files(findJavaFiles(src))
   348                 .files(findJavaFiles(src))
   349                 .run()
   349                 .run()
   350                 .writeAll();
   350                 .writeAll();
   351     }
   351     }
   352 
   352 
   368         Path src = base.resolve("src");
   368         Path src = base.resolve("src");
   369         tb.writeJavaFiles(src, "module m2 { requires m1; }", " package p; class A { void main() { pkg2.E.class.getName(); } }");
   369         tb.writeJavaFiles(src, "module m2 { requires m1; }", " package p; class A { void main() { pkg2.E.class.getName(); } }");
   370 
   370 
   371         new JavacTask(tb, Task.Mode.CMDLINE)
   371         new JavacTask(tb, Task.Mode.CMDLINE)
   372                 .options("-XDrawDiagnostics",
   372                 .options("-XDrawDiagnostics",
   373                         "-modulepath", deepModuleDir + PATH_SEP + modules)
   373                         "--module-path", deepModuleDir + PATH_SEP + modules)
   374                 .files(findJavaFiles(src))
   374                 .files(findJavaFiles(src))
   375                 .run()
   375                 .run()
   376                 .writeAll();
   376                 .writeAll();
   377     }
   377     }
   378 
   378 
   398         tb.writeJavaFiles(src, "module m { requires m3; requires m2; requires m1; }",
   398         tb.writeJavaFiles(src, "module m { requires m3; requires m2; requires m1; }",
   399                 "package p; class A { void main() { one.A.class.getName(); } }");
   399                 "package p; class A { void main() { one.A.class.getName(); } }");
   400 
   400 
   401         new JavacTask(tb, Task.Mode.CMDLINE)
   401         new JavacTask(tb, Task.Mode.CMDLINE)
   402                 .options("-XDrawDiagnostics",
   402                 .options("-XDrawDiagnostics",
   403                         "-modulepath", modules.toString())
   403                         "--module-path", modules.toString())
   404                 .files(findJavaFiles(src))
   404                 .files(findJavaFiles(src))
   405                 .run()
   405                 .run()
   406                 .writeAll();
   406                 .writeAll();
   407     }
   407     }
   408 
   408