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/AddReadsTest.java
changeset 36778 e04318f39f92
parent 36526 3b41f1c69604
child 37758 3ecf9b414e05
equal deleted inserted replaced
36777:28d33fb9097f 36778:e04318f39f92 
    26  * @summary Test the -XaddReads option
 
    26  * @summary Test the -XaddReads option
 
    27  * @library /tools/lib
 
    27  * @library /tools/lib
 
    28  * @modules jdk.compiler/com.sun.tools.javac.api
 
    28  * @modules jdk.compiler/com.sun.tools.javac.api
 
    29  *          jdk.compiler/com.sun.tools.javac.main
 
    29  *          jdk.compiler/com.sun.tools.javac.main
 
    30  *          jdk.jdeps/com.sun.tools.javap
 
    30  *          jdk.jdeps/com.sun.tools.javap
 
    31  * @build ToolBox ModuleTestBase
 
    31  * @build toolbox.ToolBox toolbox.JarTask toolbox.JavacTask toolbox.JavapTask ModuleTestBase
 
    32  * @run main AddReadsTest
 
    32  * @run main AddReadsTest
 
    33  */
 
    33  */
 
    34 
    34 
    35 import java.nio.file.Files;
 
    35 import java.nio.file.Files;
 
    36 import java.nio.file.Path;
 
    36 import java.nio.file.Path;
 
    42 import javax.lang.model.SourceVersion;
 
    42 import javax.lang.model.SourceVersion;
 
    43 import javax.lang.model.element.ModuleElement;
 
    43 import javax.lang.model.element.ModuleElement;
 
    44 import javax.lang.model.element.ModuleElement.RequiresDirective;
 
    44 import javax.lang.model.element.ModuleElement.RequiresDirective;
 
    45 import javax.lang.model.element.TypeElement;
 
    45 import javax.lang.model.element.TypeElement;
 
    46 import javax.lang.model.util.ElementFilter;
 
    46 import javax.lang.model.util.ElementFilter;
 
       
    47 
       
    48 import toolbox.JarTask;
 
       
    49 import toolbox.JavacTask;
 
       
    50 import toolbox.JavapTask;
 
       
    51 import toolbox.Task;
 
       
    52 import toolbox.ToolBox;
 
    47 
    53 
    48 public class AddReadsTest extends ModuleTestBase {
 
    54 public class AddReadsTest extends ModuleTestBase {
 
    49 
    55 
    50     public static void main(String... args) throws Exception {
 
    56     public static void main(String... args) throws Exception {
 
    51         new AddReadsTest().runTests();
 
    57         new AddReadsTest().runTests();
 
    63                           "module m2 { }",
 
    69                           "module m2 { }",
 
    64                           "package test; public class Test extends api.Api { }");
 
    70                           "package test; public class Test extends api.Api { }");
 
    65         Path classes = base.resolve("classes");
 
    71         Path classes = base.resolve("classes");
 
    66         tb.createDirectories(classes);
 
    72         tb.createDirectories(classes);
 
    67 
    73 
    68         String log = tb.new JavacTask()
 
    74         String log = new JavacTask(tb)
 
    69                 .options("-XDrawDiagnostics",
 
    75                 .options("-XDrawDiagnostics",
 
    70                          "-modulesourcepath", src.toString())
 
    76                          "-modulesourcepath", src.toString())
 
    71                 .outdir(classes)
 
    77                 .outdir(classes)
 
    72                 .files(findJavaFiles(src))
 
    78                 .files(findJavaFiles(src))
 
    73                 .run(ToolBox.Expect.FAIL)
 
    79                 .run(Task.Expect.FAIL)
 
    74                 .writeAll()
 
    80                 .writeAll()
 
    75                 .getOutput(ToolBox.OutputKind.DIRECT);
 
    81                 .getOutput(Task.OutputKind.DIRECT);
 
    76 
    82 
    77         if (!log.contains("Test.java:1:44: compiler.err.not.def.access.package.cant.access: api.Api, api"))
 
    83         if (!log.contains("Test.java:1:44: compiler.err.not.def.access.package.cant.access: api.Api, api"))
 
    78             throw new Exception("expected output not found");
 
    84             throw new Exception("expected output not found");
 
    79 
    85 
    80         //test add dependencies:
 
    86         //test add dependencies:
 
    81         tb.new JavacTask()
 
    87         new JavacTask(tb)
 
    82                 .options("-XaddReads:m2=m1",
 
    88                 .options("-XaddReads:m2=m1",
 
    83                          "-modulesourcepath", src.toString(),
 
    89                          "-modulesourcepath", src.toString(),
 
    84                          "-processor", VerifyRequires.class.getName())
 
    90                          "-processor", VerifyRequires.class.getName())
 
    85                 .outdir(classes)
 
    91                 .outdir(classes)
 
    86                 .files(findJavaFiles(src))
 
    92                 .files(findJavaFiles(src))
 
    87                 .run()
 
    93                 .run()
 
    88                 .writeAll();
 
    94                 .writeAll();
 
    89 
    95 
    90         String decompiled = tb.new JavapTask()
 
    96         String decompiled = new JavapTask(tb)
 
    91                 .options("-verbose", classes.resolve("m2").resolve("module-info.class").toString())
 
    97                 .options("-verbose", classes.resolve("m2").resolve("module-info.class").toString())
 
    92                 .run()
 
    98                 .run()
 
    93                 .getOutput(ToolBox.OutputKind.DIRECT);
 
    99                 .getOutput(Task.OutputKind.DIRECT);
 
    94 
   100 
    95         if (decompiled.contains("m1")) {
 
   101         if (decompiled.contains("m1")) {
 
    96             throw new Exception("Incorrectly refers to m1 module.");
 
   102             throw new Exception("Incorrectly refers to m1 module.");
 
    97         }
 
   103         }
 
    98 
   104 
    99         //cyclic dependencies OK when created through addReads:
 
   105         //cyclic dependencies OK when created through addReads:
 
   100         tb.new JavacTask()
 
   106         new JavacTask(tb)
 
   101                 .options("-XaddReads:m2=m1,m1=m2",
 
   107                 .options("-XaddReads:m2=m1,m1=m2",
 
   102                          "-modulesourcepath", src.toString())
 
   108                          "-modulesourcepath", src.toString())
 
   103                 .outdir(classes)
 
   109                 .outdir(classes)
 
   104                 .files(findJavaFiles(src))
 
   110                 .files(findJavaFiles(src))
 
   105                 .run()
 
   111                 .run()
 
   106                 .writeAll();
 
   112                 .writeAll();
 
   107 
   113 
   108         tb.writeJavaFiles(src_m2,
 
   114         tb.writeJavaFiles(src_m2,
 
   109                           "module m2 { requires m1; }");
 
   115                           "module m2 { requires m1; }");
 
   110 
   116 
   111         tb.new JavacTask()
 
   117         new JavacTask(tb)
 
   112                 .options("-XaddReads:m1=m2",
 
   118                 .options("-XaddReads:m1=m2",
 
   113                          "-modulesourcepath", src.toString())
 
   119                          "-modulesourcepath", src.toString())
 
   114                 .outdir(classes)
 
   120                 .outdir(classes)
 
   115                 .files(findJavaFiles(src))
 
   121                 .files(findJavaFiles(src))
 
   116                 .run()
 
   122                 .run()
 
   156 
   162 
   157         tb.writeJavaFiles(m1,
 
   163         tb.writeJavaFiles(m1,
 
   158                           "module m1 { }",
 
   164                           "module m1 { }",
 
   159                           "package impl; public class Impl { api.Api api; }");
 
   165                           "package impl; public class Impl { api.Api api; }");
 
   160 
   166 
   161         tb.new JavacTask()
 
   167         new JavacTask(tb)
 
   162           .options("-classpath", jar.toString(),
 
   168           .options("-classpath", jar.toString(),
 
   163                    "-XaddReads:m1=ALL-UNNAMED",
 
   169                    "-XaddReads:m1=ALL-UNNAMED",
 
   164                    "-XDrawDiagnostics")
 
   170                    "-XDrawDiagnostics")
 
   165           .outdir(classes)
 
   171           .outdir(classes)
 
   166           .files(findJavaFiles(moduleSrc))
 
   172           .files(findJavaFiles(moduleSrc))
 
   182         tb.writeJavaFiles(m1,
 
   188         tb.writeJavaFiles(m1,
 
   183                           "module m1 { }",
 
   189                           "module m1 { }",
 
   184                           "package api; public class Api { public static void test() { } }",
 
   190                           "package api; public class Api { public static void test() { } }",
 
   185                           "package impl; public class Impl { { api.Api.test(); } }");
 
   191                           "package impl; public class Impl { { api.Api.test(); } }");
 
   186 
   192 
   187         tb.new JavacTask()
 
   193         new JavacTask(tb)
 
   188           .options("-classpath", jar.toString(),
 
   194           .options("-classpath", jar.toString(),
 
   189                    "-modulesourcepath", moduleSrc.toString(),
 
   195                    "-modulesourcepath", moduleSrc.toString(),
 
   190                    "-XaddReads:m1=ALL-UNNAMED",
 
   196                    "-XaddReads:m1=ALL-UNNAMED",
 
   191                    "-XDrawDiagnostics")
 
   197                    "-XDrawDiagnostics")
 
   192           .outdir(classes)
 
   198           .outdir(classes)
 
   204         Files.createDirectories(classes);
 
   210         Files.createDirectories(classes);
 
   205 
   211 
   206         tb.writeJavaFiles(src,
 
   212         tb.writeJavaFiles(src,
 
   207                           "package impl; public class Impl { api.Api a; }");
 
   213                           "package impl; public class Impl { api.Api a; }");
 
   208 
   214 
   209         tb.new JavacTask()
 
   215         new JavacTask(tb)
 
   210           .options("-classpath", jar.toString(),
 
   216           .options("-classpath", jar.toString(),
 
   211                    "-XaddReads:java.base=ALL-UNNAMED",
 
   217                    "-XaddReads:java.base=ALL-UNNAMED",
 
   212                    "-Xmodule:java.base")
 
   218                    "-Xmodule:java.base")
 
   213           .outdir(classes)
 
   219           .outdir(classes)
 
   214           .files(src.resolve("impl").resolve("Impl.java"))
 
   220           .files(src.resolve("impl").resolve("Impl.java"))
 
   224         Files.createDirectories(classes);
 
   230         Files.createDirectories(classes);
 
   225 
   231 
   226         tb.writeJavaFiles(src,
 
   232         tb.writeJavaFiles(src,
 
   227                           "package impl; public class Impl { javax.swing.JButton b; }");
 
   233                           "package impl; public class Impl { javax.swing.JButton b; }");
 
   228 
   234 
   229         tb.new JavacTask()
 
   235         new JavacTask(tb)
 
   230           .options("-XaddReads:java.base=java.desktop",
 
   236           .options("-XaddReads:java.base=java.desktop",
 
   231                    "-Xmodule:java.base")
 
   237                    "-Xmodule:java.base")
 
   232           .outdir(classes)
 
   238           .outdir(classes)
 
   233           .files(findJavaFiles(src))
 
   239           .files(findJavaFiles(src))
 
   234           .run()
 
   240           .run()
 
   240         tb.writeJavaFiles(legacySrc,
 
   246         tb.writeJavaFiles(legacySrc,
 
   241                           "package api; public abstract class Api {}");
 
   247                           "package api; public abstract class Api {}");
 
   242         Path legacyClasses = base.resolve("legacy-classes");
 
   248         Path legacyClasses = base.resolve("legacy-classes");
 
   243         Files.createDirectories(legacyClasses);
 
   249         Files.createDirectories(legacyClasses);
 
   244 
   250 
   245         String log = tb.new JavacTask()
 
   251         String log = new JavacTask(tb)
 
   246                 .options()
 
   252                 .options()
 
   247                 .outdir(legacyClasses)
 
   253                 .outdir(legacyClasses)
 
   248                 .files(findJavaFiles(legacySrc))
 
   254                 .files(findJavaFiles(legacySrc))
 
   249                 .run()
 
   255                 .run()
 
   250                 .writeAll()
 
   256                 .writeAll()
 
   251                 .getOutput(ToolBox.OutputKind.DIRECT);
 
   257                 .getOutput(Task.OutputKind.DIRECT);
 
   252 
   258 
   253         if (!log.isEmpty()) {
 
   259         if (!log.isEmpty()) {
 
   254             throw new Exception("unexpected output: " + log);
 
   260             throw new Exception("unexpected output: " + log);
 
   255         }
 
   261         }
 
   256 
   262 
   258 
   264 
   259         Files.createDirectories(lib);
 
   265         Files.createDirectories(lib);
 
   260 
   266 
   261         Path jar = lib.resolve("test-api-1.0.jar");
 
   267         Path jar = lib.resolve("test-api-1.0.jar");
 
   262 
   268 
   263         tb.new JarTask(jar)
 
   269         new JarTask(tb, jar)
 
   264           .baseDir(legacyClasses)
 
   270           .baseDir(legacyClasses)
 
   265           .files("api/Api.class")
 
   271           .files("api/Api.class")
 
   266           .run();
 
   272           .run();
 
   267 
   273 
   268         return jar;
 
   274         return jar;
 
   276                           "module m1 { provides java.lang.Runnable with impl.Impl; }",
 
   282                           "module m1 { provides java.lang.Runnable with impl.Impl; }",
 
   277                           "package impl; public class Impl implements Runnable { public void run() { } }");
 
   283                           "package impl; public class Impl implements Runnable { public void run() { } }");
 
   278         Path classes = base.resolve("classes");
 
   284         Path classes = base.resolve("classes");
 
   279         tb.createDirectories(classes);
 
   285         tb.createDirectories(classes);
 
   280 
   286 
   281         tb.new JavacTask()
 
   287         new JavacTask(tb)
 
   282                 .options("-modulesourcepath", src.toString())
 
   288                 .options("-modulesourcepath", src.toString())
 
   283                 .outdir(classes)
 
   289                 .outdir(classes)
 
   284                 .files(findJavaFiles(src))
 
   290                 .files(findJavaFiles(src))
 
   285                 .run()
 
   291                 .run()
 
   286                 .writeAll();
 
   292                 .writeAll();
 
   291         Files.createDirectories(unnamedClasses);
 
   297         Files.createDirectories(unnamedClasses);
 
   292 
   298 
   293         tb.writeJavaFiles(unnamedSrc,
 
   299         tb.writeJavaFiles(unnamedSrc,
 
   294                           "package impl; public class Impl { }");
 
   300                           "package impl; public class Impl { }");
 
   295 
   301 
   296         tb.new JavacTask()
 
   302         new JavacTask(tb)
 
   297           .options("-XaddReads:m1=ALL-UNNAMED",
 
   303           .options("-XaddReads:m1=ALL-UNNAMED",
 
   298                    "-Xmodule:m1",
 
   304                    "-Xmodule:m1",
 
   299                    "-modulepath", classes.toString())
 
   305                    "-modulepath", classes.toString())
 
   300           .outdir(unnamedClasses)
 
   306           .outdir(unnamedClasses)
 
   301           .files(findJavaFiles(unnamedSrc))
 
   307           .files(findJavaFiles(unnamedSrc))
jdk-sandbox