/*
* 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 8042931
* @summary Checking EnclosingMethod attribute of anonymous/local class.
* @library /tools/lib /tools/javac/lib ../lib
* @modules jdk.compiler/com.sun.tools.javac.api
* jdk.compiler/com.sun.tools.javac.main
* jdk.jdeps/com.sun.tools.classfile
* @build toolbox.ToolBox InMemoryFileManager TestResult TestBase
* @run main EnclosingMethodTest
*/
import com.sun.tools.classfile.Attribute;
import com.sun.tools.classfile.ClassFile;
import com.sun.tools.classfile.EnclosingMethod_attribute;
import java.io.File;
import java.io.FilenameFilter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;
/**
* The test checks the enclosing method attribute of anonymous/local classes.
* The top-level class contains the anonymous and local classes to be tested. The test examines
* each inner class and determine whether the class should have the EnclosingMethod attribute or not.
* Golden information about enclosing methods are held in annotation {@code ExpectedEnclosingMethod}.
*
* The test assumes that a class must have the EnclosingMethod attribute if the class is annotated or
* if its parent class is annotated in case of anonymous class. In addition, classes
* named {@code VariableInitializer} are introduced to test variable initializer cases. These classes
* must not have the enclosing method attribute, but its anonymous derived class must.
* After classification of classes, the test checks whether classes contain the correct enclosing
* method attribute in case of anonymous/local class, or checks whether classes do not contain
* the EnclosingMethod attribute, otherwise.
*
* Test cases:
* top-level class as enclosing class:
* 1. anonymous and local classes in static initializer;
* 2. anonymous and local classes in instance initializer;
* 3. anonymous and local classes in lambda;
* 4. anonymous and local classes in constructor;
* 5. anonymous and local classes in method;
* 6. static and instance variable initializer.
*
* inner class as enclosing class:
* 1. anonymous and local classes in static initializer;
* 2. anonymous and local classes in instance initializer;
* 3. anonymous and local classes in lambda;
* 4. anonymous and local classes in constructor;
* 5. anonymous and local classes in method;
* 6. static and instance variable initializer.
*
* enum as enclosing class:
* 1. anonymous and local classes in static initializer;
* 2. anonymous and local classes in instance initializer;
* 3. anonymous and local classes in lambda;
* 4. anonymous and local classes in constructor;
* 5. anonymous and local classes in method;
* 6. static and instance variable initializer.
*
* interface as enclosing class:
* 1. anonymous and local classes in lambda;
* 2. anonymous and local classes in static method;
* 3. anonymous and local classes in default method;
* 4. static variable initializer.
*
* annotation as enclosing class:
* 1. anonymous and local classes in lambda;
* 2. static variable initializer.
*/
public class EnclosingMethodTest extends TestResult {
private final Map<Class<?>, ExpectedEnclosingMethod> class2EnclosingMethod = new HashMap<>();
private final Set<Class<?>> noEnclosingMethod = new HashSet<>();
public EnclosingMethodTest() throws ClassNotFoundException {
Class<EnclosingMethodTest> outerClass = EnclosingMethodTest.class;
String outerClassName = outerClass.getSimpleName();
File testClasses = getClassDir();
FilenameFilter filter = (dir, name) -> name.matches(outerClassName + ".*\\.class");
for (File file : testClasses.listFiles(filter)) {
Class<?> clazz = Class.forName(file.getName().replace(".class", ""));
if (clazz.isAnonymousClass()) {
// anonymous class cannot be annotated, information is in its parent class.
ExpectedEnclosingMethod declaredAnnotation =
clazz.getSuperclass().getDeclaredAnnotation(ExpectedEnclosingMethod.class);
class2EnclosingMethod.put(clazz, declaredAnnotation);
} else {
ExpectedEnclosingMethod enclosingMethod = clazz.getDeclaredAnnotation(ExpectedEnclosingMethod.class);
// if class is annotated and it does not contain information for variable initializer cases,
// then it must have the enclosing method attribute.
if (enclosingMethod != null && !clazz.getSimpleName().contains("VariableInitializer")) {
class2EnclosingMethod.put(clazz, enclosingMethod);
} else {
noEnclosingMethod.add(clazz);
}
}
}
}
public void test() throws TestFailedException {
try {
testEnclosingMethodAttribute();
testLackOfEnclosingMethodAttribute();
} finally {
checkStatus();
}
}
private void testLackOfEnclosingMethodAttribute() {
for (Class<?> clazz : noEnclosingMethod) {
try {
addTestCase("Class should not have EnclosingMethod attribute : " + clazz);
ClassFile classFile = readClassFile(clazz);
checkEquals(countEnclosingMethodAttributes(classFile),
0l, "number of the EnclosingMethod attribute in the class is zero : "
+ classFile.getName());
} catch (Exception e) {
addFailure(e);
}
}
}
private void testEnclosingMethodAttribute() {
class2EnclosingMethod.forEach((clazz, enclosingMethod) -> {
try {
String info = enclosingMethod.info() + " "
+ (clazz.isAnonymousClass() ? "anonymous" : "local");
addTestCase(info);
printf("Testing test case : %s\n", info);
ClassFile classFile = readClassFile(clazz);
String className = clazz.getName();
checkEquals(countEnclosingMethodAttributes(classFile), 1l,
"number of the EnclosingMethod attribute in the class is one : "
+ clazz);
EnclosingMethod_attribute attr = (EnclosingMethod_attribute)
classFile.getAttribute(Attribute.EnclosingMethod);
if (!checkNotNull(attr, "the EnclosingMethod attribute is not null : " + className)) {
// stop checking, attr is null. test case failed
return;
}
checkEquals(classFile.constant_pool.getUTF8Value(attr.attribute_name_index),
"EnclosingMethod",
"attribute_name_index of EnclosingMethod attribute in the class : " + className);
checkEquals(attr.attribute_length, 4,
"attribute_length of EnclosingMethod attribute in the class : " + className);
String expectedClassName = enclosingMethod.enclosingClazz().getName();
checkEquals(classFile.constant_pool.getClassInfo(attr.class_index).getName(),
expectedClassName, String.format(
"enclosing class of EnclosingMethod attribute in the class %s is %s",
className, expectedClassName));
String expectedMethodName = enclosingMethod.enclosingMethod();
if (expectedMethodName.isEmpty()) {
// class does not have an enclosing method
checkEquals(attr.method_index, 0, String.format(
"enclosing method of EnclosingMethod attribute in the class %s is null", className));
} else {
String methodName = classFile.constant_pool.getNameAndTypeInfo(attr.method_index).getName();
checkTrue(methodName.startsWith(expectedMethodName), String.format(
"enclosing method of EnclosingMethod attribute in the class %s" +
" is method name %s" +
", actual method name is %s",
className, expectedMethodName, methodName));
}
} catch (Exception e) {
addFailure(e);
}
});
}
private long countEnclosingMethodAttributes(ClassFile classFile) {
return Stream.of(classFile.attributes.attrs)
.filter(x -> x instanceof EnclosingMethod_attribute)
.count();
}
@Retention(RetentionPolicy.RUNTIME)
public @interface ExpectedEnclosingMethod {
String info();
Class<?> enclosingClazz();
String enclosingMethod() default "";
}
public static void main(String[] args) throws ClassNotFoundException, TestFailedException {
new EnclosingMethodTest().test();
}
// Test cases: enclosing class is a top-level class
static {
// anonymous and local classes in static initializer
@ExpectedEnclosingMethod(
info = "EnclosingStaticInitialization in EnclosingMethodTest",
enclosingClazz = EnclosingMethodTest.class
)
class EnclosingStaticInitialization {
}
new EnclosingStaticInitialization() {
};
}
{
// anonymous and local classes in instance initializer
@ExpectedEnclosingMethod(
info = "EnclosingInitialization in EnclosingMethodTest",
enclosingClazz = EnclosingMethodTest.class
)
class EnclosingInitialization {
}
new EnclosingInitialization() {
};
}
Runnable lambda = () -> {
// anonymous and local classes in lambda
@ExpectedEnclosingMethod(
info = "EnclosingLambda in EnclosingMethodTest",
enclosingMethod = "lambda",
enclosingClazz = EnclosingMethodTest.class
)
class EnclosingLambda {
}
new EnclosingLambda() {
};
};
EnclosingMethodTest(int i) {
// anonymous and local classes in constructor
@ExpectedEnclosingMethod(
info = "EnclosingConstructor in EnclosingMethodTest",
enclosingMethod = "<init>",
enclosingClazz = EnclosingMethodTest.class
)
class EnclosingConstructor {
}
new EnclosingConstructor() {
};
}
void method() {
// anonymous and local classes in method
@ExpectedEnclosingMethod(
info = "EnclosingMethod in EnclosingMethodTest",
enclosingMethod = "method",
enclosingClazz = EnclosingMethodTest.class
)
class EnclosingMethod {
}
new EnclosingMethod() {
};
}
@ExpectedEnclosingMethod(
info = "VariableInitializer in EnclosingMethodTest",
enclosingClazz = EnclosingMethodTest.class
)
static class VariableInitializer {
}
// static variable initializer
private static final VariableInitializer cvi = new VariableInitializer() {
};
// instance variable initializer
private final VariableInitializer ivi = new VariableInitializer() {
};
// Test cases: enclosing class is an inner class
public static class notEnclosing01 {
static {
// anonymous and local classes in static initializer
@ExpectedEnclosingMethod(
info = "EnclosingStaticInitialization in notEnclosing01",
enclosingClazz = notEnclosing01.class
)
class EnclosingStaticInitialization {
}
new EnclosingStaticInitialization() {
};
}
{
// anonymous and local classes in instance initializer
@ExpectedEnclosingMethod(
info = "EnclosingInitialization in notEnclosing01",
enclosingClazz = notEnclosing01.class
)
class EnclosingInitialization {
}
new EnclosingInitialization() {
};
}
Runnable lambda = () -> {
// anonymous and local classes in lambda
@ExpectedEnclosingMethod(
info = "EnclosingLambda in notEnclosing01",
enclosingMethod = "lambda",
enclosingClazz = notEnclosing01.class
)
class EnclosingLambda {
}
new EnclosingLambda() {
};
};
notEnclosing01() {
// anonymous and local classes in constructor
@ExpectedEnclosingMethod(
info = "EnclosingConstructor in notEnclosing01",
enclosingMethod = "<init>",
enclosingClazz = notEnclosing01.class
)
class EnclosingConstructor {
}
new EnclosingConstructor() {
};
}
void method() {
// anonymous and local classes in method
@ExpectedEnclosingMethod(
info = "EnclosingMethod in notEnclosing01",
enclosingMethod = "method",
enclosingClazz = notEnclosing01.class
)
class EnclosingMethod {
}
new EnclosingMethod() {
};
}
@ExpectedEnclosingMethod(
info = "VariableInitializer in notEnclosing01",
enclosingClazz = notEnclosing01.class
)
static class VariableInitializer {
}
// static variable initializer
private static final VariableInitializer cvi = new VariableInitializer() {
};
// instance variable initializer
private final VariableInitializer ivi = new VariableInitializer() {
};
}
// Test cases: enclosing class is an interface
public interface notEnclosing02 {
Runnable lambda = () -> {
// anonymous and local classes in lambda
@ExpectedEnclosingMethod(
info = "EnclosingLambda in notEnclosing02",
enclosingMethod = "lambda",
enclosingClazz = notEnclosing02.class
)
class EnclosingLambda {
}
new EnclosingLambda() {
};
};
static void staticMethod() {
// anonymous and local classes in static method
@ExpectedEnclosingMethod(
info = "EnclosingMethod in notEnclosing02",
enclosingMethod = "staticMethod",
enclosingClazz = notEnclosing02.class
)
class EnclosingMethod {
}
new EnclosingMethod() {
};
}
default void defaultMethod() {
// anonymous and local classes in default method
@ExpectedEnclosingMethod(
info = "EnclosingMethod in notEnclosing02",
enclosingMethod = "defaultMethod",
enclosingClazz = notEnclosing02.class
)
class EnclosingMethod {
}
new EnclosingMethod() {
};
}
@ExpectedEnclosingMethod(
info = "VariableInitializer in notEnclosing02",
enclosingClazz = notEnclosing02.class
)
static class VariableInitializer {
}
// static variable initializer
VariableInitializer cvi = new VariableInitializer() {
};
}
// Test cases: enclosing class is an enum
public enum notEnclosing03 {;
static {
// anonymous and local classes in static initializer
@ExpectedEnclosingMethod(
info = "EnclosingStaticInitialization in notEnclosing03",
enclosingClazz = notEnclosing03.class
)
class EnclosingStaticInitialization {
}
new EnclosingStaticInitialization() {
};
}
{
// anonymous and local classes in instance initializer
@ExpectedEnclosingMethod(
info = "EnclosingInitialization in notEnclosing03",
enclosingClazz = notEnclosing03.class
)
class EnclosingInitialization {
}
new EnclosingInitialization() {
};
}
Runnable lambda = () -> {
// anonymous and local classes in lambda
@ExpectedEnclosingMethod(
info = "EnclosingLambda in notEnclosing03",
enclosingMethod = "lambda",
enclosingClazz = notEnclosing03.class
)
class EnclosingLambda {
}
new EnclosingLambda() {
};
};
notEnclosing03() {
// anonymous and local classes in constructor
@ExpectedEnclosingMethod(
info = "EnclosingConstructor in notEnclosing03",
enclosingMethod = "<init>",
enclosingClazz = notEnclosing03.class
)
class EnclosingConstructor {
}
new EnclosingConstructor() {
};
}
void method() {
// anonymous and local classes in method
@ExpectedEnclosingMethod(
info = "EnclosingMethod in notEnclosing03",
enclosingMethod = "method",
enclosingClazz = notEnclosing03.class
)
class EnclosingMethod {
}
new EnclosingMethod() {
};
}
@ExpectedEnclosingMethod(
info = "VariableInitializer in notEnclosing03",
enclosingClazz = notEnclosing03.class
)
static class VariableInitializer {
}
// static variable initializer
private static final VariableInitializer cvi = new VariableInitializer() {
};
// instance variable initializer
private final VariableInitializer ivi = new VariableInitializer() {
};
}
// Test cases: enclosing class is an annotation
public @interface notEnclosing04 {
Runnable lambda = () -> {
// anonymous and local classes in lambda
@ExpectedEnclosingMethod(
info = "EnclosingLambda in notEnclosing04",
enclosingMethod = "lambda",
enclosingClazz = notEnclosing04.class
)
class EnclosingLambda {
}
new EnclosingLambda() {
};
};
@ExpectedEnclosingMethod(
info = "VariableInitializer in notEnclosing04",
enclosingClazz = notEnclosing04.class
)
static class VariableInitializer {
}
// static variable initializer
VariableInitializer cvi = new VariableInitializer() {
};
}
}