Compare commits

..

3 Commits

Author SHA1 Message Date
318f6e1cc5 code review todos erledigt 2016-05-06 16:59:59 +02:00
005ed60c26 fixed vector 2016-05-03 21:07:52 +02:00
78794e377a fixed vector 2016-05-03 20:44:55 +02:00
28 changed files with 156 additions and 336 deletions

@ -40,7 +40,6 @@ public class ClassGenerator extends ClassGen{
private Map<String, ClassGenerator> extraClasses = new HashMap<>();
private List<String> methodsNamesAndTypes = new LinkedList<>();
private MethodGenerator methodGenerator;
public ClassGenerator(String name, Type superClass, String string, short accessflags, String[] strings, TypeinferenceResults typeinferenceResults) {
super(name,superClass.get_Name(),string,accessflags,strings, new DHBWConstantPoolGen());
@ -172,7 +171,7 @@ public class ClassGenerator extends ClassGen{
@Override
public void addMethod(Method m) {
String methodNameAndTypes = m.getReturnType().toString()+m.getName()+Arrays.toString(m.getArgumentTypes());
String methodNameAndTypes = m.getName()+Arrays.toString(m.getArgumentTypes());
if(methodsNamesAndTypes.contains(methodNameAndTypes)){
return;
@ -181,14 +180,9 @@ public class ClassGenerator extends ClassGen{
methodsNamesAndTypes.add(methodNameAndTypes);
super.addMethod(m);
}
public void setMethodeGenerator(MethodGenerator methodGenerator) {
this.methodGenerator = methodGenerator;
}
public MethodGenerator getMethodGenerator() {
return methodGenerator;
}
}

@ -139,6 +139,23 @@ public class DHBWInstructionFactory extends InstructionFactory{
return new INVOKEDYNAMIC(index);
}
public static LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
}
public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
}
public static Integer getStoreIndex(String variableName) {
if(storeIndexes.get(variableName) == null){
Integer index = storeIndexes.size()+1;
storeIndexes.put(variableName, index);
}
return storeIndexes.get(variableName);
}
public static Type createObjectType() {
return new org.apache.commons.bcel6.generic.ObjectType("java.lang.Object");
}
@ -146,4 +163,8 @@ public class DHBWInstructionFactory extends InstructionFactory{
public Attribute createSignatureAttribute(String signature) {
return new Signature(cp.addUtf8("Signature"),2,cp.addUtf8(signature),cp.getConstantPool());
}
public void resetStoreIndexes() {
//storeIndexes.clear();
}
}

@ -4,9 +4,6 @@ import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
import org.apache.commons.bcel6.classfile.Attribute;
import org.apache.commons.bcel6.classfile.ConstantPool;
@ -19,9 +16,7 @@ import org.apache.commons.bcel6.classfile.Visitor;
import org.apache.commons.bcel6.generic.BranchInstruction;
import org.apache.commons.bcel6.generic.ConstantPoolGen;
import org.apache.commons.bcel6.generic.Instruction;
import org.apache.commons.bcel6.generic.InstructionFactory;
import org.apache.commons.bcel6.generic.InstructionList;
import org.apache.commons.bcel6.generic.LocalVariableInstruction;
import org.apache.commons.bcel6.generic.MethodGen;
import org.apache.commons.bcel6.generic.StackMapTableGen;
import org.apache.commons.bcel6.generic.Type;
@ -35,22 +30,15 @@ import de.dhbwstuttgart.syntaxtree.FormalParameter;
import de.dhbwstuttgart.syntaxtree.ParameterList;
import de.dhbwstuttgart.syntaxtree.statement.Block;
import de.dhbwstuttgart.syntaxtree.statement.Return;
import de.dhbwstuttgart.syntaxtree.statement.Statement;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
public class MethodGenerator extends MethodGen{
private Map<String, Integer> storeIndexes = new HashMap<>();
public MethodGenerator(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name,
String class_name, InstructionList il, ConstantPoolGen cp) {
String class_name, InstructionList il, ConstantPoolGen cp) {
super(access_flags, return_type, arg_types, arg_names, method_name, class_name, il, cp);
for(String name: arg_names){
getStoreIndex(name);
}
}
public Method createMethod(ClassGenerator cg, ParameterList parameter, de.dhbwstuttgart.syntaxtree.type.Type retType, Block block, TypeinferenceResultSet rs){
@ -92,23 +80,6 @@ public class MethodGenerator extends MethodGen{
return method.getMethod();
}
public LocalVariableInstruction createLoad(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createLoad(bytecodeType, getStoreIndex(variableName));
}
public LocalVariableInstruction createStore(org.apache.commons.bcel6.generic.Type bytecodeType, String variableName) {
return InstructionFactory.createStore(bytecodeType, getStoreIndex(variableName));
}
public Integer getStoreIndex(String variableName) {
if(storeIndexes.get(variableName) == null){
Integer index = storeIndexes.size()+1;
storeIndexes.put(variableName, index);
}
return storeIndexes.get(variableName);
}
}

@ -78,12 +78,15 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
private Modifiers modifiers;
protected static Logger inferencelog = Logger.getLogger("inference");
protected static Logger parserlog = Logger.getLogger("parser");
protected Menge<org.apache.commons.bcel6.generic.Type[]> createdMethods = new Menge<>();
public Method(int offset) {
super(offset);
}
public Method(String name, Type returnType, ParameterList parameterList, Block block, GenericDeclarationList gtvDeclarations, int offset) {
public Method(String name, Type returnType, ParameterList parameterList,
Block block, GenericDeclarationList gtvDeclarations, int offset) {
this(offset);
/*
* if(parameterList != null)parameterList.parserPostProcessing(this);
@ -416,7 +419,7 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
ArrayList<String> argumentNames = new ArrayList<String>();
if(this.parameterlist != null && this.parameterlist.size() > 0){
generateArgumentList(argumentTypes, argumentNames, cg, t);
generateArgumentList(argumentTypes, argumentNames, cg, _factory, t);
}
short constants = Constants.ACC_PUBLIC;
@ -426,15 +429,15 @@ public class Method extends Field implements IItemWithOffset, TypeInsertable
MethodGenerator method = new MethodGenerator(constants, returnType.getBytecodeType(cg, t), argumentTypes.toArray(new org.apache.commons.bcel6.generic.Type[parameterlist.size()]) , argumentNames.toArray(new String[parameterlist.size()]), this.get_Method_Name(), getParentClass().name, il, _cp);
cg.setMethodeGenerator(method);
cg.addMethod(method.createMethod(cg, getParameterList(), returnType, get_Block(), t));
}
private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, TypeinferenceResultSet t) {
private void generateArgumentList(ArrayList<org.apache.commons.bcel6.generic.Type> argumentTypes, ArrayList<String> argumentNames, ClassGenerator cg, DHBWInstructionFactory _factory, TypeinferenceResultSet t) {
for(FormalParameter parameter : this.parameterlist){
argumentTypes.add(parameter.getType().getBytecodeType(cg, t));
argumentNames.add(parameter.getIdentifier());
_factory.getStoreIndex(parameter.getIdentifier());
}
}
}

@ -172,7 +172,7 @@ public class UnifyTypeFactory {
public static Type convert(ReferenceType t) {
//TODO: Hier kann man die GTVs extrahieren
if(t.getName().toString().equals(Void.VOID_NAME))return new Void(NULL_NODE, 0);
if(t.getName() == "void")return new Void(NULL_NODE, 0);
RefType ret = new RefType(t.getName(),null,0);
ret.set_ParaList(convert(t.getTypeParams()));
return ret;

@ -179,7 +179,8 @@ public class Assign extends Expr
@Override
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
DHBWInstructionFactory _factory = new DHBWInstructionFactory(cg, cg.getConstantPool());
InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr
InstructionList il = expr2.genByteCode(cg, rs);//expr2 rechte expr
/*
String expr2Type = expr2.getType().get_Name().toString();
@ -206,7 +207,7 @@ public class Assign extends Expr
}
*/
//Es wird momentan immer von RefType ausgegangen:
il.append(cg.getMethodGenerator().createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
il.append(_factory.createStore(expr2.getType().getBytecodeType(cg, rs), expr1.get_Name()));
return il;
}

@ -169,7 +169,7 @@ public class LocalOrFieldVarOrClassname extends Expr
String name = this.get_Name();
il.append(cg.getMethodGenerator().createLoad(byteCodeType, name));
il.append(cg.getInstructionFactory().createLoad(byteCodeType, name));
return il;
}

@ -376,7 +376,7 @@ public class LocalVarDecl extends Statement implements TypeInsertable
@Override
public InstructionList genByteCode(ClassGenerator _cg, TypeinferenceResultSet rs) {
_cg.getMethodGenerator().getStoreIndex(get_Name());
_cg.getInstructionFactory().getStoreIndex(get_Name());
return new InstructionList();
}
}

@ -326,6 +326,8 @@ public class MethodCall extends Expr
public InstructionList genByteCode(ClassGenerator cg, TypeinferenceResultSet rs) {
InstructionList il = new InstructionList();
DHBWInstructionFactory _factory = cg.getInstructionFactory();
//TODO: später wiederherstelln?
_factory.resetStoreIndexes();
il.append(receiver.get_Expr().genByteCode(cg, rs));
@ -344,7 +346,7 @@ public class MethodCall extends Expr
argumentTypen = new org.apache.commons.bcel6.generic.Type[this.getArgumentList().size()];
int i = 0;
for(Expr argument : this.arglist.expr){
cg.getMethodGenerator().getStoreIndex(argument.get_Name());
_factory.getStoreIndex(argument.get_Name());
argumentTypen[i] = argument.getType().getBytecodeType(cg, rs);
//Das Argument auf den Stack legen:

@ -602,18 +602,17 @@ public class RefType extends ObjectType implements IMatchable
sb.append(((RefType) type).getCombinedType(cg, rs).replace(".", "%"));
}else if(type instanceof TypePlaceholder){
sb.append(((TypePlaceholder) type).getBytecodeType(cg, rs).toString().replace(".", "%"));
}else if(type instanceof WildcardType){
return this.getName().toString();
}else{
sb.append(type.getBytecodeType(cg, rs).toString().replace(".", "%"));
}
sb.append("%");
}
return sb.toString();
}
}else{
sb.append(this.getName().toString());
}
return sb.append(this.getName().toString()).toString();
return sb.toString();
}
public GenericClassType getGenericClassType(){

@ -17,6 +17,11 @@ import de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions;
import de.dhbwstuttgart.typeinference.exceptions.DebugException;
import de.dhbwstuttgart.typeinference.exceptions.TypeinferenceException;
class Test {
void methode(ArrayList<? super Integer> t){
}
}
//TODO: Die Klasse Type muss abstract werden!
// ino.class.Type.26716.declaration

@ -15,14 +15,13 @@ public class Void extends RefType
// ino.end
// ino.class.Void.26857.body
{
public static final String VOID_NAME = "void";
// ino.method.Void.26861.definition
public Void(SyntaxTreeNode parent,int offset)
// ino.end
// ino.method.Void.26861.body
{
super(parent,offset);
super.setName(VOID_NAME);
super.setName("void");
}
// ino.end

@ -287,7 +287,7 @@ public class RuleSet implements IRuleSet{
if(lhsSType.getTypeParams().empty())
return Optional.empty();
UnifyType rhsType = pair.getLhsType();
UnifyType rhsType = pair.getRhsType();
ReferenceType rhsSType;
if(rhsType instanceof ReferenceType)

@ -410,8 +410,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
// Case unknown: If a pair fits no other case, then the type unification has failed.
// Through application of the rules, every pair should have one of the above forms.
// Pairs that do not have one of the aboves form are contradictory.
else
undefined.add(pair);
else {
// If a pair is not defined, the unificiation will fail, so the loop can be stopped here.
undefined.add(pair);
break;
}
}
// Filter empty sets or sets that only contain an empty set.
@ -425,9 +428,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
protected Set<Set<UnifyPair>> unifyCase1(PlaceholderType a, UnifyType thetaPrime, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
boolean allGen = true;
boolean allGen = thetaPrime.getTypeParams().size() > 0;
for(UnifyType t : thetaPrime.getTypeParams())
if(t instanceof PlaceholderType && !((PlaceholderType) t).isGenerated()) {
if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {
allGen = false;
break;
}
@ -437,7 +440,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
for(UnifyType c : cs) {
Set<UnifyType> thetaQs = fc.getChildren(c).stream().collect(Collectors.toCollection(HashSet::new));
thetaQs.add(thetaPrime);
//thetaQs.add(thetaPrime);
Set<UnifyType> thetaQPrimes = new HashSet<>();
TypeParams cParams = c.getTypeParams();
if(cParams.size() == 0)
@ -493,7 +496,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
/**
* Cartesian Product Case 2: (a <.? ? ext Theta')
*/
protected Set<Set<UnifyPair>> unifyCase2(PlaceholderType a, ExtendsType extThetaPrime, IFiniteClosure fc) {
private Set<Set<UnifyPair>> unifyCase2(PlaceholderType a, ExtendsType extThetaPrime, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
UnifyType aPrime = PlaceholderType.freshPlaceholder();
@ -513,7 +516,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
/**
* Cartesian Product Case 3: (a <.? ? sup Theta')
*/
protected Set<Set<UnifyPair>> unifyCase3(PlaceholderType a, SuperType subThetaPrime, IFiniteClosure fc) {
private Set<Set<UnifyPair>> unifyCase3(PlaceholderType a, SuperType subThetaPrime, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
UnifyType aPrime = PlaceholderType.freshPlaceholder();
@ -531,27 +534,15 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
return result;
}
/**
* Cartesian Product Case 4: (a <.? Theta')
*/
protected Set<Set<UnifyPair>> unifyCase4(PlaceholderType a, UnifyType thetaPrime, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
Set<UnifyPair> resultPrime = new HashSet<>();
resultPrime.add(new UnifyPair(a, thetaPrime, PairOperator.EQUALSDOT));
result.add(resultPrime);
return result;
}
/**
* Cartesian Product Case 5: (Theta <. a)
*/
protected Set<Set<UnifyPair>> unifyCase5(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
private Set<Set<UnifyPair>> unifyCase5(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
boolean allGen = true;
boolean allGen = theta.getTypeParams().size() > 0;
for(UnifyType t : theta.getTypeParams())
if(t instanceof PlaceholderType && !((PlaceholderType) t).isGenerated()) {
if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {
allGen = false;
break;
}
@ -574,44 +565,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>> {
return result;
}
/**
* Cartesian Product Case 6: (? ext Theta <.? a)
*/
protected Set<Set<UnifyPair>> unifyCase6(ExtendsType extTheta, PlaceholderType a, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
UnifyType freshTph = PlaceholderType.freshPlaceholder();
UnifyType extFreshTph = new ExtendsType(freshTph);
Set<UnifyPair> resultPrime = new HashSet<>();
resultPrime.add(new UnifyPair(a, extFreshTph, PairOperator.EQUALSDOT));
resultPrime.add(new UnifyPair(extTheta.getExtendedType(), freshTph, PairOperator.SMALLERDOT));
result.add(resultPrime);
return result;
}
/**
* Cartesian Product Case 7: (? sup Theta <.? a)
*/
protected Set<Set<UnifyPair>> unifyCase7(SuperType supTheta, PlaceholderType a, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
UnifyType aPrime = PlaceholderType.freshPlaceholder();
UnifyType supAPrime = new SuperType(aPrime);
UnifyType theta = supTheta.getSuperedType();
Set<UnifyPair> resultPrime = new HashSet<>();
resultPrime.add(new UnifyPair(a, supAPrime, PairOperator.EQUALSDOT));
resultPrime.add(new UnifyPair(aPrime, theta, PairOperator.SMALLERDOT));
result.add(resultPrime);
return result;
}
/**
* Cartesian Product Case 8: (Theta <.? a)
*/
protected Set<Set<UnifyPair>> unifyCase8(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
private Set<Set<UnifyPair>> unifyCase8(UnifyType theta, PlaceholderType a, IFiniteClosure fc) {
Set<Set<UnifyPair>> result = new HashSet<>();
//for(UnifyType thetaS : fc.grArg(theta)) {
Set<UnifyPair> resultPrime = new HashSet<>();

@ -26,7 +26,7 @@ public class FiniteClosure implements IFiniteClosure {
/**
* A map that maps every typename to the nodes of the inheritance graph that contain a type with that name.
*/
private HashMap<String, HashSet<Node<UnifyType>>> strInheritanceGraph;
private HashMap<String, Set<Node<UnifyType>>> strInheritanceGraph;
/**
* The initial pairs of that define the inheritance tree
@ -251,7 +251,6 @@ public class FiniteClosure implements IFiniteClosure {
@Override
public Set<UnifyType> grArg(FunNType type) {
// TODO ist das richtig?
Set<UnifyType> result = new HashSet<UnifyType>();
result.add(type);
smaller(type).forEach(x -> result.add(new SuperType(x)));
@ -298,7 +297,6 @@ public class FiniteClosure implements IFiniteClosure {
@Override
public Set<UnifyType> smArg(FunNType type) {
// TODO ist das richtig?
Set<UnifyType> result = new HashSet<UnifyType>();
result.add(type);
return result;

@ -1,15 +0,0 @@
import java.util.Vector;
class UninitializedVariable{
Integer method(Integer v) {
return v;
}
public static void main(String[] args) {
UninitializedVariable ol;
ol = new UninitializedVariable();
Integer v;
ol.method(v);
}
}

@ -1,39 +0,0 @@
package bytecode;
import static org.junit.Assert.*;
import java.io.File;
import java.io.IOException;
import junit.framework.TestCase;
import org.junit.Test;
import plugindevelopment.TypeInsertTester;
import de.dhbwstuttgart.core.MyCompiler;
import de.dhbwstuttgart.core.MyCompilerAPI;
import de.dhbwstuttgart.logger.LoggerConfiguration;
import de.dhbwstuttgart.logger.Section;
import de.dhbwstuttgart.parser.JavaParser.yyException;
import de.dhbwstuttgart.typeinference.ByteCodeResult;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.TypeinferenceResultSet;
import de.dhbwstuttgart.typeinference.typedeployment.TypeInsertSet;
public class UninitializedVariableTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "UninitializedVariable";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

@ -1,14 +0,0 @@
class VariableMultimethods{
public Integer method(Integer z, Integer x, Integer y){
return x+y+z;
}
public Integer method(Integer x, Integer y){
return x+y;
}
public Integer method(Integer y){
return y;
}
}

@ -1,98 +0,0 @@
package bytecode;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Test;
import org.junit.Ignore;
import bytecode.SourceFileBytecodeTest;
public class VariableMultimethodsTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "VariableMultimethods";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
}
@Test
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
@Test
public void testOneArgument() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer y = 1;
Class[] params = new Class[]{
y.getClass()
};
Method method = cls.getDeclaredMethod("method", params);
Integer returnValue = (Integer) method.invoke(obj, y);
assertEquals(new Integer(1), returnValue);
}
@Test
public void testTwoArgument() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer x = 1;
Integer y = 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(3), returnValue);
}
@Test
public void testThreeArgument() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
Integer z = 1;
Integer x = 2;
Integer y = 4;
Class[] params = new Class[]{
z.getClass(),
x.getClass(),
y.getClass()
};
Method method = cls.getDeclaredMethod("method", params);
Integer returnValue = (Integer) method.invoke(obj, z, x, y);
assertEquals(new Integer(7), returnValue);
}
}

@ -0,0 +1,33 @@
package bytecode.types;
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 ExtendsTypeTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "ExtendsType";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
}
@Test
@Ignore
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

@ -61,7 +61,7 @@ public class ExtendsVectorStringTest extends ASTBytecodeTest{
Object obj = cls.newInstance();
Class objectClass = classLoader.loadClass("java.lang.String");
Class objectClass = classLoader.loadClass("java.lang.Object");
Class[] params = new Class[1];
params[0] = objectClass;

@ -1,6 +1,6 @@
class OL {
m(x) { return x + x; }
m(Boolean x) {return x; }
Boolean m(Boolean x) {return x; }
}

@ -0,0 +1,37 @@
package bytecode.types;
import static org.junit.Assert.*;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Vector;
import org.junit.Test;
import org.junit.Ignore;
import bytecode.SourceFileBytecodeTest;
public class SuperType extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "ExtendsType";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
}
@Test
@Ignore
public void testConstruct() throws Exception{
ClassLoader classLoader = getClassLoader();
Class cls = classLoader.loadClass(testName);
Object obj = cls.newInstance();
assertTrue(true);
}
}

@ -1,11 +1,13 @@
import java.util.Vector;
class WildcardTest{
void lower(Vector<? super Integer> v) {
class SuperType{
Vector<Number> numberVector;
void method() {
method(numberVector);
}
void upper(Vector<? extends Integer> v) {
void method(Vector<? super Integer> v) {
}
}

@ -12,7 +12,7 @@ import bytecode.SourceFileBytecodeTest;
public class WildcardTest extends SourceFileBytecodeTest{
@Override
protected void init() {
testName = "WildcardTest";
testName = "Wildcard";
rootDirectory = System.getProperty("user.dir")+"/test/bytecode/types/";
}

@ -1,21 +0,0 @@
import java.util.Vector;
class OverloadingVector{
void method(Vector<String> v) {
}
void method(Vector<Integer> v) {
}
main(String args) {
ol;
ol = new OverloadingVector();
v;
v = new Vector<String> ();
ol.method(v);
}
}

@ -1,15 +0,0 @@
package plugindevelopment.TypeInsertTests;
import de.dhbwstuttgart.typeinference.Menge;
import org.junit.Test;
public class OverloadingVectorTest {
private static final String TEST_FILE = "OverloadingVector.jav";
@Test
public void run(){
Menge<String> mustContain = new Menge<String>();
MultipleTypesInsertTester.testSingleInsert(this.TEST_FILE, mustContain);
}
}

@ -862,24 +862,23 @@ public class UnifyTest {
UnifyType tphT1 = tf.getPlaceholderType("T1");
UnifyType tphT2 = tf.getPlaceholderType("T2");
UnifyType gtv = tf.getSimpleType("gtv");
UnifyType vector = tf.getSimpleType("Vector", gtv);
UnifyType vectorT2 = tf.getSimpleType("Vector", tphT2);
UnifyType vector = tf.getSimpleType("Vector", "T");
UnifyType vectorE = tf.getSimpleType("Vector", tphT2);
UnifyType string = tf.getSimpleType("String");
UnifyType vectorString = tf.getSimpleType("Vector", string);
fcb.add(vector, vector);
fcb.add(vector, tf.getSimpleType("java.lang.Object"));
IFiniteClosure fc = fcb.getFiniteClosure();
Set<UnifyPair> eq = new HashSet<UnifyPair>();
eq.add(new UnifyPair(vectorT2, tphT1, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(tphT1, vectorString, PairOperator.SMALLERDOT));
eq.add(new UnifyPair(vectorE, tphT1, PairOperator.SMALLERDOT));
Set<Set<UnifyPair>> actual = new TypeUnify().unifySequential(eq, fc);
System.out.println("Test OverloadingVector:");
System.out.println(actual);
System.out.println(actual + "\n");
}
@Test