33  *      jdk.compiler/com.sun.tools.javac.processing

    57 import javax.lang.model.element.PackageElement;

    60 import javax.lang.model.util.Elements;

    70 import com.sun.tools.javac.code.Symbol.PackageSymbol;

    72 import com.sun.tools.javac.processing.JavacProcessingEnvironment;

    73 import com.sun.tools.javac.util.Context;

   663     @Test

   664     public void testUnnamedPackage(Path base) throws Exception {

   665         List<String> out;

   666         List<String> expected;

   667 

   668         //-source 8:

   669         Path src8 = base.resolve("src8");

   670         Files.createDirectories(src8);

   671         tb.writeJavaFiles(src8,

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

   673         Path classes = base.resolve("classes");

   674         tb.createDirectories(classes);

   675 

   676         out = new JavacTask(tb)

   677                 .options("--source-path", src8.toString(),

   678                          "-processor", UnnamedPackageProcessor.class.getName(),

   679                          "-source", "8")

   680                 .outdir(classes)

   681                 .files(findJavaFiles(src8))

   682                 .run()

   683                 .writeAll()

   684                 .getOutputLines(OutputKind.STDOUT);

   685 

   686         expected = Arrays.asList("noModule");

   687 

   688         if (!expected.equals(out)) {

   689             throw new AssertionError("Unexpected output: " + out);

   690         }

   691 

   692         //-source 9, unnamed:

   693         Path srcUnnamed = base.resolve("srcUnnamed");

   694         Files.createDirectories(srcUnnamed);

   695         tb.writeJavaFiles(srcUnnamed,

   696                           "public class Test {}");

   697         Path classesUnnamed = base.resolve("classesUnnamed");

   698         tb.createDirectories(classesUnnamed);

   699 

   700         out = new JavacTask(tb)

   701                 .options("--source-path", srcUnnamed.toString(),

   702                          "-processor", UnnamedPackageProcessor.class.getName())

   703                 .outdir(classesUnnamed)

   704                 .files(findJavaFiles(srcUnnamed))

   705                 .run()

   706                 .writeAll()

   707                 .getOutputLines(OutputKind.STDOUT);

   708 

   709         expected = Arrays.asList("unnamedModule");

   710 

   711         if (!expected.equals(out)) {

   712             throw new AssertionError("Unexpected output: " + out);

   713         }

   714 

   715         //-source 9, named:

   716         Path srcNamed = base.resolve("srcNamed");

   717         Files.createDirectories(srcNamed);

   718         tb.writeJavaFiles(srcNamed,

   719                           "module m {}",

   720                           "public class Test {}");

   721         Path classesNamed = base.resolve("classesNamed");

   722         tb.createDirectories(classesNamed);

   723 

   724         out = new JavacTask(tb)

   725                 .options("--source-path", srcNamed.toString(),

   726                          "-classpath", "",

   727                          "-processorpath", System.getProperty("test.class.path"),

   728                          "-processor", UnnamedPackageProcessor.class.getName())

   729                 .outdir(classesNamed)

   730                 .files(findJavaFiles(srcNamed))

   731                 .run()

   732                 .writeAll()

   733                 .getOutputLines(OutputKind.STDOUT);

   734 

   735         expected = Arrays.asList("m");

   736 

   737         if (!expected.equals(out)) {

   738             throw new AssertionError("Unexpected output: " + out);

   739         }

   740 

   741         //-source 9, conflict:

   742         Path srcNamed2 = base.resolve("srcNamed2");

   743         Path srcNamed2m1 = srcNamed2.resolve("m1x");

   744         Files.createDirectories(srcNamed2m1);

   745         tb.writeJavaFiles(srcNamed2m1,

   746                           "module m1x {}",

   747                           "public class Test {}");

   748         Path srcNamed2m2 = srcNamed2.resolve("m2x");

   749         Files.createDirectories(srcNamed2m2);

   750         tb.writeJavaFiles(srcNamed2m2,

   751                           "module m2x {}",

   752                           "public class Test {}");

   753         Path classesNamed2 = base.resolve("classesNamed2");

   754         tb.createDirectories(classesNamed2);

   755 

   756         out = new JavacTask(tb)

   757                 .options("--module-source-path", srcNamed2.toString(),

   758                          "-classpath", "",

   759                          "-processorpath", System.getProperty("test.class.path"),

   760                          "-processor", UnnamedPackageProcessor.class.getName(),

   761                          "-XDshould-stop.ifError=FLOW")

   762                 .outdir(classesNamed2)

   763                 .files(findJavaFiles(srcNamed2))

   764                 .run(Expect.FAIL)

   765                 .writeAll()

   766                 .getOutputLines(OutputKind.STDOUT);

   767 

   768         expected = Arrays.asList("null",

   769                                  "m1x: true",

   770                                  "m2x: true");

   771 

   772         if (!expected.equals(out)) {

   773             throw new AssertionError("Unexpected output: " + out);

   774         }

   775     }

   776 

   777     @SupportedAnnotationTypes("*")

   778     public static final class UnnamedPackageProcessor extends AbstractProcessor {

   779 

   780         int round = 0;

   781 

   782         @Override

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

   784             if (round++ != 0)

   785                 return false;

   786 

   787             Elements elements = processingEnv.getElementUtils();

   788             PackageElement pe = elements.getPackageElement("");

   789 

   790             if (pe == null) {

   791                 System.out.println("null");

   792             } else {

   793                 ModuleElement mod = (ModuleElement) pe.getEnclosingElement();

   794                 if (mod == null) {

   795                     System.out.println("noModule");

   796                 } else if (mod.isUnnamed()) {

   797                     System.out.println("unnamedModule");

   798                 } else {

   799                     System.out.println(mod);

   800                 }

   801             }

   802 

   803             ModuleElement m1x = elements.getModuleElement("m1x");

   804             ModuleElement m2x = elements.getModuleElement("m2x");

   805 

   806             if (m1x != null && m2x != null) {

   807                 System.out.println("m1x: " + (elements.getPackageElement(m1x, "") != null));

   808                 System.out.println("m2x: " + (elements.getPackageElement(m2x, "") != null));

   809             }

   810 

   811             return false;

   812         }

   813 

   814     }