JavaTX/JavaCompilerCore
2
0
Fork 3
Code Issues 99 Pull Requests Actions Packages Projects Releases Wiki Activity

- Alle Operatoren implementiert

Browse Source 
- Tests für Sub, Mul, Div
This commit is contained in:
Enrico Schrödter 2016-04-27 15:08:17 +02:00
parent 5ac19d7a59
commit b3e13d09b9
21 changed files with 408 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
src/de/dhbwstuttgart/syntaxtree/operator/AddOp.java
View File

@ -5,8 +5,17 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.InvokeInstruction;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -16,8 +25,10 @@ import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.ConstraintsSet;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.SingleConstraint;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -62,5 +73,44 @@ public abstract class AddOp extends Operator
return ret;
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
// TODO Plus Operator ist bis jetzt nur für Integer implementiert
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Integer.intValue:()I
4: aload_1
5: invokevirtual #2 // Method java/lang/Integer.intValue:()I
8: iadd
9: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
12: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2());
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
il.append(getOperator(returnType));
il.append(convertValueToObject(_factory, returnType));
return il;
}
private String getReturnType(Expr expr1, Expr expr2) {
return "java.lang.Integer";
}
abstract ArithmeticInstruction getOperator(String returnType);
private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
if(returnType.equals("java.lang.Integer")){
return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
}else{
throw new NotImplementedException();
}
}
}
// ino.end

10
src/de/dhbwstuttgart/syntaxtree/operator/DivideOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.DivideOp.8596.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IDIV;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -26,8 +29,9 @@ public class DivideOp extends MulOp
}
// ino.end
@Override
ArithmeticInstruction getOperator(String returnType) {
return new IDIV();
}
}
// ino.end

32
src/de/dhbwstuttgart/syntaxtree/operator/EqualOp.java
View File

@ -47,36 +47,8 @@ public class EqualOp extends RelOp
// ino.end
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
InstructionList linkeSeite = operator.expr1.genByteCode(_cg, rs);
linkeSeite.append(_factory.createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
InstructionList rechteSeite = operator.expr2.genByteCode(_cg, rs);
rechteSeite.append(_factory.createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
if(operator.getReturnType().getName().equals(new JavaClassName("String"))){
throw new TypeinferenceException("Zeichenketten zusammenfügen ist noch nicht unterstützt",this);
}
linkeSeite.append(rechteSeite);
//TODO: bytecode (Bis jetzt wird jeder Condition als EQUALS behandelt)
//TODO: bytecode autoboxing
BranchInstruction if_icmpneInstruction = new IF_ICMPNE(null);
linkeSeite.append(if_icmpneInstruction);
linkeSeite.append(InstructionConstants.ICONST_1);
BranchInstruction gotoInstruction = new GOTO(null);
linkeSeite.append(gotoInstruction);
if_icmpneInstruction.setTarget(linkeSeite.append(InstructionConstants.ICONST_0));
gotoInstruction.setTarget(linkeSeite.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
return linkeSeite;
BranchInstruction getOperator() {
return new IF_ICMPNE(null);
}
}

8
src/de/dhbwstuttgart/syntaxtree/operator/GreaterEquOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.GreaterEquOp.8598.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPLT;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.SyntaxTreeNode;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -26,5 +29,10 @@ public class GreaterEquOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPLT(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/GreaterOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.GreaterOp.8599.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPLE;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class GreaterOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPLE(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/LessEquOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.LessEquOp.8600.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPGT;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class LessEquOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPGT(null);
}
}
// ino.end

7
src/de/dhbwstuttgart/syntaxtree/operator/LessOp.java
View File

@ -3,6 +3,8 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.LessOp.8601.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ICMPGE;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
@ -25,5 +27,10 @@ public class LessOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ICMPGE(null);
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/MinusOp.java
View File

@ -4,6 +4,10 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.MinusOp.8603.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IADD;
import org.apache.commons.bcel6.generic.ISUB;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,6 +29,8 @@ public class MinusOp extends AddOp
}
// ino.end
ArithmeticInstruction getOperator(String returnType) {
return new ISUB();
}
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/ModuloOp.java
View File

@ -4,6 +4,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.ModuloOp.8604.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IREM;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -25,5 +28,10 @@ public class ModuloOp extends MulOp
}
// ino.end
@Override
ArithmeticInstruction getOperator(String returnType) {
return new IREM();
}
}
// ino.end

51
src/de/dhbwstuttgart/syntaxtree/operator/MulOp.java
View File

@ -6,15 +6,26 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.InvokeInstruction;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.NotImplementedException;
import de.dhbwstuttgart.typeinference.unify.Unify;
// ino.class.MulOp.24231.declaration
@ -50,6 +61,44 @@ public abstract class MulOp extends Operator
return ret;
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
// TODO Plus Operator ist bis jetzt nur für Integer implementiert
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Integer.intValue:()I
4: aload_1
5: invokevirtual #2 // Method java/lang/Integer.intValue:()I
8: imul
9: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
12: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2());
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
il.append(getOperator(returnType));
il.append(convertValueToObject(_factory, returnType));
return il;
}
private String getReturnType(Expr expr1, Expr expr2) {
return "java.lang.Integer";
}
abstract ArithmeticInstruction getOperator(String returnType);
private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
if(returnType.equals("java.lang.Integer")){
return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
}else{
throw new NotImplementedException();
}
}
}
// ino.end

17
src/de/dhbwstuttgart/syntaxtree/operator/NotEqualOp.java
View File

@ -3,16 +3,10 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.end
// ino.module.NotEqualOp.8606.import
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
import de.dhbwstuttgart.syntaxtree.statement.Null;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.unify.Unify;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.IF_ACMPEQ;
// ino.class.NotEqualOp.24241.declaration
public class NotEqualOp extends RelOp
@ -28,5 +22,10 @@ public class NotEqualOp extends RelOp
}
// ino.end
@Override
BranchInstruction getOperator() {
return new IF_ACMPEQ(null);
}
}
// ino.end

9
src/de/dhbwstuttgart/syntaxtree/operator/Operator.java
View File

@ -6,6 +6,7 @@ import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.InstructionList;
import de.dhbwstuttgart.typeinference.Menge;
@ -97,5 +98,13 @@ public abstract class Operator extends SyntaxTreeNode
public Menge<SyntaxTreeNode> getChildren() {
return new Menge<>();
}
protected InstructionList getInstructionListForOperand(ClassGenerator _cg, TypeinferenceResultSet rs, Expr operand, String returnType){
InstructionList il = new InstructionList();
il.append(operand.genByteCode(_cg, rs));
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
return il;
}
}
// ino.end

47
src/de/dhbwstuttgart/syntaxtree/operator/PlusOp.java
View File

@ -42,53 +42,8 @@ public class PlusOp extends AddOp
}
// ino.end
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
// TODO Plus Operator ist bis jetzt nur für Integer implementiert
/*
0: aload_1
1: invokevirtual #2 // Method java/lang/Integer.intValue:()I
4: aload_1
5: invokevirtual #2 // Method java/lang/Integer.intValue:()I
8: iadd
9: invokestatic #3 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
12: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
String returnType = getReturnType(operator.get_Expr1(), operator.get_Expr2());
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), returnType);
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), returnType));
il.append(getOperator(returnType));
il.append(convertValueToObject(_factory, returnType));
return il;
}
private String getReturnType(Expr expr1, Expr expr2) {
return "java.lang.Integer";
}
private ArithmeticInstruction getOperator(String returnType) {
ArithmeticInstruction getOperator(String returnType) {
return new IADD();
}
private InvokeInstruction convertValueToObject(DHBWInstructionFactory _factory, String returnType) {
if(returnType.equals("java.lang.Integer")){
return _factory.createInvoke("java.lang.Integer", "valueOf", new ObjectType("java.lang.Integer"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.INT}, Constants.INVOKESTATIC);
}else{
throw new NotImplementedException();
}
}
private InstructionList getInstructionListForOperand(ClassGenerator _cg, TypeinferenceResultSet rs, Expr operand, String returnType){
InstructionList il = new InstructionList();
il.append(operand.genByteCode(_cg, rs));
il.append(_cg.getInstructionFactory().createInvoke("java.lang.Integer", "intValue", org.apache.commons.bcel6.generic.Type.INT, new org.apache.commons.bcel6.generic.Type[] {}, Constants.INVOKEVIRTUAL));
return il;
}
}
// ino.end

51
src/de/dhbwstuttgart/syntaxtree/operator/RelOp.java
View File

@ -6,14 +6,24 @@ package de.dhbwstuttgart.syntaxtree.operator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.Constants;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.GOTO;
import org.apache.commons.bcel6.generic.InstructionConstants;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.ObjectType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.bytecode.ClassGenerator;
import de.dhbwstuttgart.bytecode.DHBWInstructionFactory;
import de.dhbwstuttgart.myexception.CTypeReconstructionException;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.unify.Unify;
@ -55,5 +65,44 @@ public abstract class RelOp extends Operator
}
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs, Binary operator) {
/*
0: aload_1
1: invokevirtual #3 // Method java/lang/Integer.intValue:()I
4: aload_2
5: invokevirtual #3 // Method java/lang/Integer.intValue:()I
8: if_icmplt 15
11: iconst_1
12: goto 16
15: iconst_0
16: invokestatic #2 // Method java/lang/Boolean.valueOf:(Z)Ljava/lang/Boolean;
19: areturn
*/
DHBWInstructionFactory _factory = _cg.getInstructionFactory();
InstructionList il = getInstructionListForOperand(_cg, rs, operator.get_Expr1(), "java.lang.Boolean");
il.append(getInstructionListForOperand(_cg, rs, operator.get_Expr2(), "java.lang.Boolean"));
BranchInstruction operatorBranchInstruction = getOperator();
il.append(operatorBranchInstruction);
il.append(InstructionConstants.ICONST_1);
BranchInstruction gotoInstruction = new GOTO(null);
il.append(gotoInstruction);
operatorBranchInstruction.setTarget(il.append(InstructionConstants.ICONST_0));
gotoInstruction.setTarget(il.append(_factory.createInvoke("java.lang.Boolean", "valueOf", new ObjectType("java.lang.Boolean"), new org.apache.commons.bcel6.generic.Type[] {org.apache.commons.bcel6.generic.Type.BOOLEAN}, Constants.INVOKESTATIC)));
return il;
}
abstract BranchInstruction getOperator();
}
// ino.end

8
src/de/dhbwstuttgart/syntaxtree/operator/TimesOp.java
View File

@ -5,6 +5,9 @@ package de.dhbwstuttgart.syntaxtree.operator;
// ino.module.TimesOp.8611.import
import de.dhbwstuttgart.typeinference.Menge;
import org.apache.commons.bcel6.generic.ArithmeticInstruction;
import org.apache.commons.bcel6.generic.IMUL;
import de.dhbwstuttgart.myexception.JVMCodeException;
import de.dhbwstuttgart.syntaxtree.statement.Binary;
import de.dhbwstuttgart.syntaxtree.statement.Expr;
@ -23,5 +26,10 @@ public class TimesOp extends MulOp
}
// ino.end
@Override
ArithmeticInstruction getOperator(String returnType) {
return new IMUL();
}
}
// ino.end

5
test/bytecode/operators/DivOperator.jav Normal file
View File

@ -0,0 +1,5 @@
class DivOperator{
Integer method(Integer x, Integer y){
return x / y;
}
}

53
test/bytecode/operators/DivOperatorTest.java Normal file
View File

@ -0,0 +1,53 @@
package bytecode.operators;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Ignore;
import org.junit.Test;
import bytecode.SourceFileBytecodeTest;
public class DivOperatorTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "DivOperator";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/operators/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testTwoIntegers() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer x = new Integer(1);
Integer y = new Integer(2);
Class[] params = new Class[]{
x.getClass(),
y.getClass(),
};
Method method = cls.getDeclaredMethod("method", params);
Integer returnValue = (Integer) method.invoke(obj, x, y);
assertEquals(new Integer(0), returnValue);
}
}

5
test/bytecode/operators/MulOperator.jav Normal file
View File

@ -0,0 +1,5 @@
class MulOperator{
Integer method(Integer x, Integer y){
return x * y;
}
}

53
test/bytecode/operators/MulOperatorTest.java Normal file
View File

@ -0,0 +1,53 @@
package bytecode.operators;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Ignore;
import org.junit.Test;
import bytecode.SourceFileBytecodeTest;
public class MulOperatorTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "MulOperator";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/operators/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testTwoIntegers() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer x = new Integer(1);
Integer y = new Integer(2);
Class[] params = new Class[]{
x.getClass(),
y.getClass(),
};
Method method = cls.getDeclaredMethod("method", params);
Integer returnValue = (Integer) method.invoke(obj, x, y);
assertEquals(new Integer(2), returnValue);
}
}

5
test/bytecode/operators/SubOperator.jav Normal file
View File

@ -0,0 +1,5 @@
class SubOperator{
Integer method(Integer x, Integer y){
return x - y;
}
}

53
test/bytecode/operators/SubOperatorTest.java Normal file
View File

@ -0,0 +1,53 @@
package bytecode.operators;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Ignore;
import org.junit.Test;
import bytecode.SourceFileBytecodeTest;
public class SubOperatorTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "SubOperator";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/operators/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testTwoIntegers() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer x = new Integer(1);
Integer y = new Integer(2);
Class[] params = new Class[]{
x.getClass(),
y.getClass(),
};
Method method = cls.getDeclaredMethod("method", params);
Integer returnValue = (Integer) method.invoke(obj, x, y);
assertEquals(new Integer(-1), returnValue);
}
}