1 /*

     2  * Copyright (c) 2016, 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  * @summary tests for module resolution

    27  * @library /tools/lib

    28  * @modules

    29  *      jdk.compiler/com.sun.tools.javac.api

    30  *      jdk.compiler/com.sun.tools.javac.main

    31  *      jdk.jdeps/com.sun.tools.javap

    32  * @build ToolBox ModuleTestBase

    33  * @run main QueryBeforeEnter

    34  */

    35 

    36 import java.io.File;

    37 import java.io.OutputStream;

    38 import java.nio.file.*;

    39 import java.util.Arrays;

    40 import java.util.Set;

    41 

    42 import javax.annotation.processing.AbstractProcessor;

    43 import javax.annotation.processing.RoundEnvironment;

    44 import javax.annotation.processing.SupportedAnnotationTypes;

    45 import javax.annotation.processing.SupportedSourceVersion;

    46 import javax.lang.model.SourceVersion;

    47 import javax.lang.model.element.TypeElement;

    48 import javax.tools.JavaCompiler;

    49 import javax.tools.StandardJavaFileManager;

    50 import javax.tools.ToolProvider;

    51 

    52 import com.sun.source.util.JavacTask;

    53 import com.sun.source.util.Plugin;

    54 import com.sun.source.util.TaskEvent;

    55 import com.sun.source.util.TaskListener;

    56 import com.sun.tools.javac.Main;

    57 

    58 public class QueryBeforeEnter extends ModuleTestBase {

    59     public static void main(String... args) throws Exception {

    60         QueryBeforeEnter t = new QueryBeforeEnter();

    61         t.runTests();

    62     }

    63 

    64     @Test

    65     void testEmpty(Path base) throws Exception {

    66         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

    67         JavacTask task = (JavacTask) javaCompiler.getTask(null, null, null, null, null, null);

    68         TypeElement jlString = task.getElements().getTypeElement("java.lang.String");

    69 

    70         assertNotNull(jlString);

    71     }

    72 

    73     @Test

    74     void testUnnamed(Path base) throws Exception {

    75         Path moduleSrc = base.resolve("module-src");

    76         Path m1 = moduleSrc.resolve("m1");

    77 

    78         tb.writeJavaFiles(m1,

    79                           "module m1 { exports m1; }",

    80                           "package m1; public class M1 {}");

    81 

    82         Path m2 = moduleSrc.resolve("m2");

    83 

    84         tb.writeJavaFiles(m2,

    85                           "module m2 { exports m2; }",

    86                           "package m2; public class M2 {}");

    87 

    88         Path modulePath = base.resolve("module-path");

    89 

    90         Files.createDirectories(modulePath);

    91 

    92         tb.new JavacTask()

    93                 .options("-modulesourcepath", moduleSrc.toString())

    94                 .outdir(modulePath)

    95                 .files(findJavaFiles(moduleSrc))

    96                 .run()

    97                 .writeAll();

    98 

    99         Path cpSrc = base.resolve("cp-src");

   100 

   101         tb.writeJavaFiles(cpSrc,

   102                           "package cp; public class CP {}");

   103 

   104         Path cp = base.resolve("cp");

   105 

   106         Files.createDirectories(cp);

   107 

   108         tb.new JavacTask()

   109                 .outdir(cp)

   110                 .files(findJavaFiles(cpSrc))

   111                 .run()

   112                 .writeAll();

   113 

   114         Path src = base.resolve("src");

   115 

   116         tb.writeJavaFiles(src,

   117                           "package test; public class Test1 {}",

   118                           "package test; public class Test2 {}");

   119 

   120         Path out = base.resolve("out");

   121 

   122         Files.createDirectories(out);

   123 

   124         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

   125         try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

   126             JavacTask task = (JavacTask) javaCompiler.getTask(null,

   127                                                               null,

   128                                                               d -> { throw new IllegalStateException(d.toString()); },

   129                                                               Arrays.asList("-modulepath", modulePath.toString(),

   130                                                                             "-classpath", cp.toString(),

   131                                                                             "-sourcepath", src.toString()),

   132                                                               null,

   133                                                               fm.getJavaFileObjects(src.resolve("test").resolve("Test2.java")));

   134             assertNotNull(task.getElements().getTypeElement("java.lang.String"));

   135             assertNotNull(task.getElements().getTypeElement("javax.tools.ToolProvider"));

   136             assertNull(task.getElements().getTypeElement("m1.M1"));

   137             assertNull(task.getElements().getTypeElement("m2.M2"));

   138             assertNotNull(task.getElements().getTypeElement("cp.CP"));

   139             assertNotNull(task.getElements().getTypeElement("test.Test1"));

   140             assertNotNull(task.getElements().getTypeElement("test.Test2"));

   141             assertNotNull(task.getElements().getModuleElement("java.base"));

   142             assertNotNull(task.getElements().getModuleElement("java.compiler"));

   143             assertNull(task.getElements().getModuleElement("m1"));

   144             assertNull(task.getElements().getModuleElement("m2"));

   145         }

   146     }

   147 

   148     @Test

   149     void testSingleNamed(Path base) throws Exception {

   150         Path moduleSrc = base.resolve("module-src");

   151         Path m1 = moduleSrc.resolve("m1");

   152 

   153         tb.writeJavaFiles(m1,

   154                           "module m1 { exports m1; }",

   155                           "package m1; public class M1 {}");

   156 

   157         Path m2 = moduleSrc.resolve("m2");

   158 

   159         tb.writeJavaFiles(m2,

   160                           "module m2 { exports m2; }",

   161                           "package m2; public class M2 {}");

   162 

   163         Path modulePath = base.resolve("module-path");

   164 

   165         Files.createDirectories(modulePath);

   166 

   167         tb.new JavacTask()

   168                 .options("-modulesourcepath", moduleSrc.toString())

   169                 .outdir(modulePath)

   170                 .files(findJavaFiles(moduleSrc))

   171                 .run()

   172                 .writeAll();

   173 

   174         Path cpSrc = base.resolve("cp-src");

   175 

   176         tb.writeJavaFiles(cpSrc,

   177                           "package cp; public class CP {}");

   178 

   179         Path cp = base.resolve("cp");

   180 

   181         Files.createDirectories(cp);

   182 

   183         tb.new JavacTask()

   184                 .outdir(cp)

   185                 .files(findJavaFiles(cpSrc))

   186                 .run()

   187                 .writeAll();

   188 

   189         Path src = base.resolve("src");

   190 

   191         tb.writeJavaFiles(src,

   192                           "module test { requires java.base; requires m1; } ",

   193                           "package test; public class Test {}");

   194 

   195         Path out = base.resolve("out");

   196 

   197         Files.createDirectories(out);

   198 

   199         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

   200         try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

   201             JavacTask task = (JavacTask) javaCompiler.getTask(null,

   202                                                               null,

   203                                                               d -> { throw new IllegalStateException(d.toString()); },

   204                                                               Arrays.asList("-modulepath", modulePath.toString(),

   205                                                                             "-classpath", cp.toString(),

   206                                                                             "-sourcepath", src.toString()),

   207                                                               null,

   208                                                               fm.getJavaFileObjects(findJavaFiles(src)));

   209             assertNotNull(task.getElements().getTypeElement("java.lang.String"));

   210             assertNull(task.getElements().getTypeElement("javax.tools.ToolProvider"));

   211             assertNotNull(task.getElements().getTypeElement("m1.M1"));

   212             assertNull(task.getElements().getTypeElement("m2.M2"));

   213             assertNotNull(task.getElements().getTypeElement("test.Test"));

   214             assertNotNull(task.getElements().getModuleElement("java.base"));

   215             assertNull(task.getElements().getModuleElement("java.compiler"));

   216             assertNotNull(task.getElements().getModuleElement("m1"));

   217             assertNull(task.getElements().getModuleElement("m2"));

   218             assertNotNull(task.getElements().getModuleElement("test"));

   219         }

   220     }

   221 

   222     @Test

   223     void testMultiModule(Path base) throws Exception {

   224         Path modulePathSrc = base.resolve("module-path-src");

   225         Path m1 = modulePathSrc.resolve("m1");

   226 

   227         tb.writeJavaFiles(m1,

   228                           "module m1 { exports m1; }",

   229                           "package m1; public class M1 {}");

   230 

   231         Path m2 = modulePathSrc.resolve("m2");

   232 

   233         tb.writeJavaFiles(m2,

   234                           "module m2 { exports m2; }",

   235                           "package m2; public class M2 {}");

   236 

   237         Path modulePath = base.resolve("module-path");

   238 

   239         Files.createDirectories(modulePath);

   240 

   241         tb.new JavacTask()

   242                 .options("-modulesourcepath", modulePathSrc.toString())

   243                 .outdir(modulePath)

   244                 .files(findJavaFiles(modulePathSrc))

   245                 .run()

   246                 .writeAll();

   247 

   248         Path cpSrc = base.resolve("cp-src");

   249 

   250         tb.writeJavaFiles(cpSrc,

   251                           "package cp; public class CP {}");

   252 

   253         Path cp = base.resolve("cp");

   254 

   255         Files.createDirectories(cp);

   256 

   257         tb.new JavacTask()

   258                 .outdir(cp)

   259                 .files(findJavaFiles(cpSrc))

   260                 .run()

   261                 .writeAll();

   262 

   263         Path moduleSrc = base.resolve("module-src");

   264         Path m3 = moduleSrc.resolve("m3");

   265 

   266         tb.writeJavaFiles(m3,

   267                           "module m3 { requires m1; exports m3; }",

   268                           "package m3; public class M3 {  }");

   269 

   270         Path m4 = moduleSrc.resolve("m4");

   271 

   272         tb.writeJavaFiles(m4,

   273                           "module m4 { exports m4; }",

   274                           "package m4; public class M4 {}");

   275 

   276         Path out = base.resolve("out");

   277 

   278         Files.createDirectories(out);

   279 

   280         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

   281         try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

   282             JavacTask task = (JavacTask) javaCompiler.getTask(null,

   283                                                               null,

   284                                                               d -> { throw new IllegalStateException(d.toString()); },

   285                                                               Arrays.asList("-modulepath", modulePath.toString(),

   286                                                                             "-classpath", cp.toString(),

   287                                                                             "-modulesourcepath", moduleSrc.toString(),

   288                                                                             "-d", out.toString()),

   289                                                               null,

   290                                                               fm.getJavaFileObjects(findJavaFiles(moduleSrc)));

   291             assertNotNull(task.getElements().getTypeElement("java.lang.String"));

   292             assertNull(task.getElements().getTypeElement("javax.tools.ToolProvider"));

   293             assertNotNull(task.getElements().getTypeElement("m1.M1"));

   294             assertNull(task.getElements().getTypeElement("m2.M2"));

   295             assertNotNull(task.getElements().getTypeElement("m3.M3"));

   296             assertNotNull(task.getElements().getTypeElement("m4.M4"));

   297             assertNotNull(task.getElements().getModuleElement("java.base"));

   298             assertNull(task.getElements().getModuleElement("java.compiler"));

   299             assertNotNull(task.getElements().getModuleElement("m1"));

   300             assertNull(task.getElements().getModuleElement("m2"));

   301             assertNotNull(task.getElements().getModuleElement("m3"));

   302             assertNotNull(task.getElements().getModuleElement("m4"));

   303         }

   304     }

   305 

   306     @Test

   307     void testTooSoon(Path base) throws Exception {

   308         Path src = base.resolve("src");

   309 

   310         tb.writeJavaFiles(src,

   311                           "package test; public class Test {}");

   312 

   313         Path out = base.resolve("out");

   314 

   315         Files.createDirectories(out);

   316 

   317         Path reg = base.resolve("reg");

   318         Path regFile = reg.resolve("META-INF").resolve("services").resolve(Plugin.class.getName());

   319 

   320         Files.createDirectories(regFile.getParent());

   321 

   322         try (OutputStream regOut = Files.newOutputStream(regFile)) {

   323             regOut.write(PluginImpl.class.getName().getBytes());

   324         }

   325 

   326         String processorPath = System.getProperty("test.class.path") + File.pathSeparator + reg.toString();

   327 

   328         JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();

   329         Path testSource = src.resolve("test").resolve("Test.java");

   330         try (StandardJavaFileManager fm = javaCompiler.getStandardFileManager(null, null, null)) {

   331             JavacTask task = (JavacTask) javaCompiler.getTask(null,

   332                                                               null,

   333                                                               d -> { throw new IllegalStateException(d.toString()); },

   334                                                               Arrays.asList("-processorpath", processorPath,

   335                                                                             "-processor", AP.class.getName(),

   336                                                                             "-Xplugin:test"),

   337                                                               null,

   338                                                               fm.getJavaFileObjects(testSource));

   339             task.call();

   340         }

   341 

   342         Main.compile(new String[] {"-processorpath", processorPath,

   343                                    "-Xplugin:test",

   344                                    testSource.toString()});

   345     }

   346 

   347     public static class PluginImpl implements Plugin {

   348 

   349         @Override

   350         public String getName() {

   351             return "test";

   352         }

   353 

   354         @Override

   355         public void init(JavacTask task, String... args) {

   356             task.addTaskListener(new TaskListener() {

   357                 boolean wasEntered;

   358                 @Override

   359                 public void started(TaskEvent e) {

   360                     switch (e.getKind()) {

   361                         case COMPILATION: case PARSE:

   362                             shouldFail(e.getKind());

   363                             break;

   364                         case ANNOTATION_PROCESSING: case ENTER:

   365                             if (wasEntered) {

   366                                 shouldPass(e.getKind());

   367                             } else {

   368                                 shouldFail(e.getKind());

   369                             }

   370                             break;

   371                         default:

   372                             shouldPass(e.getKind());

   373                             break;

   374                     }

   375                 }

   376                 @Override

   377                 public void finished(TaskEvent e) {

   378                     switch (e.getKind()) {

   379                         case PARSE:

   380                             shouldFail(e.getKind());

   381                             break;

   382                         case ENTER:

   383                             wasEntered = true;

   384                             //fall-through:

   385                         default:

   386                             shouldPass(e.getKind());

   387                             break;

   388                     }

   389                 }

   390                 private void shouldFail(TaskEvent.Kind kind) {

   391                     try {

   392                         task.getElements().getTypeElement("java.lang.String");

   393                         throw new AssertionError("Expected exception not observed; kind=" + kind.name());

   394                     } catch (IllegalStateException ex) {

   395                         //correct

   396                     }

   397                 }

   398                 private void shouldPass(TaskEvent.Kind kind) {

   399                     assertNotNull(task.getElements().getTypeElement("java.lang.String"));

   400                 }

   401             });

   402 

   403         }

   404 

   405     }

   406 

   407     @SupportedAnnotationTypes("*")

   408     public static final class AP extends AbstractProcessor {

   409 

   410         @Override

   411         public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

   412             return false;

   413         }

   414 

   415         @Override

   416         public SourceVersion getSupportedSourceVersion() {

   417             return SourceVersion.latest();

   418         }

   419 

   420     }

   421 

   422     private static void assertNotNull(Object actual) {

   423         if (actual == null) {

   424             throw new AssertionError("unexpected null!");

   425         }

   426     }

   427 

   428     private static void assertNull(Object actual) {

   429         if (actual != null) {

   430             throw new AssertionError("unexpected non null!");

   431         }

   432     }

   433 

   434 }