/*
* Copyright (c) 2014, 2016, 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 8065360
* @summary The test checks possibility of class members to be imported.
* @library /tools/lib
* @modules jdk.compiler/com.sun.tools.javac.api
* jdk.compiler/com.sun.tools.javac.main
* jdk.jdeps/com.sun.tools.javap
* @build toolbox.ToolBox ImportMembersTest
* @run main ImportMembersTest
*/
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import toolbox.ToolBox;
/**
* The test checks that members of a class, an enum, an interface or annotation
* can be imported with help of a static import or an import statement.
* The tests generates a code, compiles it and checks whether it can be compiled
* successfully or fails with a proper message.
* The following is the example of a test case:
* package pkg;
* class ChildA extends A {}
*
* package pkg;
* class A {
* static class Inner {}
* static Object field;
* static void method() {}
* }
*
* package pkg;
* import static pkg.ChildA.method;
* public class Test {{
* method();
* }}
*
*/
public class ImportMembersTest {
private static final String[] expectedErrorMessages = {
"Test.java:\\d+:\\d+: compiler.err.cant.resolve.location: .*\n1 error\n",
"Test.java:\\d+:\\d+: compiler.err.import.requires.canonical: .*\n1 error\n"
};
private static final String sourceTemplate =
"package pkg;\n" +
"#IMPORT\n" +
"public class Test {{\n" +
" #STATEMENT\n" +
"}}\n";
public static void main(String[] args) {
new ImportMembersTest().test();
}
public void test() {
int passed = 0;
int total = 0;
for (ClassType classType : ClassType.values()) {
for (ImportType importType : ImportType.values()) {
for (MemberType memberType : MemberType.values()) {
++total;
List<ToolBox.JavaSource> sources = classType.getSources();
sources.add(new ToolBox.JavaSource("Test.java",
generateSource(classType, memberType, importType)));
CompilationResult compilationResult = compile(sources);
boolean isErrorExpected = importType.hasError(classType, memberType);
if (!compilationResult.isSuccessful) {
if (isErrorExpected) {
String expectedErrorMessage =
getExpectedErrorMessage(classType, importType, memberType);
if (compilationResult.message.matches(expectedErrorMessage)) {
++passed;
} else {
reportFailure(sources, String.format("Expected compilation failure message:\n" +
"%s\ngot message:\n%s",
expectedErrorMessage, compilationResult.message));
}
} else {
reportFailure(sources, String.format("Unexpected compilation failure:\n%s",
compilationResult.message));
}
} else {
if (isErrorExpected) {
reportFailure(sources, "Expected compilation failure.");
} else {
++passed;
}
}
}
}
}
String message = String.format(
"Total test cases run: %d, passed: %d, failed: %d.",
total, passed, total - passed);
if (passed != total) {
throw new RuntimeException(message);
}
echo(message);
}
private String getExpectedErrorMessage(ClassType classType, ImportType importType, MemberType memberType) {
String expectedErrorMessage;
if (importType == ImportType.IMPORT && classType == ClassType.CHILD_A &&
memberType == MemberType.CLASS) {
expectedErrorMessage = expectedErrorMessages[1];
} else {
expectedErrorMessage = expectedErrorMessages[0];
}
return expectedErrorMessage;
}
private void reportFailure(List<ToolBox.JavaSource> sources, String message) {
echo("Test case failed!");
printSources(sources);
echo(message);
echo();
}
private String generateSource(ClassType classType, MemberType memberType, ImportType importType) {
String importString = importType.generateImport(classType.getClassName(), memberType.getMemberType());
String statement;
if (importType.hasError(classType, memberType)) {
// if the source code has a compilation error, nothing is added.
// just to prevent the compiler from appending additional
// compilation errors to output
statement = "";
} else if (memberType == MemberType.STAR) {
// in case of import-on-demand, every class member is used
if (importType == ImportType.STATIC_IMPORT) {
statement = MemberType.CLASS.getStatement() + "\n "
+ MemberType.FIELD.getStatement();
// an annotation does not have a static method.
if (classType != ClassType.D) {
statement += "\n " + MemberType.METHOD.getStatement() + "\n";
}
} else {
statement = classType != ClassType.CHILD_A
? MemberType.CLASS.getStatement() : "";
}
} else {
statement = memberType.getStatement();
}
return sourceTemplate
.replace("#IMPORT", importString)
.replace("#STATEMENT", statement);
}
private static class CompilationResult {
public final boolean isSuccessful;
public final String message;
public CompilationResult(boolean isSuccessful, String message) {
this.isSuccessful = isSuccessful;
this.message = message;
}
}
private CompilationResult compile(List<ToolBox.JavaSource> sources) {
StringWriter writer = new StringWriter();
JavaCompiler jc = ToolProvider.getSystemJavaCompiler();
Boolean call = jc.getTask(writer, null, null, Arrays.asList("-XDrawDiagnostics"), null, sources).call();
return new CompilationResult(call, writer.toString().replace(ToolBox.lineSeparator, "\n"));
}
public void printSources(List<ToolBox.JavaSource> sources) {
for (ToolBox.JavaSource javaSource : sources) {
echo(javaSource.getCharContent(true).toString());
}
}
public void echo() {
echo("");
}
public void echo(String output) {
printf(output + "\n");
}
public void printf(String template, Object...args) {
System.err.print(String.format(template, args).replace("\n", ToolBox.lineSeparator));
}
enum ClassType {
A("A",
"package pkg;\n" +
"class A {\n" +
" static class Inner {}\n" +
" static Object field;\n" +
" static void method() {}\n" +
"}\n"
),
B("B",
"package pkg;\n" +
"interface B {\n" +
" static class Inner {}\n" +
" static Object field = null;\n" +
" static void method() {}\n" +
"}\n"
),
C("C",
"package pkg;\n" +
"enum C {field;\n" +
" static class Inner {}\n" +
" static void method() {}\n" +
"}\n"
),
D("D",
"package pkg;\n" +
"@interface D {\n" +
" static class Inner {}\n" +
" static Object field = null;\n" +
"}\n"
),
CHILD_A("ChildA",
"package pkg;\n" +
"class ChildA extends A {}\n",
A);
private final String className;
private final String source;
private final ClassType parentType;
private ClassType(String className, String source) {
this(className, source, null);
}
private ClassType(String className, String source, ClassType classType) {
this.className = className;
this.source = source;
this.parentType = classType;
}
public String getClassName() {
return className;
}
public List<ToolBox.JavaSource> getSources() {
List<ToolBox.JavaSource> sourceList = new ArrayList<>();
ClassType current = this;
while (current != null) {
sourceList.add(new ToolBox.JavaSource(current.className, current.source));
current = current.parentType;
}
return sourceList;
}
}
enum MemberType {
CLASS("Inner", "Inner inner = null;"),
FIELD("field", "Object o = field;"),
METHOD("method", "method();"),
STAR("*", ""),
NOT_EXIST("NotExist", "");
private final String memberType;
private final String statement;
private MemberType(String memberType, String statement) {
this.memberType = memberType;
this.statement = statement;
}
public String getStatement() {
return statement;
}
public String getMemberType() {
return memberType;
}
}
enum ImportType {
IMPORT("import pkg.#CLASS_NAME.#MEMBER_NAME;"),
STATIC_IMPORT("import static pkg.#CLASS_NAME.#MEMBER_NAME;");
private final String importType;
private ImportType(String importType) {
this.importType = importType;
}
public String generateImport(String className, String memberName) {
return importType
.replace("#CLASS_NAME", className)
.replace("#MEMBER_NAME", memberName);
}
public boolean hasError(ClassType classType, MemberType memberType) {
switch (memberType) {
case FIELD:
return this != ImportType.STATIC_IMPORT;
case METHOD:
return this != ImportType.STATIC_IMPORT || classType == ClassType.D;
case NOT_EXIST:
return true;
case CLASS:
return classType.parentType != null && this != STATIC_IMPORT;
default:
return false;
}
}
}
}