Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
langtools/test/tools/javac/modules/GraphsTest.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92 
     1 /*
 
     1 /*
 
     2  * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 
     2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
     4  *
 
     4  *
 
     5  * This code is free software; you can redistribute it and/or modify it
 
     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
 
     6  * under the terms of the GNU General Public License version 2 only, as
 
     7  * published by the Free Software Foundation.
 
     7  * published by the Free Software Foundation.
 
    26  * @summary tests for module graph resolution issues
 
    26  * @summary tests for module graph resolution issues
 
    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  * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask ModuleTestBase
 
    32  * @build ToolBox ModuleTestBase
 
       
    33  * @run main GraphsTest
 
    32  * @run main GraphsTest
 
    34  */
 
    33  */
 
    35 
    34 
    36 import java.io.File;
 
    35 import java.io.File;
 
    37 import java.nio.file.Files;
 
    36 import java.nio.file.Files;
 
    38 import java.nio.file.Path;
 
    37 import java.nio.file.Path;
 
    39 import java.util.Arrays;
 
    38 import java.util.Arrays;
 
    40 import java.util.List;
 
    39 import java.util.List;
 
    41 import java.util.regex.Pattern;
 
    40 import java.util.regex.Pattern;
 
       
    41 
       
    42 import toolbox.JarTask;
 
       
    43 import toolbox.JavacTask;
 
       
    44 import toolbox.Task;
 
       
    45 import toolbox.ToolBox;
 
    42 
    46 
    43 public class GraphsTest extends ModuleTestBase {
 
    47 public class GraphsTest extends ModuleTestBase {
 
    44 
    48 
    45     public static void main(String... args) throws Exception {
 
    49     public static void main(String... args) throws Exception {
 
    46         GraphsTest t = new GraphsTest();
 
    50         GraphsTest t = new GraphsTest();
 
    75                 .classes("package closedJ; public class J { }")
 
    79                 .classes("package closedJ; public class J { }")
 
    76                 .build(base.resolve("jar"));
 
    80                 .build(base.resolve("jar"));
 
    77 
    81 
    78         Path jarModules = Files.createDirectories(base.resolve("jarModules"));
 
    82         Path jarModules = Files.createDirectories(base.resolve("jarModules"));
 
    79         Path jar = jarModules.resolve("J.jar");
 
    83         Path jar = jarModules.resolve("J.jar");
 
    80         tb.new JarTask(jar)
 
    84         new JarTask(tb, jar)
 
    81                 .baseDir(base.resolve("jar/J"))
 
    85                 .baseDir(base.resolve("jar/J"))
 
    82                 .files(".")
 
    86                 .files(".")
 
    83                 .run()
 
    87                 .run()
 
    84                 .writeAll();
 
    88                 .writeAll();
 
    85 
    89 
   107                 .requires("N", modules)
 
   111                 .requires("N", modules)
 
   108                 .requires("L", modules)
 
   112                 .requires("L", modules)
 
   109                 .classes("package p; public class Positive { openO.O o; openN.N n; openL.L l; }")
 
   113                 .classes("package p; public class Positive { openO.O o; openN.N n; openL.L l; }")
 
   110                 .write(base.resolve("positiveSrc"));
 
   114                 .write(base.resolve("positiveSrc"));
 
   111 
   115 
   112         tb.new JavacTask()
 
   116         new JavacTask(tb)
 
   113                 .options("-XDrawDiagnostics", "-mp", modules + File.pathSeparator + jarModules)
 
   117                 .options("-XDrawDiagnostics", "-mp", modules + File.pathSeparator + jarModules)
 
   114                 .outdir(Files.createDirectories(base.resolve("positive")))
 
   118                 .outdir(Files.createDirectories(base.resolve("positive")))
 
   115                 .files(findJavaFiles(positiveSrc))
 
   119                 .files(findJavaFiles(positiveSrc))
 
   116                 .run()
 
   120                 .run()
 
   117                 .writeAll();
 
   121                 .writeAll();
 
   118         //negative case
 
   122         //negative case
 
   119         Path negativeSrc = m.classes("package p; public class Negative { closedO.O o; closedN.N n; closedL.L l; }")
 
   123         Path negativeSrc = m.classes("package p; public class Negative { closedO.O o; closedN.N n; closedL.L l; }")
 
   120                 .write(base.resolve("negativeSrc"));
 
   124                 .write(base.resolve("negativeSrc"));
 
   121         List<String> log = tb.new JavacTask()
 
   125         List<String> log = new JavacTask(tb)
 
   122                 .options("-XDrawDiagnostics", "-mp", modules + File.pathSeparator + jarModules)
 
   126                 .options("-XDrawDiagnostics", "-mp", modules + File.pathSeparator + jarModules)
 
   123                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   127                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   124                 .files(findJavaFiles(negativeSrc))
 
   128                 .files(findJavaFiles(negativeSrc))
 
   125                 .run(ToolBox.Expect.FAIL)
 
   129                 .run(Task.Expect.FAIL)
 
   126                 .writeAll()
 
   130                 .writeAll()
 
   127                 .getOutputLines(ToolBox.OutputKind.DIRECT);
 
   131                 .getOutputLines(Task.OutputKind.DIRECT);
 
   128 
   132 
   129         List<String> expected = Arrays.asList(
 
   133         List<String> expected = Arrays.asList(
 
   130                 "Negative.java:1:43: compiler.err.doesnt.exist: closedO",
 
   134                 "Negative.java:1:43: compiler.err.doesnt.exist: closedO",
 
   131                 "Negative.java:1:56: compiler.err.doesnt.exist: closedN",
 
   135                 "Negative.java:1:56: compiler.err.doesnt.exist: closedN",
 
   132                 "Negative.java:1:69: compiler.err.doesnt.exist: closedL");
 
   136                 "Negative.java:1:69: compiler.err.doesnt.exist: closedL");
 
   133         if (!log.containsAll(expected)) {
 
   137         if (!log.containsAll(expected)) {
 
   134             throw new Exception("Expected output not found");
 
   138             throw new Exception("Expected output not found");
 
   135         }
 
   139         }
 
   136         //multi module mode
 
   140         //multi module mode
 
   137         m.write(modules);
 
   141         m.write(modules);
 
   138         List<String> out = tb.new JavacTask()
 
   142         List<String> out = new JavacTask(tb)
 
   139                 .options("-XDrawDiagnostics",
 
   143                 .options("-XDrawDiagnostics",
 
   140                         "-modulesourcepath", modules + "/*/src",
 
   144                         "-modulesourcepath", modules + "/*/src",
 
   141                         "-mp", jarModules.toString()
 
   145                         "-mp", jarModules.toString()
 
   142                 )
 
   146                 )
 
   143                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   147                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   144                 .files(findJavaFiles(modules))
 
   148                 .files(findJavaFiles(modules))
 
   145                 .run(ToolBox.Expect.FAIL)
 
   149                 .run(Task.Expect.FAIL)
 
   146                 .writeAll()
 
   150                 .writeAll()
 
   147                 .getOutputLines(ToolBox.OutputKind.DIRECT);
 
   151                 .getOutputLines(Task.OutputKind.DIRECT);
 
   148         expected = Arrays.asList(
 
   152         expected = Arrays.asList(
 
   149                 "Negative.java:1:43: compiler.err.not.def.access.package.cant.access: closedO.O, closedO",
 
   153                 "Negative.java:1:43: compiler.err.not.def.access.package.cant.access: closedO.O, closedO",
 
   150                 "Negative.java:1:56: compiler.err.not.def.access.package.cant.access: closedN.N, closedN",
 
   154                 "Negative.java:1:56: compiler.err.not.def.access.package.cant.access: closedN.N, closedN",
 
   151                 "Negative.java:1:69: compiler.err.not.def.access.package.cant.access: closedL.L, closedL");
 
   155                 "Negative.java:1:69: compiler.err.not.def.access.package.cant.access: closedL.L, closedL");
 
   152         if (!out.containsAll(expected)) {
 
   156         if (!out.containsAll(expected)) {
 
   183                 .write(modules);
 
   187                 .write(modules);
 
   184         new ModuleBuilder("L")
 
   188         new ModuleBuilder("L")
 
   185                 .requires("M")
 
   189                 .requires("M")
 
   186                 .classes("package p; public class A { A(pack.Clazz cl){} } ")
 
   190                 .classes("package p; public class A { A(pack.Clazz cl){} } ")
 
   187                 .write(modules);
 
   191                 .write(modules);
 
   188         String log = tb.new JavacTask()
 
   192         String log = new JavacTask(tb)
 
   189                 .options("-XDrawDiagnostics",
 
   193                 .options("-XDrawDiagnostics",
 
   190                         "-modulesourcepath", modules + "/*/src")
 
   194                         "-modulesourcepath", modules + "/*/src")
 
   191                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   195                 .outdir(Files.createDirectories(base.resolve("negative")))
 
   192                 .files(findJavaFiles(modules))
 
   196                 .files(findJavaFiles(modules))
 
   193                 .run(ToolBox.Expect.FAIL)
 
   197                 .run(Task.Expect.FAIL)
 
   194                 .writeAll()
 
   198                 .writeAll()
 
   195                 .getOutput(ToolBox.OutputKind.DIRECT);
 
   199                 .getOutput(Task.OutputKind.DIRECT);
 
   196 
   200 
   197         String expected = "A.java:1:35: compiler.err.not.def.access.package.cant.access: pack.Clazz, pack";
 
   201         String expected = "A.java:1:35: compiler.err.not.def.access.package.cant.access: pack.Clazz, pack";
 
   198         if (!log.contains(expected)) {
 
   202         if (!log.contains(expected)) {
 
   199             throw new Exception("Expected output not found");
 
   203             throw new Exception("Expected output not found");
 
   200         }
 
   204         }
jdk-sandbox