/*
* Copyright (c) 2015, 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.
*/
import com.sun.tools.classfile.*;
import com.sun.tools.classfile.Field;
import com.sun.tools.classfile.Method;
import java.io.File;
import java.io.FilenameFilter;
import java.lang.reflect.*;
import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* The main class of Signature tests.
* Driver reads golden data of each class member that must have a Signature attribute,
* after that the class compares expected data with actual one.
*
* Example of usage Driver:
* java Driver Test
*
* Each member of the class Test should have @ExpectedSignature annotations
* if it must have the Signature attribute. Anonymous class cannot be annotated.
* So its enclosing class should be annotated and method isAnonymous
* of ExpectedSignature must return true.
*/
public class Driver extends TestResult {
private final static String ACC_BRIDGE = "ACC_BRIDGE";
private final String topLevelClassName;
private final File[] files;
public Driver(String topLevelClassName) {
this.topLevelClassName = topLevelClassName;
// Get top level class and all inner classes.
FilenameFilter filter = (dir, file) ->
file.equals(topLevelClassName + ".class")
|| file.matches(topLevelClassName + "\\$.*\\.class");
files = getClassDir().listFiles(filter);
}
private boolean isAnonymous(String className) {
return className.matches(".*\\$\\d+$");
}
private Class<?> getEnclosingClass(String className) throws ClassNotFoundException {
return Class.forName(className.replaceFirst("\\$\\d+$", ""));
}
private ExpectedSignature getExpectedClassSignature(String className, Class<?> clazz)
throws ClassNotFoundException {
// anonymous class cannot be annotated, so information about anonymous class
// is located in its enclosing class.
boolean isAnonymous = isAnonymous(className);
clazz = isAnonymous ? getEnclosingClass(className) : clazz;
return Stream.of(clazz.getAnnotationsByType(ExpectedSignature.class))
.filter(s -> s.isAnonymous() == isAnonymous)
.collect(Collectors.toMap(ExpectedSignature::descriptor, Function.identity()))
.get(className);
}
// Class.getName() cannot be used here, because the method can rely on signature attribute.
private Map<String, ExpectedSignature> getClassExpectedSignature(String className, Class<?> clazz)
throws ClassNotFoundException {
Map<String, ExpectedSignature> classSignatures = new HashMap<>();
ExpectedSignature classSignature = getExpectedClassSignature(className, clazz);
if (classSignature != null) {
classSignatures.put(className, classSignature);
}
return classSignatures;
}
private Map<String, ExpectedSignature> getExpectedExecutableSignatures(Executable[] executables,
Predicate<Executable> filterBridge) {
return Stream.of(executables)
.filter(filterBridge)
.map(e -> e.getAnnotation(ExpectedSignature.class))
.filter(Objects::nonNull)
.collect(Collectors.toMap(ExpectedSignature::descriptor, Function.identity()));
}
private Map<String, ExpectedSignature> getExpectedMethodSignatures(Class<?> clazz) {
Map<String, ExpectedSignature> methodSignatures =
getExpectedExecutableSignatures(clazz.getDeclaredMethods(),
m -> !((java.lang.reflect.Method) m).isBridge());
methodSignatures.putAll(
getExpectedExecutableSignatures(clazz.getDeclaredConstructors(),
m -> true));
return methodSignatures;
}
private Map<String, ExpectedSignature> getExpectedFieldSignatures(Class<?> clazz) {
return Stream.of(clazz.getDeclaredFields())
.map(f -> f.getAnnotation(ExpectedSignature.class))
.filter(Objects::nonNull)
.collect(Collectors.toMap(ExpectedSignature::descriptor, Function.identity()));
}
public void test() throws TestFailedException {
try {
addTestCase("Source is " + topLevelClassName + ".java");
assertTrue(files.length > 0, "No class files found");
for (File file : files) {
try {
String className = file.getName().replace(".class", "");
Class<?> clazz = Class.forName(className);
printf("Testing class %s\n", className);
ClassFile classFile = readClassFile(file);
// test class signature
testAttribute(
className,
classFile,
() -> (Signature_attribute) classFile.getAttribute(Attribute.Signature),
getClassExpectedSignature(className, clazz).get(className));
testFields(getExpectedFieldSignatures(clazz), classFile);
testMethods(getExpectedMethodSignatures(clazz), classFile);
} catch (Exception e) {
addFailure(e);
}
}
} catch (Exception e) {
addFailure(e);
} finally {
checkStatus();
}
}
private void checkAllMembersFound(Set<String> found, Map<String, ExpectedSignature> signatures, String message) {
if (signatures != null) {
checkContains(found,
signatures.values().stream()
.map(ExpectedSignature::descriptor)
.collect(Collectors.toSet()),
message);
}
}
private void testMethods(Map<String, ExpectedSignature> expectedSignatures, ClassFile classFile)
throws ConstantPoolException, Descriptor.InvalidDescriptor {
String className = classFile.getName();
Set<String> foundMethods = new HashSet<>();
for (Method method : classFile.methods) {
String methodName = getMethodName(classFile, method);
printf("Testing method %s\n", methodName);
if (method.access_flags.getMethodFlags().contains(ACC_BRIDGE)) {
printf("Bridge method is skipped : %s\n", methodName);
continue;
}
testAttribute(
methodName,
classFile,
() -> (Signature_attribute) method.attributes.get(Attribute.Signature),
expectedSignatures.get(methodName));
foundMethods.add(methodName);
}
checkAllMembersFound(foundMethods, expectedSignatures,
"Checking that all methods of class " + className + " with Signature attribute found");
}
private String getMethodName(ClassFile classFile, Method method)
throws ConstantPoolException, Descriptor.InvalidDescriptor {
return String.format("%s%s",
method.getName(classFile.constant_pool),
method.descriptor.getParameterTypes(classFile.constant_pool));
}
private void testFields(Map<String, ExpectedSignature> expectedSignatures, ClassFile classFile)
throws ConstantPoolException {
String className = classFile.getName();
Set<String> foundFields = new HashSet<>();
for (Field field : classFile.fields) {
String fieldName = field.getName(classFile.constant_pool);
printf("Testing field %s\n", fieldName);
testAttribute(
fieldName,
classFile,
() -> (Signature_attribute) field.attributes.get(Attribute.Signature),
expectedSignatures.get(fieldName));
foundFields.add(fieldName);
}
checkAllMembersFound(foundFields, expectedSignatures,
"Checking that all fields of class " + className + " with Signature attribute found");
}
private void testAttribute(
String memberName,
ClassFile classFile,
Supplier<Signature_attribute> sup,
ExpectedSignature expectedSignature)
throws ConstantPoolException {
Signature_attribute attribute = sup.get();
if (expectedSignature != null && checkNotNull(attribute, memberName + " must have attribute")) {
checkEquals(classFile.constant_pool.getUTF8Value(attribute.attribute_name_index),
"Signature", "Attribute's name : " + memberName);
checkEquals(attribute.attribute_length, 2, "Attribute's length : " + memberName);
checkEquals(attribute.getSignature(classFile.constant_pool),
expectedSignature.signature(),
"Testing signature of : " + memberName);
} else {
checkNull(attribute, memberName + " must not have attribute");
}
}
public static void main(String[] args) throws TestFailedException {
if (args.length != 1) {
throw new IllegalArgumentException("Usage: Driver <class-name>");
}
new Driver(args[0]).test();
}
}