--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/importscope/TestLazyImportScope.java Wed Dec 03 13:46:12 2014 +0100
@@ -0,0 +1,224 @@
+/*
+ * Copyright (c) 2011-2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 7101822
+ * @summary static import fails to resolve interfaces on nested enums via import statements
+ */
+
+import com.sun.source.util.JavacTask;
+import java.net.URI;
+import java.util.Arrays;
+import javax.tools.Diagnostic;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+public class TestLazyImportScope {
+
+ static int checkCount = 0;
+
+ enum ImportOrder {
+ NORMAL("import a.C.D;\n" +
+ "#I"),
+ REVERSE("#I\n" +
+ "import a.C.D;");
+
+ String importLayout;
+
+ ImportOrder(String importLayout) {
+ this.importLayout = importLayout;
+ }
+
+ String getImportString(ImportKind ik) {
+ return importLayout.replaceAll("#I", ik.importStr);
+ }
+ }
+
+ enum ImportKind {
+ NAMED("import a.A.B.E;"),
+ ON_DEMAND("import a.A.B.*;"),
+ STATIC_NAMED_TYPE("import static a.A.B.E;"),
+ STATIC_NAMED_MEMBER("import static a.A.B.bm;"),
+ STATIC_ON_DEMAND("import static a.A.B.*;");
+
+ String importStr;
+
+ private ImportKind(String importStr) {
+ this.importStr = importStr;
+ }
+ }
+
+ enum TypeRefKind {
+ NONE(""),
+ E("E e = null;"),
+ F("F f = null;"),
+ BOTH("E e = null; F f = null;");
+
+ String typeRefStr;
+
+ private TypeRefKind(String typeRefStr) {
+ this.typeRefStr = typeRefStr;
+ }
+
+ boolean isImported(ImportKind ik) {
+ switch (ik) {
+ case NAMED:
+ case STATIC_NAMED_TYPE: return this == NONE || this == E;
+ case ON_DEMAND:
+ case STATIC_ON_DEMAND: return true;
+ default: return this == NONE;
+ }
+ }
+ }
+
+ enum MemberRefKind {
+ NONE(""),
+ FIELD("Object o = bf;"),
+ METHOD("bm();"),
+ BOTH("Object o = bf; bm();");
+
+ String memberRefStr;
+
+ private MemberRefKind(String memberRefStr) {
+ this.memberRefStr = memberRefStr;
+ }
+
+ boolean isImported(ImportKind ik) {
+ switch (ik) {
+ case STATIC_NAMED_MEMBER: return this == NONE || this == METHOD;
+ case STATIC_ON_DEMAND: return true;
+ default: return this == NONE;
+ }
+ }
+ }
+
+ public static void main(String... args) throws Exception {
+
+ //create default shared JavaCompiler - reused across multiple compilations
+ JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
+ StandardJavaFileManager fm = comp.getStandardFileManager(null, null, null);
+
+ for (ImportOrder ord : ImportOrder.values()) {
+ for (ImportKind ik : ImportKind.values()) {
+ for (TypeRefKind tk : TypeRefKind.values()) {
+ for (MemberRefKind mk : MemberRefKind.values()) {
+ new TestLazyImportScope(ord, ik, tk, mk).run(comp, fm);
+ }
+ }
+ }
+ }
+ System.out.println("Total check executed: " + checkCount);
+ }
+
+ ImportOrder ord;
+ ImportKind ik;
+ TypeRefKind tk;
+ MemberRefKind mk;
+ JavaSource source;
+ DiagnosticChecker diagChecker;
+
+ TestLazyImportScope(ImportOrder ord, ImportKind ik, TypeRefKind tk, MemberRefKind mk) {
+ this.ord = ord;
+ this.ik = ik;
+ this.tk = tk;
+ this.mk = mk;
+ this.source = new JavaSource();
+ this.diagChecker = new DiagnosticChecker();
+ }
+
+ class JavaSource extends SimpleJavaFileObject {
+
+ String bodyTemplate = "package a;\n" +
+ "#I\n" +
+ "class A {\n" +
+ " static class B extends D {\n" +
+ " static class E { }\n" +
+ " static class F { }\n" +
+ " static Object bf;\n" +
+ " static void bm() { }\n" +
+ " }\n" +
+ "}\n" +
+ "class C {\n" +
+ " static class D { }\n" +
+ "}\n" +
+ "class Test {\n" +
+ " void test() {\n" +
+ " #T\n" +
+ " #M\n" +
+ " }\n" +
+ "}";
+
+ String source;
+
+ public JavaSource() {
+ super(URI.create("myfo:/Test.java"), JavaFileObject.Kind.SOURCE);
+ source = bodyTemplate.replaceAll("#I", ord.getImportString(ik))
+ .replaceAll("#T", tk.typeRefStr)
+ .replaceAll("#M", mk.memberRefStr);
+ }
+
+ @Override
+ public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+ return source;
+ }
+ }
+
+ void run(JavaCompiler tool, StandardJavaFileManager fm) throws Exception {
+ JavacTask ct = (JavacTask)tool.getTask(null, fm, diagChecker,
+ null, null, Arrays.asList(source));
+ try {
+ ct.analyze();
+ } catch (Throwable ex) {
+ throw new AssertionError("Error thrown when compiling the following code:\n" + source.getCharContent(true));
+ }
+ check();
+ }
+
+ void check() {
+ checkCount++;
+
+ boolean errorExpected = !tk.isImported(ik) || !mk.isImported(ik);
+
+ if (errorExpected != diagChecker.errorFound) {
+ throw new Error("invalid diagnostics for source:\n" +
+ source.getCharContent(true) +
+ "\nFound error: " + diagChecker.errorFound +
+ "\nExpected error: " + errorExpected);
+ }
+ }
+
+ static class DiagnosticChecker implements javax.tools.DiagnosticListener<JavaFileObject> {
+
+ boolean errorFound;
+
+ public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
+ if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {
+ errorFound = true;
+ }
+ }
+ }
+}