2

new file:   README_aktuelle_Branches
	modified:   src/main/java/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java
	modified:   src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

README_aktuelle_Branches

@@ -0,0 +1,10 @@
+Stand: 24.5.21
+  bigRefactoring: Master-Brach
+  bigRefactoringUnifyComment: Dokumentation Unify, Martin
+  bytecodeGenericsSecond: Generated Generics, Ali, Martin
+  inferWildcards, Wildcards, Till
+  master, derzeit nicht genutzt
+  plugin, eigemntlicher Branch fuer Plugin-Basis, derzeit nicht aktuelle (aktuelle Version in simplifyRes
+  simplifyRes, Basis fuer Plugin, sollte auf Plugin gemerged werden, noch keine Packages, Michael
+  strucTypesNew, Struturelle Typen, alte Basis, arbeite derzeit niemand
+

src/main/java/de/dhbwstuttgart/bytecode/TPHExtractor.java

@@ -10,6 +10,9 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
 import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
@@ -30,6 +33,9 @@ import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
@@ -49,6 +55,10 @@ public class TPHExtractor extends AbstractASTWalker {
 	boolean inLocalOrParamOrReturn = false;
 
 	public final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
+    
+	// Alle Constraints in einer Menge (Und- & Oder-Constraints)
+	public Set<Pair> oldConstraints = new HashSet<>();
+	
 	final ArrayList<ResultPair<TypePlaceholder, TypePlaceholder>> allPairs = new ArrayList<>();
 	public final ArrayList<TPHConstraint> allCons = new ArrayList<>();
 	private ResultSet resultSet;
@@ -78,15 +88,25 @@ public class TPHExtractor extends AbstractASTWalker {
 	public void visit(TypePlaceholder tph) {
 		if (resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
 			TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
-			if (inMethod) {
-				methodAndTph.getTphs().add(resolvedTPH.getName());
-				if (inLocalOrParamOrReturn)
-					methodAndTph.getLocalTphs().add(resolvedTPH.getName());
-			}else {
-				tphsClass.add(resolvedTPH.getName());
+			String tphName = resolvedTPH.getName();
+			if (inMethod && !tphsClass.contains(tphName)) {
+				ArrayList<String> tphs = null;
+				if (!(tphs = methodAndTph.getTphs()).contains(tphName)) {
+					methodAndTph.addTph(tphName);
+			    }
+				if (inLocalOrParamOrReturn) {
+					if (!(tphs = methodAndTph.getLocalTphs()).contains(tphName)) {
+						tphs.add(tphName);
+					}
+				}
+			} else {
+				if (!tphsClass.contains(tphName)) {
+					tphsClass.add(tphName);
+				}
+			}
+			if (!allTPHS.containsKey(tphName)) {
+				allTPHS.put(tphName, inMethod);
 			}
-
-			allTPHS.put(resolvedTPH.getName(), inMethod);
 //			final List<TPHConstraint> cons = new ArrayList<>();
 //			resultSet.resolveType(tph).additionalGenerics.forEach(ag -> {
 //				TPHConstraint con = new ExtendsConstraint(ag.TA1.getName(), ag.TA2.getName(), Relation.EXTENDS);
@@ -153,7 +173,7 @@ public class TPHExtractor extends AbstractASTWalker {
 	public void visit(GenericRefType genericRefType) {
 		String name = genericRefType.getParsedName();
 		if (inMethod) {
-			methodAndTph.getTphs().add(name);
+			methodAndTph.addTph(name);
 			if (inLocalOrParamOrReturn)
 				methodAndTph.getLocalTphs().add(name);
 		}else {
@@ -175,7 +195,33 @@ public class TPHExtractor extends AbstractASTWalker {
 	public void visit(Method method) {
 		inMethod = true;
 		String id = MethodUtility.createID(resolver,method);
-		methodAndTph = new MethodAndTPH(id);
+		Predicate<Pair> filterUndConstraints =  cs -> ((cs.TA1 instanceof TypePlaceholder) && (cs.TA2 instanceof TypePlaceholder) &&
+				(resultSet.resolveType((TypePlaceholder)(cs.TA1)).resolvedType instanceof TypePlaceholder) &&
+				(resultSet.resolveType((TypePlaceholder)(cs.TA2)).resolvedType instanceof TypePlaceholder));
+		    
+		Function<ConstraintSet<Pair>, ConstraintSet<Pair>> filterConstrRemainingTVar =
+				csS -> { 
+					ConstraintSet<Pair> ret = new ConstraintSet<>();
+					ret.addAllUndConstraint(
+							csS.getUndConstraints()
+							   .stream().filter(filterUndConstraints)
+							   .collect(Collectors.toCollection(Constraint<Pair>::new)));
+					  
+					csS.getOderConstraints()
+					   .forEach(oConSSet -> { Set<Constraint<Pair>> setCons = new HashSet<>();
+					            oConSSet.forEach(OConS -> { Constraint<Pair> newConsPair = new Constraint<Pair>();
+					            				 newConsPair.isStatement = OConS.isStatement;
+					            	             setCons.add(
+					                             OConS.stream()
+					                                  .filter(filterUndConstraints)
+					                                  .collect(Collectors.toCollection(() -> newConsPair)) ); 
+					                             } ); 
+					            ret.addOderConstraint(setCons);} );
+				return ret;
+				};
+		ConstraintSet<Pair> filteredConstraints = filterConstrRemainingTVar.apply(method.getConstraints());		
+		methodAndTph = new MethodAndTPH(id, filteredConstraints);
+		oldConstraints.addAll(filteredConstraints.getAll());
 
 		inLocalOrParamOrReturn = true;
 		method.getReturnType().accept(this);
@@ -184,7 +230,7 @@ public class TPHExtractor extends AbstractASTWalker {
         
         if(method.block != null)
             method.block.accept(this);
-		
+		 
 		inMethod = false;
 		ListOfMethodsAndTph.add(methodAndTph);
 	}

src/main/java/de/dhbwstuttgart/bytecode/constraint/TPHConstraint.java

@@ -1,13 +1,25 @@
 package de.dhbwstuttgart.bytecode.constraint;
 
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
 public class TPHConstraint {
 	protected String left;
 	protected String right;
 	protected Relation rel;
+	protected int variance; //noch nicht benutzt
 	public enum Relation{
 		EXTENDS, EQUAL
 	}
 	
+	public TPHConstraint(Pair p) {
+		this.left = ((TypePlaceholder)p.TA1).getName();
+		this.right = ((TypePlaceholder)p.TA2).getName();
+		this.rel = p.GetOperator().equals(PairOperator.SMALLERDOT) ? Relation.EXTENDS : Relation.EQUAL;
+	}
+	
 	public TPHConstraint(String left, String right, Relation rel) {
 		this.left = left;
 		this.right = right;
@@ -48,6 +60,25 @@ public class TPHConstraint {
 		return rel == constraint.getRel() && left.equals(constraint.getLeft()) && right.equals(constraint.getRight());
 	}
 	
+	@Override
+	public int hashCode() {
+		return (left+right).hashCode();
+	}
+	
+	@Override
+	public boolean equals (Object o) {
+		if (o instanceof TPHConstraint) {
+			TPHConstraint o_tphcons = (TPHConstraint)o;
+			return (this.left.equals(o_tphcons.getLeft())
+					&& this.right.equals(o_tphcons.getRight())
+					&& this.rel.equals(o_tphcons.rel));
+		}
+		else {
+			return false;
+		}
+	}
+	
+	
 	@Override
 	public String toString() {
 		if(rel == Relation.EXTENDS) {

src/main/java/de/dhbwstuttgart/bytecode/genericsGenerator/GeneratedGenericsFinder.java

@@ -3,15 +3,14 @@
  */
 package de.dhbwstuttgart.bytecode.genericsGenerator;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
+import java.util.*;
 
 import de.dhbwstuttgart.bytecode.TPHExtractor;
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResultForClass;
-import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.MethodAndConstraints;
+import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.*;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
 import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
 import de.dhbwstuttgart.bytecode.utilities.MethodUtility;
 import de.dhbwstuttgart.bytecode.utilities.Resolver;
@@ -74,11 +73,13 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 	private GenericGenratorResultForSourceFile generatedGenericsForSF;//Ergebnis des GGenerics
 	private ResultSet resultSet;
 	private final List<String> methodNameAndParamsT = new ArrayList<>();
+	private FamilyOfGeneratedGenerics fogg;
 	
 	private String pkgName;
 	private JavaClassName className;
 	private Resolver resolver;
 
+	
 	/**
 	 * @param sf
 	 * @param listOfResultSets
@@ -93,6 +94,14 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 		return generatedGenericsForSF;
 	}
 	
+	/**
+	 * returns the family of Generated Generics
+	 * insbesondere fuer Testzwecke  
+	 */
+	public FamilyOfGeneratedGenerics getFogg() {
+		return fogg;
+	}
+	
 	/*
 	 * (non-Javadoc)
 	 * 
@@ -125,13 +134,28 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 		
 		ConstraintsSimplierResult simplifiedConstraints = null;
 		GenericsGeneratorResultForClass ggResult = null;
+		GenericsGeneratorResultForClass ggResultAlternative = null;
 		
 		for (int i = 0; i < listOfResultSetsList.size(); i++) {
 			resultSet = listOfResultSetsList.get(i);
 			tphExtractor.setResultSet(resultSet);
 			resolver = new Resolver(resultSet);
 			classOrInterface.accept(tphExtractor);
+			//PL 2020-10-16: Ab hier GGenerics implementieren durch Ali
+			//Rueckgabe an generatedGenericsForSF
+			fogg = new FamilyOfGeneratedGenerics(tphExtractor, resultSet);
+
+			System.out.println("fogg.allConstraints: "+ fogg.allConstraints);
+			System.out.println("fogg.posOfTPHs: "+ fogg.posOfTPHs);
+			System.out.println("fogg.classConstraints: "+ fogg.classConstraints);
+			System.out.println("fogg.methodConstraintsWithPosition: "+ fogg.methodConstraintsWithPosition);
+			System.out.println(fogg);
+
+			///* 
+			//Fayez Ansatz Anfang
 			tphsClass = tphExtractor.tphsClass;
+			//PL 2020-01-15
+			//Es muss ggResult aus fogg gebildet werden
 			simplifiedConstraints = GenericsGenerator.simplifyConstraints(tphExtractor, tphsClass);
 			if(!isVisited) {
 				ggResult = GenericsGenerator.generateConstraints(className, tphExtractor, tphsClass,simplifiedConstraints);
@@ -140,13 +164,46 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 
 			for(Method m : classOrInterface.getMethods()) {
 				addMethodConstraints(simplifiedConstraints, ggResult, m);
-				
+
 			}
 			
-			if(ggResult != null)
+
+			if(ggResult != null) {  //Hinzufuegen von Fayez ggResult
 				generatedGenericsForSF.addGenericGeneratorResultClass(ggResult);
+			}
+			// Fayez Ansatz Ende 
+			//*/
 			
-			
+			//Ali Ansatz Anfang
+			List<GenericsGeneratorResult> listOfClassCons = new ArrayList<>();
+			for(TPHConstraint clCons: fogg.classConstraints) {
+//				ExtendsConstraint ec = new ExtendsConstraint(clCons.getLeft(), clCons.getRight());
+				GenericsGeneratorResult ggR = new GenericsGeneratorResult(clCons, new HashSet<>());
+				listOfClassCons.add(ggR);
+			}
+
+			GenericGeneratorResultsForAllMethods ggRfaM = null;
+			List<MethodAndConstraints> listOfMethAndCons = new ArrayList<>();
+			for(String methID: fogg.methodConstraintsWithPosition.keySet()) {
+				List<GenericsGeneratorResult> listOfGGR = new ArrayList<>();
+				for(TPHConstraint methCons: fogg.methodConstraintsWithPosition.get(methID)) {
+//					ExtendsConstraint ec = new ExtendsConstraint(methCons.getLeft(),methCons.getRight());
+					GenericsGeneratorResult ggR = new GenericsGeneratorResult(methCons, new HashSet<>());
+					listOfGGR.add(ggR);
+				}
+				MethodAndConstraints mac = new MethodAndConstraints(methID, listOfGGR);
+				listOfMethAndCons.add(mac);
+			}
+			ggRfaM = new GenericGeneratorResultsForAllMethods(listOfMethAndCons);
+			ggResultAlternative = new GenericsGeneratorResultForClass(className, listOfClassCons, ggRfaM);
+
+			if(ggResultAlternative != null) {//hinzufuegen von Alis ggResult
+				//generatedGenericsForSF.addGenericGeneratorResultClass(ggResultAlternative);
+				System.out.println(generatedGenericsForSF);
+			}
+			System.out.println(ggResultAlternative);
+			//Ali Ansatz Ende
+
 		}
 
 	}

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericGeneratorResultsForAllMethods.java

@@ -29,5 +29,13 @@ public class GenericGeneratorResultsForAllMethods {
 	public List<MethodAndConstraints> getMethodsAndConstraints() {
 		return methodsAndConstraints;
 	}
+	
+	@Override
+	public String toString() {
+		String ret = "";
+		ret = ret + methodsAndConstraints.stream().reduce("", (x,y) -> x + y.toString(), (x,y) -> x + y);
+		//ret = ret + "\n";
+		return ret;
+	}
 
 }

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericsGeneratorResult.java

@@ -52,4 +52,8 @@ public class GenericsGeneratorResult {
 		this.equalsTPHs = equalsTPHs;
 	}
 	
+	@Override
+	public String toString() {
+		return constraint.toString() + " EqualsTPS: " + equalsTPHs.toString();
+	}
 }

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/GenericsGeneratorResultForClass.java

@@ -73,4 +73,12 @@ public class GenericsGeneratorResultForClass {
 			return Collections.emptyList();
 		}
 	}
+	
+	@Override
+	public String toString() {
+		String ret = "Classconstraints: ";
+		ret = ret + classConstraints.stream().reduce("", (x,y) -> x + y.toString(), (x,y) -> x + y);
+		ret = ret + "\n" + methodsAndTheirConstraints.toString(); 
+		return ret;
+	}
 }

src/main/java/de/dhbwstuttgart/bytecode/genericsGeneratorTypes/MethodAndConstraints.java

@@ -33,4 +33,14 @@ public class MethodAndConstraints {
 		return constraints;
 	}
 	
+	
+	@Override
+	public String toString() {
+		String ret = methodID + ": ";
+		ret = ret + constraints.stream().reduce("", 
+				(x,y) -> x + y.toString(), 
+				(x,y) -> x + y);
+		ret = ret + "\n";
+		return ret;
+	}
 }

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/ClassConstraint.java

@@ -0,0 +1,16 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+
+public class ClassConstraint extends TPHConstraint {
+    //private TPHConstraint constraint;
+
+    public ClassConstraint(String left, String right, Relation rel) {
+        super(left, right, rel);
+    }
+    //besser?
+    /*public ClassConstraint(TPHConstraint constraint) {
+        this.constraint = constraint;
+    }*/
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/FamilyOfGeneratedGenerics.java

@@ -0,0 +1,880 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.bytecode.TPHExtractor;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+
+import java.util.*;
+import java.util.function.Predicate;
+
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import org.objectweb.asm.Type;
+
+public class FamilyOfGeneratedGenerics {
+    public List<TPHConstraint> allConstraints = new ArrayList<>();
+    // HashMap speichert ob TPH in einer Methode oder in der Klasse ist; und wenn es in der Methode ist, in welcher Methode
+    public HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTPHs = new HashMap<>();
+    public List<ClassConstraint> classConstraints = new ArrayList<>();
+    private HashMap<String, MethodAndTPH> mapMethodsAndTph = new HashMap<>();
+    public List<MethodConstraint> methodConstraints = new ArrayList<>();
+    public HashMap<String, List<MethodConstraint>> methodConstraintsWithPosition = new HashMap<>();
+    public ResultSet resSet;
+    public Set<Pair> oldCons = new HashSet<>();
+
+    private static final String objectType = Type.getInternalName(Object.class);
+
+    public FamilyOfGeneratedGenerics(TPHExtractor tphExtractor, ResultSet resultSet) {
+        this.resSet = resultSet;
+        this.oldCons = tphExtractor.oldConstraints;
+        this.allConstraints = tphExtractor.allCons;
+        this.posOfTPHs = positionConverter(tphExtractor.allTPHS, tphExtractor.ListOfMethodsAndTph);
+        this.classConstraints = getClassConstraints(allConstraints,posOfTPHs);
+        tphExtractor.ListOfMethodsAndTph.forEach(matph -> this.mapMethodsAndTph.put(matph.getId(), matph));
+        this.methodConstraints = getMethodConstraints(allConstraints,classConstraints,posOfTPHs, tphExtractor.ListOfMethodsAndTph);
+        this.methodConstraintsWithPosition = getMethodConstraintsWithPositionNew(allConstraints,classConstraints,posOfTPHs, tphExtractor.ListOfMethodsAndTph, resSet, oldCons);
+    }
+
+    public static List<ClassConstraint> getClassConstraints(List<TPHConstraint> cs, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) { //Inputparameter List<TPHConstraint> constraintsSet weg
+        List<ClassConstraint> cs_cl = new ArrayList<>();
+        List<ClassConstraint> classConstraints1 = typeOfANodeOfAField(cs, posOfTphs);
+        for (ClassConstraint cons: classConstraints1) {
+            if (!checkForDuplicates(cons, cs_cl)) {
+                cs_cl.add(cons);
+            }
+        }
+
+        // if sth new is added to cs_cl, then do same step again
+        boolean addedToConstraintsListForCC2 = false;
+        do {
+            addedToConstraintsListForCC2 = false;
+            List<ClassConstraint> classConstraints2 = transitiveSubtypeForClassTypes(cs, cs_cl); // in Klammer classConstraints1 oder constraintsSet? beides eher
+            for (ClassConstraint cons: classConstraints2) {
+                if (!checkForDuplicates(cons, cs_cl)) {
+                    cs_cl.add(cons);
+                    addedToConstraintsListForCC2 = true;
+                }
+            }
+        } while (addedToConstraintsListForCC2);
+
+        List<ClassConstraint> classConstraints3 = hasNoSupertypeForClassTypes(cs_cl, posOfTphs);
+        for (ClassConstraint cons: classConstraints3) {
+            if (!checkForDuplicates(cons, cs_cl)) {
+                cs_cl.add(cons);
+            }
+        }
+        return cs_cl;
+    }
+
+    public List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph) {
+        List<MethodConstraint> cs_m = new ArrayList<>();
+        List<MethodConstraint> methodConstraints1 = typeOfTheMethodInClSigma(cs, posOfTphs);
+        for (MethodConstraint cons: methodConstraints1) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+
+        // if sth new is added to cs_cl, then do same step again
+        boolean addedToConstraintsListForMC2 = false;
+        do {
+            addedToConstraintsListForMC2 = false;
+            List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes(cs, cs_m);
+            for (MethodConstraint cons : methodConstraints2) {
+                if (!checkForDuplicates(cons, cs_m)) {
+                    cs_m.add(cons);
+                    addedToConstraintsListForMC2 = true;
+                }
+            }
+        } while (addedToConstraintsListForMC2);
+
+        // if sth new is added to cs_cl, then do same step again
+        boolean addedToConstraintsListForMC3 = false;
+        do {
+            addedToConstraintsListForMC3 = false;
+            List<MethodConstraint> methodConstraints3 = secondTransitiveSubtypeForMethodTypes(cs, cs_cl, cs_m);
+            for (MethodConstraint cons : methodConstraints3) {
+                if (!checkForDuplicates(cons, cs_m)) {
+                    cs_m.add(cons);
+                    addedToConstraintsListForMC3 = true;
+                }
+            }
+        } while (addedToConstraintsListForMC3);
+        List<MethodConstraint> methodConstraints4 = hasNoSupertypeForMethodTypes(cs, cs_m, posOfTphs, listOfMethodsAndTph);
+        for (MethodConstraint cons: methodConstraints4) {
+            if (!checkForDuplicates(cons, cs_m)) {
+                cs_m.add(cons);
+            }
+        }
+        List<MethodConstraint> methodConstraints5 = methodTypesWithoutClassTypes(cs_cl, cs_m);
+        cs_m = methodConstraints5;
+        return cs_m;
+    }
+
+    public HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPosition(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
+        HashMap<String, List<MethodConstraint>> tempMethodConstraintsWithPosition = new HashMap<>();
+        for(MethodAndTPH method: listOfMethodsAndTph){
+            List<String> methodsAddedToHashMap = new ArrayList<>();
+            String currentMethod = method.getId();
+            boolean containsCurrentMethod = false;
+            if(!containsCurrentMethod) {
+                methodsAddedToHashMap.add(currentMethod);
+                containsCurrentMethod = true;
+                List<MethodConstraint> listOfThisMethod = new ArrayList<>();
+                HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTPHsForThisMethod = new HashMap<>();
+                for(String s: posOfTphs.keySet()) {
+                    for(PairTphMethod pair: posOfTphs.get(s)) {
+                        if(pair.snd == currentMethod && pair.snd != null) {
+                            posOfTPHsForThisMethod.put(s,posOfTphs.get(s));
+                        }
+                    }
+                }
+                listOfThisMethod = getMethodConstraints(cs,cs_cl,posOfTPHsForThisMethod,listOfMethodsAndTph);
+                tempMethodConstraintsWithPosition.put(currentMethod, listOfThisMethod);
+
+                List<MethodConstraint> newMCList = firstLineMethodDefinition(cs, posOfTphs, method, resSet);
+                List<MethodConstraint> newMCList2 = secondLineMethodDefinition(cs, posOfTphs, method, resSet, oldCons);
+                System.out.println(newMCList);
+                System.out.println(newMCList2);
+            }
+        }
+
+        for(String curMeth: tempMethodConstraintsWithPosition.keySet()){
+            for(int i=0; i<tempMethodConstraintsWithPosition.get(curMeth).size(); i++) {
+                MethodConstraint currentMC = tempMethodConstraintsWithPosition.get(curMeth).get(i);
+                if(currentMC.getRight()!= objectType && !compareTphsOfConstraints(currentMC.getRight(), cs_cl) && !compareTphsOfConstraints(currentMC.getRight(), tempMethodConstraintsWithPosition.get(curMeth))) {
+                    MethodConstraint mc = new MethodConstraint(currentMC.getRight(), objectType, Relation.EXTENDS);
+                    tempMethodConstraintsWithPosition.get(curMeth).add(mc);
+                }
+            }
+        }
+        return tempMethodConstraintsWithPosition;
+    }
+
+    // Hilfsmethode um TPHs in den Methoden zu finden, die <. Object sein müssen
+    private static boolean compareTphsOfConstraints(String tph, List list) {
+        List<TPHConstraint> tempList = new ArrayList<>(list);
+        for(TPHConstraint tphC: tempList) {
+            if(tph == tphC.getLeft()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Def. FGG: erste Zeile von cs_cl
+     * {T < .T' | T is a type variable in a type of a node of a field}
+     */
+    public static List<ClassConstraint> typeOfANodeOfAField(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) {
+        //RuntimeException re = new RuntimeException("enthält EQUALS-Relation");
+        List<ClassConstraint> tempCC = new ArrayList<>();
+        for(TPHConstraint allCons: allConstraints){
+            if(posOfTphs.containsKey(allCons.getLeft()) && allCons.getRight()!=null && allCons.getRel()==Relation.EXTENDS) {
+                for(String tph: posOfTphs.keySet()) {
+                    for(PairTphMethod pair: posOfTphs.get(tph)) {
+                        if(tph == allCons.getLeft() && pair.fst == PositionFinder.Position.FIELD) {
+                            ClassConstraint consToAdd = new ClassConstraint(tph, allCons.getRight(), allCons.getRel());
+                            if (!checkForDuplicates(consToAdd, tempCC)) {
+                                tempCC.add(consToAdd);
+                            }
+                        /*}else if(pair.fst == PositionFinder.Position.FIELD){
+                            ClassConstraint consToAdd = new ClassConstraint(tph, objectType, Relation.EXTENDS);
+                            if (!checkForDuplicates(consToAdd, tempCC)) {
+                                tempCC.add(consToAdd);
+                            }*/
+                        }
+                    }
+                }
+            }
+            /*else if (allCons.getRel() != Relation.EXTENDS) {
+                throw re;
+            }*/
+        }
+        return tempCC;
+    }
+
+    /**
+     * Def. FGG: zweite Zeile von cs_cl
+     * {T' <. T'' | \exists T: (T <. T') \in cs_cl, (T' <. T'') \in cs }
+     */
+    public static List<ClassConstraint> transitiveSubtypeForClassTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl) {
+        List<ClassConstraint> tempCC = new ArrayList<>();
+        ClassConstraint consToAdd;
+        for(ClassConstraint cCons: cs_cl) {
+            if(cCons.getLeft() != null && cCons.getRel()==Relation.EXTENDS) {
+                for(TPHConstraint allCons: allConstraints) {
+                    if(cCons.getRight() == allCons.getLeft() && allCons.getRight() != null && allCons.getRel()==Relation.EXTENDS){
+                        consToAdd = new ClassConstraint(allCons.getLeft(), allCons.getRight(), allCons.getRel());
+                        if (!checkForDuplicates(consToAdd, tempCC)) {
+                            tempCC.add(consToAdd);
+                        }
+                    }
+                }
+            }
+        }
+        return tempCC;
+    }
+
+    /**
+     * Def. FGG: dritte Zeile von cs_cl
+     * {T <. Object | ((T is a type variable in a type of a node of a field
+     *                  or (\exists T~: (T~ <. T) \in cs_cl)) and (\existsnot T': T <. T') \in cs)}
+     */
+    public static List<ClassConstraint> hasNoSupertypeForClassTypes(List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) {
+        List<ClassConstraint> tempCC= new ArrayList<>();
+        List<TPHConstraint> clCons = new ArrayList<>(cs_cl);
+            for(String tph: posOfTphs.keySet()) {
+                for(PairTphMethod pair: posOfTphs.get(tph)) {
+                    boolean tvInField = pair.fst == PositionFinder.Position.FIELD;
+                    boolean hasSmallerTVInClCons = hasSmallerTVInClCons(tph, cs_cl);
+                    if ((tvInField || hasSmallerTVInClCons) &&
+                            !checkUpperBound(clCons, tph)) {
+                        ClassConstraint consToAdd = new ClassConstraint(tph, objectType, Relation.EXTENDS);
+                        if (!checkForDuplicates(consToAdd, tempCC)) {
+                            tempCC.add(consToAdd);
+                        }
+                    }
+                }
+            }
+        return tempCC;
+    }
+
+    public static boolean hasSmallerTVInClCons(String tph, List<ClassConstraint> cs_cl) {
+        for(ClassConstraint cC: cs_cl) {
+            if(tph == cC.getRight() && cC.getRel() == Relation.EXTENDS) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Def. FGG: erste Zeile von cs_m
+     * {T < .T' | T is a type variable in a type of the method/constructor m in cl_\sigma, (T <. T') \in cs}
+     */
+    public static List<MethodConstraint> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs) { // cl_\sigma??
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        for(TPHConstraint allCons: allConstraints){
+            if(posOfTphs.containsKey(allCons.getLeft()) && allCons.getRight()!=null && allCons.getRel()==Relation.EXTENDS) {
+                for(String tph: posOfTphs.keySet()) {
+                    for(PairTphMethod pair: posOfTphs.get(tph)) {
+                        if(tph == allCons.getLeft() && (pair.fst == PositionFinder.Position.METHOD || pair.fst == PositionFinder.Position.CONSTRUCTOR)) {
+                            MethodConstraint consToAdd = new MethodConstraint(allCons.getLeft(), allCons.getRight(), allCons.getRel());
+                            if (!checkForDuplicates(consToAdd, tempMC)) {
+                                tempMC.add(consToAdd);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+
+    /**
+     * Def. FGG: zweite Zeile von cs_m
+     * {R' <. S | (R <. R'), (S <. S') \in cs_m and (R',S) is in the transitive closure of cs}
+     */
+    public List<MethodConstraint> firstTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m) { //transitive closure of cs
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
+        for(MethodConstraint mC1 : cs_m) {          //(R <. R')
+            for(MethodConstraint mC2 : cs_m) {      //(S <. S')
+                String lSide = mC1.getRight();      //R'
+                String rSide = mC2.getLeft();       //S
+                for(TPHConstraint tphC : tcOfCs) {
+                    if(tphC.getLeft().equals(lSide)&&tphC.getRight().equals(rSide)) { //is it (R',S)
+                        MethodConstraint consToAdd = new MethodConstraint(lSide, rSide, tphC.getRel()); //create (R'<.S)
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                        }
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+    /**
+     * Def. FGG: dritte Zeile von cs_m
+     * {R' <. S | (R <. R') \in cs_m, (S <. S') \in cs_cl and (R',S) is in the transitive closure of cs}
+     */
+    public List<MethodConstraint> secondTransitiveSubtypeForMethodTypes(List<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        List<TPHConstraint> tcOfCs =  buildTransitiveClosure(allConstraints);
+        for(ClassConstraint cC : cs_cl) {
+            for(MethodConstraint mC : cs_m) {
+                String leftSide = mC.getRight();
+                String rightSide = cC.getLeft();
+                for(TPHConstraint tphC : tcOfCs) {
+                    if(tphC.getLeft().equals(leftSide)&&tphC.getRight().equals(rightSide)) {
+                        MethodConstraint consToAdd = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                        }
+
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+/**
+     * Def. FGG: vierte Zeile von cs_m
+     * {T <. Object | (T is a type variable in a type of a node of the method/constructor m in cl_\sigma),
+     *                  (\existsnot T': T <. T') \in cs)}
+     */
+    public static List<MethodConstraint> hasNoSupertypeForMethodTypes(List<TPHConstraint> allConstraints, List<MethodConstraint> cs_m, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph) {
+        //TODO:
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        for(String tph: posOfTphs.keySet()) {
+            for(PairTphMethod pair: posOfTphs.get(tph)) {
+                for(TPHConstraint allCons: allConstraints) {
+                    if((pair.fst.equals(PositionFinder.Position.METHOD) || pair.fst.equals(PositionFinder.Position.CONSTRUCTOR)) && !checkUpperBound(allConstraints,tph)) {
+                        MethodConstraint consToAdd = new MethodConstraint(tph, objectType, Relation.EXTENDS);
+                        if (!checkForDuplicates(consToAdd, tempMC)) {
+                            tempMC.add(consToAdd);
+                        }
+                    }
+                }
+                List<TPHConstraint> tempMCObject1 = new ArrayList<>(cs_m);
+                String currentMethod = "";
+                for(MethodAndTPH mat: listOfMethodsAndTph) {
+                    if(mat.getId().equals(pair.snd)) {
+                        currentMethod = mat.getId();
+                    }
+                    for(TPHConstraint mc1: tempMCObject1) {
+                        if(tph==mc1.getRight() && !checkUpperBound(tempMCObject1,tph)) {
+                            MethodConstraint consToAdd = new MethodConstraint(tph, objectType, Relation.EXTENDS);
+                            if (!checkForDuplicates(consToAdd, tempMC)) {
+                                tempMC.add(consToAdd);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+/**
+     * nimm die Menge cs_cl aus cs_m raus
+     */
+    public List<MethodConstraint> methodTypesWithoutClassTypes(List<ClassConstraint> cs_cl, List<MethodConstraint> cs_m) {
+        // erstelle Kopie der Liste cs_cl
+        List<TPHConstraint> tempCC = new ArrayList<>();
+        for(ClassConstraint cc: cs_cl) {
+            TPHConstraint tphC = new TPHConstraint(cc.getLeft(), cc.getRight(), cc.getRel());
+            tempCC.add(tphC);
+        }
+        // Transitive Hülle von cs_cl
+        List<TPHConstraint> tcOfCsCl = buildTransitiveClosure(tempCC);
+
+        List<TPHConstraint> tempMC = new ArrayList<>();
+        for(MethodConstraint mc: cs_m) {
+            TPHConstraint tphC = new TPHConstraint(mc.getLeft(), mc.getRight(), mc.getRel());
+            tempMC.add(tphC);
+        }
+        List<TPHConstraint> tempMC2 = new ArrayList<>();
+        tempMC2.addAll(tempMC);
+        List<MethodConstraint> tempMCToReturn = new ArrayList<>();
+
+        for(TPHConstraint cc: tcOfCsCl) {
+            for(TPHConstraint mc: tempMC) {
+                if(cc.getLeft().equals(mc.getLeft()) && cc.getRight().equals(mc.getRight())) {
+                    tempMC2.remove(mc);
+                }
+            }
+        }
+        for(TPHConstraint tphC: tempMC2) {
+            MethodConstraint mCons = new MethodConstraint(tphC.getLeft(), tphC.getRight(), tphC.getRel());
+            tempMCToReturn.add(mCons);
+        }
+        return tempMCToReturn;
+    }
+
+    public static boolean checkForDuplicates(TPHConstraint constraint, List list) {
+        List<TPHConstraint> tempList = list;
+        boolean hasSame = false;
+        for (TPHConstraint tphC: tempList) {
+           hasSame = constraint.getLeft() == tphC.getLeft() &&
+                constraint.getRight() == tphC.getRight() &&
+                constraint.getRel() == tphC.getRel(); //constraint already in ArrayList if true
+            if (hasSame)
+                return true;
+        }
+        return false;
+    }
+
+    public List<TPHConstraint> buildTransitiveClosure(List list) {
+        List<TPHConstraint> iterList = new ArrayList<>(list);
+        List<TPHConstraint> runList = new ArrayList<>(list);
+        List<TPHConstraint> tcList = new ArrayList<>(list);
+        boolean addedConToList = false;
+        for (TPHConstraint cons: iterList) {
+            for (TPHConstraint cons2: runList) {
+                if(cons.getRight() == cons2.getLeft()) {
+                    TPHConstraint consToAdd = new TPHConstraint(cons.getLeft(), cons2.getRight(), Relation.EXTENDS);
+                    if (!checkForDuplicates(consToAdd,tcList)) {
+                        tcList.add(consToAdd);
+                        addedConToList = true;
+                        if (addedConToList) {
+                            return buildTransitiveClosure(tcList);
+                        }
+                    }
+                }
+            }
+        }
+        return tcList;
+    }
+
+    public static boolean checkUpperBound(List<TPHConstraint> cs, String tph) {
+        for(int i=0; i<cs.size(); i++) {
+            if(cs.get(i).getLeft() == tph) {
+                //has upper bound
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    public static HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> positionConverter(HashMap<String, Boolean> allTphs, List<MethodAndTPH> listOfMethodsAndTphs) {
+        HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> convertedPositions = new HashMap<>();
+        for(String tph: allTphs.keySet()) {
+            List<PairTphMethod<PositionFinder.Position, String>> currMeth = new ArrayList<>();
+            if(allTphs.get(tph)) {  //if true, then tph is a method-TPH
+                for(MethodAndTPH methTph: listOfMethodsAndTphs) {
+                    if (methTph.getTphs().contains(tph)) {
+                        currMeth.add(new PairTphMethod<>(PositionFinder.Position.METHOD, methTph.getId()));
+                    }
+                }
+            } else { // else it is in the class-TPH
+                currMeth.add(new PairTphMethod<>(PositionFinder.Position.FIELD, null));
+            }
+            convertedPositions.put(tph, currMeth);
+        }
+        return convertedPositions;
+    }
+
+/*    public PositionFinder.Position positionConverter(TPHExtractor tphExtractor) {
+        if(tphExtractor.allTPHS.keySet())
+    }*/
+
+
+
+
+
+/*  GeneratedGenericsFinder genGenFinder;
+    ConstraintsSimplierResult simplifiedConstraints = null;
+    GenericsGeneratorResultForClass ggResult = null;
+    Method m;
+
+    public void addMethodConstraints(List<MethodConstraint> cs_m) {
+        genGenFinder.addMethodConstraints(simplifiedConstraints, ggResult, m);
+        cs_m.add();
+    }
+*/
+
+    public static List<MethodConstraint> firstLineMethodDefinition(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, ResultSet resSet) {
+        List<MethodConstraint> tempMC= new ArrayList<>();
+        MethodAndTPH methAndTphs = methodAndTPH;
+        Set<Pair> undCons =  methAndTphs.constraints.getUndConstraints();
+        List<Set<Constraint<Pair>>> orCons = methAndTphs.constraints.getOderConstraints();
+        Iterator<Pair> it = undCons.iterator();
+        while(it.hasNext()) {
+            Pair p = it.next();
+            String ta1 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName();
+            String ta2 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName();
+            Relation r = null;
+            if(p.GetOperator() == PairOperator.SMALLERDOT) {
+                r = Relation.EXTENDS;
+            } else if(p.GetOperator() == PairOperator.EQUALSDOT) {
+                r = Relation.EQUAL;
+            }
+            MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
+            if(mc.getRel() == Relation.EXTENDS) {
+            	if (!mc.getLeft().equals(mc.getRight())) { //eliminieren der Fälle wie AA<.AA
+            		if(!checkForDuplicates(mc, tempMC)) {
+            			tempMC.add(mc);
+            		}
+            	}
+            }
+        }
+        return tempMC;
+    }
+
+    public List<MethodConstraint> secondLineMethodDefinition(List<TPHConstraint> allConstraints, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, ResultSet resSet, Set<Pair> oldCons) {
+        List<MethodConstraint> tempMC = new ArrayList<>(); //für Ergebnisse basierend auf der neuen Datenstruktur (Ali)
+        Set<Pair> tempSet = new HashSet<>(); //für Ergebnisse des ersten Teils der Bedinung basierend auf der alten Datenstruktur
+        Set<Pair> tempSet2 = new HashSet<>(); //für Ergebnisse des zweiten Teils der Bedingung basierend auf der alten Datenstruktur
+        Set<Pair> tcOfoldConsSet = buildTransitiveClosureForCP(oldCons, resSet);
+        List<TPHConstraint> tcOfCs = buildTransitiveClosure(allConstraints);
+        MethodAndTPH methAndTphs = methodAndTPH;
+        Set<Pair> undCons =  methAndTphs.constraints.getUndConstraints();
+        List<Set<Constraint<Pair>>> orCons = methAndTphs.constraints.getOderConstraints();
+        List<HashMap<Relation, List<TPHConstraint>>> orConsListConverted = new ArrayList<>();
+        //gehe die OrConstraints der aktuellen Methode durch und teile nach Operator auf (
+        for(int i=0; i<orCons.size(); i++) {
+            List<TPHConstraint> orConsWithEQUAL = new ArrayList();
+            List<TPHConstraint> orConsWithEXTENDS = new ArrayList();
+            HashMap<Relation, List<TPHConstraint>> orConsInternal = new HashMap<>();
+            for(Constraint con: orCons.get(i)) {
+                Iterator<Pair> it = con.iterator();
+                while(it.hasNext()) {
+                    Pair p = it.next();
+                    Relation r = null;
+                    if(p.GetOperator() == PairOperator.SMALLERDOT) {
+                        r = Relation.EXTENDS;
+                        orConsWithEXTENDS.add(new TPHConstraint(((TypePlaceholder) p.TA1).getName(), ((TypePlaceholder) p.TA2).getName(), r));
+                        /*MethodConstraint mc = new MethodConstraint(((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName(), ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName(), r);
+                        if(!checkForDuplicates(mc, tempMC)) {
+                            tempMC.add(mc);
+                        }*/
+                    } else if(p.GetOperator() == PairOperator.EQUALSDOT) {
+                        r = Relation.EQUAL;
+                        orConsWithEQUAL.add(new TPHConstraint(((TypePlaceholder) p.TA1).getName(), ((TypePlaceholder) p.TA2).getName(), r));
+                        /*MethodConstraint mc = new MethodConstraint(((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName(), ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName(), r);
+                        if(!checkForDuplicates(mc, tempMC)) {
+                            tempMC.add(mc);
+                        }*/
+                    }
+                }
+            }
+            orConsInternal.put(Relation.EXTENDS, orConsWithEXTENDS);
+            orConsInternal.put(Relation.EQUAL, orConsWithEQUAL);
+            orConsListConverted.add(orConsInternal);
+        }
+
+        // oldCons sind alle Und- und Oder-Constraints
+        // zunächst in meine Datenstruktur(Ali) konvertieren
+        List<Pair> oldConsList = new ArrayList<>(oldCons);
+        List<TPHConstraint> oldConsListConverted = new ArrayList<>();
+        for(Pair pair: oldConsList) {
+            Relation r = null;
+            if(pair.GetOperator() == PairOperator.SMALLERDOT) {
+                r = Relation.EXTENDS;
+            } else if(pair.GetOperator() == PairOperator.EQUALSDOT) {
+                r = Relation.EQUAL;
+            }
+            oldConsListConverted.add(new TPHConstraint(((TypePlaceholder) pair.TA1).getName(), ((TypePlaceholder) pair.TA2).getName(), r));
+        }
+
+
+        // Berechnung des zweiten Teils der Bedingung der Regel
+        for(int i=0; i<orCons.size(); i++) {
+            Constraint<Pair> extendsSet = new Constraint<Pair>();
+            Constraint<Pair> equalSet = new Constraint<Pair>();
+            //für jede einzelne OrConstraint-Menge gehe durch
+            for (Constraint con : orCons.get(i)) {
+                Iterator<Pair> it = con.iterator();
+                while (it.hasNext()) {
+                    Pair p = it.next();
+                    if (p.OperatorSmallerDot()) {
+                        extendsSet.add(p);
+                    } else if (p.OperatorEqual()) {
+                        equalSet.add(p);
+                    }
+                }
+                Iterator<Pair> itExtends2 = extendsSet.iterator();
+                while(itExtends2.hasNext()) {
+                    Pair pairExtends2 = itExtends2.next();
+                    Set<String> containedVars = new HashSet<>(methodAndTPH.getTphs());
+                    String pairExtends2RHSName = ((TypePlaceholder)((resSet.resolveType((TypePlaceholder)pairExtends2.TA2)).resolvedType)).getName();
+                    Iterator<Pair> itEqual2 = equalSet.iterator();
+                    while (itEqual2.hasNext()) {
+                    	boolean transClo = false;
+                        Pair pairEqual2 = itEqual2.next();
+                        //TODO: Auf trans.FamilyOfGeneratedGenerics Huelle pruefen
+                        Pair newPairOld = new Pair(pairExtends2.TA2, pairEqual2.TA1);
+                        Pair newPair2 = new Pair(resSet.resolveType((TypePlaceholder) (pairExtends2.TA2)).resolvedType, resSet.resolveType((TypePlaceholder) (pairEqual2.TA1)).resolvedType, PairOperator.SMALLERDOT);
+                        TPHConstraint newPairTPHConstraint = new TPHConstraint(newPair2);
+                        if (tcOfCs.contains(newPairTPHConstraint)|| (newPairTPHConstraint.getLeft().equals(newPairTPHConstraint.getRight()))) {
+                        	transClo = true;
+                        }
+                        TypePlaceholder tphR = (TypePlaceholder) pairEqual2.TA2;
+                        Iterator<Pair> itUndCons = undCons.iterator();
+                        boolean rEqExRtilde = false;
+                        while (itUndCons.hasNext()) {
+                            Pair pairUndCons2 = itUndCons.next();
+                            rEqExRtilde = rEqExRtilde || (tphR == pairUndCons2.TA1);
+                        }            
+                        boolean isPairInTExTapostrophe = false;
+                        for(Set<Constraint<Pair>> scp: orCons) {
+                        	Iterator<Constraint<Pair>> itSCP = scp.iterator();
+                        	while(itSCP.hasNext()) {
+                        		Constraint<Pair> cp = itSCP.next();
+                        		Iterator<Pair> itCP = cp.iterator();
+                        		while(itCP.hasNext()) {
+                        			Pair p = itCP.next();
+                        			if(p.OperatorSmallerDot()) {
+                        				isPairInTExTapostrophe = isPairInTExTapostrophe || tphR.equals(p.TA1);
+                                    }
+                                }
+                            }
+                            
+                        }
+                               
+                        if (transClo && (rEqExRtilde || isPairInTExTapostrophe)) {
+                        	if (!newPair2.TA1.equals(newPair2.TA2)) { //eliminieren der Fälle wie AA<.AA
+                        		if (!checkForDuplicatesForSets(newPair2, tempSet2)) {
+                        			tempSet2.add(newPair2);
+                        		}
+                        	}
+                        	if (!checkForDuplicatesForSets(pairExtends2, tempSet2)) {
+                        		tempSet2.add(pairExtends2);
+                        	}
+                        }
+                        else {
+                        	//containedVars.remove(((TypePlaceholder)newPair2.TA2).getName());
+                        }
+                        	
+                    }	
+                    
+                    //String key = ((TypePlaceholder)((resSet.resolveType((TypePlaceholder)pairExtends2.TA2)).resolvedType)).getName();
+                    //TODO: containedVars stimmt noch nicht. Ueberpruefen, ob ggf. mit den containedVars möglicherweise auch die anderen Faelle
+                    //      rEqExRtilde isPairInTExTapostrophe abgedeckt sind => ggf. integrieren
+                    /*
+                    posOfTphs.forEach((x,y) -> { 
+                                       if (y.contains(new PairTphMethod<>(PositionFinder.Position.METHOD, methodAndTPH.getId()))) {
+                                    	   containedVars.add(x);
+                                       };
+                                      }
+                    		         );
+                    */
+                    //Referenzbeispiel Put.jav
+                    if (containedVars.stream().filter(v -> tcOfCs.contains(new TPHConstraint(pairExtends2RHSName, v, Relation.EXTENDS)))
+                    		                  .count() > 0) { 
+                    	System.out.println();
+                    	//tempSet2.add(pairExtends2);
+                    }
+                    if (posOfTphs.containsKey(pairExtends2RHSName)) {//Refrenzbeispiel TestVector.jav
+                    	if (posOfTphs.get(pairExtends2RHSName).contains(new PairTphMethod<>(PositionFinder.Position.METHOD, methodAndTPH.getId()))) {
+                    		tempSet2.add(pairExtends2);
+                    	}
+                    } 
+                }
+            }
+        }
+
+
+        // aus der alten Datenstruktur in die neue Datenstruktur (von Ali) für ersten Teil
+        Iterator<Pair> itTemp = tempSet.iterator();
+        while(itTemp.hasNext()) {
+            Pair p = itTemp.next();
+            String ta1 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName();
+            String ta2 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName();
+            Relation r = null;
+            if(p.GetOperator() == PairOperator.SMALLERDOT) {
+                r = Relation.EXTENDS;
+            } else if(p.GetOperator() == PairOperator.EQUALSDOT) {
+                r = Relation.EQUAL;
+            }
+            MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
+            if(mc.getRel() == Relation.EXTENDS) {
+                if(!checkForDuplicates(mc, tempMC)) {
+                    tempMC.add(mc);
+                }
+            }
+        }
+
+        // aus der alten Datenstruktur in die neue Datenstruktur (von Ali) für zweiten Teil
+        Iterator<Pair> itTemp2 = tempSet2.iterator();
+        while(itTemp2.hasNext()) {
+            Pair p = itTemp2.next();
+            String ta1 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA1)).resolvedType)).getName();
+            String ta2 = ((TypePlaceholder) (resSet.resolveType(((TypePlaceholder) p.TA2)).resolvedType)).getName();
+            Relation r = null;
+            if (p.GetOperator() == PairOperator.SMALLERDOT) {
+                r = Relation.EXTENDS;
+            } else if (p.GetOperator() == PairOperator.EQUALSDOT) {
+                r = Relation.EQUAL;
+            }
+            for(TPHConstraint tphCons: tcOfCs) {//TODO: hier werden Elemente der Trans. clo herausgenommen, aber die dazugehoerigen OrCons nicht.
+                if(ta1 == tphCons.getLeft() && ta2 == tphCons.getRight() && r==Relation.EXTENDS) {
+                    MethodConstraint mc = new MethodConstraint(ta1, ta2, r);
+                    if(!checkForDuplicates(mc, tempMC)) {
+                        tempMC.add(mc);
+                    }
+                }
+            }
+        }
+
+        return tempMC;
+    }
+
+
+    public static Set<Pair> buildTransitiveClosureForCP(Set constraint, ResultSet resSet) {
+        Set<Pair> iterSet = new HashSet<>(constraint);
+        Set<Pair> runSet = new HashSet<>(constraint);
+        Set<Pair> tcSet = new HashSet<>(constraint);
+        boolean addedConToList = false;
+//        for (TPHConstraint cons: iterList) {
+        Iterator<Pair> itIterSet = iterSet.iterator();
+        while(itIterSet.hasNext()) {
+            Pair pairIterSet = itIterSet.next();
+//            for (TPHConstraint cons2: runList) {
+            Iterator<Pair> itRunSet = runSet.iterator();
+            while (itRunSet.hasNext()) {
+                Pair pairRunSet = itRunSet.next();
+//                if(cons.getRight() == cons2.getLeft()) {
+                if(pairIterSet.TA2 == pairRunSet.TA1 && pairIterSet.OperatorSmallerDot() && pairRunSet.OperatorSmallerDot()) {
+//                    TPHConstraint consToAdd = new TPHConstraint(cons.getLeft(), cons2.getRight(), Relation.EXTENDS);
+                    Pair p = new Pair(resSet.resolveType((TypePlaceholder)(pairIterSet.TA1)).resolvedType, resSet.resolveType((TypePlaceholder)(pairRunSet.TA2)).resolvedType, PairOperator.SMALLERDOT);
+//                    if (!checkForDuplicates(consToAdd,tcList)) {
+                    if(!checkForDuplicatesForSets(p, tcSet)) {
+//                        tcList.add(consToAdd);
+                        tcSet.add(p);
+                        addedConToList = true;
+                        if (addedConToList) {
+                            return buildTransitiveClosureForCP(tcSet, resSet);
+                        }
+                    }
+                }
+            }
+        }
+        System.out.println("tcSet: " + tcSet);
+        return tcSet;
+    }
+
+    public static boolean checkForDuplicatesForSets(Pair pair, Set set) {
+        Set<Pair> tempSet = set;
+        boolean hasSame = false;
+//        for (TPHConstraint tphC: tempList) {
+        Iterator<Pair> it = tempSet.iterator();
+        while (it.hasNext()) {
+            Pair p = it.next();
+//            hasSame = constraint.getLeft() == tphC.getLeft() &&
+//                    constraint.getRight() == tphC.getRight() &&
+//                    constraint.getRel() == tphC.getRel(); //constraint already in ArrayList if true
+            hasSame = pair.TA1 == p.TA1 &&
+                    pair.TA2 == p.TA2 &&
+                    pair.OperatorSmallerDot() && p.OperatorSmallerDot(); //constraint already in Set if true
+            if (hasSame)
+                return true;
+        }
+        return false;
+    }
+
+    public static List<MethodConstraint> hasNoSupertypeForMethodTypesNew(HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, MethodAndTPH methodAndTPH, List<MethodConstraint> cs_m) {
+        List<MethodConstraint> tempMC = new ArrayList<>();
+        List<TPHConstraint> methCons = new ArrayList<>(cs_m);
+        MethodAndTPH methAndTphs = methodAndTPH;
+        for(String tph: posOfTphs.keySet()) {
+            for(int i=0; i<posOfTphs.get(tph).size(); i++)
+            if(posOfTphs.get(tph).get(i).fst == PositionFinder.Position.METHOD && posOfTphs.get(tph).get(i).snd == methAndTphs.getId() && !checkUpperBound(methCons,tph)) {
+                MethodConstraint mc2 = new MethodConstraint(tph, objectType, Relation.EXTENDS);
+                if (!checkForDuplicates(mc2, tempMC)) {
+                    tempMC.add(mc2);
+                }
+            }
+        }
+        return tempMC;
+    }
+
+
+
+    public static List<MethodConstraint> methodTypesWithoutClassTypesNEW(List<String> tphsToCompute, List<MethodConstraint> cs_m) {
+        List<MethodConstraint> tempMC = new ArrayList<>(cs_m);
+        List<MethodConstraint> tempMC2 = new ArrayList<>(cs_m);
+        List<String> toRemove = new ArrayList<>();
+        for(String tph: tphsToCompute) {
+            for(TPHConstraint tphCons: tempMC) {
+                if(tphCons.getLeft() == tph) {
+                    toRemove.add(tphCons.getRight());
+                    tempMC2.remove(tphCons);
+                    tempMC2 = methodTypesWithoutClassTypesNEW(toRemove,tempMC2);
+                }
+            }
+        }
+        return tempMC2;
+    }
+
+
+
+    public HashMap<String, List<MethodConstraint>> getMethodConstraintsWithPositionNew(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTphs, List<MethodAndTPH> listOfMethodsAndTph, ResultSet resSet, Set<Pair> oldCons) {
+        HashMap<String, List<MethodConstraint>> tempMethodConstraintsWithPosition = new HashMap<>();
+        List<MethodConstraint> newMCList = new ArrayList<>();
+        List<MethodConstraint> newMCList2 = new ArrayList<>();
+        List<MethodConstraint> hasNoSupType = new ArrayList<>();
+        List<MethodConstraint> mcWithoutCc = new ArrayList<>();
+
+        List<String> methodsAddedToHashMap = new ArrayList<>();
+        for(MethodAndTPH method: listOfMethodsAndTph){
+            String currentMethod = method.getId();
+            boolean containsCurrentMethod = false;
+            if(!containsCurrentMethod) {
+                methodsAddedToHashMap.add(currentMethod);
+                containsCurrentMethod = true;
+                List<MethodConstraint> listToAdd = new ArrayList<>();
+                HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> posOfTPHsForThisMethod = new HashMap<>();
+                for(String s: posOfTphs.keySet()) {
+                    for(PairTphMethod pair: posOfTphs.get(s)) {
+                        if(pair.snd == currentMethod && pair.snd != null) {
+                            posOfTPHsForThisMethod.put(s,posOfTphs.get(s));
+                        }
+                    }
+                }
+
+                newMCList = firstLineMethodDefinition(cs, posOfTphs, method, resSet);
+                for(int i=0; i<newMCList.size(); i++) {
+                    listToAdd.add(newMCList.get(i));
+                }
+                newMCList2 = secondLineMethodDefinition(cs, posOfTphs, method, resSet, oldCons);
+                for(int i=0; i<newMCList2.size(); i++) {
+                    listToAdd.add(newMCList2.get(i));
+                }
+
+                /*if(!methodsAddedToHashMap.contains(currentMethod)) {
+                    tempMethodConstraintsWithPosition.put(currentMethod, newMCList);
+                    tempMethodConstraintsWithPosition.put(currentMethod, newMCList2);
+                }*/
+
+                hasNoSupType = hasNoSupertypeForMethodTypesNew(posOfTphs,method,listToAdd);
+                for (MethodConstraint cons: hasNoSupType) {
+                    if (!checkForDuplicates(cons, listToAdd)) {
+                        listToAdd.add(cons);
+                    }
+                }
+
+                mcWithoutCc = listToAdd;
+                List<String> tphs = new ArrayList<>();
+                for(String tph: posOfTphs.keySet()) {
+                    for (PairTphMethod p : posOfTphs.get(tph)) {
+                        if(p.fst == PositionFinder.Position.FIELD) {
+                            tphs.add(tph);
+                            mcWithoutCc = methodTypesWithoutClassTypesNEW(tphs, listToAdd);
+                        }
+                    }
+                }
+
+                tempMethodConstraintsWithPosition.put(currentMethod, mcWithoutCc);
+            }
+            for(String curMeth: tempMethodConstraintsWithPosition.keySet()){
+                for(int i=0; i<tempMethodConstraintsWithPosition.get(curMeth).size(); i++) {
+                    MethodConstraint currentMC = tempMethodConstraintsWithPosition.get(curMeth).get(i);
+                    if(currentMC.getRight()!= objectType && !compareTphsOfConstraints(currentMC.getRight(), cs_cl) && !compareTphsOfConstraints(currentMC.getRight(), tempMethodConstraintsWithPosition.get(curMeth))) {
+                        MethodConstraint mc = new MethodConstraint(currentMC.getRight(), objectType, Relation.EXTENDS);
+                        tempMethodConstraintsWithPosition.get(curMeth).add(mc);
+                    }
+                }
+            }
+        }
+
+        return tempMethodConstraintsWithPosition;
+    }
+
+
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/GGenerics.java

@@ -0,0 +1,42 @@
+/*
+package de.dhbwstuttgart.bytecode.gGenericsAli;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+*/
+/**
+ * gets set of typed variable constraints with substitutions and the set of typed classes
+ * and returns the set of families of generated generics and the set of families of type variable mappings
+ *//*
+
+public class GGenerics implements preGGenerics {
+    private TVarConstraints tVarCons;
+    private Substitutions subst;
+    private TClass typedClass;
+
+
+    public GGenerics(TVarConstraints tVarCons, Substitutions subst, TClass typedClass) throws IOException, ClassNotFoundException {
+        this.tVarCons = tVarCons;
+        this.subst = subst;
+        this.typedClass = typedClass;
+    }
+
+    List<File> input = new ArrayList<>();
+    List<File> classpath = new ArrayList<>();
+
+    JavaTXCompiler compiler = new JavaTXCompiler(input, classpath);
+    compiler.typeInference();
+
+    public List<ResultSet> getResultOfTypeInference() {
+        return null;
+    }
+
+
+}
+*/

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/MethodConstraint.java

@@ -0,0 +1,10 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+
+public class MethodConstraint extends TPHConstraint {
+    public MethodConstraint(String left, String right, Relation rel) {
+        super(left, right, rel);
+    }
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/PairMethodAndConstraint.java

@@ -0,0 +1,47 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import java.util.Objects;
+
+/** A generic class for pairs.
+ *
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+
+
+public class PairMethodAndConstraint<A, B> {
+    public final A fst;
+    public final B snd;
+
+    public PairMethodAndConstraint(A fst, B snd) {
+        this.fst = fst;
+        this.snd = snd;
+    }
+
+    public String toString() {
+        return "PairTphMethod[" + fst + "," + snd + "]";
+    }
+
+    public boolean equals(Object other) {
+        return
+                other instanceof PairMethodAndConstraint<?,?> &&
+                        Objects.equals(fst, ((PairMethodAndConstraint<?,?>)other).fst) &&
+                        Objects.equals(snd, ((PairMethodAndConstraint<?,?>)other).snd);
+    }
+
+    public int hashCode() {
+        if (fst == null) return (snd == null) ? 0 : snd.hashCode() + 1;
+        else if (snd == null) return fst.hashCode() + 2;
+        else return fst.hashCode() * 17 + snd.hashCode();
+    }
+
+    public static <A,B> PairMethodAndConstraint<A,B> of(A a, B b) {
+        return new PairMethodAndConstraint<>(a,b);
+    }
+
+    public PairMethodAndConstraint add(A fst, B snd){
+        return new PairMethodAndConstraint<>(fst,snd);
+    }
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/PairTphMethod.java

@@ -0,0 +1,43 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import java.util.Objects;
+
+/** A generic class for pairs.
+ *
+ *  <p><b>This is NOT part of any supported API.
+ *  If you write code that depends on this, you do so at your own risk.
+ *  This code and its internal interfaces are subject to change or
+ *  deletion without notice.</b>
+ */
+
+
+public class PairTphMethod<A, B> {
+    public final A fst;
+    public final B snd;
+
+    public PairTphMethod(A fst, B snd) {
+        this.fst = fst;
+        this.snd = snd;
+    }
+
+    public String toString() {
+        return "PairTphMethod[" + fst + "," + snd + "]";
+    }
+
+    public boolean equals(Object other) {
+        return
+                other instanceof PairTphMethod<?,?> &&
+                        Objects.equals(fst, ((PairTphMethod<?,?>)other).fst) &&
+                        Objects.equals(snd, ((PairTphMethod<?,?>)other).snd);
+    }
+
+    public int hashCode() {
+        if (fst == null) return (snd == null) ? 0 : snd.hashCode() + 1;
+        else if (snd == null) return fst.hashCode() + 2;
+        else return fst.hashCode() * 17 + snd.hashCode();
+    }
+
+    public static <A,B> PairTphMethod<A,B> of(A a, B b) {
+        return new PairTphMethod<>(a,b);
+    }
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/PositionFinder.java

@@ -0,0 +1,79 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+import java.util.HashMap;
+import java.util.Set;
+
+public class PositionFinder{
+    static HashMap<String, PairTphMethod<Position, String>> posOfTphs = new HashMap<String, PairTphMethod<Position, String>>();
+
+    static PairTphMethod<Position, String> whichMethod; // gibt an, in welcher Methode sich TPH befindet (Position.METHOD, id_of_method)
+
+    public enum Position{
+        METHOD,
+        CONSTRUCTOR,
+        FIELD
+    }
+
+    public static HashMap<String, PairTphMethod<Position, String>> getPositionOfTPH(SourceFile sf, Set<String> tphs)  {
+
+        new Walker().visit(sf);
+        for (String tph: posOfTphs.keySet()) {
+            System.out.println(tph + " " + posOfTphs.get(tph));
+        }
+
+        return null;
+    }
+    public static void putPositionInMethod(String tph, String methodId) {
+        posOfTphs.put(tph, new PairTphMethod<>(Position.METHOD, methodId));
+    }
+
+    public static void putPositionInField(String tph) {
+        posOfTphs.put(tph, new PairTphMethod<>(Position.FIELD, null));
+    }
+
+    public static void putPositionInConstructor(String tph, String id) {
+        posOfTphs.put(tph, new PairTphMethod<>(Position.CONSTRUCTOR, id));
+    }
+
+
+
+    static class Walker extends AbstractASTWalker{
+        Boolean inMethod = false;
+        Boolean inConstructor = false;
+
+        @Override
+        public void visit(TypePlaceholder tph) {
+            if (inMethod) {
+                if (inConstructor) {
+//                    System.out.println(tph);
+//                    putPositionInConstructor(tph.getName(),);
+                }
+//                System.out.println(tph);
+//                putPositionInMethod(tph.getName(),);
+            } else {
+                putPositionInField(tph.getName());
+            }
+        }
+
+        @Override
+        public void visit(Field field) {
+            super.visit(field);
+        }
+
+        @Override
+        public void visit(Method method) {
+            inMethod = true;
+            super.visit(method);
+        }
+
+        @Override
+        public void visit(Constructor cons) {
+            inConstructor = true;
+            super.visit(cons);
+        }
+    }
+
+}

src/main/java/de/dhbwstuttgart/bytecode/insertGenerics/preGGenerics.java

@@ -0,0 +1,9 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.List;
+
+interface preGGenerics {
+    public List<ResultSet> getResultOfTypeInference();
+}

src/main/java/de/dhbwstuttgart/bytecode/utilities/MethodAndTPH.java

@@ -4,6 +4,8 @@ import java.util.ArrayList;
 
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
+import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
 import de.dhbwstuttgart.typeinference.result.ResultPair;
 
@@ -15,11 +17,21 @@ public class MethodAndTPH {
 	private final ArrayList<ResultPair<TypePlaceholder, TypePlaceholder>> pairs = new ArrayList<>();
 	// tphs of local variables and parameters
 	private final ArrayList<String> localTphs = new ArrayList<>();
+	/*
+	 * its Constraints
+	 * eingefuegt PL 2021-02-15
+	 */
+	public final ConstraintSet constraints;
 
-	public MethodAndTPH(String name) {
+	public MethodAndTPH(String name, ConstraintSet<Pair> constraints) {
 		this.id = name;
+		this.constraints = constraints;
 	}
-
+	
+	public void addTph(String tph) {
+		tphs.add(tph);
+	}
+	
 	public ArrayList<String> getTphs() {
 		return tphs;
 	}
@@ -39,4 +51,9 @@ public class MethodAndTPH {
 		return localTphs;
 	}
 	
+	@Override
+	public String toString() {
+		return id;
+	} 
+	
 }

src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -6,6 +6,7 @@ import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
 import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
@@ -78,7 +79,12 @@ public class JavaTXCompiler {
     Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"src/test/java/logFiles" geschrieben werden soll?
     public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
     private final ClassLoader classLoader;
+    
+    //nur fuer Testzwecke of Generated Generics
+    //wieder loeschen PL 2021-03-22
+    public FamilyOfGeneratedGenerics fogg;
 
+    
 	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
 		this(Arrays.asList(sourceFile), null);
 	}
@@ -872,6 +878,7 @@ public class JavaTXCompiler {
 			SourceFile sf = sourceFiles.get(f);
 			GeneratedGenericsFinder sResFinder = new GeneratedGenericsFinder(sf, typeinferenceResult);
 			GenericGenratorResultForSourceFile simplifyResOfSF = sResFinder.findGeneratedGenerics();
+			this.fogg = sResFinder.getFogg();
 			result.add(simplifyResOfSF);
 		}
 		return result;

src/main/java/de/dhbwstuttgart/parser/SyntaxTreeGenerator/StatementGenerator.java

@@ -216,6 +216,7 @@ public class StatementGenerator {
         MethodCall ret = new MethodCall(TypePlaceholder.fresh(methodInvocationContext.getStart()), 
         		getReceiver(receiver), name, argumentList, TypePlaceholder.fresh(methodInvocationContext.getStart()), 
         		argTypes, methodInvocationContext.getStart());
+        ret.setStatement();
         return ret;
     }
 
@@ -302,33 +303,45 @@ public class StatementGenerator {
         ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes = args.getArguments().stream()
         		.map(x -> TypePlaceholder.fresh(newExpression.getStart()))
         		.collect(Collectors.toCollection(ArrayList::new));
-        return new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+        Statement ret = new NewClass(newClass, args, null, argTypes, newExpression.getStart());
+        ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PreIncrementExpressionContext stmt) {
     		Expression argument = convert(stmt.unaryExpression());
     		Token offset = stmt.getStart();
-    		return new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
-    }
+    		Statement ret =  new UnaryExpr(UnaryExpr.Operation.PREINCREMENT, argument, TypePlaceholder.fresh(offset), offset);
+    		ret.setStatement();
+            return ret;
+        }
 
 	private Statement convert(Java8Parser.PreDecrementExpressionContext stmt) {
-		return new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
+		Statement ret =  new UnaryExpr(UnaryExpr.Operation.PREDECREMENT, convert(stmt.unaryExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+		ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PostIncrementExpressionContext stmt) {
-        return new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, convert(stmt.postfixExpression()),
+    	Statement ret =  new UnaryExpr(UnaryExpr.Operation.POSTINCREMENT, convert(stmt.postfixExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+    	ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.PostDecrementExpressionContext stmt) {
-    		return new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
+    	Statement ret =  new UnaryExpr(UnaryExpr.Operation.POSTDECREMENT, convert(stmt.postfixExpression()),
                 TypePlaceholder.fresh(stmt.getStart()), stmt.getStart());
+    	ret.setStatement();
+        return ret;
     }
 
     private Statement convert(Java8Parser.AssignmentContext stmt) {
         AssignLeftSide leftHandSide = convert(stmt.leftHandSide());
-        return new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
+        Statement ret = new Assign(leftHandSide, convert(stmt.expression()), stmt.getStart());
+        ret.setStatement();
+        return ret;
     }
 
     private AssignLeftSide convert(Java8Parser.LeftHandSideContext leftHandSide) {

src/main/java/de/dhbwstuttgart/parser/scope/GatherNames.java

@@ -43,7 +43,7 @@ public class GatherNames {
 	      }
 	      else{
 	        if(typeDecl.classDeclaration().normalClassDeclaration() != null){
-	          if(pkgName != ""){
+	          if(!pkgName.isEmpty()){
 	            nameString = pkgName + "." + typeDecl.classDeclaration().normalClassDeclaration().Identifier().toString();
 	          }
 	          else{

src/main/java/de/dhbwstuttgart/syntaxtree/AbstractASTWalker.java

@@ -126,6 +126,7 @@ public abstract class AbstractASTWalker implements ASTVisitor{
     public void visit(Assign assign) {
         assign.lefSide.accept(this);
         assign.rightSide.accept(this);
+        assign.rightSide.getType().accept((ASTVisitor) this);
     }
 
     @Override
@@ -186,8 +187,10 @@ public abstract class AbstractASTWalker implements ASTVisitor{
     public void visit(MethodCall methodCall) {
         methodCall.receiver.accept(this);
         methodCall.getArgumentList().accept(this);
+        methodCall.getArgumentList().getArguments().forEach(a -> a.getType().accept((ASTVisitor) this));
     }
 
+    
     @Override
     public void visit(NewClass methodCall) {
         visit((MethodCall) methodCall);
@@ -211,6 +214,7 @@ public abstract class AbstractASTWalker implements ASTVisitor{
     @Override
     public void visit(Return aReturn) {
         aReturn.retexpr.accept(this);
+        aReturn.getType().accept((ASTVisitor) this);
     }
 
     @Override

src/main/java/de/dhbwstuttgart/syntaxtree/Method.java

@@ -31,8 +31,14 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 	private ExceptionList exceptionlist;
 	private GenericDeclarationList generics;
 	private final RefTypeOrTPHOrWildcardOrGeneric returnType;
-	public final Boolean isInherited;  
-
+	public final Boolean isInherited; 
+	
+	/*
+	 * its Constraints
+	 * eingefuegt PL 2021-02-15
+	 */
+	public final ConstraintSet constraints = new ConstraintSet();
+	
 	public Method(int modifier, String name, RefTypeOrTPHOrWildcardOrGeneric returnType, ParameterList parameterList, Block block,
 				  GenericDeclarationList gtvDeclarations, Token offset) {
 		super(offset);
@@ -70,6 +76,10 @@ public class Method extends SyntaxTreeNode implements IItemWithOffset, TypeScope
 		return this.returnType;
 	}
 
+	public ConstraintSet getConstraints() {
+		return this.constraints;
+	}
+	
 	@Override
 	public void accept(ASTVisitor visitor) {
 		visitor.visit(this);

src/main/java/de/dhbwstuttgart/syntaxtree/SourceFile.java

@@ -45,6 +45,12 @@ public class SourceFile extends SyntaxTreeNode{
   public List<ClassOrInterface> getClasses() {
     return KlassenVektor;
   }
+  
+  public List<Method> getAllMethods() {
+	  List<Method> ret = new ArrayList<>();
+	  getClasses().forEach(cl -> ret.addAll(cl.getMethods()));
+	  return ret;
+  }
 
   @Override
   public void accept(ASTVisitor visitor) {

src/main/java/de/dhbwstuttgart/syntaxtree/factory/NameGenerator.java

@@ -4,6 +4,16 @@ public class NameGenerator {
 
     private static String strNextName = "A";
     
+    /**
+     * Setzt den zu Beginn der Typinferenz auf "A" zurueck.
+     * Dies ist bei JUnit-Test noetig                       
+     * <code>TypePlaceholder</code>. <br>Author: Martin Pluemicke
+     * @return void
+     */
+    public static void reset() {
+    	strNextName = "A";
+    }
+    
     /**
      * Berechnet einen neuen, eindeutigen Namen f�r eine neue                          
      * <code>TypePlaceholder</code>. <br>Author: J�rg B�uerle

src/main/java/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java

@@ -18,6 +18,7 @@ import de.dhbwstuttgart.syntaxtree.type.WildcardType;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.result.PairNoResult;
 import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
 import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
 import de.dhbwstuttgart.typeinference.result.PairTPHsmallerTPH;
@@ -208,6 +209,7 @@ public class UnifyTypeFactory {
     }
 
     public static ResultPair convert(UnifyPair mp, Map<String,TypePlaceholder> tphs) {
+    	if (mp == null) { return null;} //kann bei basePairs passieren
         RefTypeOrTPHOrWildcardOrGeneric tl = UnifyTypeFactory.convert(mp.getLhsType(), tphs);
         RefTypeOrTPHOrWildcardOrGeneric tr = UnifyTypeFactory.convert(mp.getRhsType(), tphs);
         if(tl instanceof TypePlaceholder){
@@ -218,7 +220,7 @@ public class UnifyTypeFactory {
                     //Einfach ignorieren TODO: Das hier muss ausgebessert werden:
                     //return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, ASTFactory.createObjectType());
                 }else{
-                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr);
+                    return new PairTPHsmallerTPH((TypePlaceholder)tl, (TypePlaceholder)tr, convert(mp.getBasePair(), tphs));
                 }
             }else if(tr instanceof RefType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (RefType) tr);
@@ -227,7 +229,7 @@ public class UnifyTypeFactory {
             }else if(tr instanceof GenericRefType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (GenericRefType) tr);
             }else throw new NotImplementedException();
-        }else throw new NotImplementedException();
+        }else return new PairNoResult(tl, tr);//throw new NotImplementedException();
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
@@ -258,6 +260,7 @@ public class UnifyTypeFactory {
             ret = TypePlaceholder.fresh(new NullToken());
             tphs.put(t.getName(), ret);
         }
+        ret.setVariance(t.getVariance());
         return ret;
     }
 

src/main/java/de/dhbwstuttgart/syntaxtree/statement/MethodCall.java

@@ -24,13 +24,9 @@ public class MethodCall extends Statement
     
     public final ArgumentList arglist;
     
-    /*
-     * noetig fuer Bytecodegenerierung
-     */
     public RefTypeOrTPHOrWildcardOrGeneric receiverType;
     public final ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes;
     
-
     public MethodCall(RefTypeOrTPHOrWildcardOrGeneric retType, Receiver receiver, String methodName, ArgumentList argumentList, 
     		          RefTypeOrTPHOrWildcardOrGeneric receiverType, ArrayList<RefTypeOrTPHOrWildcardOrGeneric> argTypes, Token offset){
 		super(retType,offset);
@@ -40,6 +36,7 @@ public class MethodCall extends Statement
         this.receiverType = receiverType;
         this.argTypes = argTypes;
 	}
+    
 
     @Override
     public void accept(StatementVisitor visitor) {

src/main/java/de/dhbwstuttgart/syntaxtree/statement/Statement.java

@@ -6,11 +6,20 @@ import org.antlr.v4.runtime.Token;
 
 public abstract class Statement extends Expression
 {
-    
+	/* zeigt an, dass eine StatementExpression als Statement benutzt wird
+     */
+    private boolean isStatement = false;
     
     public Statement(RefTypeOrTPHOrWildcardOrGeneric type, Token offset)
     {
         super(type, offset);
     }
 
+    public void setStatement() {
+    	isStatement=true;
+    }
+    
+    public boolean getStatement() {
+    	return isStatement;
+    }
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/ExtendsWildcardType.java

@@ -53,4 +53,10 @@ public class ExtendsWildcardType extends WildcardType{
 	public void accept(ResultSetVisitor visitor) {
 		visitor.visit(this);
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		// TODO Auto-generated method stub
+		return false;
+	}
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/GenericRefType.java

@@ -32,5 +32,18 @@ public class GenericRefType extends RefTypeOrTPHOrWildcardOrGeneric
     public void accept(ResultSetVisitor visitor) {
         visitor.visit(this);
     }
+
+	@Override
+	public boolean equals(Object o) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+	
+	    
+	 @Override
+	public String toString()
+	{
+		 return "GTV " + this.name;
+	}
 }
 

src/main/java/de/dhbwstuttgart/syntaxtree/type/RefType.java

@@ -77,8 +77,8 @@ public class RefType extends RefTypeOrTPHOrWildcardOrGeneric
         if(obj instanceof RefType){
             boolean ret = true;
             
-            if(!super.equals(obj))
-            	return false;
+            //if(!(super.equals(obj))) PL 2020-03-12 muss vll. einkommentiert werden   
+            //	return false;
             
             if(parameter==null || parameter.size()==0){
                 ret &= (((RefType)obj).getParaList()==null || ((RefType)obj).getParaList().size()==0);

src/main/java/de/dhbwstuttgart/syntaxtree/type/RefTypeOrTPHOrWildcardOrGeneric.java

@@ -16,4 +16,7 @@ public abstract class RefTypeOrTPHOrWildcardOrGeneric extends SyntaxTreeNode{
     public abstract <A> A acceptTV(TypeVisitor<A> visitor);
     public abstract void accept(ResultSetVisitor visitor);
     
+    @Override
+    public abstract boolean equals(Object o);
+    
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/SuperWildcardType.java

@@ -64,4 +64,10 @@ public class SuperWildcardType extends WildcardType{
 	public void accept(ResultSetVisitor visitor) {
 		visitor.visit(this);
 	}
+
+	@Override
+	public boolean equals(Object o) {
+		// TODO Auto-generated method stub
+		return false;
+	}
 }

src/main/java/de/dhbwstuttgart/syntaxtree/type/TypePlaceholder.java

@@ -20,10 +20,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
 	private final String name;
 	
 	/**
-	 * wird bisher nicht genutzt
-	 * setVariance muss ggf. auskommentiert werden.
+	 * wird im Generate Generics Teil nach der Rueckumwandlung nach dem Unify genutzt
 	 */
-	int variance = 0;
+	private int variance = 0;
 
 
     /**
@@ -64,6 +63,10 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
         }
     }
 
+    @Override
+    public int hashCode() {
+        return this.getName().hashCode();
+    }
 
     public String toString()
     {
@@ -74,11 +77,9 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
         return name;
     }
 
-    /* wird bisher nicht genutzt
     public void setVariance(int variance) {
     	this.variance= variance;
     }
-    */
     
     public int getVariance() {
     	return this.variance;

src/main/java/de/dhbwstuttgart/typeinference/constraints/Constraint.java

@@ -9,6 +9,12 @@ import java.util.Set;
 public class Constraint<A> extends HashSet<A> {
 	private static final long serialVersionUID = 1L;
 	private Boolean isInherited = false;//wird nur für die Method-Constraints benoetigt
+	
+	/* es darf kein Constraint für den Return-Type erstellt werden, sonst gibt 
+     * es Probleme beim Generated Generics  
+     */
+    public boolean isStatement = false;
+	
 	private Constraint<A> extendConstraint = null;
 	
 	public Constraint() {
@@ -41,7 +47,7 @@ public class Constraint<A> extends HashSet<A> {
 	}
 
 	public String toString() {
-		return super.toString() + " isInherited = " + isInherited 
+		return super.toString() + "\nisInherited = " + isInherited + "\nisStatement = " + isStatement
 				//" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" ) 
 				+ "\n" ;
 	}

src/main/java/de/dhbwstuttgart/typeinference/constraints/ConstraintSet.java

@@ -23,9 +23,17 @@ public class ConstraintSet<A> {
         oderConstraints.add(methodConstraints);
     }
 
+    public void addAllUndConstraint(Constraint<A> allUndConstraints){
+        undConstraints.addAll(allUndConstraints);
+    }
+    
+    public void addAllOderConstraint(List<Set<Constraint<A>>> allOderConstraints){
+        this.oderConstraints.addAll(allOderConstraints);
+    }
+    
     public void addAll(ConstraintSet constraints) {
-        this.undConstraints.addAll(constraints.undConstraints);
-        this.oderConstraints.addAll(constraints.oderConstraints);
+        this.addAllUndConstraint(constraints.undConstraints);
+        this.addAllOderConstraint(constraints.oderConstraints);
     }
 
     @Override

src/main/java/de/dhbwstuttgart/typeinference/result/PairNoResult.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.typeinference.result;
+
+import de.dhbwstuttgart.exceptions.NotImplementedException;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+/**
+ * enthaelt alle Paare, die in einem Ergebnis nicht vorkommen koennen
+ * sie sind noetig fuer origPairs in PairTPHsmallerTPH, da hier auch
+ * Paare vorkommen koennen die keine Result sind (z.B. bei FunN$$)
+ */
+public class PairNoResult extends ResultPair<RefTypeOrTPHOrWildcardOrGeneric, RefTypeOrTPHOrWildcardOrGeneric>{
+    //public final TypePlaceholder left;
+    //public final TypePlaceholder right;
+    
+    /*
+     * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
+     * wichtig fuer generated Generics
+     */
+    ResultPair origPair;
+
+    public PairNoResult(RefTypeOrTPHOrWildcardOrGeneric left, RefTypeOrTPHOrWildcardOrGeneric right){
+        super(left, right);
+    }
+
+    /* noch nicht implementiert. */
+    @Override
+    public void accept(ResultPairVisitor visitor) {
+    	throw new NotImplementedException();
+        //visitor.visit(this);
+    }
+}

src/main/java/de/dhbwstuttgart/typeinference/result/PairTPHsmallerTPH.java

@@ -9,6 +9,12 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 public class PairTPHsmallerTPH extends ResultPair{
     public final TypePlaceholder left;
     public final TypePlaceholder right;
+    
+    /*
+     * urspruengliches Paar aus diesem dieses Resultpair erzeugt wurde
+     * wichtig fuer generated Generics
+     */
+    ResultPair origPair;
 
     public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right){
         super(left, right);
@@ -16,6 +22,11 @@ public class PairTPHsmallerTPH extends ResultPair{
         this.right = right;
     }
 
+    public PairTPHsmallerTPH(TypePlaceholder left, TypePlaceholder right, ResultPair origPair){
+    	this(left, right);
+    	this.origPair = origPair;
+    }
+    
     @Override
     public void accept(ResultPairVisitor visitor) {
         visitor.visit(this);

src/main/java/de/dhbwstuttgart/typeinference/result/ResultPairVisitor.java

@@ -4,4 +4,7 @@ public interface ResultPairVisitor {
     void visit(PairTPHsmallerTPH p);
     void visit(PairTPHequalRefTypeOrWildcardType p);
     void visit(PairTPHEqualTPH p);
+    
+    //bisher nicht umgesetzt 
+    //void visit(PairNoResult p);
 }

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPE.java

@@ -32,8 +32,10 @@ public class TYPE {
 
     private ConstraintSet getConstraintsClass(ClassOrInterface cl, TypeInferenceInformation info) {
         ConstraintSet ret = new ConstraintSet();
+        ConstraintSet methConstrains;
         for(Method m : cl.getMethods()){
-            ret.addAll(getConstraintsMethod(m,info, cl));
+            ret.addAll(methConstrains = getConstraintsMethod(m,info, cl));
+            m.constraints.addAll(methConstrains);
         }
         for(Constructor m : cl.getConstructors()){
             ret.addAll(getConstraintsConstructor(m,info, cl));

src/main/java/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java

@@ -11,6 +11,7 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.type.Void;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.FunNClass;
 import de.dhbwstuttgart.typeinference.assumptions.MethodAssumption;
@@ -180,6 +181,7 @@ public class TYPEStmt implements StatementVisitor{
 					        		   ? new Pair(x.TA1, new ExtendsWildcardType(x.TA2, x.TA2.getOffset()), PairOperator.EQUALSDOT)
 					        		   : x)
             		.collect(Collectors.toCollection(() -> new Constraint<Pair>(oneMethodConstraint.isInherited())));
+            extendsOneMethodConstraint.isStatement = oneMethodConstraint.isStatement;
             oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint);
             extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint);
             methodConstraints.add(extendsOneMethodConstraint);
@@ -490,7 +492,7 @@ public class TYPEStmt implements StatementVisitor{
     @Override
     public void visit(Return returnExpr) {
         returnExpr.retexpr.accept(this);
-        constraintsSet.addUndConstraint(new Pair(returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.SMALLERDOT));
+        constraintsSet.addUndConstraint(new Pair(returnExpr.getType(),info.getCurrentTypeScope().getReturnType(), PairOperator.EQUALSDOT));
     }
 
     @Override
@@ -594,9 +596,11 @@ public class TYPEStmt implements StatementVisitor{
         //methodConstraint.add(new Pair(forMethod.receiverType, retType,
         //        PairOperator.EQUALSDOT));
         //Fuer Bytecodegenerierung PL 2020-03-09 wird derzeit nicht benutzt ENDE
-
+        
+      
+        methodConstraint.isStatement = forMethod.getStatement();
         methodConstraint.add(new Pair(assumption.getReturnType(resolver), forMethod.getType(),
-                PairOperator.EQUALSDOT));
+        			PairOperator.EQUALSDOT));
         methodConstraint.addAll(generateParameterConstraints(forMethod, assumption, info, resolver));
         return methodConstraint;
     }

src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java

@@ -269,6 +269,9 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			System.err.println("no log-File");
 		}
 		if (isUndefinedPairSetSet(res)) { 
+			//fuer debug-Zwecke
+			ArrayList al = res.stream().map(x -> x.stream().collect(Collectors.toCollection(ArrayList::new)))
+					          .collect(Collectors.toCollection(ArrayList::new));
 				throw new TypeinferenceException("Unresolved constraints: " + res.toString(), new NullToken()); //return new HashSet<>(); 
 			}
 		else {
@@ -2181,6 +2184,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			
 		Set<Set<UnifyPair>> result = new HashSet<>();
 		
+		if (thetaPrime instanceof ReferenceType && ((ReferenceType)thetaPrime).isGenTypeVar()) {
+			Set<UnifyPair> resultOne = new HashSet<>();
+			resultOne.add(new UnifyPair (a, thetaPrime, PairOperator.EQUALSDOT, pair.getSubstitution(), pair));
+			result.add(resultOne);
+		}     
+		
 		boolean allGen = thetaPrime.getTypeParams().size() > 0;
 		for(UnifyType t : thetaPrime.getTypeParams())
 			if(!(t instanceof PlaceholderType) || !((PlaceholderType) t).isGenerated()) {

src/main/java/de/dhbwstuttgart/typeinference/unify/model/UnifyType.java

@@ -114,6 +114,7 @@ public abstract class UnifyType {
 
 	@Override
 	public boolean equals(Object obj) {
+		if(obj == null)return false;
 		return this.toString().equals(obj.toString());
 	}
 }

src/test/java/constraintSimplify/FamilyOfGenerics.java

@@ -0,0 +1,68 @@
+package constraintSimplify;
+
+import de.dhbwstuttgart.bytecode.TPHExtractor;
+import de.dhbwstuttgart.bytecode.insertGenerics.PositionFinder;
+import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import org.junit.Test;
+
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+
+public class FamilyOfGenerics {
+	
+	@Test
+	public void generateBC() throws Exception {
+		SourceFile sf = generateAST();
+		PositionFinder.getPositionOfTPH(sf, null);
+		TPHExtractor tphExtractor = new TPHExtractor();
+		List<ResultSet> results = new ArrayList<ResultSet>();
+		GeneratedGenericsFinder generatedGenericsFinder = new GeneratedGenericsFinder(sf, results);
+	}
+
+	public static SourceFile generateAST(){
+		ArrayList<ClassOrInterface> classes = new ArrayList<>();
+		ArrayList<Field> fields = new ArrayList<>();
+		ArrayList<Method> methods = new ArrayList<>();
+
+		fields.add(generateField("fld1"));
+		String[] paramNames = {"a"};
+		methods.add(generateMethod("testMethode", paramNames));
+
+		classes.add(new ClassOrInterface(Modifier.PUBLIC, new JavaClassName("Test"), fields, Optional.empty(), methods,
+				new ArrayList<>(), generateEmptyGenericDeclList(),
+				new RefType(new JavaClassName("java.lang.Object"), new NullToken()),
+				false, new ArrayList<>(), new NullToken()));
+
+		return new SourceFile("Test.jav", classes, new HashSet<>());
+	}
+
+	public static Method generateMethod(String methodName, String[] paramNames){
+		ArrayList<FormalParameter> parameters = new ArrayList<>();
+		for(String str: paramNames) {
+			FormalParameter fp = new FormalParameter(str, TypePlaceholder.fresh(new NullToken()), new NullToken());
+			parameters.add(fp);
+
+		}
+		ParameterList parameterList = new ParameterList(parameters, new NullToken());
+		return new Method(Modifier.PUBLIC, methodName, TypePlaceholder.fresh(new NullToken()), parameterList,
+				new Block(new ArrayList<>(), new NullToken()), generateEmptyGenericDeclList(), new NullToken());
+	}
+
+	public static GenericDeclarationList generateEmptyGenericDeclList(){
+		return new GenericDeclarationList(new ArrayList<>(), new NullToken());
+	}
+
+	public static Field generateField(String fieldName) {
+		return new Field(fieldName, TypePlaceholder.fresh(new NullToken()), Modifier.PUBLIC, new NullToken());
+	}
+}

src/test/java/insertGenerics/FamilyOfGeneratedGenericsTest.java

@@ -0,0 +1,228 @@
+/*
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.*;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import junit.framework.TestCase;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class FamilyOfGeneratedGenericsTest extends TestCase {
+
+    public void testIdentityMethod(){
+        */
+/*
+        Example method:
+        A id(B i) return i;
+        gives constraint: B <. A and A <. Object, which are method constraints
+         *//*
+
+
+        List<TPHConstraint> inputConstraints = new ArrayList<>();
+        inputConstraints.add(new TPHConstraint("B", "A", TPHConstraint.Relation.EXTENDS));
+
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> tphPositions = new HashMap<>();
+        PairTphMethod<PositionFinder.Position, String> meth1 = new PairTphMethod<PositionFinder.Position, String>(PositionFinder.Position.METHOD, "m1");
+        tphPositions.put("A", meth1);
+        tphPositions.put("B", meth1);
+
+        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
+        assertTrue(classConstraints.isEmpty());
+
+        */
+/*
+        MethodConstraints should be the same as the input constraint
+         *//*
+
+//        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, new ArrayList<ClassConstraint>(), tphPositions);
+//        assertTrue(methodConstraints.size() == 2);
+//        assertTrue(methodConstraints.get(0).getLeft().equals("B"));
+//        assertTrue(methodConstraints.get(0).getRight().equals("A"));
+    }
+
+    public void testClassField(){
+        */
+/*
+        class Example{
+            A f;
+            B fReturn(){
+                return f;
+            }
+        }
+        gives constraint: A <. B and B <. Object which are class constraints
+         *//*
+
+
+        List<TPHConstraint> inputConstraints = new ArrayList<>();
+        inputConstraints.add(new TPHConstraint("A", "B", TPHConstraint.Relation.EXTENDS));
+
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> tphPositions = new HashMap<>();
+        PairTphMethod<PositionFinder.Position, String> posOfA = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+        tphPositions.put("A", posOfA);
+        PairTphMethod<PositionFinder.Position, String> posOfB = new PairTphMethod<>(PositionFinder.Position.METHOD, "fReturn");
+        tphPositions.put("B", posOfB);
+
+        */
+/*
+        ClassConstraints should not be the same as the input constraint
+         *//*
+
+        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
+        System.out.println(classConstraints);
+        assertTrue(classConstraints.size() == 2);
+        //assertTrue(classConstraints.get(0).getLeft().equals("A"));
+        //assertTrue(classConstraints.get(0).getRight().equals("B"));
+//        HashMap<String, List<MethodConstraint>> methodConstraintsWithPosition = FamilyOfGeneratedGenerics.getMethodConstraintsWithPosition(inputConstraints,classConstraints,tphPositions,)
+    }
+
+    public void testSecondLineOfClassConstraints() {
+        */
+/*
+        class Example() {
+            A a;
+            B b = a;
+            C anyMethod() {
+                F f;
+                return f;
+            }
+            D otherMethod(E e) {
+                this.b = e;
+                e = this.a;
+                return e;
+            }
+        }
+        *//*
+
+
+        List<TPHConstraint> inputConstraints = new ArrayList<>();
+        inputConstraints.add(new TPHConstraint("A", "B", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("F", "C", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("E", "B", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("A", "E", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("E", "D", TPHConstraint.Relation.EXTENDS));
+
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> tphPositions = new HashMap<>();
+        PairTphMethod<PositionFinder.Position, String> posOfA = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+        PairTphMethod<PositionFinder.Position, String> posOfB = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+        PairTphMethod<PositionFinder.Position, String> posOfC = new PairTphMethod<>(PositionFinder.Position.METHOD, "anyMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfD = new PairTphMethod<>(PositionFinder.Position.METHOD, "otherMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfE = new PairTphMethod<>(PositionFinder.Position.METHOD, "otherMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfF = new PairTphMethod<>(PositionFinder.Position.METHOD, "anyMethod");
+
+        tphPositions.put("A", posOfA);
+        tphPositions.put("B", posOfB);
+        tphPositions.put("C", posOfC);
+        tphPositions.put("F", posOfF);
+        tphPositions.put("D", posOfD);
+        tphPositions.put("E", posOfE);
+
+        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
+        System.out.println(classConstraints);
+//        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+//        System.out.println(methodConstraints);
+        assertFalse(classConstraints.isEmpty());
+        assertTrue(classConstraints.size() == 6);
+//        assertFalse(methodConstraints.isEmpty());
+//        assertTrue(methodConstraints.size() == 2);
+
+    }
+
+    public void testTPHsAndGenerics() {
+        */
+/*
+        class TPHsAndGenerics {
+            Fun1<A,B> id = x -> x;
+            C id2 (D x) {
+                return id.apply(x);
+            }
+            E m(F a, G b){
+                var c = m2(a,b);
+                return a;
+            }
+            H m2(I a, J b){
+                return b;
+            }
+        }
+        *//*
+
+
+        List<TPHConstraint> inputConstraints = new ArrayList<>();
+        inputConstraints.add(new TPHConstraint("A","B", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("B","C", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("D","A", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("F","E", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("F","I", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("G","J", TPHConstraint.Relation.EXTENDS));
+        inputConstraints.add(new TPHConstraint("J","H", TPHConstraint.Relation.EXTENDS));
+
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> tphPositions = new HashMap<>();
+        PairTphMethod<PositionFinder.Position, String> posOfA = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+        PairTphMethod<PositionFinder.Position, String> posOfB = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+        PairTphMethod<PositionFinder.Position, String> posOfC = new PairTphMethod<>(PositionFinder.Position.METHOD, "id2");
+        PairTphMethod<PositionFinder.Position, String> posOfD = new PairTphMethod<>(PositionFinder.Position.METHOD, "id2");
+        PairTphMethod<PositionFinder.Position, String> posOfE = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfF = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfG = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfH = new PairTphMethod<>(PositionFinder.Position.METHOD, "m2");
+        PairTphMethod<PositionFinder.Position, String> posOfI = new PairTphMethod<>(PositionFinder.Position.METHOD, "m2");
+        PairTphMethod<PositionFinder.Position, String> posOfJ = new PairTphMethod<>(PositionFinder.Position.METHOD, "m2");
+
+        tphPositions.put("A", posOfA);
+        tphPositions.put("B", posOfB);
+        tphPositions.put("C", posOfC);
+        tphPositions.put("D", posOfD);
+        tphPositions.put("E", posOfE);
+        tphPositions.put("F", posOfF);
+        tphPositions.put("G", posOfG);
+        tphPositions.put("H", posOfH);
+        tphPositions.put("I", posOfI);
+        tphPositions.put("J", posOfJ);
+
+        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(inputConstraints, tphPositions);
+        System.out.println(classConstraints);
+//        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(inputConstraints, classConstraints, tphPositions);
+//        System.out.println(methodConstraints);
+
+        assertFalse(classConstraints.isEmpty());
+        assertTrue(classConstraints.size() == 3);
+//        assertFalse(methodConstraints.isEmpty());
+//        assertTrue(methodConstraints.size()==9);
+    }
+
+
+    public void testPositionConverter() {
+        HashMap<String, Boolean> allTphsOld = new HashMap<>();
+        List<MethodAndTPH> listOfMethodsAndTphs = new ArrayList<>();
+        allTphsOld.put("A", true);
+        allTphsOld.put("B", false);
+        MethodAndTPH m1 = new MethodAndTPH("m1");
+        m1.getTphs().add("A");
+        MethodAndTPH bla = new MethodAndTPH("bla");
+        MethodAndTPH blubb = new MethodAndTPH("blubb");
+//        blubb.getTphs().add("A");
+        listOfMethodsAndTphs.add(bla);
+        listOfMethodsAndTphs.add(blubb);
+        listOfMethodsAndTphs.add(m1);
+
+
+
+        HashMap<String, List<PairTphMethod<PositionFinder.Position, String>>> allTphsNew = FamilyOfGeneratedGenerics.positionConverter(allTphsOld, listOfMethodsAndTphs);
+        System.out.println(allTphsNew);
+        //was tun wenn zwei (oder mehr) Methoden gleiches TPH enthalten?
+        //ist dies möglich oder werden die TPHs immer verschieden initialisiert und dann erst am Ende gemappt?
+        //überarbeiten oder lassen?
+
+
+        assertTrue(allTphsNew.get("A").fst.equals(PositionFinder.Position.METHOD));
+        assertTrue(allTphsNew.get("B").fst.equals(PositionFinder.Position.FIELD));
+    }
+
+
+    public void testFirstTransitiveSubtypeForMethodTypes(){
+
+    }
+
+}*/

src/test/java/insertGenerics/TestAny.java

@@ -0,0 +1,112 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestAny {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestAny.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("N", "O", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("N", "U", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("U", "O", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("O", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH RanyMethod()",  lmc);
+        lmc = new HashSet<>();
+        methodConstraintsWithPositionTest.put("TPH UotherMethod(TPH U)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestClassField.java

@@ -0,0 +1,79 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestClassField {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestClassField.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestContraVariant.java

@@ -0,0 +1,112 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestContraVariant {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestContraVariant.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("R", "O", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("O", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rm(TPH O)",  lmc);
+        lmc = new HashSet<>();
+        //lmc.add(new MethodConstraint("S", "O", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("S", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rmain(TPH S)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestExample42.java

@@ -0,0 +1,62 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.insertGenerics.*;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class TestExample42 {
+    public List<TPHConstraint> fillConstraintsList() {
+        List<TPHConstraint> cs = new ArrayList<>();
+        cs.add(new TPHConstraint("M", "N", Relation.EXTENDS));
+        cs.add(new TPHConstraint("N", "Z", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Q", "K", Relation.EXTENDS));
+        cs.add(new TPHConstraint("K", "P", Relation.EXTENDS));
+        cs.add(new TPHConstraint("W", "M", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Z", "V", Relation.EXTENDS));
+        return cs;
+    }
+
+    public HashMap<String, PairTphMethod<PositionFinder.Position, String>> fillPosOfTphs() {
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs = new HashMap<>();
+
+        // TPHs "U" und "L" auskommentiert, da nach Vorgaben L zu Z umbenannt und U als void interpretiert wird
+        PairTphMethod<PositionFinder.Position, String> posOfK = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+//        PairTphMethod<PositionFinder.Position, String> posOfL = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
+        PairTphMethod<PositionFinder.Position, String> posOfM = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
+        PairTphMethod<PositionFinder.Position, String> posOfN = new PairTphMethod<>(PositionFinder.Position.METHOD, "id");
+        PairTphMethod<PositionFinder.Position, String> posOfP = new PairTphMethod<>(PositionFinder.Position.METHOD, "setA");
+        PairTphMethod<PositionFinder.Position, String> posOfQ = new PairTphMethod<>(PositionFinder.Position.METHOD, "setA");
+//        PairTphMethod<PositionFinder.Position, String> posOfU = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfV = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfW = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+        PairTphMethod<PositionFinder.Position, String> posOfZ = new PairTphMethod<>(PositionFinder.Position.METHOD, "m");
+
+        posOfTphs.put("K", posOfK);
+//        posOfTphs.put("L", posOfL);
+        posOfTphs.put("M", posOfM);
+        posOfTphs.put("N", posOfN);
+        posOfTphs.put("P", posOfP);
+        posOfTphs.put("Q", posOfQ);
+//        posOfTphs.put("U", posOfU);
+        posOfTphs.put("V", posOfV);
+        posOfTphs.put("W", posOfW);
+        posOfTphs.put("Z", posOfZ);
+        return posOfTphs;
+    }
+
+    @Test
+    public void genericTest() {
+//        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
+//        System.out.println("ClassConstraints: " + classConstraints);
+//        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs());
+//        System.out.println("MethodConstraints: " + methodConstraints);
+
+        List<TPHConstraint> testCons;
+    }
+}

src/test/java/insertGenerics/TestExample42_allInOneMethod.java

@@ -0,0 +1,61 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.insertGenerics.*;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class TestExample42_allInOneMethod {
+    public List<TPHConstraint> fillConstraintsList() {
+        List<TPHConstraint> cs = new ArrayList<>();
+        cs.add(new TPHConstraint("M", "N", Relation.EXTENDS));
+        cs.add(new TPHConstraint("N", "Z", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Q", "K", Relation.EXTENDS));
+        cs.add(new TPHConstraint("K", "P", Relation.EXTENDS));
+        cs.add(new TPHConstraint("W", "M", Relation.EXTENDS));
+        cs.add(new TPHConstraint("Z", "V", Relation.EXTENDS));
+        return cs;
+    }
+
+    public HashMap<String, PairTphMethod<PositionFinder.Position, String>> fillPosOfTphs() {
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs = new HashMap<>();
+
+        // TPHs "U" und "L" auskommentiert, da nach Vorgaben L zu Z umbenannt und U als void interpretiert wird
+        PairTphMethod<PositionFinder.Position, String> posOfK = new PairTphMethod<>(PositionFinder.Position.FIELD, null);
+//        PairTphMethod<PositionFinder.Position, String> posOfL = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfM = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfN = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfP = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfQ = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+//        PairTphMethod<PositionFinder.Position, String> posOfU = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfV = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfW = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+        PairTphMethod<PositionFinder.Position, String> posOfZ = new PairTphMethod<>(PositionFinder.Position.METHOD, "sameMethod");
+
+        posOfTphs.put("K", posOfK);
+//        posOfTphs.put("L", posOfL);
+        posOfTphs.put("M", posOfM);
+        posOfTphs.put("N", posOfN);
+        posOfTphs.put("P", posOfP);
+        posOfTphs.put("Q", posOfQ);
+//        posOfTphs.put("U", posOfU);
+        posOfTphs.put("V", posOfV);
+        posOfTphs.put("W", posOfW);
+        posOfTphs.put("Z", posOfZ);
+        return posOfTphs;
+    }
+
+    @Test
+    public void genericTest() {
+//        List<ClassConstraint> classConstraints = FamilyOfGeneratedGenerics.getClassConstraints(fillConstraintsList(),fillPosOfTphs());
+//        System.out.println("ClassConstraints: " + classConstraints);
+//        List<MethodConstraint> methodConstraints = FamilyOfGeneratedGenerics.getMethodConstraints(fillConstraintsList(),classConstraints,fillPosOfTphs(),);
+//        System.out.println("MethodConstraints: " + methodConstraints);
+
+        List<TPHConstraint> testCons;
+    }
+}

src/test/java/insertGenerics/TestGGFinder.java

@@ -0,0 +1,99 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestGGFinder {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestGGFinder";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("S", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("P", "AC", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AC", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH ACid(TPH P)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "S", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH SsetA(TPH T)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AC", "Y", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("Z", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AC", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("Y", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("voidm(TPH YTPH Z)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestLocalVarLambda.java

@@ -0,0 +1,112 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestLocalVarLambda {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestLocalVarLambda";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        
+        if (fogg.allConstraints.contains((new MethodConstraint("O", "ALU", Relation.EXTENDS)))) {
+        	lmc.add(new MethodConstraint("O", "ALU", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("DIU", "java/lang/Object", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("ALU", "DIU", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH DIUm(TPH O)",  lmc);
+        }
+        else if (fogg.allConstraints.contains((new MethodConstraint("O", "DIV", Relation.EXTENDS)))) {
+        	lmc.add(new MethodConstraint("O", "DIV", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("DIV", "N", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH Nm(TPH O)",  lmc);
+        }
+        else
+        {
+        	lmc.add(new MethodConstraint("O", "DIU", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("DIU", "N", Relation.EXTENDS));
+        	lmc.add(new MethodConstraint("SY", "java/lang/Object", Relation.EXTENDS));
+        	methodConstraintsWithPositionTest.put("TPH Nm(TPH O)",  lmc);
+        }
+        
+        
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestMutualRecursion.java

@@ -0,0 +1,126 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestMutualRecursion {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className;
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void TestMutualRecursion1() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        className = "TestMutualRecursion"; 
+        JavaTXCompiler compiler = new JavaTXCompiler(new File(rootDirectory+className+".jav"));
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+
+		
+		List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+		classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
+		HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+		Set<MethodConstraint> lmc;
+		lmc = new HashSet<>();
+		lmc.add(new MethodConstraint("P", "Q", Relation.EXTENDS));
+		lmc.add(new MethodConstraint("Q", "java/lang/Object", Relation.EXTENDS));
+		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
+		methodConstraintsWithPositionTest.put("TPH ALid(TPH P)",  lmc);
+		lmc = new HashSet<>();
+		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
+		lmc.add(new MethodConstraint("Z", "java/lang/Object", Relation.EXTENDS));
+		methodConstraintsWithPositionTest.put("TPH ALm(TPH ALTPH Z)",  lmc);
+		lmc = new HashSet<>();
+		lmc.add(new MethodConstraint("AG", "java/lang/Object", Relation.EXTENDS));
+		lmc.add(new MethodConstraint("AH", "java/lang/Object", Relation.EXTENDS));
+		lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
+		methodConstraintsWithPositionTest.put("TPH ALmain(TPH AGTPH AH)",  lmc);
+		
+		FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+		
+		compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+    }
+	
+	@Test
+    public void TestMutualRecursionWithField() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        className = "TestMutualRecursionWithField"; 
+		execute(new File(rootDirectory+className+".jav"));
+    }
+	
+	@Test
+    public void TestMutualRecursionWithField2() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        className = "TestMutualRecursionWithField2"; 
+		execute(new File(rootDirectory+className+".jav"));
+    }
+
+	@Test
+    public void TestMutualRecursionWithField3() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        className = "TestMutualRecursionWithField3"; 
+		execute(new File(rootDirectory+className+".jav"));
+    }
+	
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestReturnVar.java

@@ -0,0 +1,79 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestReturnVar {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestReturnVar.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestSecondLineOfClassConstraints.java

@@ -0,0 +1,79 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestSecondLineOfClassConstraints {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestSecondLineOfClassConstraints.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestTPHsAndGenerics.java

@@ -0,0 +1,154 @@
+package insertGenerics;
+
+	import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+	import de.dhbwstuttgart.syntaxtree.SourceFile;
+	import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+	import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+	import de.dhbwstuttgart.typedeployment.TypeInsert;
+	import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+	import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+	import java.io.IOException;
+	import java.lang.reflect.InvocationTargetException;
+	import java.net.URL;
+	import java.net.URLClassLoader;
+	import java.nio.charset.Charset;
+	import java.nio.charset.StandardCharsets;
+	import java.nio.file.Files;
+	import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+	import java.util.List;
+	import java.util.Set;
+
+
+public class TestTPHsAndGenerics {
+
+	    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+	    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+	    private static ClassLoader loader;
+	    private static Class<?> classToTest;
+		private static Object instanceOfClass;
+		private static String className = "TestTPHsAndGenerics";
+
+	    @BeforeClass
+	    public static void resetNamesOfTypePlaceholder() {
+	    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+	    }
+	    
+	    @Test
+	    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+	        execute(new File(rootDirectory+className+".jav"));
+	    }
+
+	    private static class TestResultSet{
+
+	    }
+
+	    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+	        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+	        List<ResultSet> results = compiler.typeInference();
+	        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+	        
+	        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+	        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+	        
+	        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+	        
+	        Set<MethodConstraint> lmc;
+	        lmc = new HashSet<>();
+	        
+	        if (fogg.allConstraints.contains((new MethodConstraint("DZP", "ETW", Relation.EXTENDS)))) {
+	        	classConstraintsTest.add(new ClassConstraint("UD", "DZP", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("DZP", "ETW", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("ETW", "java/lang/Object", Relation.EXTENDS));
+	        
+	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("V", "UD", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH ETWid2(TPH V)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
+	        } else {
+	        if (fogg.allConstraints.contains((new MethodConstraint("DZP", "U", Relation.EXTENDS)))) {
+	        	classConstraintsTest.add(new ClassConstraint("ETW", "DZP", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("DZP", "U", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("U", "java/lang/Object", Relation.EXTENDS));
+	        
+	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("V", "ETW", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH Uid2(TPH V)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
+	        } else {
+	        if (fogg.allConstraints.contains((new MethodConstraint("EIM", "FEA", Relation.EXTENDS)))) {
+	        	classConstraintsTest.add(new ClassConstraint("VK", "EIM", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("EIM", "FEA", Relation.EXTENDS));
+	        	classConstraintsTest.add(new ClassConstraint("FEA", "java/lang/Object", Relation.EXTENDS));
+	        
+	        	lmc.add(new MethodConstraint("AI", "AE", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AD", "AI", Relation.EXTENDS));
+	        	//lmc.add(new MethodConstraint("AB", "AM", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AE", "java/lang/Object", Relation.EXTENDS));
+	        	lmc.add(new MethodConstraint("AB", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH ABm(TPH ABTPH AD)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("V", "VK", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH FEAid2(TPH V)",  lmc);
+	        	lmc = new HashSet<>();
+	        	lmc.add(new MethodConstraint("AM", "java/lang/Object", Relation.EXTENDS));
+				lmc.add(new MethodConstraint("AI", "java/lang/Object", Relation.EXTENDS));
+	        	methodConstraintsWithPositionTest.put("TPH AIm2(TPH AMTPH AI)",  lmc);
+	        }
+	        }
+	        	
+	        }
+
+	        
+	        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+	        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+	        
+	        assertEquals(expectedClassCons, computedClassCons);
+	        
+	        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+	        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+	        
+	        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+	        
+	        /*
+	        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+	        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+	        classToTest = loader.loadClass(className);
+			instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+			*/
+	        return new TestResultSet();
+	        
+	    }
+	}

src/test/java/insertGenerics/TestTPHsAndGenerics2.java

@@ -0,0 +1,79 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestTPHsAndGenerics2 {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestTPHSAndGenerics2.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/java/insertGenerics/TestThreeArgs.java

@@ -0,0 +1,99 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestThreeArgs {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestThreeArgs";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("P", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("Q", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AF", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AFid(TPH P)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AF", "W", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AB", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AC", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Wm(TPH WTPH ABTPH AC)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+        //liefert Fehler, da Variable "a" nicht initialisiert ist.
+		//instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestTransitiveClosure.java

@@ -0,0 +1,28 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TestTransitiveClosure {
+    public List<TPHConstraint> fillList() {
+        List<TPHConstraint> list = new ArrayList<>();
+        list.add(new TPHConstraint("A", "B", Relation.EXTENDS));
+        list.add(new TPHConstraint("B", "C", Relation.EXTENDS));
+        list.add(new TPHConstraint("C", "D", Relation.EXTENDS));
+
+        return list;
+    }
+
+    @Test
+    public void genericTest() {
+        //List<TPHConstraint> testCons = FamilyOfGeneratedGenerics.buildTransitiveClosure(fillList());
+        //System.out.println(testCons);
+
+    }
+}

src/test/java/insertGenerics/TestTwoArgs.java

@@ -0,0 +1,111 @@
+package insertGenerics;
+
+import static org.junit.Assert.*;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestTwoArgs {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestTwoArgs";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("AP", "Z", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("Z", "P", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("P", "AL", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("AL", "AF", Relation.EXTENDS));
+        classConstraintsTest.add(new ClassConstraint("AF", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AL", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH ALid(TPH P)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AL", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("Z", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AF", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AFm(TPH AFTPH Z)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "AP", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH APsetA(TPH T)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AG", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AH", "T", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("T", "AP", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AL", "AF", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AL", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AFmain(TPH AGTPH AH)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);       
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestTwoArgs2.java

@@ -0,0 +1,105 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestTwoArgs2 {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestTwoArgs2";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        classConstraintsTest.add(new ClassConstraint("N", "java/lang/Object", Relation.EXTENDS));
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AG", "AA", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("U", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AA", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AAm(TPH AATPH U)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("AB", "P", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AC", "U", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AB", "AA", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AA", "U", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AG", "AA", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("U", "AA", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AAmain(TPH ABTPH AC)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("P", "AG", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("AG", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH AGid(TPH P)",  lmc);
+
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+        
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestTwoCalls.java

@@ -0,0 +1,95 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestTwoCalls {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestTwoCalls";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+	@Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("O", "R", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rid(TPH O)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "O", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("O", "R", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("R", "java/lang/Object", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("S", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Rmain(TPH STPH T)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestVector.java

@@ -0,0 +1,92 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestVector {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestVector";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "W", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("W", "ZU", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("ZU", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("voidm(java/util/Vectorjava/util/Vector)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Wid(TPH W)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        assertEquals(expectedClassCons, computedClassCons);     
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestVectorArg.java

@@ -0,0 +1,92 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.bytecode.insertGenerics.ClassConstraint;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
+import de.dhbwstuttgart.bytecode.insertGenerics.MethodConstraint;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestVectorArg {
+
+    private static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    private String pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
+    private static ClassLoader loader;
+    private static Class<?> classToTest;
+	private static Object instanceOfClass;
+	private static String className = "TestVectorArg";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        execute(new File(rootDirectory+className+".jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        
+        List<ClassConstraint> classConstraintsTest = new ArrayList<>();
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionTest = new HashMap<>();
+        Set<MethodConstraint> lmc;
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("T", "W", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("W", "ZU", Relation.EXTENDS));
+        lmc.add(new MethodConstraint("ZU", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("voidm(java/util/Vectorjava/util/Vector)",  lmc);
+        lmc = new HashSet<>();
+        lmc.add(new MethodConstraint("W", "java/lang/Object", Relation.EXTENDS));
+        methodConstraintsWithPositionTest.put("TPH Wid(TPH W)",  lmc);
+        
+        FamilyOfGeneratedGenerics fogg = compiler.fogg;
+        Set<ClassConstraint> computedClassCons = new HashSet<>(fogg.classConstraints);
+        Set<ClassConstraint> expectedClassCons = new HashSet<>(classConstraintsTest);
+        
+        //assertEquals(expectedClassCons, computedClassCons);     
+
+        HashMap<String, Set<MethodConstraint>> methodConstraintsWithPositionComputed = new HashMap<>();
+        fogg.methodConstraintsWithPosition.forEach((s, l) -> methodConstraintsWithPositionComputed.put(s,new HashSet<>(l)));
+        
+        //assertEquals(methodConstraintsWithPositionTest, methodConstraintsWithPositionComputed);
+        compiler.generateBytecode(new File(pathToClassFile), results, simplifyResultsForAllSourceFiles);
+        loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+        classToTest = loader.loadClass(className);
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+        return new TestResultSet();
+    }
+}

src/test/java/insertGenerics/TestVoidMeth.java

@@ -0,0 +1,79 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TestVoidMeth {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @BeforeClass
+    public static void resetNamesOfTypePlaceholder() {
+    	de.dhbwstuttgart.syntaxtree.factory.NameGenerator.reset();
+    }
+    
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestVoidMeth.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+        }
+        List<ResultSet> results = compiler.typeInference();
+        List<GenericGenratorResultForSourceFile> simplifyResultsForAllSourceFiles = compiler.getGeneratedGenericResultsForAllSourceFiles(results);
+        //compiler.generateBytecode(rootDirectory+"xxx.class", results, simplifyResultsForAllSourceFiles);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+            System.out.println(ASTTypePrinter.print(sf));
+            System.out.println(ASTPrinter.print(sf));
+            //List<ResultSet> results = compiler.typeInference(); PL 2017-10-03 vor die For-Schleife gezogen
+            assert results.size()>0;
+            Set<String> insertedTypes = new HashSet<>();
+            for(ResultSet resultSet : results){
+                Set<TypeInsert> result = TypeInsertFactory.createTypeInsertPoints(sf, resultSet, results, simplifyResultsForAllSourceFiles);
+                assert result.size()>0;
+                String content = readFile(f.getPath(), StandardCharsets.UTF_8);
+                for(TypeInsert tip : result){
+                    insertedTypes.add(tip.insert(content));
+                }
+            }
+            for(String s : insertedTypes){
+                System.out.println(s);
+            }
+        }
+        return new TestResultSet();
+    }
+
+    static String readFile(String path, Charset encoding)
+            throws IOException
+    {
+        byte[] encoded = Files.readAllBytes(Paths.get(path));
+        return new String(encoded, encoding);
+    }
+}

src/test/resources/bytecode/javFiles/Fac.jav

@@ -3,7 +3,7 @@ import java.lang.Integer;
 
 public class Fac  {
 	
-	getFac(java.lang.Integer n){
+	getFac(n){
 		var res = 1;
 		var i = 1;
 		while(i<=n) {

src/test/resources/insertGenericsJav/TestAny.jav

@@ -0,0 +1,13 @@
+class TestAny {
+    a;
+    b = a;
+    anyMethod() {
+        var f;
+        return f;
+    }
+    otherMethod(e) {
+        b = e;
+        e = a;
+        return e;
+    }
+}

src/test/resources/insertGenericsJav/TestClassField.jav

@@ -0,0 +1,6 @@
+class Example{
+    f;
+    fReturn(){
+        return f;
+    }
+}

src/test/resources/insertGenericsJav/TestContraVariant.jav

@@ -0,0 +1,12 @@
+public class TestContraVariant {
+
+    m(x) {
+        var y;
+        x = y;
+        return y;
+    }
+    
+    main(x) {
+    	return m(x);
+    }
+}

src/test/resources/insertGenericsJav/TestGGFinder.jav

@@ -0,0 +1,17 @@
+public class TestGGFinder {
+    a;
+
+    id(b) {
+        var c = b;
+        return c;
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+    }
+}

src/test/resources/insertGenericsJav/TestLocalVarLambda.jav

@@ -0,0 +1,7 @@
+public class TestLocalVarLambda {
+
+m(x) {
+  var id = z -> z;
+  return id.apply(x);
+  }
+} 

src/test/resources/insertGenericsJav/TestMutualRecursion.jav

@@ -0,0 +1,17 @@
+public class TestMutualRecursion {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(id(x),y);
+    }
+}

src/test/resources/insertGenericsJav/TestMutualRecursionWithField.jav

@@ -0,0 +1,22 @@
+public class TestMutualRecursionWithField {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(id(x),setA(y));
+    }
+}

src/test/resources/insertGenericsJav/TestMutualRecursionWithField2.jav

@@ -0,0 +1,22 @@
+public class TestMutualRecursionWithField2 {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(setA(x),id(y));
+    }
+}

src/test/resources/insertGenericsJav/TestMutualRecursionWithField3.jav

@@ -0,0 +1,23 @@
+public class TestMutualRecursionWithField3 {
+    a;
+
+    id(b) {
+        var c = b;
+        return main(b,c);
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	var z = m(setA(x),id(y));
+    	return z;
+    }
+}

src/test/resources/insertGenericsJav/TestReturnVar.jav

@@ -0,0 +1,6 @@
+class VarReturn {
+    anyMethod() {
+        var f;
+        return f;
+    }
+}

src/test/resources/insertGenericsJav/TestSecondLineOfClassConstraints.jav

@@ -0,0 +1,12 @@
+class Example {
+    a;
+    b = a;
+    anyMethod() {
+        var f;
+        return f;
+    }
+    otherMethod(e) {
+        e = a;
+        return e;
+    }
+}

src/test/resources/insertGenericsJav/TestTPHsAndGenerics.jav

@@ -0,0 +1,13 @@
+class TPHsAndGenerics {
+    id = x -> x;
+    id2 (x) {
+        return id.apply(x);
+    }
+    m(a, b){
+        var c = m2(a,b);
+        return a;
+    }
+    m2(a, b){
+        return b;
+    }
+}

src/test/resources/insertGenericsJav/TestTPHsAndGenerics2.jav

@@ -0,0 +1,13 @@
+class TPHsAndGenerics2 {
+    id = x -> x;
+    id2 (x) {
+        return id.apply(x);
+    }
+    m(a, b){
+        var c = m2(a,b);
+        return a;
+    }
+    m2(a, b){
+        return b;
+    }
+}

src/test/resources/insertGenericsJav/TestThreeArgs.jav

@@ -0,0 +1,15 @@
+public class TestThreeArgs {
+    a;
+
+    id(b) {
+        var a /* = null */;
+        var c = b;
+        m(a,a,b);
+        return c;
+    }
+
+    m(x,y, z) {
+        x = id(y);
+        return x;
+    }
+}

src/test/resources/insertGenericsJav/TestTwoArgs.jav

@@ -0,0 +1,22 @@
+public class TestTwoArgs {
+    a;
+
+    id(b) {
+        var c = b;
+        return c;
+    }
+
+    setA(x) {
+        a = x;
+        return a;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(id(x),setA(y));
+    }
+}

src/test/resources/insertGenericsJav/TestTwoArgs2.jav

@@ -0,0 +1,17 @@
+public class TestTwoArgs2 {
+    a;
+
+    id(b) {
+        var c = b;
+        return c;
+    }
+
+    m(x,y) {
+        x = id(y);
+        return x;
+    }
+    
+    main(x,y) {
+    	return m(id(x),m(x,y));
+    }
+}

src/test/resources/insertGenericsJav/TestTwoCalls.jav

@@ -0,0 +1,12 @@
+public class TestTwoCalls {
+
+    id(b) {
+        var c = b;
+        return c;
+    }
+    
+    main(x,y) {
+    	id(x);
+    	return id(y);
+    }
+}

src/test/resources/insertGenericsJav/TestVector.jav

@@ -0,0 +1,12 @@
+import java.util.Vector;
+
+public class TestVector {
+
+	m(v, w) {
+		w.addElement(id(v.elementAt(0)));
+	}
+	
+	id(x) {
+		return x;
+	}
+}

src/test/resources/insertGenericsJav/TestVectorArg.jav

@@ -0,0 +1,12 @@
+import java.util.Vector;
+
+public class TestVectorArg {
+
+    add(v, e) {
+		v.addElement(e);
+    }
+
+    main(v, e) {
+		add(v, e);
+    }
+}

src/test/resources/insertGenericsJav/TestVoidMeth.jav

@@ -0,0 +1,4 @@
+class VoidMeth {
+    anyMethod() {
+    }
+}