/*
* Copyright (c) 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.
*/
package selectionresolution;
import java.util.ArrayList;
import java.util.Iterator;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_ABSTRACT;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PRIVATE;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_PROTECTED;
import static jdk.internal.org.objectweb.asm.Opcodes.ACC_STATIC;
/**
* Constructs classes and interfaces based on the information from a
* DefaultMethodTestCase
*
*/
public class ClassBuilder extends Builder {
private final ArrayList<ClassConstruct> classes;
// Add a class in every package to be able to instantiate package
// private classes from outside the package
private final Clazz[] helpers = new Clazz[4];
private ClassConstruct callsiteClass;
public enum ExecutionMode { DIRECT, INDY, MH_INVOKE_EXACT, MH_INVOKE_GENERIC}
private final ExecutionMode execMode;
public ClassBuilder(SelectionResolutionTestCase testcase,
ExecutionMode execMode) {
super(testcase);
this.classes = new ArrayList<>();
this.execMode = execMode;
}
public ClassConstruct[] build() throws Exception {
buildClassConstructs();
return classes.toArray(new ClassConstruct[0]);
}
public ClassConstruct getCallsiteClass() {
return callsiteClass;
}
private void buildClassConstructs() throws Exception {
TestBuilder tb = new TestBuilder(testcase.methodref, testcase);
classes.add(new Clazz("Test", ACC_PUBLIC, -1));
for (int classId = 0; classId < classdata.size(); classId++) {
ClassConstruct C;
String[] interfaces = getInterfaces(classId);
ClassData data = classdata.get(classId);
if (isClass(classId)) {
C = new Clazz(getName(classId),
getExtending(classId),
getClassModifiers(data),
classId,
interfaces);
addHelperMethod(classId);
} else {
C = new Interface(getName(classId),
getAccessibility(data.access),
classId, interfaces);
}
// Add a method "m()LTestObject;" if applicable
if (containsMethod(data)) {
// Method will either be abstract or concrete depending on the
// abstract modifier
C.addTestMethod(getMethodModifiers(data));
}
if (classId == testcase.callsite) {
// Add test() method
tb.addTest(C, execMode);
callsiteClass = C;
}
classes.add(C);
}
classes.add(tb.getMainTestClass());
}
private void addHelperMethod(int classId) {
int packageId = classdata.get(classId).packageId.ordinal();
Clazz C = helpers[packageId];
if (C == null) {
C = new Clazz(getPackageName(packageId) + "Helper", -1, ACC_PUBLIC);
helpers[packageId] = C;
classes.add(C);
}
Method m = C.addMethod("get" + getClassName(classId),
"()L" + getName(classId) + ";",
ACC_PUBLIC + ACC_STATIC);
m.makeInstantiateMethod(getName(classId));
}
private String[] getInterfaces(int classId) {
ArrayList<String> interfaces = new ArrayList<>();
// Figure out if we're extending/implementing an interface
for (final int intf : hier.interfaces()) {
if (hier.inherits(classId, intf)) {
interfaces.add(getName(intf));
}
}
return interfaces.toArray(new String[0]);
}
private String getExtending(int classId) {
int extending = -1;
// See if we're extending another class
for (final int extendsClass : hier.classes()) {
if (hier.inherits(classId, extendsClass)) {
// Sanity check that we haven't already found an extending class
if (extending != -1) {
throw new RuntimeException("Multiple extending classes");
}
extending = extendsClass;
}
}
return extending == -1 ? null : getName(extending);
}
/**
* Returns modifiers for a Class
* @param cd ClassData for the Class
* @return ASM modifiers for a Class
*/
private int getClassModifiers(ClassData cd) {
// For Classes we only care about accessibility (public, private etc)
return getAccessibility(cd.access) | getAbstraction(cd.abstraction);
}
/**
* Returns modifiers for Method type
* @param cd ClassData for the Class or Interface where the Method resides
* @return ASM modifiers for the Method
*/
private int getMethodModifiers(ClassData cd) {
int mod = 0;
// For methods we want everything
mod += getAccessibility(cd.methoddata.access);
mod += getAbstraction(cd.methoddata.context);
mod += getContext(cd.methoddata.context);
mod += getExtensibility();
return mod;
}
/**
* Convert ClassData access type to ASM
* @param access
* @return ASM version of accessibility (public / private / protected)
*/
private int getAccessibility(MethodData.Access access) {
switch(access) {
case PACKAGE:
//TODO: Do I need to set this or will this be the default?
return 0;
case PRIVATE:
return ACC_PRIVATE;
case PROTECTED:
return ACC_PROTECTED;
case PUBLIC:
return ACC_PUBLIC;
default:
throw new RuntimeException("Illegal accessibility modifier: " + access);
}
}
/**
* Convert ClassData abstraction type to ASM
* @param abstraction
* @return ASM version of abstraction (abstract / non-abstract)
*/
private int getAbstraction(MethodData.Context context) {
return context == MethodData.Context.ABSTRACT ? ACC_ABSTRACT : 0;
}
/**
* Convert ClassData context type to ASM
* @param context
* @return ASM version of context (static / non-static)
*/
private int getContext(MethodData.Context context) {
return context == MethodData.Context.STATIC ? ACC_STATIC : 0;
}
/**
* Convert ClassData extensibility type to ASM
* @param extensibility
* @return ASM version of extensibility (final / non-final)
*/
private int getExtensibility() {
return 0;
}
/**
* Determine if we need a method at all, abstraction is set to null if this
* Class/Interface should not have a test method
* @param cd
* @return
*/
private boolean containsMethod(ClassData cd) {
return cd.methoddata != null;
}
}