/*
* Copyright (c) 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.
*/
import com.sun.tools.classfile.*;
import java.io.IOException;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Stream;
import static java.lang.String.format;
import static java.util.stream.Collectors.*;
/**
* Base class for LocalVariableTable and LocalVariableTypeTable attributes tests.
* To add tests cases you should extend this class.
* Then implement {@link #getVariableTables} to get LocalVariableTable or LocalVariableTypeTable attribute.
* Then add method with local variables.
* Finally, annotate method with information about expected variables and their types
* by several {@link LocalVariableTestBase.ExpectedLocals} annotations.
* To run test invoke {@link #test()} method.
* If there are variables with the same name, set different scopes for them.
*
* @see #test()
*/
public abstract class LocalVariableTestBase extends TestBase {
public static final int DEFAULT_SCOPE = 0;
private final ClassFile classFile;
private final Class<?> clazz;
/**
* @param clazz class to test. Must contains annotated methods with expected results.
*/
public LocalVariableTestBase(Class<?> clazz) {
this.clazz = clazz;
try {
this.classFile = ClassFile.read(getClassFile(clazz));
} catch (IOException | ConstantPoolException e) {
throw new IllegalArgumentException("Can't read classfile for specified class", e);
}
}
protected abstract List<VariableTable> getVariableTables(Code_attribute codeAttribute);
/**
* Finds expected variables with their type in VariableTable.
* Also does consistency checks, like variables from the same scope must point to different indexes.
*/
public void test() throws IOException {
List<java.lang.reflect.Method> testMethods = Stream.of(clazz.getDeclaredMethods())
.filter(m -> m.getAnnotationsByType(ExpectedLocals.class).length > 0)
.collect(toList());
int failed = 0;
for (java.lang.reflect.Method method : testMethods) {
try {
Map<String, String> expectedLocals2Types = new HashMap<>();
Map<String, Integer> sig2scope = new HashMap<>();
for (ExpectedLocals anno : method.getDeclaredAnnotationsByType(ExpectedLocals.class)) {
expectedLocals2Types.put(anno.name(), anno.type());
sig2scope.put(anno.name() + "&" + anno.type(), anno.scope());
}
test(method.getName(), expectedLocals2Types, sig2scope);
} catch (AssertionFailedException ex) {
System.err.printf("Test %s failed.%n", method.getName());
ex.printStackTrace();
failed++;
}
}
if (failed > 0)
throw new RuntimeException(format("Failed %d out of %d. See logs.", failed, testMethods.size()));
}
public void test(String methodName, Map<String, String> expectedLocals2Types, Map<String, Integer> sig2scope)
throws IOException {
for (Method m : classFile.methods) {
String mName = getString(m.name_index);
if (methodName.equals(mName)) {
System.out.println("Testing local variable table in method " + mName);
Code_attribute code_attribute = (Code_attribute) m.attributes.get(Attribute.Code);
List<? extends VariableTable> variableTables = getVariableTables(code_attribute);
generalLocalVariableTableCheck(variableTables);
List<VariableTable.Entry> entries = variableTables.stream()
.flatMap(table -> table.entries().stream())
.collect(toList());
generalEntriesCheck(entries, code_attribute);
assertIndexesAreUnique(entries, sig2scope);
checkNamesAndTypes(entries, expectedLocals2Types);
checkDoubleAndLongIndexes(entries, sig2scope, code_attribute.max_locals);
}
}
}
private void generalLocalVariableTableCheck(List<? extends VariableTable> variableTables) {
for (VariableTable localTable : variableTables) {
//only one per variable.
assertEquals(localTable.localVariableTableLength(),
localTable.entries().size(), "Incorrect local variable table length");
//attribute length is offset(line_number_table_length) + element_size*element_count
assertEquals(localTable.attributeLength(),
2 + (5 * 2) * localTable.localVariableTableLength(), "Incorrect attribute length");
}
}
private void generalEntriesCheck(List<VariableTable.Entry> entries, Code_attribute code_attribute) {
for (VariableTable.Entry e : entries) {
assertTrue(e.index() >= 0 && e.index() < code_attribute.max_locals,
"Index " + e.index() + " out of variable array. Size of array is " + code_attribute.max_locals);
assertTrue(e.startPC() >= 0, "StartPC is less then 0. StartPC = " + e.startPC());
assertTrue(e.length() >= 0, "Length is less then 0. Length = " + e.length());
assertTrue(e.startPC() + e.length() <= code_attribute.code_length,
format("StartPC+Length > code length.%n" +
"%s%n" +
"code_length = %s"
, e, code_attribute.code_length));
}
}
private void checkNamesAndTypes(List<VariableTable.Entry> entries,
Map<String, String> expectedLocals2Types) {
Map<String, List<String>> actualNames2Types = entries.stream()
.collect(
groupingBy(VariableTable.Entry::name,
mapping(VariableTable.Entry::type, toList())));
for (Map.Entry<String, String> name2type : expectedLocals2Types.entrySet()) {
String name = name2type.getKey();
String type = name2type.getValue();
assertTrue(actualNames2Types.containsKey(name),
format("There is no record for local variable %s%nEntries: %s", name, entries));
assertTrue(actualNames2Types.get(name).contains(type),
format("Types are different for local variable %s%nExpected type: %s%nActual type: %s",
name, type, actualNames2Types.get(name)));
}
}
private void assertIndexesAreUnique(Collection<VariableTable.Entry> entries, Map<String, Integer> scopes) {
//check every scope separately
Map<Object, List<VariableTable.Entry>> entriesByScope = groupByScope(entries, scopes);
for (Map.Entry<Object, List<VariableTable.Entry>> mapEntry : entriesByScope.entrySet()) {
mapEntry.getValue().stream()
.collect(groupingBy(VariableTable.Entry::index))
.entrySet()
.forEach(e ->
assertTrue(e.getValue().size() == 1,
"Multiple variables point to the same index in common scope. " + e.getValue()));
}
}
private void checkDoubleAndLongIndexes(Collection<VariableTable.Entry> entries,
Map<String, Integer> scopes, int maxLocals) {
//check every scope separately
Map<Object, List<VariableTable.Entry>> entriesByScope = groupByScope(entries, scopes);
for (List<VariableTable.Entry> entryList : entriesByScope.values()) {
Map<Integer, VariableTable.Entry> index2Entry = entryList.stream()
.collect(toMap(VariableTable.Entry::index, e -> e));
entryList.stream()
.filter(e -> "J".equals(e.type()) || "D".equals(e.type()))
.forEach(e -> {
assertTrue(e.index() + 1 < maxLocals,
format("Index %s is out of variable array. Long and double occupy 2 cells." +
" Size of array is %d", e.index() + 1, maxLocals));
assertTrue(!index2Entry.containsKey(e.index() + 1),
format("An entry points to the second cell of long/double entry.%n%s%n%s", e,
index2Entry.get(e.index() + 1)));
});
}
}
private Map<Object, List<VariableTable.Entry>> groupByScope(
Collection<VariableTable.Entry> entries, Map<String, Integer> scopes) {
return entries.stream().collect(groupingBy(e -> scopes.getOrDefault(e.name() + "&" + e.type(), DEFAULT_SCOPE)));
}
protected String getString(int i) {
try {
return classFile.constant_pool.getUTF8Info(i).value;
} catch (ConstantPool.InvalidIndex | ConstantPool.UnexpectedEntry ex) {
ex.printStackTrace();
throw new AssertionFailedException("Issue while reading constant pool");
}
}
/**
* LocalVariableTable and LocalVariableTypeTable are similar.
* VariableTable interface is introduced to test this attributes in the same way without code duplication.
*/
interface VariableTable {
int localVariableTableLength();
List<VariableTable.Entry> entries();
int attributeLength();
interface Entry {
int index();
int startPC();
int length();
String name();
String type();
default String dump() {
return format("Entry{" +
"%n name = %s" +
"%n type = %s" +
"%n index = %d" +
"%n startPC = %d" +
"%n length = %d" +
"%n}", name(), type(), index(), startPC(), length());
}
}
}
/**
* Used to store expected results in sources
*/
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(Container.class)
@interface ExpectedLocals {
/**
* @return name of a local variable
*/
String name();
/**
* @return type of local variable in the internal format.
*/
String type();
//variables from different scopes can share the local variable table index and/or name.
int scope() default DEFAULT_SCOPE;
}
@Retention(RetentionPolicy.RUNTIME)
@interface Container {
ExpectedLocals[] value();
}
}