1 /*
2 * Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 8192920 8204588 8246774 8248843 8268869 8235876
27 * @summary Test source launcher
28 * @library /tools/lib
29 * @enablePreview
30 * @modules jdk.compiler/com.sun.tools.javac.api
31 * jdk.compiler/com.sun.tools.javac.launcher
32 * jdk.compiler/com.sun.tools.javac.main
33 * java.base/jdk.internal.classfile.impl
34 * java.base/jdk.internal.module
35 * @build toolbox.JavaTask toolbox.JavacTask toolbox.TestRunner toolbox.ToolBox
36 * @run main SourceLauncherTest
37 * @ignore Verifier error
38 */
39
40 import java.lang.classfile.*;
41 import java.lang.classfile.attribute.ModuleResolutionAttribute;
42 import java.io.ByteArrayOutputStream;
43 import java.io.File;
44 import java.io.IOException;
45 import java.io.OutputStream;
46 import java.io.PrintStream;
47 import java.io.PrintWriter;
48 import java.io.StringWriter;
49 import java.lang.reflect.InvocationTargetException;
50 import java.nio.file.Files;
51 import java.nio.file.Path;
52 import java.nio.file.Paths;
53 import java.util.ArrayList;
54 import java.util.Collections;
55 import java.util.HashMap;
56 import java.util.Map;
57 import java.util.List;
58 import java.util.Properties;
59 import java.util.regex.Pattern;
60 import java.util.stream.Collectors;
61
62 import com.sun.tools.javac.launcher.SourceLauncher;
63 import com.sun.tools.javac.launcher.Fault;
64
65 import toolbox.JavaTask;
66 import toolbox.JavacTask;
67 import toolbox.Task;
68 import toolbox.TestRunner;
69 import toolbox.ToolBox;
70
71 import static jdk.internal.module.ClassFileConstants.WARN_INCUBATING;
72
73 public class SourceLauncherTest extends TestRunner {
74 public static void main(String... args) throws Exception {
75 SourceLauncherTest t = new SourceLauncherTest();
76 t.runTests(m -> new Object[] { Paths.get(m.getName()) });
77 }
78
79 SourceLauncherTest() {
80 super(System.err);
81 tb = new ToolBox();
82 System.err.println("version: " + thisVersion);
83 }
84
85 private final ToolBox tb;
86 private static final String thisVersion = System.getProperty("java.specification.version");
87
88 /*
89 * Positive tests.
90 */
91
92 @Test
93 public void testHelloWorld(Path base) throws IOException {
94 tb.writeJavaFiles(base,
95 "import java.util.Arrays;\n" +
96 "class HelloWorld {\n" +
97 " public static void main(String... args) {\n" +
98 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
99 " }\n" +
100 "}");
101 testSuccess(base.resolve("HelloWorld.java"), "Hello World! [1, 2, 3]\n");
102 }
103
104 @Test
105 public void testHelloWorldInPackage(Path base) throws IOException {
106 tb.writeJavaFiles(base,
107 "package hello;\n" +
108 "import java.util.Arrays;\n" +
109 "class World {\n" +
110 " public static void main(String... args) {\n" +
111 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
112 " }\n" +
113 "}");
114 testSuccess(base.resolve("hello").resolve("World.java"), "Hello World! [1, 2, 3]\n");
115 }
116
117 @Test
118 public void testHelloWorldWithAux(Path base) throws IOException {
119 tb.writeJavaFiles(base,
120 "import java.util.Arrays;\n" +
121 "class HelloWorld {\n" +
122 " public static void main(String... args) {\n" +
123 " Aux.write(args);\n" +
124 " }\n" +
125 "}\n" +
126 "class Aux {\n" +
127 " static void write(String... args) {\n" +
128 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
129 " }\n" +
130 "}");
131 testSuccess(base.resolve("HelloWorld.java"), "Hello World! [1, 2, 3]\n");
132 }
133
134 @Test
135 public void testHelloWorldWithShebang(Path base) throws IOException {
136 tb.writeJavaFiles(base,
137 "#!/usr/bin/java --source " + thisVersion + "\n" +
138 "import java.util.Arrays;\n" +
139 "class HelloWorld {\n" +
140 " public static void main(String... args) {\n" +
141 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
142 " }\n" +
143 "}");
144 Files.copy(base.resolve("HelloWorld.java"), base.resolve("HelloWorld"));
145 testSuccess(base.resolve("HelloWorld"), "Hello World! [1, 2, 3]\n");
146 }
147
148 @Test
149 public void testNoAnnoProcessing(Path base) throws IOException {
150 Path annoSrc = base.resolve("annoSrc");
151 tb.writeJavaFiles(annoSrc,
152 "import java.util.*;\n" +
153 "import javax.annotation.processing.*;\n" +
154 "import javax.lang.model.element.*;\n" +
155 "@SupportedAnnotationTypes(\"*\")\n" +
156 "public class AnnoProc extends AbstractProcessor {\n" +
157 " public boolean process(Set<? extends TypeElement> annos, RoundEnvironment rEnv) {\n" +
158 " throw new Error(\"Annotation processor should not be invoked\");\n" +
159 " }\n" +
160 "}\n");
161 Path annoClasses = Files.createDirectories(base.resolve("classes"));
162 new JavacTask(tb)
163 .outdir(annoClasses)
164 .files(annoSrc.resolve("AnnoProc.java").toString())
165 .run();
166 Path serviceFile = annoClasses.resolve("META-INF").resolve("services")
167 .resolve("javax.annotation.processing.Processor");
168 tb.writeFile(serviceFile, "AnnoProc");
169
170 Path mainSrc = base.resolve("mainSrc");
171 tb.writeJavaFiles(mainSrc,
172 "import java.util.Arrays;\n" +
173 "class HelloWorld {\n" +
174 " public static void main(String... args) {\n" +
175 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
176 " }\n" +
177 "}");
178
179 List<String> javacArgs = List.of("-classpath", annoClasses.toString());
180 List<String> classArgs = List.of("1", "2", "3");
181 String expect = "Hello World! [1, 2, 3]\n";
182 Result r = run(mainSrc.resolve("HelloWorld.java"), javacArgs, classArgs);
183 checkEqual("stdout", r.stdOut, expect);
184 checkEmpty("stderr", r.stdErr);
185 checkNull("exception", r.exception);
186 }
187
188 @Test
189 public void testEnablePreview(Path base) throws IOException {
190 tb.writeJavaFiles(base,
191 "import java.util.Arrays;\n" +
192 "class HelloWorld {\n" +
193 " public static void main(String... args) {\n" +
194 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
195 " }\n" +
196 "}");
197
198 String log = new JavaTask(tb)
199 .vmOptions("--enable-preview", "--source", thisVersion)
200 .className(base.resolve("HelloWorld.java").toString())
201 .classArgs("1", "2", "3")
202 .run(Task.Expect.SUCCESS)
203 .getOutput(Task.OutputKind.STDOUT);
204 checkEqual("stdout", log.trim(), "Hello World! [1, 2, 3]");
205 }
206
207 @Test
208 public void testCodeSource(Path base) throws IOException {
209 tb.writeJavaFiles(base,
210 "import java.net.URL;\n" +
211 "class ShowCodeSource {\n" +
212 " public static void main(String... args) {\n" +
213 " URL u = ShowCodeSource.class.getProtectionDomain().getCodeSource().getLocation();\n" +
214 " System.out.println(u);\n" +
215 " }\n" +
216 "}");
217
218 Path file = base.resolve("ShowCodeSource.java");
219 String log = new JavaTask(tb)
220 .className(file.toString())
221 .run(Task.Expect.SUCCESS)
222 .getOutput(Task.OutputKind.STDOUT);
223 checkEqual("stdout", log.trim(), file.toAbsolutePath().toUri().toURL().toString());
224 }
225
226 @Test
227 public void testSecurityManager(Path base) throws IOException {
228 Path sourceFile = base.resolve("HelloWorld.java");
229 tb.writeJavaFiles(base,
230 "class HelloWorld {\n" +
231 " public static void main(String... args) {\n" +
232 " System.out.println(\"Hello World!\");\n" +
233 " }\n" +
234 "}");
235
236 String log = new JavaTask(tb)
237 .vmOptions("-Djava.security.manager=default")
238 .className(sourceFile.toString())
239 .run(Task.Expect.FAIL)
240 .getOutput(Task.OutputKind.STDERR);
241 checkContains("stderr", log,
242 "error: cannot use source-code launcher with a security manager enabled");
243 }
244
245 @Test
246 public void testSystemProperty(Path base) throws IOException {
247 tb.writeJavaFiles(base,
248 "class ShowProperty {\n" +
249 " public static void main(String... args) {\n" +
250 " System.out.println(System.getProperty(\"jdk.launcher.sourcefile\"));\n" +
251 " }\n" +
252 "}");
253
254 Path file = base.resolve("ShowProperty.java");
255 String log = new JavaTask(tb)
256 .className(file.toString())
257 .run(Task.Expect.SUCCESS)
258 .getOutput(Task.OutputKind.STDOUT);
259 checkEqual("stdout", log.trim(), file.toAbsolutePath().toString());
260 }
261
262 void testSuccess(Path file, String expect) throws IOException {
263 Result r = run(file, Collections.emptyList(), List.of("1", "2", "3"));
264 checkEqual("stdout", r.stdOut, expect);
265 checkEmpty("stderr", r.stdErr);
266 checkNull("exception", r.exception);
267 }
268
269 /*
270 * Negative tests: such as cannot find or execute main method.
271 */
272
273 @Test
274 public void testHelloWorldWithShebangJava(Path base) throws IOException {
275 tb.writeJavaFiles(base,
276 "#!/usr/bin/java --source " + thisVersion + "\n" +
277 "import java.util.Arrays;\n" +
278 "class HelloWorld {\n" +
279 " public static void main(String... args) {\n" +
280 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
281 " }\n" +
282 "}");
283 Path file = base.resolve("HelloWorld.java");
284 testError(file,
285 file + ":1: error: illegal character: '#'\n" +
286 "#!/usr/bin/java --source " + thisVersion + "\n" +
287 "^\n" +
288 file + ":1: error: class, interface, enum, or record expected\n" +
289 "#!/usr/bin/java --source " + thisVersion + "\n" +
290 " ^\n" +
291 "2 errors\n",
292 "error: compilation failed");
293 }
294
295 @Test
296 public void testNoClass(Path base) throws IOException {
297 var path = Files.createDirectories(base.resolve("p"));
298 Path file = path.resolve("NoClass.java");
299 Files.write(file, List.of("package p;"));
300 testError(file, "", "error: no class declared in source file");
301 }
302
303 @Test
304 public void testMismatchOfPathAndPackage(Path base) throws IOException {
305 Files.createDirectories(base);
306 Path file = base.resolve("MismatchOfPathAndPackage.java");
307 Files.write(file, List.of("package p;"));
308 testError(file, "", "error: end of path to source file does not match its package name p: " + file);
309 }
310
311 @Test
312 public void testLoadClass(Path base) throws IOException {
313 Path src1 = base.resolve("src1");
314 Path file1 = src1.resolve("LoadClass.java");
315 tb.writeJavaFiles(src1,
316 "class LoadClass {\n"
317 + " public static void main(String... args) {\n"
318 + " System.out.println(\"on classpath\");\n"
319 + " };\n"
320 + "}\n");
321 Path classes1 = Files.createDirectories(base.resolve("classes"));
322 new JavacTask(tb)
323 .outdir(classes1)
324 .files(file1)
325 .run();
326 String log1 = new JavaTask(tb)
327 .classpath(classes1.toString())
328 .className("LoadClass")
329 .run(Task.Expect.SUCCESS)
330 .getOutput(Task.OutputKind.STDOUT);
331 checkEqual("stdout", log1.trim(),
332 "on classpath");
333
334 Path src2 = base.resolve("src2");
335 Path file2 = src2.resolve("LoadClass.java");
336 tb.writeJavaFiles(src2,
337 "class LoadClass {\n"
338 + " public static void main(String... args) {\n"
339 + " System.out.println(\"in source file\");\n"
340 + " };\n"
341 + "}\n");
342 String log2 = new JavaTask(tb)
343 .classpath(classes1.toString())
344 .className(file2.toString())
345 .run(Task.Expect.SUCCESS)
346 .getOutput(Task.OutputKind.STDOUT);
347 checkEqual("stdout", log2.trim(),
348 "in source file");
349 }
350
351 @Test
352 public void testGetResource(Path base) throws IOException {
353 Path src = base.resolve("src");
354 Path file = src.resolve("GetResource.java");
355 tb.writeJavaFiles(src,
356 "class GetResource {\n"
357 + " public static void main(String... args) {\n"
358 + " System.out.println(GetResource.class.getClassLoader().getResource(\"GetResource.class\"));\n"
359 + " };\n"
360 + "}\n");
361 Path classes = Files.createDirectories(base.resolve("classes"));
362 new JavacTask(tb)
363 .outdir(classes)
364 .files(file)
365 .run();
366
367 String log = new JavaTask(tb)
368 .classpath(classes.toString())
369 .className(file.toString())
370 .run(Task.Expect.SUCCESS)
371 .getOutput(Task.OutputKind.STDOUT);
372 checkMatch("stdout", log.trim(),
373 Pattern.compile("sourcelauncher-memoryclassloader[0-9]+:GetResource.class"));
374 }
375
376 @Test
377 public void testGetResources(Path base) throws IOException {
378 Path src = base.resolve("src");
379 Path file = src.resolve("GetResources.java");
380 tb.writeJavaFiles(src,
381 "import java.io.*; import java.net.*; import java.util.*;\n"
382 + "class GetResources {\n"
383 + " public static void main(String... args) throws IOException {\n"
384 + " Enumeration<URL> e =\n"
385 + " GetResources.class.getClassLoader().getResources(\"GetResources.class\");\n"
386 + " while (e.hasMoreElements()) System.out.println(e.nextElement());\n"
387 + " };\n"
388 + "}\n");
389 Path classes = Files.createDirectories(base.resolve("classes"));
390 new JavacTask(tb)
391 .outdir(classes)
392 .files(file)
393 .run();
394
395 List<String> log = new JavaTask(tb)
396 .classpath(classes.toString())
397 .className(file.toString())
398 .run(Task.Expect.SUCCESS)
399 .getOutputLines(Task.OutputKind.STDOUT);
400 checkMatch("stdout:0", log.get(0).trim(),
401 Pattern.compile("sourcelauncher-memoryclassloader[0-9]+:GetResources.class"));
402 checkMatch("stdout:1", log.get(1).trim(),
403 Pattern.compile("file:/.*/testGetResources/classes/GetResources.class"));
404 }
405
406 @Test
407 public void testSyntaxErr(Path base) throws IOException {
408 tb.writeJavaFiles(base, "class SyntaxErr {");
409 Path file = base.resolve("SyntaxErr.java");
410 testError(file,
411 file + ":1: error: reached end of file while parsing\n" +
412 "class SyntaxErr {\n" +
413 " ^\n" +
414 "1 error\n",
415 "error: compilation failed");
416 }
417
418 @Test
419 public void testNoSourceOnClassPath(Path base) throws IOException {
420 Path extraSrc = base.resolve("extraSrc");
421 tb.writeJavaFiles(extraSrc,
422 "public class Extra {\n" +
423 " static final String MESSAGE = \"Hello World\";\n" +
424 "}\n");
425
426 Path mainSrc = base.resolve("mainSrc");
427 tb.writeJavaFiles(mainSrc,
428 "import java.util.Arrays;\n" +
429 "class HelloWorld {\n" +
430 " public static void main(String... args) {\n" +
431 " System.out.println(Extra.MESSAGE + Arrays.toString(args));\n" +
432 " }\n" +
433 "}");
434
435 List<String> javacArgs = List.of("-classpath", extraSrc.toString());
436 List<String> classArgs = List.of("1", "2", "3");
437 String FS = File.separator;
438 String expectStdErr =
439 "testNoSourceOnClassPath" + FS + "mainSrc" + FS + "HelloWorld.java:4: error: cannot find symbol\n" +
440 " System.out.println(Extra.MESSAGE + Arrays.toString(args));\n" +
441 " ^\n" +
442 " symbol: variable Extra\n" +
443 " location: class HelloWorld\n" +
444 "1 error\n";
445 Result r = run(mainSrc.resolve("HelloWorld.java"), javacArgs, classArgs);
446 checkEmpty("stdout", r.stdOut);
447 checkEqual("stderr", r.stdErr, expectStdErr);
448 checkFault("exception", r.exception, "error: compilation failed");
449 }
450
451 @Test
452 public void testClassNotFound(Path base) throws IOException {
453 Path src = base.resolve("src");
454 Path file = src.resolve("ClassNotFound.java");
455 tb.writeJavaFiles(src,
456 "class ClassNotFound {\n"
457 + " public static void main(String... args) {\n"
458 + " try {\n"
459 + " Class.forName(\"NoSuchClass\");\n"
460 + " System.out.println(\"no exception\");\n"
461 + " System.exit(1);\n"
462 + " } catch (ClassNotFoundException e) {\n"
463 + " System.out.println(\"Expected exception thrown: \" + e);\n"
464 + " }\n"
465 + " };\n"
466 + "}\n");
467 Path classes = Files.createDirectories(base.resolve("classes"));
468 new JavacTask(tb)
469 .outdir(classes)
470 .files(file)
471 .run();
472
473 String log = new JavaTask(tb)
474 .classpath(classes.toString())
475 .className(file.toString())
476 .run(Task.Expect.SUCCESS)
477 .getOutput(Task.OutputKind.STDOUT);
478 checkEqual("stdout", log.trim(),
479 "Expected exception thrown: java.lang.ClassNotFoundException: NoSuchClass");
480 }
481
482 // For any source file that is invoked through the OS shebang mechanism, invalid shebang
483 // lines will be caught and handled by the OS, before the launcher is even invoked.
484 // However, if such a file is passed directly to the launcher, perhaps using the --source
485 // option, a well-formed shebang line will be removed but a badly-formed one will be not be
486 // removed and will cause compilation errors.
487 @Test
488 public void testBadShebang(Path base) throws IOException {
489 tb.writeJavaFiles(base,
490 "#/usr/bin/java --source " + thisVersion + "\n" +
491 "import java.util.Arrays;\n" +
492 "class HelloWorld {\n" +
493 " public static void main(String... args) {\n" +
494 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
495 " }\n" +
496 "}");
497 Path file = base.resolve("HelloWorld.java");
498 testError(file,
499 file + ":1: error: illegal character: '#'\n" +
500 "#/usr/bin/java --source " + thisVersion + "\n" +
501 "^\n" +
502 file + ":1: error: class, interface, enum, or record expected\n" +
503 "#/usr/bin/java --source " + thisVersion + "\n" +
504 " ^\n" +
505 "2 errors\n",
506 "error: compilation failed");
507 }
508
509 @Test
510 public void testBadSourceOpt(Path base) throws IOException {
511 Files.createDirectories(base);
512 Path file = base.resolve("DummyClass.java");
513 Files.write(file, List.of("class DummyClass { }"));
514 Properties sysProps = System.getProperties();
515 Properties p = new Properties(sysProps);
516 p.setProperty("jdk.internal.javac.source", "<BAD>");
517 System.setProperties(p);
518 try {
519 testError(file, "", "error: invalid value for --source option: <BAD>");
520 } finally {
521 System.setProperties(sysProps);
522 }
523 }
524
525 @Test
526 public void testEnablePreviewNoSource(Path base) throws IOException {
527 tb.writeJavaFiles(base,
528 "import java.util.Arrays;\n" +
529 "class HelloWorld {\n" +
530 " public static void main(String... args) {\n" +
531 " System.out.println(\"Hello World! \" + Arrays.toString(args));\n" +
532 " }\n" +
533 "}");
534
535 List<String> log = new JavaTask(tb)
536 .vmOptions("--enable-preview")
537 .className(base.resolve("HelloWorld.java").toString())
538 .run(Task.Expect.FAIL)
539 .getOutputLines(Task.OutputKind.STDERR);
540 log = log.stream().filter(s->!s.matches("^Picked up .*JAVA.*OPTIONS:.*")).collect(Collectors.toList());
541 checkEqual("stderr", log, List.of("error: --enable-preview must be used with --source"));
542 }
543
544 @Test
545 public void testNoMain(Path base) throws IOException {
546 tb.writeJavaFiles(base, "class NoMain { }");
547 testError(base.resolve("NoMain.java"), "",
548 "error: can't find main(String[]) method in class: NoMain");
549 }
550
551 //@Test temporary disabled as enabled preview allows no-param main
552 public void testMainBadParams(Path base) throws IOException {
553 tb.writeJavaFiles(base,
554 "class BadParams { public static void main() { } }");
555 testError(base.resolve("BadParams.java"), "",
556 "error: can't find main(String[]) method in class: BadParams");
557 }
558
559 //@Test temporary disabled as enabled preview allows non-public main
560 public void testMainNotPublic(Path base) throws IOException {
561 tb.writeJavaFiles(base,
562 "class NotPublic { static void main(String... args) { } }");
563 testError(base.resolve("NotPublic.java"), "",
564 "error: can't find main(String[]) method in class: NotPublic");
565 }
566
567 //@Test temporary disabled as enabled preview allows non-static main
568 public void testMainNotStatic(Path base) throws IOException {
569 tb.writeJavaFiles(base,
570 "class NotStatic { public void main(String... args) { } }");
571 testError(base.resolve("NotStatic.java"), "",
572 "error: can't find main(String[]) method in class: NotStatic");
573 }
574
575 @Test
576 public void testMainNotVoid(Path base) throws IOException {
577 tb.writeJavaFiles(base,
578 "class NotVoid { public static int main(String... args) { return 0; } }");
579 testError(base.resolve("NotVoid.java"), "",
580 "error: can't find main(String[]) method in class: NotVoid");
581 }
582
583 @Test
584 public void testClassInModule(Path base) throws IOException {
585 tb.writeJavaFiles(base, "package java.net; class InModule { }");
586 Path file = base.resolve("java").resolve("net").resolve("InModule.java");
587 testError(file,
588 file + ":1: error: package exists in another module: java.base\n" +
589 "package java.net; class InModule { }\n" +
590 "^\n" +
591 "1 error\n",
592 "error: compilation failed");
593 }
594
595 @Test
596 public void testNoRecompileWithSuggestions(Path base) throws IOException {
597 tb.writeJavaFiles(base,
598 "class NoRecompile {\n" +
599 " void use(String s) {}\n" +
600 " void test() {\n" +
601 " use(1);\n" +
602 " }\n" +
603 " <T> void test(T t, Object o) {\n" +
604 " T t1 = (T) o;\n" +
605 " }\n" +
606 " static class Generic<T> {\n" +
607 " T t;\n" +
608 " void raw(Generic raw) {\n" +
609 " raw.t = \"\";\n" +
610 " }\n" +
611 " }\n" +
612 " void deprecation() {\n" +
613 " Thread.currentThread().stop();\n" +
614 " }\n" +
615 " void preview(Object o) {\n" +
616 " if (o instanceof String s) {\n" +
617 " System.out.println(s);\n" +
618 " }\n" +
619 " }\n" +
620 "}");
621 Result r = run(base.resolve("NoRecompile.java"), Collections.emptyList(), Collections.emptyList());
622 if (r.stdErr.contains("recompile with")) {
623 error("Unexpected recompile suggestions in error output: " + r.stdErr);
624 }
625 }
626
627 @Test
628 public void testNoOptionsWarnings(Path base) throws IOException {
629 tb.writeJavaFiles(base, "public class Main { public static void main(String... args) {}}");
630 String log = new JavaTask(tb)
631 .vmOptions("--source", "21")
632 .className(base.resolve("Main.java").toString())
633 .run(Task.Expect.SUCCESS)
634 .getOutput(Task.OutputKind.STDERR);
635
636 if (log.contains("warning: [options]")) {
637 error("Unexpected options warning in error output: " + log);
638 }
639 }
640
641 void testError(Path file, String expectStdErr, String expectFault) throws IOException {
642 Result r = run(file, Collections.emptyList(), List.of("1", "2", "3"));
643 checkEmpty("stdout", r.stdOut);
644 checkEqual("stderr", r.stdErr, expectStdErr);
645 checkFault("exception", r.exception, expectFault);
646 }
647
648 /*
649 * Tests in which main throws an exception.
650 */
651 @Test
652 public void testTargetException1(Path base) throws IOException {
653 tb.writeJavaFiles(base,
654 "import java.util.Arrays;\n" +
655 "class Thrower {\n" +
656 " public static void main(String... args) {\n" +
657 " throwWhenZero(Integer.parseInt(args[0]));\n" +
658 " }\n" +
659 " static void throwWhenZero(int arg) {\n" +
660 " if (arg == 0) throw new Error(\"zero!\");\n" +
661 " throwWhenZero(arg - 1);\n" +
662 " }\n" +
663 "}");
664 Path file = base.resolve("Thrower.java");
665 Result r = run(file, Collections.emptyList(), List.of("3"));
666 checkEmpty("stdout", r.stdOut);
667 checkEmpty("stderr", r.stdErr);
668 checkTrace("exception", r.exception,
669 "java.lang.Error: zero!",
670 "at Thrower.throwWhenZero(Thrower.java:7)",
671 "at Thrower.throwWhenZero(Thrower.java:8)",
672 "at Thrower.throwWhenZero(Thrower.java:8)",
673 "at Thrower.throwWhenZero(Thrower.java:8)",
674 "at Thrower.main(Thrower.java:4)");
675 }
676
677 @Test
678 public void testNoDuplicateIncubatorWarning(Path base) throws Exception {
679 Path module = base.resolve("lib");
680 Path moduleSrc = module.resolve("src");
681 Path moduleClasses = module.resolve("classes");
682 Files.createDirectories(moduleClasses);
683 tb.cleanDirectory(moduleClasses);
684 tb.writeJavaFiles(moduleSrc, "module test {}");
685 new JavacTask(tb)
686 .outdir(moduleClasses)
687 .files(tb.findJavaFiles(moduleSrc))
688 .run()
689 .writeAll();
690 markModuleAsIncubator(moduleClasses.resolve("module-info.class"));
691 tb.writeJavaFiles(base, "public class Main { public static void main(String... args) {}}");
692 String log = new JavaTask(tb)
693 .vmOptions("--module-path", moduleClasses.toString(),
694 "--add-modules", "test")
695 .className(base.resolve("Main.java").toString())
696 .run(Task.Expect.SUCCESS)
697 .writeAll()
698 .getOutput(Task.OutputKind.STDERR);
699
700 int numberOfWarnings = log.split("WARNING").length - 1;
701
702 if (log.contains("warning:") || numberOfWarnings != 1) {
703 error("Unexpected warning in error output: " + log);
704 }
705
706 List<String> compileLog = new JavacTask(tb)
707 .options("--module-path", moduleClasses.toString(),
708 "--add-modules", "test",
709 "-XDrawDiagnostics",
710 "-XDsourceLauncher",
711 "-XDshould-stop.at=FLOW")
712 .files(base.resolve("Main.java").toString())
713 .run(Task.Expect.SUCCESS)
714 .writeAll()
715 .getOutputLines(Task.OutputKind.DIRECT);
716
717 List<String> expectedOutput = List.of(
718 "- compiler.warn.incubating.modules: test",
719 "1 warning"
720 );
721
722 if (!expectedOutput.equals(compileLog)) {
723 error("Unexpected options : " + compileLog);
724 }
725 }
726 //where:
727 private static void markModuleAsIncubator(Path moduleInfoFile) throws Exception {
728 ClassModel cf = ClassFile.of().parse(moduleInfoFile);
729 ModuleResolutionAttribute newAttr = ModuleResolutionAttribute.of(WARN_INCUBATING);
730 byte[] newBytes = ClassFile.of().transform(cf, ClassTransform.dropping(ce -> ce instanceof Attributes)
731 .andThen(ClassTransform.endHandler(classBuilder -> classBuilder.with(newAttr))));
732 try (OutputStream out = Files.newOutputStream(moduleInfoFile)) {
733 out.write(newBytes);
734 }
735 }
736
737 Result run(Path file, List<String> runtimeArgs, List<String> appArgs) {
738 List<String> args = new ArrayList<>();
739 args.add(file.toString());
740 args.addAll(appArgs);
741
742 PrintStream prev = System.out;
743 ByteArrayOutputStream baos = new ByteArrayOutputStream();
744 try (PrintStream out = new PrintStream(baos, true)) {
745 System.setOut(out);
746 StringWriter sw = new StringWriter();
747 try (PrintWriter err = new PrintWriter(sw, true)) {
748 SourceLauncher m = new SourceLauncher(err);
749 m.run(toArray(runtimeArgs), toArray(args));
750 return new Result(baos.toString(), sw.toString(), null);
751 } catch (Throwable t) {
752 return new Result(baos.toString(), sw.toString(), t);
753 }
754 } finally {
755 System.setOut(prev);
756 }
757 }
758
759 void checkEqual(String name, String found, String expect) {
760 expect = expect.replace("\n", tb.lineSeparator);
761 out.println(name + ": " + found);
762 if (!expect.equals(found)) {
763 error("Unexpected output; expected: " + expect);
764 }
765 }
766
767 void checkContains(String name, String found, String expect) {
768 expect = expect.replace("\n", tb.lineSeparator);
769 out.println(name + ": " + found);
770 if (!found.contains(expect)) {
771 error("Expected output not found: " + expect);
772 }
773 }
774
775 void checkEqual(String name, List<String> found, List<String> expect) {
776 out.println(name + ": " + found);
777 tb.checkEqual(expect, found);
778 }
779
780 void checkMatch(String name, String found, Pattern expect) {
781 out.println(name + ": " + found);
782 if (!expect.matcher(found).matches()) {
783 error("Unexpected output; expected match for: " + expect);
784 }
785 }
786
787 void checkEmpty(String name, String found) {
788 out.println(name + ": " + found);
789 if (!found.isEmpty()) {
790 error("Unexpected output; expected empty string");
791 }
792 }
793
794 void checkNull(String name, Throwable found) {
795 out.println(name + ": " + found);
796 if (found != null) {
797 error("Unexpected exception; expected null");
798 }
799 }
800
801 void checkFault(String name, Throwable found, String expect) {
802 expect = expect.replace("\n", tb.lineSeparator);
803 out.println(name + ": " + found);
804 if (found == null) {
805 error("No exception thrown; expected Fault");
806 } else {
807 if (!(found instanceof Fault)) {
808 error("Unexpected exception; expected Fault");
809 }
810 if (!(found.getMessage().equals(expect))) {
811 error("Unexpected detail message; expected: " + expect);
812 }
813 }
814 }
815
816 void checkTrace(String name, Throwable found, String... expect) {
817 if (!(found instanceof InvocationTargetException)) {
818 error("Unexpected exception; expected InvocationTargetException");
819 out.println("Found:");
820 found.printStackTrace(out);
821 }
822 StringWriter sw = new StringWriter();
823 try (PrintWriter pw = new PrintWriter(sw)) {
824 ((InvocationTargetException) found).getTargetException().printStackTrace(pw);
825 }
826 String trace = sw.toString();
827 out.println(name + ":\n" + trace);
828 String[] traceLines = trace.trim().split("[\r\n]+\\s+");
829 try {
830 tb.checkEqual(List.of(traceLines), List.of(expect));
831 } catch (Error e) {
832 error(e.getMessage());
833 }
834 }
835
836 String[] toArray(List<String> list) {
837 return list.toArray(new String[list.size()]);
838 }
839
840 record Result(String stdOut, String stdErr, Throwable exception) {}
841 }