langtools/test/tools/javac/modules/UpgradeModulePathTest.java
changeset 40308 274367a99f98
parent 39103 91a64ec5b970
child 40763 209113892b0d
equal deleted inserted replaced
40306:1a0fcaf3f2ed 40308:274367a99f98
    64         Path src = base.resolve("src");
    64         Path src = base.resolve("src");
    65         tb.writeJavaFiles(src, "module m2 { requires m1; }",
    65         tb.writeJavaFiles(src, "module m2 { requires m1; }",
    66                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
    66                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
    67 
    67 
    68         new JavacTask(tb, Task.Mode.CMDLINE)
    68         new JavacTask(tb, Task.Mode.CMDLINE)
    69                 .options("-modulepath", modules.toString(),
    69                 .options("--module-path", modules.toString(),
    70                         "-upgrademodulepath", upgradeModules.toString())
    70                         "--upgrade-module-path", upgradeModules.toString())
    71                 .files(findJavaFiles(src))
    71                 .files(findJavaFiles(src))
    72                 .run()
    72                 .run()
    73                 .writeAll();
    73                 .writeAll();
    74     }
    74     }
    75 
    75 
    90         Path src = base.resolve("src");
    90         Path src = base.resolve("src");
    91         tb.writeJavaFiles(src, "module m2 { requires m1; }",
    91         tb.writeJavaFiles(src, "module m2 { requires m1; }",
    92                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
    92                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
    93 
    93 
    94         new JavacTask(tb, Task.Mode.CMDLINE)
    94         new JavacTask(tb, Task.Mode.CMDLINE)
    95                 .options("-upgrademodulepath", upgradeModule + File.pathSeparator + module)
    95                 .options("--upgrade-module-path", upgradeModule + File.pathSeparator + module)
    96                 .files(findJavaFiles(src))
    96                 .files(findJavaFiles(src))
    97                 .run()
    97                 .run()
    98                 .writeAll();
    98                 .writeAll();
    99     }
    99     }
   100 
   100 
   124         Path src = base.resolve("src");
   124         Path src = base.resolve("src");
   125         tb.writeJavaFiles(src.resolve("m2"), "module m2 { requires m1; requires m3; }",
   125         tb.writeJavaFiles(src.resolve("m2"), "module m2 { requires m1; requires m3; }",
   126                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   126                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   127 
   127 
   128         new JavacTask(tb, Task.Mode.CMDLINE)
   128         new JavacTask(tb, Task.Mode.CMDLINE)
   129                 .options("-modulepath", module.toString(),
   129                 .options("--module-path", module.toString(),
   130                         "-modulesourcepath", src + File.pathSeparator + s,
   130                         "--module-source-path", src + File.pathSeparator + s,
   131                         "-upgrademodulepath", upgradeModule + File.pathSeparator + upgradeModule3)
   131                         "--upgrade-module-path", upgradeModule + File.pathSeparator + upgradeModule3)
   132                 .outdir(module)
   132                 .outdir(module)
   133                 .files(findJavaFiles(src))
   133                 .files(findJavaFiles(src))
   134                 .run()
   134                 .run()
   135                 .writeAll();
   135                 .writeAll();
   136     }
   136     }
   152         Path src = base.resolve("src");
   152         Path src = base.resolve("src");
   153         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   153         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   154                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   154                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   155 
   155 
   156         new JavacTask(tb, Task.Mode.CMDLINE)
   156         new JavacTask(tb, Task.Mode.CMDLINE)
   157                 .options("-modulepath", upgradeModule + File.pathSeparator + module,
   157                 .options("--module-path", upgradeModule + File.pathSeparator + module,
   158                         "-upgrademodulepath", upgradeModule.toString())
   158                         "--upgrade-module-path", upgradeModule.toString())
   159                 .files(findJavaFiles(src))
   159                 .files(findJavaFiles(src))
   160                 .run()
   160                 .run()
   161                 .writeAll();
   161                 .writeAll();
   162     }
   162     }
   163 
   163 
   176         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   176         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   177                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   177                 "package p; class A { void main() { pkg2.E.class.getName(); } }");
   178 
   178 
   179         String output = new JavacTask(tb, Task.Mode.CMDLINE)
   179         String output = new JavacTask(tb, Task.Mode.CMDLINE)
   180                 .options("-XDrawDiagnostics",
   180                 .options("-XDrawDiagnostics",
   181                         "-modulepath", module.toString(),
   181                         "--module-path", module.toString(),
   182                         "-upgrademodulepath", dummy.toString())
   182                         "--upgrade-module-path", dummy.toString())
   183                 .files(findJavaFiles(src))
   183                 .files(findJavaFiles(src))
   184                 .run(Task.Expect.FAIL)
   184                 .run(Task.Expect.FAIL)
   185                 .writeAll()
   185                 .writeAll()
   186                 .getOutput(Task.OutputKind.DIRECT);
   186                 .getOutput(Task.OutputKind.DIRECT);
   187         if (!output.contains("compiler.err.illegal.argument.for.option: -upgrademodulepath, " + dummy)) {
   187         if (!output.contains("compiler.err.illegal.argument.for.option: --upgrade-module-path, " + dummy)) {
   188             throw new Exception("Expected output was not found");
   188             throw new Exception("Expected output was not found");
   189         }
   189         }
   190     }
   190     }
   191 
   191 
   192     @Test
   192     @Test
   215         Path src = base.resolve("src");
   215         Path src = base.resolve("src");
   216         tb.writeJavaFiles(src, "module m4 { requires m1; requires m2; requires m3; }",
   216         tb.writeJavaFiles(src, "module m4 { requires m1; requires m2; requires m3; }",
   217                 "package p; class A { void main() { pkg1.A.class.getName(); pkg2.BC.class.getName(); pkg3.DC.class.getName(); } }");
   217                 "package p; class A { void main() { pkg1.A.class.getName(); pkg2.BC.class.getName(); pkg3.DC.class.getName(); } }");
   218 
   218 
   219         new JavacTask(tb, Task.Mode.CMDLINE)
   219         new JavacTask(tb, Task.Mode.CMDLINE)
   220                 .options("-modulepath", module.toString(),
   220                 .options("--module-path", module.toString(),
   221                         "-upgrademodulepath", upgradeModule.toString())
   221                         "--upgrade-module-path", upgradeModule.toString())
   222                 .files(findJavaFiles(src))
   222                 .files(findJavaFiles(src))
   223                 .run()
   223                 .run()
   224                 .writeAll();
   224                 .writeAll();
   225 
   225 
   226         Path src2 = base.resolve("src2");
   226         Path src2 = base.resolve("src2");
   227         tb.writeJavaFiles(src2, "module m4 { requires m1; }",
   227         tb.writeJavaFiles(src2, "module m4 { requires m1; }",
   228                 "package p; class A { void main() { pkg2.B.class.getName(); } }");
   228                 "package p; class A { void main() { pkg2.B.class.getName(); } }");
   229 
   229 
   230         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   230         String log = new JavacTask(tb, Task.Mode.CMDLINE)
   231                 .options("-XDrawDiagnostics",
   231                 .options("-XDrawDiagnostics",
   232                         "-modulepath", module.toString(),
   232                         "--module-path", module.toString(),
   233                         "-upgrademodulepath", upgradeModule.toString())
   233                         "--upgrade-module-path", upgradeModule.toString())
   234                 .files(findJavaFiles(src2))
   234                 .files(findJavaFiles(src2))
   235                 .run(Task.Expect.FAIL)
   235                 .run(Task.Expect.FAIL)
   236                 .writeAll()
   236                 .writeAll()
   237                 .getOutput(Task.OutputKind.DIRECT);
   237                 .getOutput(Task.OutputKind.DIRECT);
   238         if (!log.contains("compiler.err.doesnt.exist: pkg2")) {
   238         if (!log.contains("compiler.err.doesnt.exist: pkg2")) {
   263         Path src = base.resolve("src");
   263         Path src = base.resolve("src");
   264         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   264         tb.writeJavaFiles(src, "module m2 { requires m1; }",
   265                 "package p; class A { void main() { pkg2.EC2.class.getName(); } }");
   265                 "package p; class A { void main() { pkg2.EC2.class.getName(); } }");
   266 
   266 
   267         new JavacTask(tb, Task.Mode.CMDLINE)
   267         new JavacTask(tb, Task.Mode.CMDLINE)
   268                 .options("-modulepath", module.toString(),
   268                 .options("--module-path", module.toString(),
   269                         "-upgrademodulepath", upgradeModule1.toString(),
   269                         "--upgrade-module-path", upgradeModule1.toString(),
   270                         "-upgrademodulepath", upgradeModule2.toString())
   270                         "--upgrade-module-path", upgradeModule2.toString())
   271                 .files(findJavaFiles(src))
   271                 .files(findJavaFiles(src))
   272                 .run()
   272                 .run()
   273                 .writeAll();
   273                 .writeAll();
   274 
   274 
   275         Path src2 = base.resolve("src2");
   275         Path src2 = base.resolve("src2");
   276         tb.writeJavaFiles(src2, "module m2 { requires m1; }",
   276         tb.writeJavaFiles(src2, "module m2 { requires m1; }",
   277                 "package p; class A { void main() { pkg2.EC1.class.getName(); } }");
   277                 "package p; class A { void main() { pkg2.EC1.class.getName(); } }");
   278 
   278 
   279         final String log = new JavacTask(tb, Task.Mode.CMDLINE)
   279         final String log = new JavacTask(tb, Task.Mode.CMDLINE)
   280                 .options("-XDrawDiagnostics",
   280                 .options("-XDrawDiagnostics",
   281                         "-modulepath", module.toString(),
   281                         "--module-path", module.toString(),
   282                         "-upgrademodulepath", upgradeModule1.toString(),
   282                         "--upgrade-module-path", upgradeModule1.toString(),
   283                         "-upgrademodulepath", upgradeModule2.toString())
   283                         "--upgrade-module-path", upgradeModule2.toString())
   284                 .files(findJavaFiles(src2))
   284                 .files(findJavaFiles(src2))
   285                 .run(Task.Expect.FAIL)
   285                 .run(Task.Expect.FAIL)
   286                 .writeAll()
   286                 .writeAll()
   287                 .getOutput(Task.OutputKind.DIRECT);
   287                 .getOutput(Task.OutputKind.DIRECT);
   288 
   288