Add tests for source code gen

Var

.gitignore

@@ -29,3 +29,4 @@ logFiles/**
 
 src/main/java/de/dhbwstuttgart/parser/antlr/
 src/main/java/de/dhbwstuttgart/sat/asp/parser/antlr/
+/pull.sh

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

@@ -9,6 +9,7 @@ import java.util.List;
 import java.util.Optional;
 
 import de.dhbwstuttgart.bytecode.TPHExtractor;
+import de.dhbwstuttgart.bytecode.insertGenerics.FamilyOfGeneratedGenerics;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericGenratorResultForSourceFile;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.GenericsGeneratorResultForClass;
 import de.dhbwstuttgart.bytecode.genericsGeneratorTypes.MethodAndConstraints;
@@ -74,6 +75,7 @@ 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;
@@ -131,6 +133,10 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 			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);
+			
 			tphsClass = tphExtractor.tphsClass;
 			simplifiedConstraints = GenericsGenerator.simplifyConstraints(tphExtractor, tphsClass);
 			if(!isVisited) {
@@ -145,8 +151,8 @@ public class GeneratedGenericsFinder implements ASTVisitor {
 			
 			if(ggResult != null)
 				generatedGenericsForSF.addGenericGeneratorResultClass(ggResult);
-			
+				System.out.println("ddd");
-			
+
 		}
 
 	}

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

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+
+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,271 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import com.ibm.icu.text.CurrencyMetaInfo;
+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 de.dhbwstuttgart.exceptions.NotImplementedException;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+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, PairTphMethod<PositionFinder.Position, String>> posOfTPHs = new HashMap<>();
+    public List<ClassConstraint> classConstraints = new ArrayList<>();
+    public List<MethodConstraint> methodConstraints = new ArrayList<>();
+    public HashMap<MethodConstraint, String> methodsWithPosition = new HashMap<>();
+
+
+    public FamilyOfGeneratedGenerics(TPHExtractor tphExtractor) {
+        this.allConstraints = tphExtractor.allCons;
+        this.posOfTPHs = positionConverter(tphExtractor.allTPHS, tphExtractor.ListOfMethodsAndTph);
+        this.classConstraints = getClassConstraints(allConstraints,posOfTPHs);
+//        this.methodConstraints = getMethodConstraints(allConstraints,classConstraints,posOfTPHs);
+
+    }
+
+    public static List<ClassConstraint> getClassConstraints(List<TPHConstraint> cs, HashMap<String, 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);
+            }
+        }
+        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);
+            }
+        }
+        List<ClassConstraint> classConstraints3 = hasNoSupertypeForClassTypes(cs, cs_cl, posOfTphs);
+        for (ClassConstraint cons: classConstraints3) {
+            if (!checkForDuplicates(cons, cs_cl)) {
+                cs_cl.add(cons);
+            }
+        }
+        return cs_cl;
+    }
+
+//    public static List<MethodConstraint> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+//        //TODO: Regeln
+//        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);
+//            }
+//        }
+//        List<MethodConstraint> methodConstraints2 = firstTransitiveSubtypeForMethodTypes(cs, cs_m);
+//        for (MethodConstraint cons: methodConstraints2) {
+//            if (!checkForDuplicates(cons, cs_m)) {
+//                cs_m.add(cons);
+//            }
+//        }
+//        List<MethodConstraint> methodConstraints3 = secondTransitiveSubtypeForMethodTypes(cs, cs_cl, cs_m);
+//        for (MethodConstraint cons: methodConstraints3) {
+//            if (!checkForDuplicates(cons, cs_m)) {
+//                cs_m.add(cons);
+//            }
+//        }
+//        List<MethodConstraint> methodConstraints4 = hasNoSupertypeForMethodTypes(cs, posOfTphs);
+//        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 static HashMap<MethodConstraint, String> getMethodConstraints(List<TPHConstraint> cs, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+        throw new NotImplementedException();
+    }
+
+
+
+    /**
+     * 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, 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()) {
+                    if(tph == allCons.getLeft() && posOfTphs.get(tph).fst == PositionFinder.Position.FIELD) {
+                        ClassConstraint consToAdd = new ClassConstraint(tph, allCons.getRight(), allCons.getRel());
+                        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<>();
+        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){
+                        ClassConstraint 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<TPHConstraint> allConstraints, List<ClassConstraint> cs_cl, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+        List<ClassConstraint> tempCC= new ArrayList<>();
+        for(TPHConstraint allCons: allConstraints) {
+            for(ClassConstraint cCons: cs_cl) {
+                for(String tph: posOfTphs.keySet()) {
+                    boolean tvInField = posOfTphs.get(tph).fst == PositionFinder.Position.FIELD;
+                    boolean hasSmallerTVInClCons = (posOfTphs.containsKey(cCons.getRight()) && cCons.getRight() == tph && cCons.getLeft() != null);
+                    if( ((tvInField || hasSmallerTVInClCons) && cCons.getRel()==Relation.EXTENDS) &&
+                            checkUpperBound(allConstraints, tph)  && allCons.getRel()==Relation.EXTENDS) {
+                        ClassConstraint consToAdd = new ClassConstraint(tph, "Object", Relation.EXTENDS);
+                        if (!checkForDuplicates(consToAdd, tempCC)){
+                            tempCC.add(consToAdd);
+                        }
+                    }
+                }
+            }
+        }
+        return tempCC;
+    }
+
+    /**
+     * 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 HashMap<MethodConstraint, String> typeOfTheMethodInClSigma(List<TPHConstraint> allConstraints, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) { // cl_\sigma??
+        //TODO:
+        HashMap<MethodConstraint, String> tempMC= new HashMap<>();
+        for(TPHConstraint allCons: allConstraints){
+            if(posOfTphs.containsKey(allCons.getLeft()) && allCons.getRight()!=null && allCons.getRel()==Relation.EXTENDS) {
+                for(String tph: posOfTphs.keySet()) {
+                    if(tph == allCons.getLeft() && (posOfTphs.get(tph).fst == PositionFinder.Position.METHOD || posOfTphs.get(tph).fst == PositionFinder.Position.CONSTRUCTOR)) {
+                        MethodConstraint consToAdd = new MethodConstraint(allCons.getLeft(), allCons.getRight(), allCons.getRel());
+                        if (!checkForDuplicatesInMethods(consToAdd, tempMC, posOfTphs)) {
+                            tempMC.put(consToAdd, posOfTphs.get(tph).snd);
+                        }
+                    }
+                }
+            }
+        }
+        return tempMC;
+    }
+
+
+
+    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 static boolean checkForDuplicatesInMethods(TPHConstraint constraint, HashMap<MethodConstraint, String> hashMap, HashMap<String, PairTphMethod<PositionFinder.Position, String>> posOfTphs) {
+        throw new NotImplementedException();
+    }
+
+    public static 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) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    public static HashMap<String, PairTphMethod<PositionFinder.Position, String>> positionConverter(HashMap<String, Boolean> allTphs, List<MethodAndTPH> listOfMethodsAndTphs) {
+        HashMap<String, PairTphMethod<PositionFinder.Position, String>> convertedPositions = new HashMap<>();
+        for(String tph: allTphs.keySet()) {
+            if(allTphs.get(tph)) {  //if true, then tph is a method-TPH
+                for(MethodAndTPH methTph: listOfMethodsAndTphs) {
+                    if (methTph.getTphs().contains(tph)) {
+                        convertedPositions.put(tph, new PairTphMethod<>(PositionFinder.Position.METHOD, methTph.getId()));
+                    }
+                }
+            } else { // else it is in the class-TPH
+                convertedPositions.put(tph, new PairTphMethod<>(PositionFinder.Position.FIELD, null));
+            }
+        }
+        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();
+    }
+*/
+
+}

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,9 @@
+package de.dhbwstuttgart.bytecode.insertGenerics;
+
+import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
+
+public class MethodConstraint extends TPHConstraint {
+    public MethodConstraint(String left, String right, Relation rel) {
+        super(left, right, rel);
+    }
+}

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/core/JavaTXCompiler.java

@@ -1,7 +1,25 @@
 //PL 2018-12-19: typeInferenceOld nach typeInference uebertragen
 package de.dhbwstuttgart.core;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
 import com.google.common.collect.Lists;
+
 import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.bytecode.Exception.BytecodeGeneratorError;
 import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
@@ -11,21 +29,19 @@ import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.JavaTXParser;
 import de.dhbwstuttgart.parser.NullToken;
-import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.SyntaxTreeGenerator;
 import de.dhbwstuttgart.parser.antlr.Java8Parser.CompilationUnitContext;
+import de.dhbwstuttgart.parser.scope.GenericsRegistry;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.TypeScope;
-import de.dhbwstuttgart.syntaxtree.FormalParameter;
-import de.dhbwstuttgart.syntaxtree.GenericDeclarationList;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.statement.Block;
 import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -41,32 +57,17 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.typeAlgo.TYPE;
 import de.dhbwstuttgart.typeinference.unify.RuleSet;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
+import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
-import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
-import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
-import java.io.OutputStreamWriter;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import org.antlr.v4.runtime.Token;
-import org.apache.commons.io.output.NullOutputStream;
 
 
 public class JavaTXCompiler {
@@ -74,12 +75,13 @@ public class JavaTXCompiler {
 	//public static JavaTXCompiler INSTANCE;
     final CompilationEnvironment environment;
 	Boolean resultmodel = true;
+	// TODO change the AST for replace generics with TPH
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
     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;
 
-	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
+	public JavaTXCompiler (File... sourceFile) throws IOException, ClassNotFoundException {
 		this(Arrays.asList(sourceFile), null);
 	}
     public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
@@ -102,6 +104,10 @@ public class JavaTXCompiler {
         //INSTANCE = this;
     }
 
+	public Map<File, SourceFile> getSourceFiles () {
+		return sourceFiles;
+	}
+
     public ConstraintSet<Pair> getConstraints() throws ClassNotFoundException, IOException {
         List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
         List<ClassOrInterface> importedClasses = new ArrayList<>();
@@ -120,11 +126,11 @@ public class JavaTXCompiler {
 				importedClasses.add(importedClass);
 			}
         }
-        for (File f : this.sourceFiles.keySet()) {
+		for (File f : this.sourceFiles.keySet()) {
 			SourceFile sf = sourceFiles.get(f);
 			sf = new SourceFile(sf.getPkgName(),
 					       sf.KlassenVektor.stream()
-										   .map(cl -> new ClassOrInterface(cl))
+							.map(ClassOrInterface::new)
 							               .collect(Collectors.toCollection(ArrayList::new)),
 						   sf.imports);
 			//sf enthaelt neues Source-File, neue Klassen-Objekte und neue 
@@ -609,7 +615,7 @@ public class JavaTXCompiler {
 					});
 
 			Set<String> constructorParaTypeVarNames = allClasses.stream().map(x -> x.getConstructors().stream()
-					.map(y -> y.getParameterList().getFormalparalist().stream()
+					.filter(y -> y != null).map(y -> y.getParameterList().getFormalparalist().stream()
 							.filter(z -> z.getType() instanceof TypePlaceholder)
 							.map(z -> ((TypePlaceholder) z.getType()).getName())
 							.collect(Collectors.toCollection(HashSet::new)))

src/main/java/de/dhbwstuttgart/inferWildcards/ConstraintsGenerationUtils.java

@@ -0,0 +1,132 @@
+package de.dhbwstuttgart.inferWildcards;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
+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.unify.model.PairOperator;
+
+/**
+ * Utilities to generate the constraints for the infer wildcards algorithm.
+ * 
+ * @author Till Schnell
+ * @version 1.0
+ */
+public final class ConstraintsGenerationUtils
+{
+
+	private ConstraintsGenerationUtils () {
+		throw new AssertionError("No ConstraintsGenerationUtils instance for you");
+	}
+
+	/**
+	 * Generate the constraints for a map of type placeholder and RefType and merge
+	 * these to the already provided constraints.
+	 * 
+	 * @param tphMap      {@link Map} of {@link TypePlaceholder} and
+	 *                    {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 * @param constraints {@link ConstraintSet} over {@link Pair} to merge to
+	 * @return The same instance {@code constraints} provided including the merged
+	 *         constraints
+	 */
+	public static ConstraintSet<Pair> generateAndMergeConstraints (
+			Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap,
+			ConstraintSet<Pair> constraints) {
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+		constraints.addAll(generateConstraints);
+		return constraints;
+	}
+
+	/**
+	 * Generate the constraints for a map of type placeholder and RefType.
+	 * 
+	 * @param tphMap {@link Map} of {@link TypePlaceholder} and
+	 *               {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 * @return {@link ConstraintSet} of {@link Pair} containing the constraints to
+	 *         infer the matching wildcard type.
+	 */
+	public static ConstraintSet<Pair> generateConstraints (
+			Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap) {
+		return tphMap.entrySet().stream().map(ConstraintsGenerationUtils::generateConstraints)
+				.reduce(
+				new ConstraintSet<>(),
+				(cs, c) -> {
+					cs.addAll(c);
+					return cs;
+						});
+	}
+
+	/**
+	 * Generate the constraints for a single RefType type placeholder pair to infer
+	 * the wildcards for the generic parameter type.
+	 * 
+	 * @param tphEntry {@link Entry} of {@link TypePlaceholder} and
+	 *                 {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 * @return {@link ConstraintSet} of {@link Pair} generated containing the
+	 *         constraints.
+	 */
+	private static ConstraintSet<Pair> generateConstraints (
+			Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphEntry) {
+		return generateConstraints(tphEntry.getValue(), tphEntry.getKey());
+	}
+
+	/**
+	 * Generate the constraints for a single RefType type placeholder pair to infer
+	 * the wildcards for the generic parameter type.
+	 * 
+	 * @param refType {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 * @param tph     {@link TypePlaceholder}
+	 * @return {@link ConstraintSet} of {@link Pair} generated containing the
+	 *         constraints.
+	 */
+	public static ConstraintSet<Pair> generateConstraints (RefTypeOrTPHOrWildcardOrGeneric refType,
+			TypePlaceholder tph) {
+		ConstraintSet<Pair> constraintSet = new ConstraintSet<>();
+		Set<Constraint<Pair>> oderConstraints = new HashSet<>();
+		constraintSet.addOderConstraint(oderConstraints);
+
+		// single type
+		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, refType);
+
+		// extends type
+		ExtendsWildcardType extendsWildcardType = new ExtendsWildcardType(refType, new NullToken());
+		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, extendsWildcardType);
+
+		// super type
+		SuperWildcardType superWildcardType = new SuperWildcardType(refType, new NullToken());
+		ConstraintsGenerationUtils.addToOderConstraint(oderConstraints, tph, superWildcardType);
+
+		return constraintSet;
+	}
+
+	private static void addToOderConstraint (Set<Constraint<Pair>> oderConstraints, TypePlaceholder tph,
+			RefTypeOrTPHOrWildcardOrGeneric refType) {
+		Constraint<Pair> c = new Constraint<>();
+		oderConstraints.add(c);
+
+		ConstraintsGenerationUtils.addToConstraint(c, tph, refType);
+	}
+
+	/**
+	 * Generate a pair and adds it to a constraint.
+	 * 
+	 * @param c    {@link Constraint} of {@link Pair}
+	 * @param tph  {@link TypePlaceholder}
+	 * @param type {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 */
+	private static void addToConstraint (Constraint<Pair> c, TypePlaceholder tph,
+			RefTypeOrTPHOrWildcardOrGeneric type) {
+		Pair pair = new Pair(tph, type, PairOperator.EQUALSDOT);
+		c.add(pair);
+	}
+
+}

src/main/java/de/dhbwstuttgart/inferWildcards/JavaTXCompilerWildcards.java

@@ -0,0 +1,159 @@
+package de.dhbwstuttgart.inferWildcards;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.antlr.v4.runtime.Token;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+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.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+/**
+ * Extension of the JavaTX Compiler providing the capabilities to inference
+ * wildcard types.
+ * <p>
+ * <code>
+ * <ul>
+ * <li>? super Type</li>
+ * <li>? extends Type</li>
+ * <li>Type</li>
+ * </ul>
+ * </code>
+ * 
+ * @author Till Schnell
+ * @version 1.0
+ */
+public class JavaTXCompilerWildcards
+	extends JavaTXCompiler
+{
+
+	/**
+	 * Generated Type placeholder and the implementation type represented.
+	 */
+	private final Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap;
+
+	public JavaTXCompilerWildcards (File... sourceFile) throws IOException, ClassNotFoundException {
+		super(sourceFile);
+		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
+	}
+
+	public JavaTXCompilerWildcards (File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
+		super(sourceFile, log);
+		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
+	}
+
+	public JavaTXCompilerWildcards (List<File> sourceFiles) throws IOException, ClassNotFoundException {
+		super(sourceFiles);
+		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
+	}
+
+	public JavaTXCompilerWildcards (List<File> sources, List<File> contextPath)
+			throws IOException, ClassNotFoundException {
+		super(sources, contextPath);
+		this.tphMap = TypePlaceholderReplaceUtils.generateTypePlaceholder(this);
+	}
+
+	/**
+	 * Return the Type Placeholder generated.
+	 * 
+	 * @return {@link Map} over {@link TypePlaceholder} and
+	 *         {@link RefTypeOrTPHOrWildcardOrGeneric}
+	 */
+	public Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> getTphMap () {
+		return tphMap;
+	}
+
+	@Override
+	public ConstraintSet<Pair> getConstraints () throws ClassNotFoundException, IOException {
+		ConstraintSet<Pair> constraints = super.getConstraints();
+		return ConstraintsGenerationUtils.generateAndMergeConstraints(tphMap, constraints);
+	}
+
+	public void generateSourceCode (File outputDir) throws IOException, ClassNotFoundException {
+		if (!outputDir.exists() && outputDir.isDirectory()) {
+			boolean mkdirs = outputDir.mkdirs();
+			if (!mkdirs)
+				throw new IOException("Could not create output directory at: " + outputDir.getAbsolutePath());
+		}
+
+		// TODO for all result sets
+		List<ResultSet> typeInference = typeInference();
+		ResultSet resultSet = typeInference.get(0);
+
+		for (Map.Entry<File, SourceFile> e : sourceFiles.entrySet())
+			generateSourceCode(e.getKey(), outputDir, resultSet);
+
+	}
+
+	private void generateSourceCode (File inputFile, File outputDir, ResultSet results)
+			throws IOException {
+	
+		File outputFile = new File(outputDir, inputFile.getName());
+		
+		Files.deleteIfExists(outputFile.toPath());
+
+		if(!outputFile.createNewFile()) 
+			throw new IOException("File could not be created at: " + outputFile.getAbsolutePath());
+		
+		try(BufferedReader reader = new BufferedReader(new FileReader(inputFile));
+		BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))){
+			List<Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric>> list = tphMap.entrySet().stream().sorted( (c1, c2) -> Integer.compare(c1.getValue().getOffset().getStartIndex(),
+					c2.getValue().getOffset().getStartIndex())).collect(Collectors.toList());
+			
+			int readIdx = 0;
+			
+			for (Map.Entry<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> e : list) {
+				Token token = e.getValue().getOffset();
+				
+				// read the characters before the token
+				int startIndex = token.getStartIndex();
+				char[] read = new char[startIndex - readIdx];
+
+				int i = reader.read(read);
+				if (i != read.length)
+					throw new IOException("Could not read the assumed number of character, read " + i
+							+ " assumed " + read.length);
+
+				readIdx += read.length;
+
+				// Write to output file
+				writer.write(read);
+
+				// Write the new type
+				ResolvedType resolveType = results.resolveType(e.getKey());
+				String string = resolveType.resolvedType.toString();
+				writer.write(string);
+
+				// Read the replaced type and count the read counter
+				int length = token.getStopIndex() - token.getStartIndex() + 1;
+				reader.read(new char[length]);
+				readIdx += length;
+			}
+			
+			// Read the rest of the file.
+			while (true) {
+				char[] tmp = new char[1024];
+				int read = reader.read(tmp);
+				if (read == -1)
+					break;
+
+				writer.write(tmp, 0, read);
+			}
+		}
+		
+	}
+}

src/main/java/de/dhbwstuttgart/inferWildcards/ReplaceTypeparamVisitor.java

@@ -0,0 +1,171 @@
+package de.dhbwstuttgart.inferWildcards;
+
+import java.util.HashMap;
+import java.util.ListIterator;
+import java.util.Map;
+
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
+import de.dhbwstuttgart.syntaxtree.Field;
+import de.dhbwstuttgart.syntaxtree.FormalParameter;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+/**
+ * Visitor replace type parameter of the type RefType by Type Placeholder in a
+ * AST.
+ * 
+ * @author Till Schnell
+ * @version 1.0
+ */
+public class ReplaceTypeparamVisitor
+	extends AbstractASTWalker
+{
+
+	/**
+	 * Containing the replaced RefType and the mapping TPH
+	 */
+	private final Map<TypePlaceholder, RefTypeOrTPHOrWildcardOrGeneric> tphMap;
+	
+	/**
+	 * Constructor for a {@code ReplaceTypeparamVisitor}.
+	 */
+	public ReplaceTypeparamVisitor () {
+		this.tphMap = new HashMap<>();
+	}
+
+	@Override
+	public void visit (Field field) {
+		System.out.println("Field: " + field.getName());
+
+		field.accept(new ReplaceRefTypeVisitor());
+
+		super.visit(field);
+	}
+
+	@Override
+	public void visit (FormalParameter formalParameter) {
+		System.out.println("FormalParameter: " + formalParameter.getName());
+
+		formalParameter.accept(new ReplaceRefTypeVisitor());
+
+		super.visit(formalParameter);
+	}
+
+	@Override
+	public void visit (LocalVarDecl localVarDecl) {
+		System.out.println("LocalVarDecl: " + localVarDecl.getName());
+
+		localVarDecl.accept(new ReplaceRefTypeVisitor());
+
+		super.visit(localVarDecl);
+	}
+
+	@Override
+	public void visit (Method method) {
+		System.out.println("Method: " + method.getName());
+
+		RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
+		if (returnType != null)
+			returnType.accept(new ReplaceRefTypeVisitor());
+		
+		super.visit(method);
+	}
+
+	/**
+	 * Return the mapping of the replaced {@link RefType} and the inserted
+	 * {@link TypePlaceholder}.
+	 * 
+	 * @return {@link Map} of {@link TypePlaceholder} and {@link RefType}
+	 */
+	public Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> getTphMap () {
+		return tphMap;
+	}
+
+	/**
+	 * Visitor replace each RefType occurs.
+	 * 
+	 * @author Till Schnell
+	 * @version 1.0
+	 */
+	private class ReplaceRefTypeVisitor
+		extends AbstractASTWalker
+	{
+		@Override
+		public void visit (RefType refType) {
+
+			// check if RefType has Parameter Types
+			if (!refType.getParaList().isEmpty()) {
+				System.out.print("Visit Type: " + refType + " -> ");
+
+				// Iterate over all Parameter Types
+				for (ListIterator<RefTypeOrTPHOrWildcardOrGeneric> listIterator = refType.getParaList()
+						.listIterator(); listIterator.hasNext();) {
+					RefTypeOrTPHOrWildcardOrGeneric next = listIterator.next();
+
+					// If Parameter type is RefType replace with TPH
+					if (next instanceof RefType) {
+						RefType nextRefType = (RefType) next;
+
+						// Visit replaced RefType to get all nested type parameters
+						// Should be done before generating parents TPH to include child TPH in the
+						// parent TPH mapping
+						this.visit(nextRefType);
+
+						generateTphAndReplaceInTree(listIterator, next);
+					}
+					else if (next instanceof GenericRefType) {
+
+						// Visit of nested type arguments not necessary as Generic Types cannot contain
+						// type parameters
+
+						generateTphAndReplaceInTree(listIterator, next);
+					}
+				}
+
+				System.out.println(refType);
+			}
+
+			// Let the parent care about all the other stuff
+			super.visit(refType);
+		}
+
+		/**
+		 * Generate the TPH for a {@link RefTypeOrTPHOrWildcardOrGeneric} and saves the
+		 * mapping.
+		 * 
+		 * @param t {@link RefTypeOrTPHOrWildcardOrGeneric}
+		 * @return {@link TypePlaceholder} generated
+		 */
+		private TypePlaceholder generateTypePlaceholder (RefTypeOrTPHOrWildcardOrGeneric t) {
+			TypePlaceholder tph = TypePlaceholder.fresh(new NullToken());
+			tphMap.put(tph, t);
+			return tph;
+		}
+
+		/**
+		 * Generate the TPH for a {@link RefTypeOrTPHOrWildcardOrGeneric}, saves the
+		 * mapping and replaces the type by the type placeholder in the tree.
+		 * 
+		 * @param listIterator {@link ListIterator} over
+		 *                     {@link RefTypeOrTPHOrWildcardOrGeneric} representing the
+		 *                     tree to replace in
+		 * @param refType      {@link RefTypeOrTPHOrWildcardOrGeneric} to generate type
+		 *                     placeholder for and replace
+		 */
+		private void generateTphAndReplaceInTree (ListIterator<RefTypeOrTPHOrWildcardOrGeneric> listIterator,
+				RefTypeOrTPHOrWildcardOrGeneric refType) {
+			// Generate TPH
+			TypePlaceholder tph = generateTypePlaceholder(refType);
+
+			// Replace in AST
+			listIterator.set(tph);
+		}
+
+	}
+
+}

src/main/java/de/dhbwstuttgart/inferWildcards/TypePlaceholderReplaceUtils.java

@@ -0,0 +1,42 @@
+package de.dhbwstuttgart.inferWildcards;
+
+import java.io.File;
+import java.util.Map;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
+/**
+ * Class providing utilities to generate the Type placeholder for parameter
+ * types which shall be inferred.
+ * 
+ * @author Till Schnell
+ * @version 1.0
+ */
+public final class TypePlaceholderReplaceUtils
+{
+
+	private TypePlaceholderReplaceUtils () {
+		throw new AssertionError("No TypePlaceholderReplaceUtils instance for you");
+	}
+
+	/**
+	 * Return the map of the generated type placeholder for the associate parameter
+	 * type
+	 * 
+	 * @param compiler {@link JavaTXCompiler} to get the source file from
+	 * @return {@link Map} over {@link TypePlaceholder} and the {@link RefType}
+	 *         replaced
+	 */
+	public static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTypePlaceholder (
+			JavaTXCompiler compiler) {
+		Map<File, SourceFile> sourceFiles = compiler.getSourceFiles();
+		ReplaceTypeparamVisitor visitor = new ReplaceTypeparamVisitor();
+		sourceFiles.forEach( (k, v) -> v.accept(visitor));
+		return visitor.getTphMap();
+	}
+
+}

src/main/java/de/dhbwstuttgart/parser/antlr/Java8BaseListener.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.7
+// Generated from Java8.g4 by ANTLR 4.8
 package de.dhbwstuttgart.parser.antlr;
 
 import org.antlr.v4.runtime.ParserRuleContext;

src/main/java/de/dhbwstuttgart/parser/antlr/Java8Lexer.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.7
+// Generated from Java8.g4 by ANTLR 4.8
 package de.dhbwstuttgart.parser.antlr;
 import org.antlr.v4.runtime.Lexer;
 import org.antlr.v4.runtime.CharStream;
@@ -11,7 +11,7 @@ import org.antlr.v4.runtime.misc.*;
 
 @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
 public class Java8Lexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.7", RuntimeMetaData.VERSION); }
+	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }
 
 	protected static final DFA[] _decisionToDFA;
 	protected static final PredictionContextCache _sharedContextCache =
@@ -42,68 +42,79 @@ public class Java8Lexer extends Lexer {
 		"DEFAULT_MODE"
 	};
 
-	public static final String[] ruleNames = {
+	private static String[] makeRuleNames() {
-		"T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
+		return new String[] {
-		"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
+			"T__0", "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", 
-		"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", 
+			"CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", 
-		"IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
+			"ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", 
-		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
+			"IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", 
-		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
+			"NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", 
-		"TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", "DecimalIntegerLiteral", 
+			"STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", 
-		"HexIntegerLiteral", "OctalIntegerLiteral", "BinaryIntegerLiteral", "IntegerTypeSuffix", 
+			"THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
-		"DecimalNumeral", "Digits", "Digit", "NonZeroDigit", "DigitsAndUnderscores", 
+			"DecimalIntegerLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", 
-		"DigitOrUnderscore", "Underscores", "HexNumeral", "HexDigits", "HexDigit", 
+			"BinaryIntegerLiteral", "IntegerTypeSuffix", "DecimalNumeral", "Digits", 
-		"HexDigitsAndUnderscores", "HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", 
+			"Digit", "NonZeroDigit", "DigitsAndUnderscores", "DigitOrUnderscore", 
-		"OctalDigit", "OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
+			"Underscores", "HexNumeral", "HexDigits", "HexDigit", "HexDigitsAndUnderscores", 
-		"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
+			"HexDigitOrUnderscore", "OctalNumeral", "OctalDigits", "OctalDigit", 
-		"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
+			"OctalDigitsAndUnderscores", "OctalDigitOrUnderscore", "BinaryNumeral", 
-		"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
+			"BinaryDigits", "BinaryDigit", "BinaryDigitsAndUnderscores", "BinaryDigitOrUnderscore", 
-		"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
+			"FloatingPointLiteral", "DecimalFloatingPointLiteral", "ExponentPart", 
-		"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
+			"ExponentIndicator", "SignedInteger", "Sign", "FloatTypeSuffix", "HexadecimalFloatingPointLiteral", 
-		"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
+			"HexSignificand", "BinaryExponent", "BinaryExponentIndicator", "BooleanLiteral", 
-		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+			"CharacterLiteral", "SingleCharacter", "StringLiteral", "StringCharacters", 
-		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+			"StringCharacter", "EscapeSequence", "OctalEscape", "ZeroToThree", "UnicodeEscape", 
-		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+			"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
-		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+			"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
-		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+			"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", 
-		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+			"ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", 
-		"URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", "AT", 
+			"COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", 
-		"ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+			"AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", 
-	};
+			"RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "JavaLetter", "JavaLetterOrDigit", 
+			"AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+		};
+	}
+	public static final String[] ruleNames = makeRuleNames();
 
-	private static final String[] _LITERAL_NAMES = {
+	private static String[] makeLiteralNames() {
-		null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", 
+		return new String[] {
-		"'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
+			null, "'var'", "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", 
-		"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
+			"'case'", "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", 
-		"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
+			"'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", 
-		"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
+			"'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", 
-		"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
+			"'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", 
-		"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
+			"'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", 
-		"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
+			"'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", 
-		null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+			"'transient'", "'try'", "'void'", "'volatile'", "'while'", null, null, 
-		"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
+			null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", 
-		"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
+			"';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
-		"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
+			"'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", 
-		"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
+			"'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'->'", "'::'", "'+='", 
-		"'>>>='", null, "'@'", "'...'"
+			"'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", 
-	};
+			"'>>>='", null, "'@'", "'...'"
-	private static final String[] _SYMBOLIC_NAMES = {
+		};
-		null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", 
+	}
-		"CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", 
+	private static final String[] _LITERAL_NAMES = makeLiteralNames();
-		"ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", 
+	private static String[] makeSymbolicNames() {
-		"IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", 
+		return new String[] {
-		"NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", 
+			null, null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", 
-		"STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", 
+			"CATCH", "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", 
-		"THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
+			"ELSE", "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", 
-		"FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", 
+			"GOTO", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", 
-		"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
+			"NATIVE", "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", 
-		"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
+			"SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", 
-		"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", 
+			"THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "WHILE", "IntegerLiteral", 
-		"SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", "COLONCOLON", 
+			"FloatingPointLiteral", "BooleanLiteral", "CharacterLiteral", "StringLiteral", 
-		"ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
+			"NullLiteral", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", 
-		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
+			"SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", 
-		"URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT"
+			"COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", 
-	};
+			"ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ARROW", 
+			"COLONCOLON", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", 
+			"AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", 
+			"RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "Identifier", "AT", "ELLIPSIS", "WS", 
+			"COMMENT", "LINE_COMMENT"
+		};
+	}
+	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
 
 	/**

src/main/java/de/dhbwstuttgart/parser/antlr/Java8Listener.java

@@ -1,4 +1,4 @@
-// Generated from Java8.g4 by ANTLR 4.7
+// Generated from Java8.g4 by ANTLR 4.8
 package de.dhbwstuttgart.parser.antlr;
 import org.antlr.v4.runtime.tree.ParseTreeListener;
 

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/type/TypePlaceholder.java

@@ -64,6 +64,10 @@ public class TypePlaceholder extends RefTypeOrTPHOrWildcardOrGeneric
         }
     }
 
+    @Override
+    public int hashCode() {
+        return this.getName().hashCode();
+    }
 
     public String toString()
     {

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/inferWildcards/TestInferWildcardsFields.java

@@ -0,0 +1,148 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
+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.PairTPHequalRefTypeOrWildcardType;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+public class TestInferWildcardsFields
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsFields.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	private static List<ResultSet> generateExpectedTypeInferResult (JavaTXCompilerWildcards compiler) {
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = compiler.getTphMap();
+
+		ArrayList<ResultSet> list = new ArrayList<>();
+
+		tphMap.forEach( (tph, t) -> {
+			ResultPair r = new PairTPHequalRefTypeOrWildcardType(tph,
+					new RefType(new JavaClassName("java.lang.String"), new NullToken()));
+			HashSet<ResultPair> set = new HashSet<>();
+			set.add(r);
+			list.add(new ResultSet(set));
+		});
+		
+		return list;
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 4", 4, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsMap.java

@@ -0,0 +1,125 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsMap
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsMap.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 6", 6, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsMapNested.java

@@ -0,0 +1,126 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsMapNested
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsMapNested.java";
+	}
+
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 9", 9, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsNested.java

@@ -0,0 +1,125 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsNested
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsNested.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 6", 6, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsParamType.java

@@ -0,0 +1,125 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsParamType
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsParamType.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 4", 4, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsSingle.java

@@ -0,0 +1,125 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsSingle
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsSingle.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 3", 3, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/inferWildcards/TestInferWildcardsSingleLib.java

@@ -0,0 +1,125 @@
+package inferWildcards;
+
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.hamcrest.CoreMatchers;
+import org.junit.Before;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.inferWildcards.ConstraintsGenerationUtils;
+import de.dhbwstuttgart.inferWildcards.JavaTXCompilerWildcards;
+import de.dhbwstuttgart.inferWildcards.TypePlaceholderReplaceUtils;
+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.ResultSet;
+
+public class TestInferWildcardsSingleLib
+{
+
+	private String resourceFilePath;
+	private String resourceDirPath;
+
+	@Before
+	public void setup () {
+		resourceDirPath = System.getProperty("user.dir") + "/src/test/resources/inferWildcards";
+		resourceFilePath = resourceDirPath + "/TestClassWildcardsSingleLib.java";
+	}
+
+	private JavaTXCompiler getStandardCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompiler(files1);
+	}
+
+	private JavaTXCompilerWildcards getWildcardsCompiler () throws ClassNotFoundException, IOException {
+		File[] files1 = { new File(resourceFilePath) };
+		return new JavaTXCompilerWildcards(files1);
+	}
+
+	private static Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph (
+			JavaTXCompiler javaTXCompiler) {
+		System.out.println("\nReplacements:");
+
+		return TypePlaceholderReplaceUtils.generateTypePlaceholder(javaTXCompiler);
+	}
+
+	@Test
+	public void testGenerateTph () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate TPH --------------\n");
+
+		JavaTXCompiler javaTXCompiler = getStandardCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> generateTph = generateTph(
+				javaTXCompiler);
+
+		System.out.println(generateTph);
+		
+		assertThat("Number of TPH is 2", 2, CoreMatchers.is(generateTph.size()));
+	}
+
+	@Test
+	public void testGeneratedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Generate Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		Map<? extends TypePlaceholder, ? extends RefTypeOrTPHOrWildcardOrGeneric> tphMap = javaTXCompilerWildcards
+				.getTphMap();
+		ConstraintSet<Pair> generateConstraints = ConstraintsGenerationUtils.generateConstraints(tphMap);
+
+		System.out.println(generateConstraints);
+
+		int size = 0;
+		for (Set<Constraint<Pair>> l : generateConstraints.getOderConstraints())
+			for (Constraint<Pair> c : l)
+				size += c.size();
+
+		assertThat("Number of Generated Constraints", tphMap.size() * 3, CoreMatchers.is(size));
+	}
+
+	@Test
+	public void testCombinedConstraints () throws ClassNotFoundException, IOException {
+		System.out.println("\n--------- Test Combined Constraints --------------\n");
+
+		JavaTXCompilerWildcards javaTXCompilerWildcards = getWildcardsCompiler();
+		ConstraintSet<Pair> constraints = javaTXCompilerWildcards.getConstraints();
+
+		System.out.println(constraints);
+	}
+
+	@Test
+	public void testTypeInference () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+		List<ResultSet> typeInference = wildcardsCompiler.typeInference();
+
+		System.out.println(typeInference);
+
+		assertThat("Type Inference Results containing the correct Wildcard results", typeInference,
+				CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationBytecode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateBytecode(new File(resourceDirPath + "/generatedBC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+
+	@Test
+	public void testGenrationSourceCode () throws ClassNotFoundException, IOException {
+		JavaTXCompilerWildcards wildcardsCompiler = getWildcardsCompiler();
+
+		wildcardsCompiler.generateSourceCode(new File(resourceDirPath + "/generatedSC"));
+
+		assertThat("Generation Succeeded", null, CoreMatchers.anything());
+	}
+}

src/test/java/insertGenerics/FamilyOfGeneratedGenericsTest.java

@@ -0,0 +1,196 @@
+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());
+
+    }
+
+    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"));
+    }
+
+    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);
+        assertFalse(classConstraints.isEmpty());
+        assertTrue(classConstraints.size() == 6);
+
+    }
+
+    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);
+    }
+
+
+    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, 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/MethodsTest.java

@@ -0,0 +1,30 @@
+package insertGenerics;
+
+import de.dhbwstuttgart.bytecode.genericsGenerator.GeneratedGenericsFinder;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import junit.framework.TestResult;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+public class MethodsTest {
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+    public static final String fileDirectory = rootDirectory + "TestGGFinder.jav";
+
+    @Test
+    public void testVisit(ClassOrInterface coi) throws IOException, ClassNotFoundException {
+        JavaTXCompiler compiler = new JavaTXCompiler(new File(fileDirectory));
+        SourceFile sf = compiler.sourceFiles.get(compiler.sourceFiles.keySet());
+        List<ResultSet> results = compiler.typeInference();
+
+        GeneratedGenericsFinder ggf = new GeneratedGenericsFinder(sf, results);
+        ClassOrInterface coiHere = coi;
+        ggf.visit(coiHere);
+        //assert results.size()>0;
+    }
+}

src/test/java/insertGenerics/TestExample42.java

@@ -0,0 +1,60 @@
+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<TPHConstraint> testCons;
+    }
+}

src/test/java/insertGenerics/TestExample42_allInOneMethod.java

@@ -0,0 +1,59 @@
+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<TPHConstraint> testCons;
+    }
+}

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/TryTest.java

@@ -0,0 +1,92 @@
+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.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 TryTest {
+
+    public static final String rootDirectory = System.getProperty("user.dir")+"/src/test/resources/insertGenericsJav/";
+
+    @Test
+    public void ggFinder() throws IOException, ClassNotFoundException {
+        execute(new File(rootDirectory+"TestGGFinder.jav"));
+    }
+
+    private static class TestResultSet{
+
+    }
+
+    public TestResultSet execute(File fileToTest) throws IOException, ClassNotFoundException {
+        //filesToTest.add(new File(rootDirectory+"fc.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda2.jav"));
+        //filesToTest.add(new File(rootDirectory+"Lambda3.jav"));
+        //filesToTest.add(new File(rootDirectory+"Vector.jav"));
+        //filesToTest.add(new File(rootDirectory+"Generics.jav"));
+        //filesToTest.add(new File(rootDirectory+"MethodsEasy.jav"));
+        //filesToTest.add(new File(rootDirectory+"Matrix.jav"));
+        //filesToTest.add(new File(rootDirectory+"Import.jav"));
+        //        //filesToTest.add(new File(rootDirectory+"Faculty.jav"));
+        //        //filesToTest.add(new File(rootDirectory+"mathStruc.jav"));
+        //        //filesToTest.add(new File(rootDirectory+"test.jav"));
+        JavaTXCompiler compiler = new JavaTXCompiler(fileToTest);
+        for(File f : compiler.sourceFiles.keySet()){
+            SourceFile sf = compiler.sourceFiles.get(f);
+//            System.out.println(ASTTypePrinter.print(sf));
+//            System.out.println("---------------------------1");
+//            System.out.println(ASTPrinter.print(sf));
+//            System.out.println("---------------------------2");
+        }
+        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("---------------------------3");
+            System.out.println(ASTPrinter.print(sf));
+//            System.out.println("---------------------------4");
+            //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("---------------------------51");
+                System.out.println(s);
+                System.out.println("---------------------------52");
+            }
+        }
+        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/inferWildcards/.gitignore

@@ -0,0 +1,2 @@
+/generatedSC/
+/generatedBC/

src/test/resources/inferWildcards/TestClassWildcardsFields.java

@@ -0,0 +1,31 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.lang.String;
+
+class TestClassWildcardsFields
+{
+
+	private List<String> field1;
+	//private int counter;
+
+	public TestClassWildcards () {
+		//field1 = new ArrayList<>();
+		//counter = 0;
+	}
+
+	/**
+	 * Working method for Java
+	 * @param param1
+	 * @return
+	 */
+	public List<String> test (List<String> param1) {
+		List<String> localVar = field1;
+		field1 = param1;
+		//counter++;
+		return localVar;
+	}
+	
+	public void foo() {
+		
+	}
+}

src/test/resources/inferWildcards/TestClassWildcardsMap.java

@@ -0,0 +1,13 @@
+import java.lang.String;
+import java.lang.Object;
+import java.util.Map;
+import java.lang.Integer;
+
+class TestClassWildcardsMap
+{
+	
+	public Map<Integer, Object> test(Map<Integer, String> input){
+		Map<Integer, Object> listOfObjects = input;
+		return listOfObjects;
+	}
+}

src/test/resources/inferWildcards/TestClassWildcardsMapNested.java

@@ -0,0 +1,16 @@
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.lang.String;
+import java.lang.Object;
+import java.util.Map;
+import java.lang.Integer;
+
+class TestClassWildcardsMapNested
+{
+	
+	public Map<Integer, Collection<Object>> test(Map<Integer, List<String>> input){
+		Map<Integer, Collection<Object>> listOfObjects = input;
+		return listOfObjects;
+	}
+}

src/test/resources/inferWildcards/TestClassWildcardsNested.java

@@ -0,0 +1,15 @@
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.lang.String;
+import java.lang.Object;
+import java.util.Map;
+import java.lang.Integer;
+
+class TestClassWildcardsNested
+{	
+	public List<Collection<Object>> test(List<List<String>> input){
+		List<Collection<Object>> listOfObjects = input;
+		return listOfObjects;
+	}
+}

src/test/resources/inferWildcards/TestClassWildcardsParamType.java

@@ -0,0 +1,23 @@
+import java.util.List;
+import java.lang.String;
+
+public final class TestClassWildcardsParamType<T1, T2> {
+    public final T1 first;
+    public final T2 second;
+
+    public TestClassWildcardsParamType(T1 first, T2 second) {
+        this.first = first;
+        this.second = second;
+    }
+
+    public static <T1, T2> TestClassWildcardsParamType<T1, T2> of(T1 first, T2 second) {
+        return new TestClassWildcardsParamType<>(first, second);
+    }
+    
+    public static void main(String[] agrs) {
+    	TestClassWildcardsParamType<Class<?>, String> pair = TestClassWildcardsParamType.of(List.class, "hello");
+    	    	
+    	//Output of compiler
+    	//TestClassWildcardsParamType<? extends Class<?>, String> pair = TestClassWildcardsParamType.of(List.class, "hello");
+    }
+}

src/test/resources/inferWildcards/TestClassWildcardsSingle.java

@@ -0,0 +1,20 @@
+import java.util.List;
+import java.lang.String;
+import java.lang.Object;
+
+class TestClassWildcardsSingle
+{
+
+	/**
+	 * Non working method in normal Java
+	 * @param input
+	 * @return
+	 */
+	public List<Object> test (List<String> input) {
+		List<Object> listOfObjects = input;
+		Object test = listOfObjects.get(0);
+		String string = "Test";
+		input.add(string);
+		return listOfObjects;
+	}
+}

src/test/resources/inferWildcards/TestClassWildcardsSingleLib.java

@@ -0,0 +1,15 @@
+import java.util.List;
+
+class TestClassWildcardsLib
+{
+
+//  public <T> List<T> merge (List<T> l1, List<T> l2) {
+//		l2.forEach(s -> {if(!l1.contains(s)) l1.add(s);});
+//		return l2;
+//	}
+	
+	public <T, S extends T> List<S> di(List<T> dd){
+		T t = dd.get(1);
+		return dd;
+	}	
+}

src/test/resources/insertGenericsJav/TestGGFinder.jav

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