modified: src/de/dhbwstuttgart/core/JavaTXCompiler.java

modified:   src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
Zeilen 606 - 623 eingefuegt, um die parallel berechneten Ergebnisse richtig zu filtern
TODO
- Fuer Variance -1 muss das gleiche gemacht werden
- ab Zeile 550: nextSetasListRest muss nach jedem fork aufruf gefiltert werden.

.gitignore

@@ -20,3 +20,6 @@ bin
 .project
 .settings/
 /target/
+
+#
+manually/

README.md

@@ -0,0 +1,19 @@
+
+
+# plugin site erstellen
+* die JAvaTXCOmpiler DAtei in ein plugin umwandeln und deployen.
+* siehe: http://www.vogella.com/tutorials/EclipseJarToPlugin/article.html#convert-jar-files-to-osgi-bundles-with-the-p2-maven-plugin
+* AUsführung:
+	* mvn deploy #erstellt die JAR-Datei und steckt sie in ein lokales Repo (maven-repository)
+	* mvn p2:site
+	* mvn package # hier wird die ZIP-Filf zum Einbinden in Eclipse erstellt
+
+# Einbinden in Eclipse
+* In Eclipse kann die Zip-FIle wie ein Plugin installiert werden
+* Hier tritt FEhler auf. Reflections-Library kann nicht installiert werden. Möglicherweise wird sie auch nicht gebraucht
+* Nach dem installieren de.dhbwstuttagrt.JavaTXcompiler zu den DEpendencies des plugins hinzufügen
+* Anschließend unter "Overview" auf "Updata Classpath" klicken
+
+# Windows
+* JAVA_HOME setzen:
+	* export JAVA_HOME=/c/Program\ Files/Java/jdk1.8.0_102/

pom.xml

@@ -7,6 +7,7 @@
   <groupId>de.dhbwstuttgart</groupId>
   <artifactId>JavaTXcompiler</artifactId>
   <packaging>jar</packaging>
+   
   <version>0.1</version>
   <name>JavaTXcompiler</name>
   <url>http://maven.apache.org</url>
@@ -53,7 +54,7 @@
   <build>
     <directory>target</directory>
     <outputDirectory>target/classes</outputDirectory>
-    <finalName>${artifactId}-${version}</finalName>
+    <finalName>${project.artifactId}-${project.version}</finalName>
     <testOutputDirectory>target/test-classes</testOutputDirectory>
     <sourceDirectory>src/</sourceDirectory>
     <testSourceDirectory>test/</testSourceDirectory>
@@ -71,10 +72,7 @@
 	    <configuration>
 		    <sourceDirectory>src/de/dhbwstuttgart/parser/antlr/</sourceDirectory>
 		    <outputDirectory>src/de/dhbwstuttgart/parser/antlr/</outputDirectory>
-		    <arguments>
+		    <arguments> <argument>-package</argument> <argument>de.dhbwstuttgart.parser.antlr</argument> </arguments>
-			    <argument>-package</argument>
-			   <argument>de.dhbwstuttgart.parser.antlr</argument>
-	  	    </arguments>
 	    </configuration>
 	    </execution>
 	    <execution>
@@ -93,19 +91,91 @@
           </execution>
 
         </executions>
+</plugin>
+ <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <descriptorRefs>
+            <descriptorRef>jar-with-dependencies</descriptorRef>
+          </descriptorRefs>
+        </configuration>
       </plugin>
+<plugin>
+    <groupId>org.reficio</groupId>
+    <artifactId>p2-maven-plugin</artifactId>
+    <version>1.1.2-SNAPSHOT</version>
+    <executions>
+     <execution>
+      <id>default-cli</id>
+      <configuration>
+       <artifacts>
+        <!-- specify your depencies here -->
+	<!-- groupId:artifactId:version -->
+        <artifact>
+		<id>de.dhbwstuttgart:JavaTXcompiler:0.1</id>
+        </artifact>
+		<artifact><id>org.reflections:reflections:0.9.11</id></artifact>
+		<artifact><id>com.google.guava:guava:22.0</id></artifact>
+		<artifact><id>javax.annotation:javax.annotation-api:1.3.1</id></artifact>
+		<artifact><id>org.glassfish:javax.annotation:3.1.1</id></artifact>
+       </artifacts>
+      </configuration>
+     </execution>
+    </executions>
+   </plugin>
+   <plugin>
+    <groupId>org.eclipse.tycho</groupId>
+    <artifactId>tycho-p2-repository-plugin</artifactId>
+    <version>${tycho.version}</version>
+    <executions>
+     <execution>
+      <phase>package</phase>
+      <goals>
+       <goal>archive-repository</goal>
+      </goals>
+     </execution>
+    </executions>
+   </plugin>
         <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-compiler-plugin</artifactId>
             <configuration>
-                <source>8</source>
+                <source>9</source>
-                <target>8</target>
+                <target>9</target>
             </configuration>
         </plugin>
     </plugins>
        </build>
+        <pluginRepositories>
+  <pluginRepository>
+   <id>reficio</id>
+   <url>http://repo.reficio.org/maven/</url>
+  </pluginRepository>
+ </pluginRepositories>
+ <repositories>
+	 <repository>
+        <id>maven-repository</id>
+	<url>file:///${project.basedir}/target</url>
+</repository>
+</repositories>
    <properties>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
+    <tycho.version>0.23.0</tycho.version>
   </properties>
+  <distributionManagement>
+    <repository>
+	    <id>maven-repository</id>
+      <name>MyCo Internal Repository</name>
+      <url>file:///${project.basedir}/maven-repository/</url>
+    </repository>
+  </distributionManagement>
 </project>

src/de/dhbwstuttgart/bytecode/AStatement.java

@@ -0,0 +1,30 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public abstract class AStatement implements IStatement {
+	protected Expression expr;
+	
+	public AStatement(Expression expr) {
+		this.expr = expr;
+	}
+	
+	@Override
+	public boolean isExprBinary() {
+		return (expr instanceof BinaryExpr);
+	}
+	
+	@Override
+	public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
+		mv.visitInsn(Opcodes.ICONST_1);
+		mv.visitJumpInsn(Opcodes.GOTO, endLabel);
+		mv.visitLabel(branchLabel);
+		mv.visitInsn(Opcodes.ICONST_0);
+		mv.visitLabel(endLabel);
+	}
+}

src/de/dhbwstuttgart/bytecode/ArgumentExpr.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.bytecode;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class ArgumentExpr extends AStatement {
+	
+	public ArgumentExpr(Expression expr) {
+		super(expr);
+	}
+	
+}

src/de/dhbwstuttgart/bytecode/ArgumentVisitor.java

@@ -0,0 +1,255 @@
+package de.dhbwstuttgart.bytecode;
+
+import java.util.List;
+
+import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
+import de.dhbwstuttgart.syntaxtree.statement.ArgumentList;
+import de.dhbwstuttgart.syntaxtree.statement.Assign;
+import de.dhbwstuttgart.syntaxtree.statement.AssignToField;
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Block;
+import de.dhbwstuttgart.syntaxtree.statement.CastExpr;
+import de.dhbwstuttgart.syntaxtree.statement.DoStmt;
+import de.dhbwstuttgart.syntaxtree.statement.EmptyStmt;
+import de.dhbwstuttgart.syntaxtree.statement.ExpressionReceiver;
+import de.dhbwstuttgart.syntaxtree.statement.FieldVar;
+import de.dhbwstuttgart.syntaxtree.statement.ForStmt;
+import de.dhbwstuttgart.syntaxtree.statement.IfStmt;
+import de.dhbwstuttgart.syntaxtree.statement.InstanceOf;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.statement.Literal;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVar;
+import de.dhbwstuttgart.syntaxtree.statement.LocalVarDecl;
+import de.dhbwstuttgart.syntaxtree.statement.MethodCall;
+import de.dhbwstuttgart.syntaxtree.statement.NewArray;
+import de.dhbwstuttgart.syntaxtree.statement.NewClass;
+import de.dhbwstuttgart.syntaxtree.statement.Return;
+import de.dhbwstuttgart.syntaxtree.statement.ReturnVoid;
+import de.dhbwstuttgart.syntaxtree.statement.StaticClassName;
+import de.dhbwstuttgart.syntaxtree.statement.Super;
+import de.dhbwstuttgart.syntaxtree.statement.SuperCall;
+import de.dhbwstuttgart.syntaxtree.statement.This;
+import de.dhbwstuttgart.syntaxtree.statement.UnaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.WhileStmt;
+
+public class ArgumentVisitor implements StatementVisitor {
+	private List<Boolean> argListMethCall;
+	private BytecodeGenMethod bytecodeGenMethod;
+	
+	public ArgumentVisitor(List<Boolean> argListMethCall, BytecodeGenMethod bytecodeGenMethod) {
+		this.argListMethCall = argListMethCall;
+		this.bytecodeGenMethod = bytecodeGenMethod;
+	}
+
+	@Override
+	public void visit(ArgumentList argumentList) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(LambdaExpression lambdaExpression) {
+		lambdaExpression.accept(bytecodeGenMethod);
+		// Zieltype des Lambas ist Funktionale Interface
+		// kann nie primitiv sein => un-/boxing wird hier nicht gebraucht
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Assign assign) {
+		assign.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(assign.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(BinaryExpr binary) {
+		binary.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(binary.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Block block) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(CastExpr castExpr) {
+		castExpr.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(castExpr.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(EmptyStmt emptyStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(FieldVar fieldVar) {
+		fieldVar.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(fieldVar.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(ForStmt forStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(IfStmt ifStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(InstanceOf instanceOf) {
+		instanceOf.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(instanceOf.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(LocalVar localVar) {
+		localVar.accept(bytecodeGenMethod);
+		if(!bytecodeGenMethod.isBinaryExp) {
+			if(argListMethCall.get(0))
+				bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(localVar.getType()));
+		}
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(LocalVarDecl localVarDecl) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(MethodCall methodCall) {
+		methodCall.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(NewClass methodCall) {
+		methodCall.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(methodCall.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(NewArray newArray) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Return aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ReturnVoid aReturn) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(StaticClassName staticClassName) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(Super aSuper) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(This aThis) {
+		aThis.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(aThis.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(WhileStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(DoStmt whileStmt) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToField assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(AssignToLocal assignLeftSide) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(SuperCall superCall) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(ExpressionReceiver expressionReceiver) {
+		// TODO Auto-generated method stub
+		
+	}
+
+	@Override
+	public void visit(UnaryExpr unaryExpr) {
+		unaryExpr.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(unaryExpr.getType()));
+		argListMethCall.remove(0);
+	}
+
+	@Override
+	public void visit(Literal literal) {
+		literal.accept(bytecodeGenMethod);
+		
+		if(argListMethCall.get(0))
+			bytecodeGenMethod.doUnboxing(bytecodeGenMethod.getResolvedType(literal.getType()));
+		argListMethCall.remove(0);
+	}
+
+}

src/de/dhbwstuttgart/bytecode/AssignStmt.java

@@ -0,0 +1,11 @@
+package de.dhbwstuttgart.bytecode;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class AssignStmt extends AStatement {
+	
+	public AssignStmt(Expression rightSide) {
+		super(rightSide);
+	}
+
+}

src/de/dhbwstuttgart/bytecode/BytecodeGen.java

@@ -1,7 +1,9 @@
 package de.dhbwstuttgart.bytecode;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;
@@ -9,11 +11,16 @@ import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.FieldVisitor;
 import org.objectweb.asm.MethodVisitor;
 import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
 
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorToString;
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
 import de.dhbwstuttgart.bytecode.signature.Signature;
+import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
 import de.dhbwstuttgart.bytecode.signature.TypeToString;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.Literal;
@@ -23,6 +30,9 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
+import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class BytecodeGen implements ASTVisitor {
@@ -30,12 +40,18 @@ public class BytecodeGen implements ASTVisitor {
 	ClassWriter cw =new ClassWriter(ClassWriter.COMPUTE_FRAMES|ClassWriter.COMPUTE_MAXS);
 	
 	String type;
-	
+
 	String className;
 	private boolean isInterface;
+	private List<ResultSet> listOfResultSets;
 	private ResultSet resultSet;
+	private SourceFile sf;
+	private String path;
+	
 	private int indexOfFirstParam = 0;
 	
+	private String superClass;
+	
 	// stores parameter, local vars and the next index on the local variable table, which use for aload_i, astore_i,...
 	HashMap<String, Integer> paramsAndLocals = new HashMap<>();
 	// stores generics and their bounds of class
@@ -43,20 +59,27 @@ public class BytecodeGen implements ASTVisitor {
 	// stores generics and their bounds of method
 	HashMap<String, String> genericsAndBoundsMethod = new HashMap<>();
 	
+	private final TPHExtractor tphExtractor = new TPHExtractor();
+	private final ArrayList<GenericInsertPair> commonPairs = new ArrayList<>();
+	
 	HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes = new HashMap<>();
 	byte[] bytecode;
 	HashMap<String,byte[]> classFiles;
 	
-	public BytecodeGen(HashMap<String,byte[]> classFiles, ResultSet resultSet) {
+	ArrayList<String> methodNameAndParamsT = new ArrayList<>();
+	
+	public BytecodeGen(HashMap<String,byte[]> classFiles, List<ResultSet> listOfResultSets,SourceFile sf ,String path) {
 		this.classFiles = classFiles;
-		this.resultSet = resultSet;
+		this.listOfResultSets = listOfResultSets;
+		this.sf = sf;
+		this.path = path;
 	}
 	
 	@Override
 	public void visit(SourceFile sourceFile) {
 		for(ClassOrInterface cl : sourceFile.getClasses()) {
 			System.out.println("in Class: " + cl.getClassName().toString());
-			BytecodeGen classGen = new BytecodeGen(classFiles, resultSet);
+			BytecodeGen classGen = new BytecodeGen(classFiles, listOfResultSets, sf, path);
 			cl.accept(classGen);
 			classGen.writeClass(cl.getClassName().toString());
 		}
@@ -81,6 +104,7 @@ public class BytecodeGen implements ASTVisitor {
 	
 	@Override
 	public void visit(ClassOrInterface classOrInterface) {
+		
 		className = classOrInterface.getClassName().toString();
 		
 		cw.visitSource(className +".jav", null);
@@ -88,30 +112,64 @@ public class BytecodeGen implements ASTVisitor {
 		isInterface = (classOrInterface.getModifiers()&512)==512;
 
 		int acc = isInterface?classOrInterface.getModifiers()+Opcodes.ACC_ABSTRACT:classOrInterface.getModifiers()+Opcodes.ACC_SUPER;
-		String sig = null;
-		/* if class has generics then creates signature
-		 * Signature looks like:
-		 * <E:Ljava/...>Superclass 
-		 */
-		if(classOrInterface.getGenerics().iterator().hasNext()) {
-			Signature signature = new Signature(classOrInterface, genericsAndBounds);
-			sig = signature.toString();
-		}
-		// needs implemented Interfaces?
-		cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
-				, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
 		
-		// for each field in the class
+		
-		for(Field f : classOrInterface.getFieldDecl()) {
+//		resultSet = listOfResultSets.get(0);
-			f.accept(this);
+		boolean isConsWithNoParamsVisited = false;
+		boolean isVisited = false;
+		for(ResultSet rs : listOfResultSets) {
+			superClass = classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor());
+			resultSet = rs;
+			// Nur einmal ausführen!!
+			if(!isVisited) {
+				classOrInterface.accept(tphExtractor);
+
+				getCommonTPHS(tphExtractor);
+
+				String sig = null;
+				/* if class has generics then creates signature
+				 * Signature looks like:
+				 * <E:Ljava/...>Superclass 
+				 */
+				if(classOrInterface.getGenerics().iterator().hasNext() || !commonPairs.isEmpty() || 
+						classOrInterface.getSuperClass().acceptTV(new TypeToSignature()).contains("<")) {
+					Signature signature = new Signature(classOrInterface, genericsAndBounds,commonPairs);
+					sig = signature.toString();
+					System.out.println("Signature: => " + sig);
+				}
+				
+				cw.visit(Opcodes.V1_8, acc, classOrInterface.getClassName().toString()
+						, sig, classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()), null);
+				
+				isVisited = true;
+			}
+			
+			for(Field f : classOrInterface.getFieldDecl()) {
+				f.accept(this);
+			}
+			
+			for(Constructor c : classOrInterface.getConstructors()) {
+				if(!isConsWithNoParamsVisited)
+					c.accept(this);
+				if(!c.getParameterList().iterator().hasNext())
+					isConsWithNoParamsVisited = true;
+			}
+			
+			for(Method m : classOrInterface.getMethods()) {
+				m.accept(this);
+			}
+		
 		}
 		
-		for(Constructor c : classOrInterface.getConstructors()) {
+	}
-			c.accept(this);
+
-		}
+	private void getCommonTPHS(TPHExtractor tphExtractor) {
-		
+		// Gemeinsame TPHs
-		for(Method m : classOrInterface.getMethods()) {
+		ArrayList<TypePlaceholder> cTPHs = new ArrayList<>();
-			m.accept(this);
+		// Alle TPHs der Felder speichern
+		for(TypePlaceholder tph : tphExtractor.allTPHS.keySet()) {
+			if(!tphExtractor.allTPHS.get(tph))
+				cTPHs.add(tph);
 		}
 	}
 
@@ -123,46 +181,67 @@ public class BytecodeGen implements ASTVisitor {
 		boolean hasGen = false;
 		
 		for(String paramName : methodParamsAndTypes.keySet()) {
-			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
+			String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
-			if(genericsAndBounds.containsKey(typeOfParam)) {
+			if(genericsAndBounds.containsKey(typeOfParam) ||typeOfParam.substring(0, 4).equals("TPH ")
+					|| typeOfParam.contains("<")) {
 				hasGen = true;
 				break;
 			}
 		}
 		String sig = null;
 		if(hasGen) {
-			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes);
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(field.name,tphExtractor.allPairs);
+			Signature signature = new Signature(field, genericsAndBounds,methodParamsAndTypes,resultSet,pairs);
 			sig = signature.toString();
 		}
 		NormalConstructor constructor = new NormalConstructor(field,genericsAndBounds,hasGen);
 		desc = constructor.accept(new DescriptorToString(resultSet));
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", desc, sig, null);
 		mv.visitCode();		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,field, mv,paramsAndLocals,cw,
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,field, mv,paramsAndLocals,cw,
-				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles);
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		if(!field.getParameterList().iterator().hasNext()) {
 			mv.visitInsn(Opcodes.RETURN);
 		}
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
-
+	
 	@Override
 	public void visit(Method method) {
 		// TODO: check if the method is static => if static then the first param will be stored in pos 0
 		// else it will be stored in pos 1 and this will be stored in pos 0
+		String retType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		String methParamTypes = retType+method.name+"%%";
 		method.getParameterList().accept(this);
 
+		Iterator<FormalParameter> itr = method.getParameterList().iterator();
+		while(itr.hasNext()) {
+			FormalParameter fp = itr.next();
+			methParamTypes += resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
+		}
+		
+		if(methodNameAndParamsT.contains(methParamTypes)) {
+			return;
+		}
+		methodNameAndParamsT.add(methParamTypes);
+		System.out.println("Method: "+method.name +" , paramsType: "+methParamTypes);
 		String methDesc = null;
 		
 		// Method getModifiers() ?
 		int acc = isInterface?Opcodes.ACC_ABSTRACT:method.modifier;
+		System.out.println(acc);
 		
-		boolean hasGenInParameterList = genericsAndBounds.containsKey(resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor()));
+		/*Prüfe, ob die Rückgabe-Type der Methode eine Type-Variable ist*/
+		boolean hasGenInParameterList = genericsAndBounds.containsKey(retType) || retType.subSequence(0, 4).equals("TPH ") ||
+										resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).contains("<");
+		/*Wenn die Rückgabe-Type eine Typ-variable ist, erzeuge direkt die Signature, wenn nicht,
+		 * prüfe, ob einer der Parameter Typ-Variable als Typ hat*/
 		if(!hasGenInParameterList) {
 			for(String paramName : methodParamsAndTypes.keySet()) {
 				String typeOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToDescriptor());
-				if(genericsAndBounds.containsKey(typeOfParam)) {
+				String sigOfParam = methodParamsAndTypes.get(paramName).acceptTV(new TypeToSignature());
+				if(genericsAndBounds.containsKey(typeOfParam)||typeOfParam.substring(0, 4).equals("TPH ")||sigOfParam.contains("<")) {
 					hasGenInParameterList = true;
 					break;
 				}
@@ -170,31 +249,126 @@ public class BytecodeGen implements ASTVisitor {
 		}
 		
 		//TODO: Test if the return-type or any of the parameter is a parameterized type. (VP)
-		//than create the descriptor with the new syntax.
+		//then create the descriptor with the new syntax.
 		
 		String sig = null;
+		/* method.getGenerics: <....> RT method(..) 
+		 * */
 		boolean hasGen = method.getGenerics().iterator().hasNext() || hasGenInParameterList;
-		
 		/* if method has generics or return type is TPH, create signature */
-		if(hasGen||method.getReturnType().acceptTV(new TypeToString()).equals("TPH")) {
+		// zwite operand muss weggelassen werden
-			// resultset hier zum testen 
+		if(hasGen||resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToString()).equals("TPH")) {
-			Signature signature = new Signature(method, genericsAndBoundsMethod, methodParamsAndTypes,resultSet);
+			ArrayList<GenericInsertPair> pairs = simplifyPairs(method.name,tphExtractor.allPairs);
+			System.out.println(method.name + " => Simplified Pairs: ");
+			pairs.forEach(p->System.out.println(p.TA1.getName() + " -> "+p.TA2.getName()));
+			Signature signature = new Signature(method, genericsAndBoundsMethod, genericsAndBounds,methodParamsAndTypes,resultSet, pairs);
 			sig = signature.toString();
 		}
-		System.out.println(sig);
+		System.out.println(method.getName()+" ==> "+sig);
 		NormalMethod meth = new NormalMethod(method,genericsAndBounds,genericsAndBoundsMethod,hasGen);
 		methDesc = meth.accept(new DescriptorToString(resultSet));
-		System.out.println(methDesc);
+		
+//		System.out.println(methDesc);
 		MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC+acc, method.getName(), methDesc, sig, null);
 
 		mv.visitCode();		
+		BytecodeGenMethod gen = new BytecodeGenMethod(className,superClass,resultSet,method, mv,paramsAndLocals,cw,
+				genericsAndBoundsMethod,genericsAndBounds,isInterface,classFiles, sf,path);
 		
-		BytecodeGenMethod gen = new BytecodeGenMethod(className,resultSet,method, mv,paramsAndLocals,cw,
-				genericsAndBounds,genericsAndBounds,isInterface,classFiles);
 		mv.visitMaxs(0, 0);
 		mv.visitEnd();
 	}
 	
+	private ArrayList<GenericInsertPair> simplifyPairs(String methodName, ArrayList<GenericInsertPair> allPairs) {
+		allPairs.forEach(p->System.out.print(p.TA1 + " < "+ p.TA2+ " ; "));
+		
+		if(allPairs.size() < 2)
+			return allPairs;
+		
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		MethodAndTPH method;
+		ArrayList<TypePlaceholder> methodTphs = new ArrayList<>();
+		ArrayList<GenericInsertPair> methodPairs = new ArrayList<>();
+		for(MethodAndTPH m : tphExtractor.ListOfMethodsAndTph) {
+			if(m.getName().equals(methodName)) {
+				methodTphs = m.getTphs();
+				methodPairs = m.getPairs();
+				break;
+			}
+		}
+
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			// Tph2.jav
+			if(subAndSuperTph.containsKey(p.TA1)) {
+				if(methodTphs.contains(subAndSuperTph.get(p.TA1)))
+					continue;
+			}
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			if(!methodTphs.contains(subTph))
+				continue;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(methodTphs.contains(tph) && subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				if(subTphRes.equals(tphsInRel.get(0))) {
+					break;
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			
+			int i = 2;
+			while(!methodTphs.contains(superTphRes) && (tphsInRel.size()-i) >0) {
+				superTphRes = tphsInRel.get(tphsInRel.size()-i);
+				i++;
+			}
+			// teste noch den Fall X < Y und Y nicht in TPHS der Methode
+			// 		 Dann hat man nach der While-Schleife X < Y
+			//		 Y muss durch Object ersetzt.
+			
+			// Zweite Operand für die Fälle wie in Lambda.jav (Paramtrisierte Typen) 
+			if(methodTphs.contains(superTphRes) || !tphExtractor.allTPHS.containsKey(superTphRes)) {
+				GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+				simplifiedPairs.add(sPair);
+			}
+		}
+		return simplifiedPairs;
+	}
+
 	@Override
 	public void visit(ParameterList formalParameters) {
 		paramsAndLocals = new HashMap<>();
@@ -436,5 +610,50 @@ public class BytecodeGen implements ASTVisitor {
 	public void visit(UnaryExpr unaryExpr) {
 		throw new NotImplementedException();
 	}
+	
+	private class TPHExtractor extends AbstractASTWalker{
+		// Alle TPHs der Felder werden iKopf der Klasse definiert
+		// alle TPHs der Klasse: (TPH, is in Method?)
+		final HashMap<TypePlaceholder,Boolean> allTPHS = new HashMap<>();
+		MethodAndTPH methodAndTph;
+		Boolean inMethod = false;
+		final ArrayList<MethodAndTPH> ListOfMethodsAndTph = new ArrayList<>();
+		final ArrayList<GenericInsertPair> allPairs = new ArrayList<>();
+		
+		@Override
+		public void visit(TypePlaceholder tph) {
+			if(resultSet.resolveType(tph).resolvedType instanceof TypePlaceholder) {
+				TypePlaceholder resolvedTPH = (TypePlaceholder) resultSet.resolveType(tph).resolvedType;
+				if(inMethod)
+					methodAndTph.getTphs().add(resolvedTPH);
+				
+				allTPHS.put(resolvedTPH,inMethod);
+				resultSet.resolveType(tph).additionalGenerics.forEach(ag ->{
+					if(ag.contains(resolvedTPH)&&ag.TA1.equals(resolvedTPH)&&!contains(allPairs,ag)) {
+						if(inMethod)
+							methodAndTph.getPairs().add(ag);
+						allPairs.add(ag);
+					}
+				});
+			}
+		}
+		private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+			for(int i=0; i<pairs.size();++i) {
+				GenericInsertPair p = pairs.get(i);
+				if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+					return true;
+			}
+			return false;
+		}
+		@Override
+		public void visit(Method method) {
+			inMethod = true;
+			methodAndTph = new MethodAndTPH(method.name);
+			super.visit(method);
+			inMethod = false;
+			ListOfMethodsAndTph.add(methodAndTph);
+		}
+		
+	}
 
 }

src/de/dhbwstuttgart/bytecode/IStatement.java

@@ -0,0 +1,9 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+
+public interface IStatement {
+	public boolean isExprBinary();
+	public void genBCForRelOp(MethodVisitor mv, Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod);
+}

src/de/dhbwstuttgart/bytecode/LoopStmt.java

@@ -0,0 +1,26 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+import de.dhbwstuttgart.syntaxtree.statement.Statement;
+
+public class LoopStmt extends AStatement {
+	
+    private Statement loopBlock;
+    
+    public LoopStmt(Expression expr, Statement loopBlock) {
+    		super(expr);
+    		this.loopBlock = loopBlock;
+    }
+
+	@Override
+	public void genBCForRelOp(MethodVisitor mv,Label branchLabel, Label endLabel, BytecodeGenMethod bytecodeGenMethod) {
+		bytecodeGenMethod.isBinary(false);
+		this.loopBlock.accept(bytecodeGenMethod);
+		mv.visitJumpInsn(Opcodes.GOTO, endLabel);
+		mv.visitLabel(branchLabel);
+	}
+}

src/de/dhbwstuttgart/bytecode/ReturnStmt.java

@@ -0,0 +1,14 @@
+package de.dhbwstuttgart.bytecode;
+
+import org.objectweb.asm.MethodVisitor;
+
+import de.dhbwstuttgart.syntaxtree.statement.BinaryExpr;
+import de.dhbwstuttgart.syntaxtree.statement.Expression;
+
+public class ReturnStmt extends AStatement {
+	
+	public ReturnStmt(Expression retexpr) {
+		super(retexpr);
+	}
+	
+}

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorToString.java

@@ -2,12 +2,14 @@ package de.dhbwstuttgart.bytecode.descriptor;
 
 import java.util.Iterator;
 
-import de.dhbwstuttgart.bytecode.Lambda;
+import org.objectweb.asm.Type;
-import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
+
-import de.dhbwstuttgart.bytecode.NormalConstructor;
-import de.dhbwstuttgart.bytecode.NormalMethod;
-import de.dhbwstuttgart.bytecode.SamMethod;
 import de.dhbwstuttgart.bytecode.signature.TypeToSignature;
+import de.dhbwstuttgart.bytecode.utilities.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
+import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 import de.dhbwstuttgart.syntaxtree.FormalParameter;
 import de.dhbwstuttgart.syntaxtree.statement.Expression;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
@@ -46,12 +48,20 @@ public class DescriptorToString implements DescriptorVisitor{
 				}else if(method.getGenericsAndBounds().containsKey(fpDesc)){
 					desc += "L"+method.getGenericsAndBounds().get(fpDesc)+ ";";
 				}else {
-					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+//					desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+					String resType = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+					if(resType.subSequence(0, 4).equals("TPH ")) {
+						// Bound ist immer Object
+						desc += "L"+Type.getInternalName(Object.class)+ ";";
+					} else {
+						desc += "L"+resType+ ";";
+					}
 				}
 			}
-//			else if(((RefType) fp.getType()).getParaList().size() > 0){
+			//TODO: generate a class java%% ... %%
-//				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "%").replace("<", "%%").replace(">", "%%")+ ";";
+			else if(resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()).contains("<")){
-//			}
+				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.toString().replace(".", "$$").replace("<", "$$$").replace(">", "$$$")+ ";";
+			}
 			else {
 				desc += "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
 			}
@@ -67,7 +77,13 @@ public class DescriptorToString implements DescriptorVisitor{
 				}else if(method.getGenericsAndBounds().containsKey(ret)){
 					desc += ")L"+method.getGenericsAndBounds().get(ret)+ ";";
 				}else {
-					desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+					String resType = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+					if(resType.subSequence(0, 4).equals("TPH ")) {
+//						desc += ")" + "L"+method.getGenericsAndBoundsMethod().get(resType.substring(4)+"$")+ ";";
+						desc += ")" + "L"+Type.getInternalName(Object.class)+ ";";
+					} else {
+						desc += ")" + "L"+resType+ ";";
+					}
 				}
 			}else {
 				desc += ")" + "L"+resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
@@ -107,9 +123,21 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<FormalParameter> itr = lambdaExpression.getParams().iterator();
 		while(itr.hasNext()) {
 			FormalParameter fp = itr.next();
-			desc = desc + "L"+resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor()) + ";";
+			String d = resultSet.resolveType(fp.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc = desc + "L"+ d + ";";
+			}
+		}
+		
+		String retType = resultSet.resolveType(lambdaExpression.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = addReturnType(desc, lambdaExpression.getReturnType(), resultSet);
 		return desc;
 	}
 
@@ -119,9 +147,22 @@ public class DescriptorToString implements DescriptorVisitor{
 		Iterator<RefTypeOrTPHOrWildcardOrGeneric> itr = samMethod.getArgumentList().iterator();
 		while(itr.hasNext()) {
 			RefTypeOrTPHOrWildcardOrGeneric rt = itr.next();
-			desc = desc + "L"+resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor())+";";
+			String d = resultSet.resolveType(rt).resolvedType.acceptTV(new TypeToDescriptor());
+			
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<")) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
+			}else {
+				desc += "L"+ d + ";";
+				
+			}
+		}
+		String retType = resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+		
+		if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
+		}else {
+			desc = desc + ")"+"L"+retType+";";
 		}
-		desc = desc + ")"+"L"+resultSet.resolveType(samMethod.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+";";
 		return desc;
 	}
 
@@ -129,26 +170,34 @@ public class DescriptorToString implements DescriptorVisitor{
 	public String visit(MethodFromMethodCall methodFromMethodCall) {
 		String desc = "(";
 		for(Expression e : methodFromMethodCall.getArgList().getArguments()) {
-			String d = e.getType().acceptTV(new TypeToDescriptor());
+			String d = resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
+			
-				desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
+			if(d.substring(0, 4).equals("TPH ") ||d.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")) {
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
+				desc += "L"+Type.getInternalName(Object.class)+ ";";
-				desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
 			}else {
-				desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(d)) {
+					desc += "L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(d)+ ";";
+				}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(d)) {
+					desc += "L"+methodFromMethodCall.getGenericsAndBounds().get(d)+ ";";
+				}else {
+					desc += "L"+resultSet.resolveType(e.getType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				}
 			}
+			
 		}
-		
+		String retType = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
-		if(resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.toString().equals("void")) {
+		System.out.println("DescriptorToString retType = " + retType);
+		if(retType.equals("void")) {
 			desc += ")V";
+		}else if(retType.substring(0, 4).equals("TPH ")|| retType.contains("<") || methodFromMethodCall.getReceiverName().contains("$$")){
+			desc += ")L"+Type.getInternalName(Object.class)+ ";";
 		}else {
-			String ret = resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor());
+			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(retType)) {
-			if(methodFromMethodCall.getGenericsAndBoundsMethod().containsKey(ret)) {
+				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(retType)+ ";";
-				desc += ")L"+methodFromMethodCall.getGenericsAndBoundsMethod().get(ret)+ ";";
+			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(retType)){
-			}else if(methodFromMethodCall.getGenericsAndBounds().containsKey(ret)){
+				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(retType)+ ";";
-				desc += ")L"+methodFromMethodCall.getGenericsAndBounds().get(ret)+ ";";
 			}else {
-				desc += ")" + "L"+resultSet.resolveType(methodFromMethodCall.getReturnType()).resolvedType.acceptTV(new TypeToDescriptor())+ ";";
+				desc += ")" + "L"+retType+ ";";
 			}
 		}
 //		desc = addReturnType(desc, methodFromMethodCall.getReturnType(), resultSet);

src/de/dhbwstuttgart/bytecode/descriptor/DescriptorVisitor.java

@@ -1,10 +1,10 @@
 package de.dhbwstuttgart.bytecode.descriptor;
 
-import de.dhbwstuttgart.bytecode.Lambda;
+import de.dhbwstuttgart.bytecode.utilities.Lambda;
-import de.dhbwstuttgart.bytecode.MethodFromMethodCall;
+import de.dhbwstuttgart.bytecode.utilities.MethodFromMethodCall;
-import de.dhbwstuttgart.bytecode.NormalConstructor;
+import de.dhbwstuttgart.bytecode.utilities.NormalConstructor;
-import de.dhbwstuttgart.bytecode.NormalMethod;
+import de.dhbwstuttgart.bytecode.utilities.NormalMethod;
-import de.dhbwstuttgart.bytecode.SamMethod;
+import de.dhbwstuttgart.bytecode.utilities.SamMethod;
 
 public interface DescriptorVisitor {
 	public String visit(NormalMethod method);

src/de/dhbwstuttgart/bytecode/descriptor/TypeToDescriptor.java

@@ -13,11 +13,15 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 	@Override
 	public String visit(RefType refType) {
 		return refType.getName().toString().replace(".", "/");
+//		String t = refType.getName().toString().replace(".", "/");
+//		return t.equals("Fun1")?(t+"$$"):t;
 	}
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		System.out.println("\nWILDCARD ="+superWildcardType.getInnerType().toString().replace(".", "/"));
+		return superWildcardType.getInnerType().toString().replace(".", "/");
+		//throw new NotImplementedException();
 	}
 
 	@Override
@@ -27,7 +31,9 @@ public class TypeToDescriptor implements TypeVisitor<String>{
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+		System.out.println("\nWILDCARD extends ="+extendsWildcardType.getInnerType().toString().replace(".", "/"));
+		return extendsWildcardType.getInnerType().toString().replace(".", "/");
+		//throw new NotImplementedException();
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/signature/Signature.java

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.bytecode.signature;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 
@@ -8,13 +9,19 @@ import org.objectweb.asm.signature.SignatureVisitor;
 import org.objectweb.asm.signature.SignatureWriter;
 
 import de.dhbwstuttgart.bytecode.descriptor.TypeToDescriptor;
+import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
+import de.dhbwstuttgart.syntaxtree.AbstractASTWalker;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Constructor;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
+import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+import de.dhbwstuttgart.typeinference.result.ResolvedType;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
 public class Signature {
@@ -26,28 +33,36 @@ public class Signature {
 	private Method method;
 	private HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes;
 	private ResultSet resultSet;
+	private ArrayList<GenericInsertPair> commonPairs;
+	private ArrayList<GenericInsertPair> methodPairs;
 	
-	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds) {
+	public Signature(ClassOrInterface classOrInterface, HashMap<String, String> genericsAndBounds,ArrayList<GenericInsertPair> commonPairs) {
 		this.classOrInterface = classOrInterface;
 		this.genericsAndBounds = genericsAndBounds;
+		this.commonPairs = commonPairs;
 		sw = new SignatureWriter();
 		createSignatureForClassOrInterface();
 	}
 
-	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes) {
+	public Signature(Constructor constructor, HashMap<String, String> genericsAndBounds, 
+			HashMap<String,RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes,ResultSet resultSet,ArrayList<GenericInsertPair> methodPairs) {
 		this.constructor = constructor;
 		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
+		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.constructor,true);
 	}
 
-	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,
+	public Signature(Method method, HashMap<String, String> genericsAndBoundsMethod,HashMap<String, String> genericsAndBounds,
-			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet) {
+			HashMap<String, RefTypeOrTPHOrWildcardOrGeneric> methodParamsAndTypes, ResultSet resultSet, ArrayList<GenericInsertPair> methodPairs) {
 		this.method = method;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
+		this.genericsAndBounds = genericsAndBounds;
 		this.methodParamsAndTypes = methodParamsAndTypes;
 		this.resultSet = resultSet;
+		this.methodPairs = methodPairs;
 		sw = new SignatureWriter();
 		createSignatureForConsOrMethod(this.method,false);
 	}
@@ -59,10 +74,7 @@ public class Signature {
 
 	private void createSignatureForFunN(LambdaExpression lambdaExpression, int numberOfParams) {
 		
-		sw.visitFormalTypeParameter("R");
+//		sw.visitClassBound().visitEnd();
-		// getBounds vom Return-Type
-		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
-		sw.visitClassBound().visitEnd();
 		for(int i = 0;i<numberOfParams;i++) {
 			int j = i+1;
 			sw.visitFormalTypeParameter("T"+ j);
@@ -70,6 +82,11 @@ public class Signature {
 			sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
 			sw.visitClassBound().visitEnd();
 		}
+
+		sw.visitFormalTypeParameter("R");
+		// getBounds vom Return-Type
+		sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+		sw.visitClassBound().visitEnd();
 		// TODO: prüfe ob Return-Type = void,
 		sw.visitSuperclass().visitClassType(Type.getInternalName(Object.class));;
 		sw.visitEnd();
@@ -90,13 +107,112 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBoundsMethod);
 		}
-		// visits each method-parameter to create the signature 
+		
+		// Wenn die RückgabeType eine TPH ist, wird als generic behandelt
+		// z.B: Type = TPH K => wird eine Formal Type Parameter K$ erzeugt und Bound = Object
+		if(!isConstructor) {
+			String ret = resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature());
+			System.out.println("RET:::: " + ret);
+			if(!ret.equals("V")) {
+				// TODO TypeToSignature nochmal kontrollieren und schauen ob man dort wirklich 
+				// T... braucht und L ...
+				if(ret.contains("$") && !ret.contains("$$")) {
+//					String g = ret.substring(4,ret.length())+"$";
+					if(genericsAndBounds.containsKey(ret)) {
+						genericsAndBoundsMethod.put(ret.substring(1), genericsAndBounds.get(ret.substring(1)));
+					}else {
+						sw.visitFormalTypeParameter(ret.substring(1));
+						sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+						genericsAndBoundsMethod.put(ret.substring(1), Type.getInternalName(Object.class));
+						sw.visitClassBound().visitEnd();
+					}
+				}
+				
+				if(ret.contains("<")) {
+					RefType ref = (RefType) resultSet.resolveType(method.getReturnType()).resolvedType;
+					if(hasTPHs(ref)) {
+						createSignatureForParameterizedType(ref);
+					}
+					
+				}
+			}
+		}
+		
+		// Parameters
+		for(String paramName : methodParamsAndTypes.keySet()) {
+			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
+			String pT = t.acceptTV(new TypeToSignature()); 
+			// S.o
+//			if(pT.substring(0,4).equals("TPH ")) {
+			if(t instanceof TypePlaceholder) {
+//				String gP = pT.substring(4,pT.length())+"$";
+				String gP = t.acceptTV(new TypeToSignature());
+				if(!genericsAndBounds.containsKey(gP.substring(1)) && !genericsAndBoundsMethod.containsKey(gP.substring(1))) {
+					sw.visitFormalTypeParameter(gP.substring(1));
+					String bound = Type.getInternalName(Object.class);
+					boolean isTypeVar = false;
+					for(GenericInsertPair pair : methodPairs) {
+						if(pT.substring(1,pT.length()-1).equals(pair.TA1.getName())) {
+							bound = pair.TA2.getName()+"$";
+							isTypeVar = true;
+							break;
+						}
+					}
+					
+					if(isTypeVar) {
+						sw.visitClassBound().visitTypeVariable(bound);
+					}else {
+						sw.visitClassBound().visitClassType(bound);
+						sw.visitClassBound().visitEnd();
+					}
+					
+					genericsAndBoundsMethod.put(gP.substring(1), bound);
+				}
+			}
+			
+			if(pT.contains("<")) {
+				RefType ref = (RefType) methodParamsAndTypes.get(paramName);
+				if(hasTPHs(ref))
+					createSignatureForParameterizedType(ref);
+			}
+			
+			for(GenericInsertPair p:methodPairs) {
+				String name = p.TA1.getName()+"$";
+				if(!genericsAndBoundsMethod.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitTypeVariable(p.TA2.getName()+"$");
+					genericsAndBoundsMethod.put(name, p.TA2.getName()+"$");
+				}
+			}
+			
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : methodPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : methodPairs) {
+				String name = p.TA2.getName()+"$";
+				if(!types.contains(p.TA2) && !genericsAndBoundsMethod.containsKey(name)) {
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBoundsMethod.put(name, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
+		
+		// visit each method-parameter to create the signature 
 		for(String paramName : methodParamsAndTypes.keySet()) {
 			RefTypeOrTPHOrWildcardOrGeneric t = methodParamsAndTypes.get(paramName);
 			// parameter type deswegen ist true
 			doVisitParamsOrReturn(t,true);
 		}
-		if(isConstructor) {
+		if(isConstructor || 
+				resultSet.resolveType(method.getReturnType()).resolvedType.acceptTV(new TypeToSignature()).equals("V")) {
 			sw.visitReturnType().visitBaseType('V');
 		}else {
 			RefTypeOrTPHOrWildcardOrGeneric returnType = method.getReturnType();
@@ -105,6 +221,146 @@ public class Signature {
 		}
 //		sw.visitEnd();
 	}
+	
+	private void createSignatureForParameterizedType(RefType ref) {
+		ArrayList<GenericInsertPair> allPairs = getAllPairs(ref);
+		allPairs.addAll(methodPairs);
+		ArrayList<GenericInsertPair> simplifiedPairs = simplifyPairs(allPairs);
+		
+		HashMap<String, String> names = new HashMap<>();
+		
+		for(GenericInsertPair pair : simplifiedPairs) {
+			if(ref.getParaList().contains(pair.TA1)) {
+				String sub = pair.TA1.getName()+"$";
+				String superT = pair.TA2.getName()+"$";
+				names.put(sub, superT);
+			}
+		}
+		
+		for(String sub : names.keySet()) {
+			if(!genericsAndBoundsMethod.containsKey(sub) && !genericsAndBounds.containsKey(sub)) {
+				sw.visitFormalTypeParameter(sub);
+				String bound = names.get(sub);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBoundsMethod.put(sub, bound);
+			}
+		}
+		
+		for(String superT : names.values()) {
+			if(!names.containsKey(superT)) {
+				if(!genericsAndBoundsMethod.containsKey(superT) && !genericsAndBounds.containsKey(superT)) {
+					sw.visitFormalTypeParameter(superT);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(superT, Type.getInternalName(Object.class));
+				}
+			}
+		}
+		
+		for(RefTypeOrTPHOrWildcardOrGeneric p: ref.getParaList()) {
+			if(p instanceof TypePlaceholder) {
+				String name = ((TypePlaceholder) p).getName() + "$";
+				if(!genericsAndBoundsMethod.containsKey(name) && !genericsAndBounds.containsKey(name)) {
+					sw.visitFormalTypeParameter(name);
+					sw.visitClassBound().visitClassType(Type.getInternalName(Object.class));
+					sw.visitClassBound().visitEnd();
+					genericsAndBoundsMethod.put(name, Type.getInternalName(Object.class));
+				}
+			}
+		}
+	}
+
+	private ArrayList<GenericInsertPair> getAllPairs(RefType ref) {
+		final ArrayList<GenericInsertPair> res = new ArrayList<>();
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			RefTypeOrTPHOrWildcardOrGeneric resolved = resultSet.resolveType(p).resolvedType;
+			if(resolved instanceof TypePlaceholder) {
+				resultSet.resolveType(p).additionalGenerics.forEach(ag ->{
+					if(!contains(res,ag)) {
+						res.add(ag);
+					}
+				});
+			}
+				
+		}
+		return res;
+	}
+	
+	private boolean contains(ArrayList<GenericInsertPair> pairs, GenericInsertPair genPair) {
+		for(int i=0; i<pairs.size();++i) {
+			GenericInsertPair p = pairs.get(i);
+			if(p.TA1.equals(genPair.TA1) && p.TA2.equals(genPair.TA2))
+				return true;
+		}
+		return false;
+	}
+	
+	private ArrayList<GenericInsertPair> simplifyPairs(ArrayList<GenericInsertPair> allPairs) {
+		ArrayList<GenericInsertPair> simplifiedPairs = new ArrayList<>();
+		
+		HashMap<TypePlaceholder, TypePlaceholder> subAndSuperTph = new HashMap<>();
+		for(GenericInsertPair p : allPairs) {
+			subAndSuperTph.put(p.TA1, p.TA2);
+		}
+		
+		subAndSuperTph.forEach((k,v)->System.out.println(k.getName() + " || " + v.getName()));
+		
+		int numOfVisitedPairs = 0;
+		for(TypePlaceholder subTph: subAndSuperTph.keySet()) {
+			
+			if(numOfVisitedPairs>=subAndSuperTph.size())
+				break;
+			
+			HashMap<Integer, TypePlaceholder> tphsInRel= new HashMap<>();
+			
+			tphsInRel.put(tphsInRel.size(), subTph);
+			TypePlaceholder superTph = subAndSuperTph.get(subTph);
+			tphsInRel.put(tphsInRel.size(), superTph);
+			
+			numOfVisitedPairs++;
+			
+			while(subAndSuperTph.containsKey(superTph)) {
+				superTph = subAndSuperTph.get(superTph);
+				tphsInRel.put(tphsInRel.size(), superTph);
+				numOfVisitedPairs++;
+			}
+			
+			// Subtype
+			TypePlaceholder subTphRes = tphsInRel.get(0);
+			// Die größte Supertype
+			TypePlaceholder superTphRes = tphsInRel.get(tphsInRel.size()-1);
+			
+			
+			while(subAndSuperTph.containsValue(subTphRes)) {
+				for(TypePlaceholder tph : subAndSuperTph.keySet()) {
+					if(subAndSuperTph.get(tph).equals(subTphRes)) {
+						subTphRes = tph;
+						break;
+					}
+				}
+				tphsInRel.put(0, subTphRes);
+				numOfVisitedPairs++;
+			}
+			
+			subTphRes = tphsInRel.get(0);
+			GenericInsertPair sPair = new GenericInsertPair(subTphRes, superTphRes);
+			simplifiedPairs.add(sPair);
+		}
+		return simplifiedPairs;
+	}
+	
+	private boolean hasTPHs(RefType ref) {
+		for(RefTypeOrTPHOrWildcardOrGeneric p : ref.getParaList()) {
+			System.out.println(p.acceptTV(new TypeToString()));
+			if(p.acceptTV(new TypeToString()).contains("WC")){
+				continue;
+			}
+			if(resultSet.resolveType(p).resolvedType instanceof TypePlaceholder)
+				return true;
+		}
+		return false;
+	}
+
 	/**
 	 * Visits parameter type or return type with {@link SignatureVisitor} to create
 	 * the method signature
@@ -122,18 +378,34 @@ public class Signature {
 		}
 		switch (type) {
 		case "RT":
-			sv.visitClassType(t.acceptTV(new TypeToSignature()));
+			String sig = t.acceptTV(new TypeToSignature());
+			sv.visitClassType(sig.substring(1, sig.length()));
 			break;
 		case "GRT":
 			GenericRefType g = (GenericRefType) t;
-			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()));
+			sv.visitTypeVariable(g.acceptTV(new TypeToSignature()).substring(1));
 			break;
 		case "TPH":
 			RefTypeOrTPHOrWildcardOrGeneric r = resultSet.resolveType(t).resolvedType;
-			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH "))
+			// der Fall wenn die Type eine Interface ist, muss betrachtet werden
-				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+			// Deswegen muss in ResutSet noch enthalten werden, ob die Type eine
-//			sv.visitClassType(r.acceptTV(new TypeToSignature()));
+			// Interface oder eine Klasse ist.
-			System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+			
+			// das braucht man nicht es reicht: sv.visitTypeVariable(r.acceptTV(new TypeToSignature())
+			// 
+//			if(!r.acceptTV(new TypeToSignature()).substring(0, 4).equals("TPH ")) {
+			String sig2 = r.acceptTV(new TypeToSignature());
+			if(!(r instanceof TypePlaceholder)) {
+				
+//				sv.visitInterface().visitClassType(r.acceptTV(new TypeToSignature()));
+//				sv.visitClassType(r.acceptTV(new TypeToSignature()));
+				sv.visitClassType(sig2.substring(1, sig2.length()));
+			} else {
+				System.out.println(r.getClass()+" Signature TPH: "+r.acceptTV(new TypeToSignature()));
+//				sv.visitTypeVariable(r.acceptTV(new TypeToSignature()).substring(4)+"$");
+				sv.visitTypeVariable(sig2.substring(1, sig2.length()));
+			}
+			
 			break;
 		default:
 			if(!isParameterType)
@@ -153,8 +425,36 @@ public class Signature {
 			GenericTypeVar g = itr.next();
 			getBoundsOfTypeVar(g,genericsAndBounds);
 		}
-		
+		if(!commonPairs.isEmpty()) {
-		sw.visitSuperclass().visitClassType(classOrInterface.getSuperClass().acceptTV(new TypeToDescriptor()));;
+			ArrayList<TypePlaceholder> types = new ArrayList<>();
+			ArrayList<TypePlaceholder> superTypes = new ArrayList<>();
+			
+			for(GenericInsertPair p : commonPairs) {
+				types.add(p.TA1);
+				superTypes.add(p.TA2);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				String t = p.TA1.getName()+"$";
+				String bound = p.TA2.getName()+"$";
+				sw.visitFormalTypeParameter(t);
+				sw.visitClassBound().visitTypeVariable(bound);
+				genericsAndBounds.put(t, bound);
+			}
+			
+			for(GenericInsertPair p : commonPairs) {
+				if(!types.contains(p.TA2)) {
+					String t = p.TA2.getName()+"$";
+					String bound = Type.getInternalName(Object.class);
+					sw.visitFormalTypeParameter(t);
+					sw.visitClassBound().visitClassType(bound);
+					genericsAndBounds.put(t, bound);
+					sw.visitClassBound().visitEnd();
+				}
+			}
+		}
+		String sClass = classOrInterface.getSuperClass().acceptTV(new TypeToSignature());
+		sw.visitSuperclass().visitClassType(sClass.substring(1, sClass.length()-1));
 		sw.visitEnd();
 	}
 	/**

src/de/dhbwstuttgart/bytecode/signature/TypeToSignature.java

@@ -15,6 +15,8 @@ public class TypeToSignature implements TypeVisitor<String> {
 
 	@Override
 	public String visit(RefType refType) {
+		if(refType.getName().toString().equals("void"))
+			return "V";
 //		return refType.toString().replace(".", "/");
 		String params = "";
         if(refType.getParaList().size()>0){
@@ -22,27 +24,41 @@ public class TypeToSignature implements TypeVisitor<String> {
             Iterator<RefTypeOrTPHOrWildcardOrGeneric> it = refType.getParaList().iterator();
             while(it.hasNext()){
                 RefTypeOrTPHOrWildcardOrGeneric param = it.next();
-                params += "L"+param.toString().replace(".", "/");
+//                if(param instanceof TypePlaceholder) {
-                if(it.hasNext())params += ";";
+//                	params += "T" + ((TypePlaceholder) param).getName() + "$";
+//                } else if(param instanceof ExtendsWildcardType) {
+//                	params += "+" + ((ExtendsWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
+//                } else if(param instanceof SuperWildcardType) {
+//                	params += "-" + ((SuperWildcardType) param).getInnerType().acceptTV(new TypeToSignature());
+//                } else {
+//                		params += "L"+param.toString().replace(".", "/");
+//                }
+                params += param.acceptTV(new TypeToSignature());
+//                if(it.hasNext())params += ";";
             }
-            params += ";>";
+            params += ">";
         }
-        return refType.getName().toString().replace(".", "/") + params+";";
+//        		String t = refType.getName().toString().replace(".", "/");
+//        		return t.equals("Fun1")?t+"$$"+params+";":t+params+";";
+        return "L"+refType.getName().toString().replace(".", "/") + params+";";
 	}
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
+		return "-" + superWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 
 	@Override
 	public String visit(TypePlaceholder typePlaceholder) {
-		return typePlaceholder.toString().replace(".", "/");
+//		return typePlaceholder.toString().replace(".", "/");
+		return "T" + typePlaceholder.getName() + "$";
 	}
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+//		throw new NotImplementedException();
+		return "+" + extendsWildcardType.getInnerType().acceptTV(new TypeToSignature());
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/signature/TypeToString.java

@@ -17,7 +17,7 @@ public class TypeToString implements TypeVisitor<String>{
 
 	@Override
 	public String visit(SuperWildcardType superWildcardType) {
-		throw new NotImplementedException();
+		return "SWC";
 	}
 
 	@Override
@@ -27,7 +27,7 @@ public class TypeToString implements TypeVisitor<String>{
 
 	@Override
 	public String visit(ExtendsWildcardType extendsWildcardType) {
-		throw new NotImplementedException();
+		return "EWC";
 	}
 
 	@Override

src/de/dhbwstuttgart/bytecode/utilities/KindOfLambda.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.statement.*;

src/de/dhbwstuttgart/bytecode/utilities/Lambda.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import de.dhbwstuttgart.bytecode.descriptor.DescriptorVisitor;
 import de.dhbwstuttgart.syntaxtree.ParameterList;

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

@@ -0,0 +1,29 @@
+package de.dhbwstuttgart.bytecode.utilities;
+
+import java.util.ArrayList;
+
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.typeinference.result.GenericInsertPair;
+
+public class MethodAndTPH {
+	
+	private String name;
+	private final ArrayList<TypePlaceholder> tphs = new ArrayList<>();
+	private final ArrayList<GenericInsertPair> pairs = new ArrayList<>();
+
+	public MethodAndTPH(String name) {
+		this.name = name;
+	}
+
+	public ArrayList<TypePlaceholder> getTphs() {
+		return tphs;
+	}
+	
+	public ArrayList<GenericInsertPair> getPairs(){
+		return pairs;
+	}
+	
+	public String getName() {
+		return name;
+	}
+}

src/de/dhbwstuttgart/bytecode/utilities/MethodFromMethodCall.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 
@@ -9,13 +9,16 @@ import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
 public class MethodFromMethodCall {
 	private ArgumentList argList;
 	private RefTypeOrTPHOrWildcardOrGeneric returnType;
+	private String receiverName;
 	private HashMap<String, String> genericsAndBoundsMethod;
 	private HashMap<String,String> genericsAndBounds;
 	
-	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType,
+	public MethodFromMethodCall(ArgumentList argList,RefTypeOrTPHOrWildcardOrGeneric returnType, 
-			HashMap<String, String> genericsAndBoundsMethod,HashMap<String,String> genericsAndBounds) {
+			String receiverName, HashMap<String, String> genericsAndBoundsMethod,
+			HashMap<String,String> genericsAndBounds) {
 		this.argList = argList;
 		this.returnType = returnType;
+		this.receiverName = receiverName;
 		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
 		this.genericsAndBounds = genericsAndBounds;
 	}
@@ -28,6 +31,10 @@ public class MethodFromMethodCall {
 		return returnType;
 	}
 	
+	public String getReceiverName() {
+		return receiverName;
+	}
+	
 	public HashMap<String, String> getGenericsAndBoundsMethod(){
 		return genericsAndBoundsMethod;
 	}

src/de/dhbwstuttgart/bytecode/utilities/NormalConstructor.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 

src/de/dhbwstuttgart/bytecode/utilities/NormalMethod.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.HashMap;
 

src/de/dhbwstuttgart/bytecode/utilities/SamMethod.java

@@ -1,4 +1,4 @@
-package de.dhbwstuttgart.bytecode;
+package de.dhbwstuttgart.bytecode.utilities;
 
 import java.util.List;
 

src/de/dhbwstuttgart/core/JavaTXCompiler.java

@@ -1,41 +1,58 @@
 package de.dhbwstuttgart.core;
 
 
+import de.dhbwstuttgart.bytecode.BytecodeGen;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 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.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.ParameterList;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
 import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.syntaxtree.visual.ASTTypePrinter;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 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.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.util.*;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class JavaTXCompiler {
-
+	final boolean parallel = true;
     final CompilationEnvironment environment;
     public final Map<File, SourceFile> sourceFiles = new HashMap<>();
+    Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
 
     public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
         this(Arrays.asList(sourceFile));
     }
 
+    public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
+    	this(sourceFile);
+    	this.log = log;
+    }
+    
     public JavaTXCompiler(List<File> sources) throws IOException, ClassNotFoundException {
         environment = new CompilationEnvironment(sources);
         for (File s : sources) {
@@ -94,20 +111,140 @@ public class JavaTXCompiler {
 
         TypeUnify unify = new TypeUnify();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        for (List<Constraint<UnifyPair>> xCons : unifyCons.cartesianProduct()) {
+        try {
-            Set<UnifyPair> xConsSet = new HashSet<>();
+			FileWriter logFile = new FileWriter(new File(System.getProperty("user.dir")+"/test/logFiles/"+"log"));
-            for (Constraint<UnifyPair> constraint : xCons) {
+			logFile.write("FC:\\" + finiteClosure.toString()+"\n");
-                xConsSet.addAll(constraint);
+			for(SourceFile sf : this.sourceFiles.values()) {
-            }
+				logFile.write(ASTTypePrinter.print(sf));
-
+			}
-            System.out.println(xConsSet);
+			logFile.flush();
-            Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+			Set<TypeUnifyTask> forks = new HashSet<>();
-            System.out.println("RESULT: " + result.size());
+			Set<List<Constraint<UnifyPair>>> cardProd = unifyCons.cartesianProduct(); 
-            results.addAll(result);
+			for (List<Constraint<UnifyPair>> xCons : cardProd ){
+				Set<UnifyPair> xConsSet = new HashSet<>();
+				for (Constraint<UnifyPair> constraint : xCons) {
+					xConsSet.addAll(constraint);
+				}
+				//.collect(Collectors.toCollection(ArrayList::new))))
+				System.out.println(xConsSet);
+				Set<String> paraTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
+						.stream().filter(z -> z.getType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
+				
+				Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
+						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
+				
+				
+				xConsSet = xConsSet.stream().map(x -> { 
+					//Hier muss ueberlegt werden, ob
+					//1. alle Argument- und Retuntyp-Variablen in allen UnifyPairs 
+					//   mit disableWildcardtable() werden.
+					//2. alle Typvariablen mit Argument- oder Retuntyp-Variablen 
+					//in Beziehung auch auf disableWildcardtable() gesetzt werden muessen
+					//PL 2018-04-23
+					if ((x.getLhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getLhsType().getName())) { 
+							((PlaceholderType)x.getLhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getLhsType().getName())) {
+							((PlaceholderType)x.getLhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getLhsType()).disableWildcardtable();
+						}
+					}
+					if ((x.getRhsType() instanceof PlaceholderType)) {
+						if (paraTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}
+						if (returnTypeVarNames.contains(x.getRhsType().getName())) {
+							((PlaceholderType)x.getRhsType()).setVariance((byte)-1);
+							((PlaceholderType)x.getRhsType()).disableWildcardtable();
+						}	
+					}
+					return x;//HIER DIE JEWEILS RECHT BZW. LINKE SEITE AUF GLEICHE VARIANZ SETZEN WIE DIE JEWEILS ANDERE SEITE 
+				}).map( y -> { 
+						if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) {
+							if (((PlaceholderType)y.getLhsType()).getVariance() != 0  && ((PlaceholderType)y.getRhsType()).getVariance() == 0) { 
+								((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType()).getVariance()); 
+							} 
+							if (((PlaceholderType)y.getLhsType()).getVariance() == 0  && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { 
+								((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType()).getVariance()); 
+							} 
+						}
+					return y; } )
+				.collect(Collectors.toCollection(HashSet::new));
+					varianceInheritance(xConsSet);
+					if (parallel) {
+						//Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+						Set<UnifyPair> eq = new HashSet<>(xConsSet);
+						TypeUnifyTask fork = new TypeUnifyTask(eq, finiteClosure, true, logFile, log);
+						forks.add(fork);
+						fork.fork();
+					}
+					else {
+						Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure, logFile, log);
+						System.out.println("RESULT: " + result);
+		    			logFile.write("RES: " + result.toString()+"\n");
+		    			logFile.flush();
+		    			results.addAll(result);
+					}
+			}
+			for (TypeUnifyTask fork : forks) {
+				try {
+					Set<Set<UnifyPair>> result = fork.join();
+					System.out.println("RESULT: " + result);
+					logFile.write("RES: " + result.toString()+"\n");
+					logFile.flush();
+					results.addAll(result);
+				}
+				catch (ConcurrentModificationException v) {
+					v.printStackTrace();
+					while (v.getCause() instanceof ConcurrentModificationException) {
+						v = (ConcurrentModificationException)v.getCause();
+					}
+					System.out.println(v);
+				}
+			}
         }
-        return results.stream().map((unifyPairs ->
+    	catch (IOException e) { }
-                new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
+			
-    }
+		return results.stream().map((unifyPairs ->
+               new ResultSet(UnifyTypeFactory.convert(unifyPairs, generateTPHMap(cons))))).collect(Collectors.toList());
+        }
+    
+    /**
+	 * Vererbt alle Variancen
+	 * @param eq The set of constraints
+	 */
+	private void varianceInheritance(Set<UnifyPair> eq) {
+		Set<PlaceholderType> usedTPH = new HashSet<>();
+		Set<PlaceholderType> phSet = eq.stream().map(x -> { 
+			Set<PlaceholderType> pair = new HashSet<>();
+			if (x.getLhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getLhsType());
+			if (x.getRhsType() instanceof PlaceholderType) pair.add((PlaceholderType)x.getRhsType());
+			return pair;
+		}).reduce(new HashSet<>(), (a,b) -> { a.addAll(b); return a;} , (c,d) -> { c.addAll(d); return c;});
+		
+		ArrayList<PlaceholderType> phSetVariance =  new ArrayList<>(phSet);
+		phSetVariance.removeIf(x -> (x.getVariance() == 0));
+		while(!phSetVariance.isEmpty()) {
+			PlaceholderType a = phSetVariance.remove(0);
+			usedTPH.add(a);
+			//HashMap<PlaceholderType,Integer> ht = new HashMap<>();
+			//ht.put(a, a.getVariance());
+			Set<UnifyPair> eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getLhsType() instanceof PlaceholderType && ((PlaceholderType)x.getLhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getRhsType().accept(new distributeVariance(), a.getVariance());});
+			eq1 = new HashSet<>(eq); 
+			eq1.removeIf(x -> !(x.getRhsType() instanceof PlaceholderType && ((PlaceholderType)x.getRhsType()).equals(a)));
+			eq1.stream().forEach(x -> { x.getLhsType().accept(new distributeVariance(), a.getVariance());});
+			phSetVariance =  new ArrayList<>(phSet);
+			phSetVariance.removeIf(x -> (x.getVariance() == 0 || usedTPH.contains(x)));
+		}		
+}
 
     private Map<String, TypePlaceholder> generateTPHMap(ConstraintSet<Pair> constraints) {
         HashMap<String, TypePlaceholder> ret = new HashMap<>();
@@ -129,5 +266,29 @@ public class JavaTXCompiler {
         SourceFile ret = generator.convert(tree, environment.packageCrawler);
         return ret;
     }
+    // um pfad erweitern
+    public void generateBytecode(String path) throws ClassNotFoundException, IOException {
+    		for(File f : sourceFiles.keySet()) {
+    			HashMap<String,byte[]> classFiles = new HashMap<>();
+    			SourceFile sf = sourceFiles.get(f);
+    			List<ResultSet> typeinferenceResult = this.typeInference();
+    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult,sf,path);
+//    			BytecodeGen bytecodeGen = new BytecodeGen(classFiles,typeinferenceResult.get(0));
+        		bytecodeGen.visit(sf);
+        		this.writeClassFile(bytecodeGen.getClassFiles(), path);
+    		}
+    }
 
-}
+	private void writeClassFile(HashMap<String, byte[]> classFiles, String path) throws IOException {
+		FileOutputStream output;
+		for(String name : classFiles.keySet()) {
+			byte[] bytecode = classFiles.get(name);
+			System.out.println("generating "+name+ ".class file ...");
+			//output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
+			output = new FileOutputStream(new File(path +name+".class"));
+			output.write(bytecode);
+			output.close();
+			System.out.println(name+".class file generated");
+		}
+	}
+}

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

@@ -832,7 +832,7 @@ public class StatementGenerator {
         }else if(literal.StringLiteral()!=null){
             RefType type = new RefType(reg.getName("java.lang.String"),literal.getStart());
             return new Literal(type,
-                    literal.StringLiteral().getText(),
+                    literal.StringLiteral().getText().substring(1,  literal.StringLiteral().getText().length()-1),
                     literal.getStart());
         }else  if(literal.NullLiteral() != null){
             return new Literal(TypePlaceholder.fresh(literal.getStart()), null,
@@ -904,7 +904,7 @@ public class StatementGenerator {
                 funNParams.add(TypePlaceholder.fresh(expression.getStart())));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         //RefType lambdaType = new RefType(reg.getName("Fun"+params.getFormalparalist().size()),
-                //funNParams, name.getStart());
+        		//funNParams, name.getStart());
         return new LambdaExpression(lambdaType, params, block, expression.getStart());
     }
 }

src/de/dhbwstuttgart/parser/SyntaxTreeGenerator/TypeGenerator.java

@@ -22,18 +22,20 @@ import java.util.List;
 public class TypeGenerator {
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(Java8Parser.UnannClassOrInterfaceTypeContext unannClassOrInterfaceTypeContext, JavaClassRegistry reg, GenericsRegistry generics) {
-        String name;
-        if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText();
-            }
         Java8Parser.TypeArgumentsContext arguments;
         if(unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().Identifier().getText();
             arguments = unannClassOrInterfaceTypeContext.unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }else{// if(unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType() != null){
-            name = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().getText();
             arguments = unannClassOrInterfaceTypeContext.unannInterfaceType_lfno_unannClassOrInterfaceType().unannClassType_lfno_unannClassOrInterfaceType().typeArguments();
         }
+        /**
+         * Problem sind hier die verschachtelten Typen mit verschachtelten Typargumenten
+         * Beispiel: Typ<String>.InnererTyp<Integer>
+         */
+        String name = unannClassOrInterfaceTypeContext.getText();
+        if(name.contains("<")){
+            name = name.split("<")[0]; //Der Typ ist alles vor den ersten Argumenten
+        }
         return convertTypeName(name, arguments, unannClassOrInterfaceTypeContext.getStart(), reg, generics);
     }
 
@@ -113,9 +115,7 @@ public class TypeGenerator {
         if(referenceTypeContext.classOrInterfaceType() != null){
             if(referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType()!= null){
                 Java8Parser.ClassType_lfno_classOrInterfaceTypeContext ctx = referenceTypeContext.classOrInterfaceType().classType_lfno_classOrInterfaceType();
-                //return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
+                return convertTypeName(ctx.Identifier().toString(), ctx.typeArguments(),referenceTypeContext.getStart(), reg, generics);
-                if(ctx.typeArguments() != null)throw new NotImplementedException();
-                return convertTypeName(referenceTypeContext.getText(), null,referenceTypeContext.getStart(), reg, generics);
             }else{
                 throw new NotImplementedException();
             }

src/de/dhbwstuttgart/syntaxtree/ClassOrInterface.java

@@ -106,4 +106,8 @@ public class ClassOrInterface extends SyntaxTreeNode implements TypeScope{
   public Collection<RefType> getSuperInterfaces() {
     return implementedInterfaces;
   }
+  
+  public String toString() {
+	  return this.name.toString() + this.genericClassParameters.toString();
+  }
 }

src/de/dhbwstuttgart/syntaxtree/GenericDeclarationList.java

@@ -31,4 +31,8 @@ public class GenericDeclarationList extends SyntaxTreeNode implements Iterable<G
 	public void accept(ASTVisitor visitor) {
 		visitor.visit(this);
 	}
+	
+	public String toString() {
+		return this.gtvs.toString();
+	}
 }

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

@@ -26,6 +26,8 @@ import de.dhbwstuttgart.typeinference.result.ResultPair;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 
 public class UnifyTypeFactory {
+	
+	private static ArrayList<PlaceholderType> PLACEHOLDERS = new ArrayList<>(); 
 
     public static FiniteClosure generateFC(List<ClassOrInterface> fromClasses) throws ClassNotFoundException {
         /*
@@ -49,6 +51,10 @@ public class UnifyTypeFactory {
         return new UnifyPair(tl, tr, PairOperator.SMALLERDOT);
     }
 
+    public static UnifyPair generateSmallNotEqualDotPair(UnifyType tl, UnifyType tr){
+        return new UnifyPair(tl, tr, PairOperator.SMALLERNEQDOT);
+    }
+    
     public static UnifyPair generateEqualDotPair(UnifyType tl, UnifyType tr){
         return new UnifyPair(tl, tr, PairOperator.EQUALSDOT);
     }
@@ -113,7 +119,15 @@ public class UnifyTypeFactory {
     }
 
     public static UnifyType convert(TypePlaceholder tph){
-        return new PlaceholderType(tph.getName());
+    	PlaceholderType ntph = new PlaceholderType(tph.getName());
+    	int in = PLACEHOLDERS.indexOf(ntph);
+		if (in == -1) {
+			PLACEHOLDERS.add(ntph);
+			return ntph;
+		}
+		else {
+			return PLACEHOLDERS.get(in);
+		}
     }
 
     public static UnifyType convert(GenericRefType t){
@@ -142,6 +156,10 @@ public class UnifyTypeFactory {
             UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
+        }else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
+            UnifyPair ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(p.TA1)
+                    , UnifyTypeFactory.convert(p.TA2));
+            return ret;
         }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
             UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
@@ -180,7 +198,9 @@ public class UnifyTypeFactory {
             }else if(tr instanceof WildcardType){
                 return new PairTPHequalRefTypeOrWildcardType((TypePlaceholder)tl, (WildcardType) tr);
             }else throw new NotImplementedException();
-        }else throw new NotImplementedException();
+        }else { 
+        	throw new NotImplementedException();
+        }
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(ReferenceType t, Map<String,TypePlaceholder> tphs) {
@@ -190,7 +210,7 @@ public class UnifyTypeFactory {
     }
 
     public static RefTypeOrTPHOrWildcardOrGeneric convert(FunNType t, Map<String,TypePlaceholder> tphs) {
-        RefType ret = new RefType(new JavaClassName(t.getName()), convert(t.getTypeParams(), tphs), new NullToken());
+        RefType ret = new RefType(new JavaClassName(t.getName()+"$$"), convert(t.getTypeParams(), tphs), new NullToken());
         return ret;
     }
 

src/de/dhbwstuttgart/syntaxtree/type/FunN.java

@@ -24,7 +24,7 @@ public class FunN extends RefType {
 	 * @return
 	 */
 	public FunN(List<RefTypeOrTPHOrWildcardOrGeneric> params) {
-		super(new JavaClassName("Fun"+params.size()), params, new NullToken());
+		super(new JavaClassName("Fun"+(params.size())), params, new NullToken());
 	}
 
 	/**

src/de/dhbwstuttgart/typeinference/assumptions/FunNClass.java

@@ -8,32 +8,36 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+
 import org.antlr.v4.runtime.Token;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class FunNClass extends ClassOrInterface {
-    public FunNClass(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    public FunNClass(List<GenericRefType> funNParams) {
-        super(0, new JavaClassName("Fun"+(funNParams.size()-1)), new ArrayList<>(),
+        super(0, new JavaClassName("Fun"+(funNParams.size())), new ArrayList<>(),
                 createMethods(funNParams), new ArrayList<>(), createGenerics(funNParams),
                 ASTFactory.createObjectType(), true, new ArrayList<>(), new NullToken());
 
 
         }
 
-    private static GenericDeclarationList createGenerics(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static GenericDeclarationList createGenerics(List<GenericRefType> funNParams) {
+    	//PL 2018-06-22: so geaendert, dass generierte Generics den Namen der funParams entsprechen.
         List<GenericTypeVar> generics = new ArrayList<>();
-        for(RefTypeOrTPHOrWildcardOrGeneric param : funNParams){
+        for(GenericRefType param : funNParams){
-            generics.add(new GenericTypeVar(NameGenerator.makeNewName(),
+            generics.add(new GenericTypeVar(param.getParsedName(),//NameGenerator.makeNewName(),
                     new ArrayList<>(), new NullToken(), new NullToken()));
         }
         return new GenericDeclarationList(generics, new NullToken());
     }
 
-    private static List<Method> createMethods(List<RefTypeOrTPHOrWildcardOrGeneric> funNParams) {
+    private static List<Method> createMethods(List<GenericRefType> funNParams) {
         return null;
     }
 }

src/de/dhbwstuttgart/typeinference/assumptions/MethodAssumption.java

@@ -16,10 +16,10 @@ import java.util.List;
 public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
-    List<RefTypeOrTPHOrWildcardOrGeneric> params;
+    List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -38,7 +38,9 @@ public class MethodAssumption extends Assumption{
     }
 
     public RefTypeOrTPHOrWildcardOrGeneric getReturnType(GenericsResolver resolver) {
-        if(retType instanceof GenericRefType)return resolver.resolve(retType);
+        if(retType instanceof GenericRefType) {
+        	return resolver.resolve(retType);
+        }
         return retType;
     }
 

src/de/dhbwstuttgart/typeinference/constraints/Pair.java

@@ -11,6 +11,7 @@ public class Pair implements Serializable
     public final RefTypeOrTPHOrWildcardOrGeneric TA2;
 
     private PairOperator eOperator = PairOperator.SMALLER;
+    
 
     public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2 )
     {
@@ -41,14 +42,16 @@ public class Pair implements Serializable
         if( TA2 != null )
            strElement2 = TA2.toString();
         
+       /* PL ausskommentiert 2018-05-24
         if(OperatorEqual())
         	Operator = "=";
         if(OperatorSmaller())
         	Operator = "<.";
         if(OperatorSmallerExtends())
         	Operator = "<?";
+        	*/
         
-        return "\n(" + strElement1 + " " + Operator + " " + strElement2 + ")";
+        return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
         
        /*- Equals: " + bEqual*/
     }

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

@@ -6,6 +6,7 @@ import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.AssignToLocal;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
@@ -57,8 +58,8 @@ public class TYPEStmt implements StatementVisitor{
     public void visit(LambdaExpression lambdaExpression) {
         TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
-        //lambdaParams.add(tphRetType);
+        lambdaParams.add(tphRetType);
-        lambdaParams.add(0,tphRetType);
+        //lambdaParams.add(0,tphRetType);
         constraintsSet.addUndConstraint(
                 new Pair(lambdaExpression.getType(),
                         new FunN(lambdaParams),PairOperator.EQUALSDOT));
@@ -185,6 +186,12 @@ public class TYPEStmt implements StatementVisitor{
     }
 
     private final RefType number = new RefType(ASTFactory.createClass(Number.class).getClassName(), new NullToken());
+    private final RefType longg = new RefType(ASTFactory.createClass(Long.class).getClassName(), new NullToken());
+    private final RefType integer = new RefType(ASTFactory.createClass(Integer.class).getClassName(), new NullToken());
+    private final RefType shortt = new RefType(ASTFactory.createClass(Short.class).getClassName(), new NullToken());
+    private final RefType bytee = new RefType(ASTFactory.createClass(Byte.class).getClassName(), new NullToken());
+    private final RefType floatt = new RefType(ASTFactory.createClass(Float.class).getClassName(), new NullToken());
+    private final RefType doublee = new RefType(ASTFactory.createClass(Double.class).getClassName(), new NullToken());
     private final RefType string = new RefType(ASTFactory.createClass(String.class).getClassName(), new NullToken());
     private final RefType bool =  new RefType(ASTFactory.createClass(Boolean.class).getClassName(), new NullToken());
     @Override
@@ -195,7 +202,7 @@ public class TYPEStmt implements StatementVisitor{
                 unaryExpr.operation == UnaryExpr.Operation.PREINCREMENT){
             //@see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.14.2
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERDOT));
+            constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), number, PairOperator.SMALLERNEQDOT));
             //The type of the postfix increment expression is the type of the variable
             constraintsSet.addUndConstraint(new Pair(unaryExpr.expr.getType(), unaryExpr.getType(), PairOperator.EQUALSDOT));
         }else{
@@ -205,42 +212,140 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(BinaryExpr binary) {
-
+    		binary.lexpr.accept(this);
+    		binary.rexpr.accept(this);
         if(binary.operation.equals(BinaryExpr.Operator.DIV) ||
                 binary.operation.equals(BinaryExpr.Operator.MUL)||
                 binary.operation.equals(BinaryExpr.Operator.MOD)||
                 binary.operation.equals(BinaryExpr.Operator.ADD)){
-            Set<Constraint> numericAdditionOrStringConcatenation = new HashSet<>();
+            Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
-            Constraint<Pair> numeric = new Constraint<>();
+            
             //Zuerst der Fall für Numerische AusdrücPairOpnumericeratorke, das sind Mul, Mod und Div immer:
             //see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             //Expression muss zu Numeric Convertierbar sein. also von Numeric erben
-            numeric.add(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
+            Constraint<Pair> numeric;
-            numeric.add(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+                numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), integer, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), longg, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), floatt, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            //PL eingefuegt 2018-07-17
+            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            	numeric = new Constraint<>();
+            	numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            	numeric.add(new Pair(binary.getType(), doublee, PairOperator.SMALLERDOT));
+            	numericAdditionOrStringConcatenation.add(numeric);
+            }
+            /* PL auskommentiert Anfang 2018-07-17
             /*
             In Java passiert bei den binären Operatoren eine sogenannte Type Promotion:
             https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2
             Das bedeutet, dass Java die Typen je nach belieben castet, so lange sie nur von Number erben
-             */
+             
+            numeric = new Constraint<>();
             numeric.add(new Pair(binary.getType(), number, PairOperator.SMALLERDOT));
             numericAdditionOrStringConcatenation.add(numeric);
+            * PL auskommentiert Ende 2018-07-17 */
+            
             if(binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 //Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                Constraint<Pair> stringConcat = new Constraint<>();
+            	if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
-                stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT));
+            		Constraint<Pair> stringConcat = new Constraint<>();
-                stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT));
+            		stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT));
-                stringConcat.add(new Pair(binary.getType(), string, PairOperator.EQUALSDOT));
+            		stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT));
-                numericAdditionOrStringConcatenation.add(stringConcat);
+            		stringConcat.add(new Pair(binary.getType(), string, PairOperator.EQUALSDOT));
+            		numericAdditionOrStringConcatenation.add(stringConcat);
+            	}
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
         }else if(binary.operation.equals(BinaryExpr.Operator.LESSEQUAL) ||
                 binary.operation.equals(BinaryExpr.Operator.BIGGEREQUAL) ||
                 binary.operation.equals(BinaryExpr.Operator.BIGGERTHAN) ||
                 binary.operation.equals(BinaryExpr.Operator.LESSTHAN)){
-            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
+  /*      	//eingefuegt PL 2018-05-24
-            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+        	Set<Constraint<Pair>> numericRelationConcatenation = new HashSet<>();
+        	Constraint<Pair> numeric = new Constraint<>();
+        	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            numeric = new Constraint<>();
+            numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT));
+            numeric.add(new Pair(binary.getType(), bool, PairOperator.SMALLERDOT));
+            numericRelationConcatenation.add(numeric);
+            
+            //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
+            constraintsSet.addOderConstraint(numericRelationConcatenation);
+            //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
+    */        
+            //Testeise eingefuegt PL 2018-05-24
+            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERNEQDOT));
+            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERNEQDOT));
             //Rückgabetyp ist Boolean
-            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
+        	
+            //auskommentiert PL 2018-05-24
+            //constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
+            //constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
+            //Rückgabetyp ist Boolean
+            //constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.EQUALSDOT));
         }else{
                 throw new NotImplementedException();
         }
@@ -248,7 +353,16 @@ public class TYPEStmt implements StatementVisitor{
 
     @Override
     public void visit(Literal literal) {
-        //Nothing to do here. Literale erzeugen keine Constraints
+        //Nothing to do here. Literale erzeugen keine Constraints 
+    	//PL 2018-06-23 Sie haben einen Typ. Der muesste hier eingefuegt werden
+    	//wie hier fuer double gezeigt. Im Momment auskommentiert, weil zu wenige Literaltypen
+    	//funktionieren
+    	//if (literal.value instanceof Double) {
+    	//	constraintsSet.addUndConstraint(new Pair(literal.getType(), doublee, PairOperator.EQUALSDOT));
+    	//}
+    	//else {
+    	//	throw new NotImplementedException();
+    	//}
     }
 
     @Override
@@ -372,11 +486,14 @@ public class TYPEStmt implements StatementVisitor{
         List<MethodAssumption> ret = new ArrayList<>();
         //TODO: apply Methoden wieder anfügen. Diese könnten möglicherweise auch in den Assumptions auftauchen (überdenken)
         if(name.equals("apply")){
-            List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
+            List<GenericRefType> funNParams = new ArrayList<>();
             for(int i = 0; i< numArgs + 1 ; i++){
-                funNParams.add(TypePlaceholder.fresh(new NullToken()));
+                //funNParams.add(TypePlaceholder.fresh(new NullToken()));
+            	funNParams.add(new GenericRefType(NameGenerator.makeNewName(),
+                        new NullToken()));
             }
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(0), funNParams.subList(1, funNParams.size()),
+            funNParams.get(funNParams.size()-1);
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size()-1), funNParams.subList(0, funNParams.size()-1),
                     new TypeScope() {
                         @Override
                         public Iterable<? extends GenericTypeVar> getGenerics() {
@@ -419,7 +536,7 @@ public class TYPEStmt implements StatementVisitor{
          */
         List<RefTypeOrTPHOrWildcardOrGeneric> params = new ArrayList<>();
         for(FormalParameter fp : parameterList.getFormalparalist()){
-            params.add(info.checkGTV(fp.getType()));
+            params.add(fp.getType()); //info.checkGTV(fp.getType())); //PL 2018-06-22 GTV sollen in Argumenten erhalten bleiben
         }
         return params;
     }

src/de/dhbwstuttgart/typeinference/unify/MartelliMontanariUnify.java

@@ -94,7 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			if(lhsType instanceof PlaceholderType) {
 				mgu.add((PlaceholderType) lhsType, rhsType);
-				termsList = termsList.stream().map(mgu::apply).collect(Collectors.toCollection(ArrayList::new));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen. 
+				termsList = termsList.stream().map(x -> mgu.apply(x)).collect(Collectors.toCollection(ArrayList::new));
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}

src/de/dhbwstuttgart/typeinference/unify/RuleSet.java

@@ -24,13 +24,27 @@ import de.dhbwstuttgart.typeinference.unify.model.Unifier;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
+
+import java.io.FileWriter;
+import java.io.IOException;
 
 /**
  * Implementation of the type inference rules.
  * @author Florian Steurer
  *
  */
-public class RuleSet implements IRuleSet{	
+public class RuleSet implements IRuleSet{
+	
+	FileWriter logFile;
+	
+	RuleSet() {
+		super();
+	}
+	
+	RuleSet(FileWriter logFile) {
+		this.logFile = logFile;
+	}
 	
 	@Override
 	public Optional<UnifyPair> reduceUp(UnifyPair pair) {
@@ -47,7 +61,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		// Rule is applicable, unpack the SuperType 
-		return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(lhsType, ((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -65,7 +79,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 
 		// Rule is applicable, unpack the ExtendsType
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), rhsType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -83,7 +97,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		// Rule is applicable, unpack both sides
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(),((SuperType) rhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -117,7 +131,7 @@ public class RuleSet implements IRuleSet{
 		if(x instanceof ExtendsType)
 			xFromFc = new ExtendsType(xFromFc);
 		
-		UnifyType extYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		UnifyType extYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(extY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
 		
 		if(extYFromFc == null || extYFromFc.getTypeParams() != xFromFc.getTypeParams())
 			return Optional.empty();
@@ -133,7 +147,7 @@ public class RuleSet implements IRuleSet{
 		Set<UnifyPair> result = new HashSet<>();
 		
 		for(int rhsIdx = 0; rhsIdx < extYParams.size(); rhsIdx++)
-			result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(xParams.get(pi[rhsIdx]), extYParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -169,7 +183,7 @@ public class RuleSet implements IRuleSet{
 		if(x instanceof SuperType)
 			xFromFc = new SuperType(xFromFc);
 		
-		UnifyType supYFromFc = fc.grArg(xFromFc).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
+		UnifyType supYFromFc = fc.grArg(xFromFc, new HashSet<>()).stream().filter(t -> t.getName().equals(supY.getName())).filter(t -> t.getTypeParams().arePlaceholders()).findAny().orElse(null);
 		
 		if(supYFromFc == null || supYFromFc.getTypeParams() != xFromFc.getTypeParams())
 			return Optional.empty();
@@ -184,7 +198,7 @@ public class RuleSet implements IRuleSet{
 			return Optional.empty();
 		
 		for(int rhsIdx = 0; rhsIdx < supYParams.size(); rhsIdx++)
-			result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(supYParams.get(rhsIdx), xParams.get(pi[rhsIdx]), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -215,7 +229,7 @@ public class RuleSet implements IRuleSet{
 		TypeParams rhsTypeParams = rhsType.getTypeParams();
 		
 		for(int i = 0; i < lhsTypeParams.size(); i++)
-			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -236,19 +250,53 @@ public class RuleSet implements IRuleSet{
 		ReferenceType lhsSType = (ReferenceType) c;
 		ReferenceType rhsSType = (ReferenceType) d;
 		
+		//try {
+		//	logFile.write("PAIR Rules: " + pair + "\n");
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
 		if(lhsSType.getTypeParams().empty() || lhsSType.getTypeParams().size() != rhsSType.getTypeParams().size())
 			return Optional.empty();
 		
 		UnifyType cFromFc = fc.getLeftHandedType(c.getName()).orElse(null);
+		//2018-02-23: liefert Vector<Vector<Integer>>: Das kann nicht sein.
+		
+		//NOCHMAL UEBERPRUEFEN
+		//PL 18-02-09 Eingfuegt Anfang
+		//C und D koennen auch gleich sein.
+		if (c.getName().equals(d.getName())) {
+			Set<UnifyPair> result = new HashSet<>();
+			TypeParams rhsTypeParams = d.getTypeParams();
+			TypeParams lhsTypeParams = c.getTypeParams();
+			for(int rhsIdx = 0; rhsIdx < c.getTypeParams().size(); rhsIdx++)
+				result.add(new UnifyPair(lhsTypeParams.get(rhsIdx), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
+		
+			return Optional.of(result);
+		}
+		//PL 18-02-09 Eingfuegt ENDE
+		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
 		
 		if(cFromFc == null || !cFromFc.getTypeParams().arePlaceholders())
 			return Optional.empty();
 		
 		UnifyType dFromFc = fc.getAncestors(cFromFc).stream().filter(x -> x.getName().equals(d.getName())).findAny().orElse(null);
 		
+		//try {
+		//	logFile.write("cFromFc: " + cFromFc);
+		//	logFile.flush();
+		//}
+		//catch (IOException e) { }
+		
 		if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
 			return Optional.empty();
-		
+		//System.out.println("cFromFc: " + cFromFc);
+		//System.out.println("dFromFc: " + dFromFc);
 		int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
 		
 		if(pi.length == 0)
@@ -259,7 +307,7 @@ public class RuleSet implements IRuleSet{
 		Set<UnifyPair> result = new HashSet<>();
 		
 		for(int rhsIdx = 0; rhsIdx < rhsTypeParams.size(); rhsIdx++)
-			result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC));
+			result.add(new UnifyPair(lhsTypeParams.get(pi[rhsIdx]), rhsTypeParams.get(rhsIdx), PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
@@ -314,16 +362,31 @@ public class RuleSet implements IRuleSet{
 		TypeParams rhsTypeParams = rhsSType.getTypeParams();
 		TypeParams lhsTypeParams = lhsSType.getTypeParams();
 		for(int i = 0; i < rhsTypeParams.size(); i++)
-			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(lhsTypeParams.get(i), rhsTypeParams.get(i), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		return Optional.of(result);
 	}
 
 	@Override
 	public boolean erase1(UnifyPair pair, IFiniteClosure fc) {
-		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+		if((pair.getPairOp() != PairOperator.SMALLERDOT) && (pair.getPairOp() != PairOperator.SMALLERNEQDOT))
 			return false;
 		
+		if (pair.getPairOp() == PairOperator.SMALLERNEQDOT) {
+			UnifyType lhs = pair.getLhsType();
+			UnifyType rhs = pair.getRhsType();
+			if (lhs instanceof WildcardType) {
+				lhs = ((WildcardType)lhs).getWildcardedType();
+			}
+			if (rhs instanceof WildcardType) {
+				rhs = ((WildcardType)rhs).getWildcardedType();
+			}
+		
+			if	(lhs.equals(rhs)){
+				return false;
+			}
+		}
+		
 		UnifyType lhsType = pair.getLhsType();
 		if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
 			return false;
@@ -332,7 +395,7 @@ public class RuleSet implements IRuleSet{
 		if(!(rhsType instanceof ReferenceType) && !(rhsType instanceof PlaceholderType))
 			return false;
 		
-		return fc.greater(lhsType).contains(rhsType);
+		return fc.greater(lhsType, new HashSet<>()).contains(rhsType);
 	}
 
 	@Override
@@ -343,7 +406,7 @@ public class RuleSet implements IRuleSet{
 		UnifyType lhsType = pair.getLhsType();		
 		UnifyType rhsType = pair.getRhsType();
 		
-		return fc.grArg(lhsType).contains(rhsType);
+		return fc.grArg(lhsType, new HashSet<>()).contains(rhsType);
 	}
 
 	@Override
@@ -365,7 +428,7 @@ public class RuleSet implements IRuleSet{
 		if(!(pair.getRhsType() instanceof PlaceholderType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT));
+		return Optional.of(new UnifyPair(pair.getRhsType(), pair.getLhsType(), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -407,11 +470,19 @@ public class RuleSet implements IRuleSet{
 		TypeParams typeDParams = typeD.getTypeParams();
 		TypeParams typeDgenParams = typeDgen.getTypeParams();
 		
+		//System.out.println("Pair: " +pair);
+		//System.out.println("typeD: " +typeD);
+		//System.out.println("typeDParams: " +typeDParams);
+		//System.out.println("typeDgen: " +typeD);
+		//System.out.println("typeDgenParams: " +typeDgenParams);
 		Unifier unif = Unifier.identity();
-		for(int i = 0; i < typeDParams.size(); i++) 
+		for(int i = 0; i < typeDParams.size(); i++) { 
+			//System.out.println("ADAPT" +typeDgenParams);
+			if (typeDgenParams.get(i) instanceof PlaceholderType) 
 			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
-		
+			else System.out.println("ERROR");
-		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT));
+		}
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -441,7 +512,7 @@ public class RuleSet implements IRuleSet{
 		if(typeDgen == null)
 			return Optional.empty();
 		
-		Set<UnifyType> grArg = fc.grArg(typeDgen);
+		Set<UnifyType> grArg = fc.grArg(typeDgen, new HashSet<>());
 		
 		Optional<UnifyType> opt = grArg.stream().filter(x -> x.getName().equals(typeExtDs.getName())).findAny();
 
@@ -457,7 +528,7 @@ public class RuleSet implements IRuleSet{
 		for(int i = 1; i < typeDParams.size(); i++) 
 			unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
 		
-		return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(unif.apply(newLhs), typeExtDs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -487,7 +558,7 @@ public class RuleSet implements IRuleSet{
 
 		// Use of smArg instead of grArg because
 		// a in grArg(b) => b in smArg(a)
-		Set<UnifyType> smArg = fc.smArg(typeSupDgen);
+		Set<UnifyType> smArg = fc.smArg(typeSupDgen, new HashSet<>());
 		opt = smArg.stream().filter(x -> x.getName().equals(typeDs.getName())).findAny();
 
 		if(!opt.isPresent())
@@ -509,7 +580,7 @@ public class RuleSet implements IRuleSet{
 		for(int i = 1; i < typeDParams.size(); i++) 
 			unif.add((PlaceholderType) typeSupDsgenParams.get(i), typeDParams.get(i));
 		
-		return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(unif.apply(newLhs), newRhs, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	/**
@@ -581,8 +652,8 @@ public class RuleSet implements IRuleSet{
 					&& typeMap.get(lhsType) > 1  // The type occurs in more pairs in the set than just the recent pair.
 					&& !rhsType.getTypeParams().occurs(lhsType)) {
 				Unifier uni = new Unifier(lhsType,  rhsType);
-				result = result.stream().map(uni::apply).collect(Collectors.toCollection(ArrayList::new));
+				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
-				result1 = result1.stream().map(uni::apply).collect(Collectors.toCollection(LinkedList::new));
+				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
 				applied = true;
 			}
 			
@@ -602,7 +673,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ExtendsType) || !(rhsType instanceof ExtendsType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT)); 
+		return Optional.of(new UnifyPair(((ExtendsType) lhsType).getExtendedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair())); 
 	}
 
 	@Override
@@ -615,7 +686,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof ExtendsType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(lhsType, ((ExtendsType) rhsType).getExtendedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -628,7 +699,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof SuperType) || !(rhsType instanceof SuperType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT));
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), ((SuperType) lhsType).getSuperedType(), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -641,9 +712,11 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof ReferenceType) || !(rhsType instanceof SuperType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC));
+		return Optional.of(new UnifyPair(((SuperType) rhsType).getSuperedType(), lhsType, PairOperator.SMALLERDOTWC, pair.getSubstitution(), pair.getBasePair()));
 	}
 
+	/* PL 2018-03-06 auskommentiert sind mutmaßlich falsch
+	 * vgl. JAVA_BSP/Wildcard6.java
 	@Override
 	public Optional<UnifyPair> reduceWildcardLowUp(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
@@ -670,6 +743,7 @@ public class RuleSet implements IRuleSet{
 		return Optional.of(new UnifyPair(((SuperType) lhsType).getSuperedType(), ((ExtendsType) rhsType).getExtendedType(), PairOperator.EQUALSDOT));
 	}
 
+	
 	@Override
 	public Optional<UnifyPair> reduceWildcardLeft(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOTWC)
@@ -686,7 +760,7 @@ public class RuleSet implements IRuleSet{
 		
 		return Optional.empty();
 	}
-
+	*/
 	@Override
 	public Optional<Set<UnifyPair>> reduceFunN(UnifyPair pair) {
 		if((pair.getPairOp() != PairOperator.SMALLERDOT)  
@@ -709,13 +783,19 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
+		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
-		for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
+		for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
-			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
+			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
-		
+		}
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+        								   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+        								   UnifyType r = x.getRhsType();
+        								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+								     } );
 		return Optional.of(result);
 	}
-
+	
+	
 	@Override
 	public Optional<Set<UnifyPair>> greaterFunN(UnifyPair pair) {
 		if(pair.getPairOp() != PairOperator.SMALLERDOT)
@@ -731,15 +811,29 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
+		Integer variance = ((PlaceholderType)rhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
 		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
-		for(int i = 0; i < freshPlaceholders.length; i++)
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
 			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
+		result.add(new UnifyPair(funNLhsType.getTypeParams().get(funNLhsType.getTypeParams().size()-1), freshPlaceholders[funNLhsType.getTypeParams().size()-1], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		
-		result.add(new UnifyPair(funNLhsType.getTypeParams().get(0), freshPlaceholders[0], PairOperator.SMALLERDOT));
+		for(int i = 0; i < funNLhsType.getTypeParams().size()-1; i++) {
-		for(int i = 1; i < funNLhsType.getTypeParams().size(); i++)
+			result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
-			result.add(new UnifyPair(freshPlaceholders[i], funNLhsType.getTypeParams().get(i), PairOperator.SMALLERDOT));
+		}
-		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
 		
+		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+									   UnifyType r = x.getRhsType();
+									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
 		return Optional.of(result);
 	}
 
@@ -758,15 +852,30 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
+		Integer variance = ((PlaceholderType)lhsType).getVariance();
+		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		
 		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
-		for(int i = 0; i < freshPlaceholders.length; i++)
+		for(int i = 0; i < freshPlaceholders.length-1; i++) {
 			freshPlaceholders[i] = PlaceholderType.freshPlaceholder();
+			((PlaceholderType)freshPlaceholders[i]).setVariance(inversVariance);
+		}
+		freshPlaceholders[freshPlaceholders.length-1] = PlaceholderType.freshPlaceholder();
+		((PlaceholderType)freshPlaceholders[freshPlaceholders.length-1]).setVariance(variance);
 		
-		result.add(new UnifyPair(freshPlaceholders[0], funNRhsType.getTypeParams().get(0), PairOperator.SMALLERDOT));
+		result.add(new UnifyPair(freshPlaceholders[funNRhsType.getTypeParams().size()-1], funNRhsType.getTypeParams().get(funNRhsType.getTypeParams().size()-1), PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
-		for(int i = 1; i < funNRhsType.getTypeParams().size(); i++)
-			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT));
-		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT));
 		
+		for(int i = 0; i < funNRhsType.getTypeParams().size()-1; i++) {
+			result.add(new UnifyPair(funNRhsType.getTypeParams().get(i), freshPlaceholders[i], PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
+		}
+		
+		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
+		
+		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+		   							   UnifyType r = x.getRhsType();
+		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
+									 } );
 		return Optional.of(result);
 	}
 
@@ -780,7 +889,7 @@ public class RuleSet implements IRuleSet{
 		if(!(lhsType instanceof PlaceholderType) || !(rhsType instanceof ReferenceType))
 			return Optional.empty();
 		
-		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT));
+		return Optional.of(new UnifyPair(lhsType, rhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
 
 	@Override
@@ -799,11 +908,11 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<>();
 		if(isGen)
-			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
-			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, new ExtendsType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
-			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT));
+			result.add(new UnifyPair(extendedType, freshTph, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 		}
 		
 		return Optional.of(result);
@@ -825,11 +934,13 @@ public class RuleSet implements IRuleSet{
 		
 		Set<UnifyPair> result = new HashSet<>();
 		if(isGen)
-			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, lhsType, PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		else {
 			UnifyType freshTph = PlaceholderType.freshPlaceholder();
-			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT));
+			result.add(new UnifyPair(rhsType, new SuperType(freshTph), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
-			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT));
+			Set<UnifyType> fBounded = pair.getfBounded();
+			fBounded.add(lhsType);
+			result.add(new UnifyPair(freshTph, superedType, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair(), fBounded));
 		}
 		
 		return Optional.of(result);

src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java

@@ -1,5 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify;
 
+import java.io.FileWriter;
+import java.util.ConcurrentModificationException;
 import java.util.Set;
 import java.util.concurrent.ForkJoinPool;
 
@@ -7,16 +9,21 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc) {
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true);
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true, logFile, log);
 		ForkJoinPool pool = new ForkJoinPool();
+		try {
 		pool.invoke(unifyTask);
+		}
+		catch (ConcurrentModificationException v) {
+			v.printStackTrace();
+		}
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}
 	
-	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc) {
+	public Set<Set<UnifyPair>> unifySequential(Set<UnifyPair> eq, IFiniteClosure fc, FileWriter logFile, Boolean log) {
-		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false);
+		TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false, logFile, log);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
 		return res;
 	}

src/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.io.FileWriter;
+import java.util.HashSet;
+import java.util.Set;
+
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+
+public class TypeUnify2Task extends TypeUnifyTask {
+	
+	Set<Set<UnifyPair>> setToFlatten;
+
+	public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, IFiniteClosure fc, boolean parallel, FileWriter logFile, Boolean log) {
+		super(eq, fc, parallel, logFile, log);
+		this.setToFlatten = setToFlatten;
+	}
+	
+	@Override
+	protected Set<Set<UnifyPair>> compute() {
+		if (one) {
+			System.out.println("two");
+		}
+		one = true;
+		Set<Set<UnifyPair>> res = unify2(setToFlatten, eq, fc, parallel);
+		/*if (isUndefinedPairSetSet(res)) { 
+			return new HashSet<>(); }
+		else
+		*/ 
+			return res;
+	}
+}

src/de/dhbwstuttgart/typeinference/unify/distributeVariance.java

@@ -0,0 +1,54 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+
+public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
+	
+	public static int inverseVariance(int variance) { 
+		Integer ret = 0;
+		if (variance == 1) {
+		   ret = -1;
+		}
+		if (variance == -1) {
+			ret = 1;
+		}
+		return ret;
+	}
+
+
+	@Override
+	public PlaceholderType visit(PlaceholderType phty, Integer ht) {
+		if (ht != 0) {
+			if (phty.getVariance() == 0) {
+				phty.setVariance(ht);
+			}
+			//PL 2018-05-17 urspruengliche Variance nicht veraendern
+			//else if (phty.getVariance() != ht) {
+			//	phty.setVariance(0);
+			//}
+		}
+		return phty;
+	}
+	
+	public FunNType visit(FunNType funnty, Integer ht) {
+		List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
+		param.addAll(Arrays.asList(funnty.getTypeParams().get()));
+		UnifyType resultType = param.remove(param.size()-1);
+		Integer htInverse = inverseVariance(ht);
+		param = param.stream()
+				     .map(x -> x.accept(this, htInverse))
+				     .collect(Collectors.toCollection(ArrayList::new));
+		param.add(resultType.accept(this, ht));
+		return FunNType.getFunNType(new TypeParams(param));
+	}
+	
+	
+}

src/de/dhbwstuttgart/typeinference/unify/freshPlaceholder.java

@@ -0,0 +1,15 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+
+import java.util.HashMap;
+
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+
+
+public class freshPlaceholder extends visitUnifyTypeVisitor<HashMap<PlaceholderType,PlaceholderType>> {
+
+	@Override
+	public PlaceholderType visit(PlaceholderType phty, HashMap<PlaceholderType,PlaceholderType> ht) {
+		return ht.get(phty);
+	}	
+}

src/de/dhbwstuttgart/typeinference/unify/interfaces/IFiniteClosure.java

@@ -5,6 +5,7 @@ import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
 import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
 import de.dhbwstuttgart.typeinference.unify.model.SuperType;
@@ -20,45 +21,47 @@ public interface IFiniteClosure {
 	 * Returns all types of the finite closure that are subtypes of the argument.
 	 * @return The set of subtypes of the argument.
 	 */
-	public Set<UnifyType> smaller(UnifyType type);
+	public Set<UnifyType> smaller(UnifyType type, Set<UnifyType> fBounded);
 	
 	/**
 	 * Returns all types of the finite closure that are supertypes of the argument.
 	 * @return The set of supertypes of the argument.
 	 */
-	public Set<UnifyType> greater(UnifyType type);
+	public Set<UnifyType> greater(UnifyType type, Set<UnifyType> fBounded);
 
 	/**
 	 * Wo passt Type rein?
 	 * @param type
 	 * @return
 	 */
-	public Set<UnifyType> grArg(UnifyType type);
+	public Set<UnifyType> grArg(UnifyType type, Set<UnifyType> fBounded);
 	
 	/**
 	 * Was passt in Type rein?
 	 * @param type
 	 * @return
 	 */
-	public Set<UnifyType> smArg(UnifyType type);
+	public Set<UnifyType> smArg(UnifyType type, Set<UnifyType> fBounded);
 	
-	public Set<UnifyType> grArg(ReferenceType type);
+	public Set<UnifyType> grArg(ReferenceType type, Set<UnifyType> fBounded);
-	public Set<UnifyType> smArg(ReferenceType type);
+	public Set<UnifyType> smArg(ReferenceType type, Set<UnifyType> fBounded);
 	
-	public Set<UnifyType> grArg(ExtendsType type);
+	public Set<UnifyType> grArg(ExtendsType type, Set<UnifyType> fBounded);
-	public Set<UnifyType> smArg(ExtendsType type);
+	public Set<UnifyType> smArg(ExtendsType type, Set<UnifyType> fBounded);
 	
-	public Set<UnifyType> grArg(SuperType type);
+	public Set<UnifyType> grArg(SuperType type, Set<UnifyType> fBounded);
-	public Set<UnifyType> smArg(SuperType type);
+	public Set<UnifyType> smArg(SuperType type, Set<UnifyType> fBounded);
 
-	public Set<UnifyType> grArg(PlaceholderType type);
+	public Set<UnifyType> grArg(PlaceholderType type, Set<UnifyType> fBounded);
-	public Set<UnifyType> smArg(PlaceholderType type);
+	public Set<UnifyType> smArg(PlaceholderType type, Set<UnifyType> fBounded);
 
-	public Set<UnifyType> grArg(FunNType type);
+	public Set<UnifyType> grArg(FunNType type, Set<UnifyType> fBounded);
-	public Set<UnifyType> smArg(FunNType type);
+	public Set<UnifyType> smArg(FunNType type, Set<UnifyType> fBounded);
 	
 	public Optional<UnifyType> getLeftHandedType(String typeName);
 	public Set<UnifyType> getAncestors(UnifyType t);
 	public Set<UnifyType> getChildren(UnifyType t);
-	public Set<UnifyType> getAllTypesByName(String typeName);
+	public Set<UnifyType> getAllTypesByName(String typeName);
+
+	public int compare(UnifyType rhsType, UnifyType rhsType2, PairOperator pairop);
 }

src/de/dhbwstuttgart/typeinference/unify/interfaces/IMatch.java

@@ -13,23 +13,17 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 /**
  * Match
  * @author Martin Pluemicke
+ * abgeleitet aus IUnify.java
  */
 public interface IMatch {
 	
 	/**
-	 * Finds the most general unifier sigma of the set {t1,...,tn} so that
+	 * Finds the most general matcher sigma of the set {t1 =. t1',...,tn =. tn'} so that
-	 * sigma(t1) = sigma(t2) = ... = sigma(tn). 
+	 * sigma(t1) = t1' , ... sigma(tn) = tn'. 
-	 * @param terms The set of terms to be unified
+	 * @param terms The set of terms to be matched
-	 * @return An optional of the most general unifier if it exists or an empty optional if there is no unifier.
+	 * @return An optional of the most general matcher if it exists or an empty optional if there is no matcher.
 	 */
 	public Optional<Unifier> match(ArrayList<UnifyPair> termsList);
-
-	/**
-	 * Finds the most general unifier sigma of the set {t1,...,tn} so that
-	 * sigma(t1) = sigma(t2) = ... = sigma(tn). 
-	 * @param terms The set of terms to be unified
-	 * @return An optional of the most general unifier if it exists or an empty optional if there is no unifier.
-	 */
 	
 
 }

src/de/dhbwstuttgart/typeinference/unify/interfaces/IRuleSet.java

@@ -27,9 +27,13 @@ public interface IRuleSet {
 	public Optional<UnifyPair> reduceWildcardLowRight(UnifyPair pair);
 	public Optional<UnifyPair> reduceWildcardUp(UnifyPair pair);
 	public Optional<UnifyPair> reduceWildcardUpRight(UnifyPair pair);
+	
+	/*
+	 * vgl. JAVA_BSP/Wildcard6.java
 	public Optional<UnifyPair> reduceWildcardLowUp(UnifyPair pair);
 	public Optional<UnifyPair> reduceWildcardUpLow(UnifyPair pair);
 	public Optional<UnifyPair> reduceWildcardLeft(UnifyPair pair);
+	 */
 	
 	/*
 	 * Additional Rules which replace cases of the cartesian product

src/de/dhbwstuttgart/typeinference/unify/interfaces/IUnify.java

@@ -15,16 +15,16 @@ import de.dhbwstuttgart.typeinference.unify.model.Unifier;
 public interface IUnify {
 	
 	/**
-	 * Finds the most general unifier sigma of the set {t1,...,tn} so that
+	 * Finds the most general unifier sigma of the set {t1 =. t1',...,tn =. tn'} so that
-	 * sigma(t1) = sigma(t2) = ... = sigma(tn). 
+	 * sigma(t1) = sigma(t1') , ... sigma(tn) = sigma(tn'). 
 	 * @param terms The set of terms to be unified
 	 * @return An optional of the most general unifier if it exists or an empty optional if there is no unifier.
 	 */
 	public Optional<Unifier> unify(Set<UnifyType> terms);
 	
 	/**
-	 * Finds the most general unifier sigma of the set {t1,...,tn} so that
+	 * Finds the most general unifier sigma of the set {t1 =. t1',...,tn =. tn'} so that
-	 * sigma(t1) = sigma(t2) = ... = sigma(tn). 
+	 * sigma(t1) = sigma(t1') , ... sigma(tn) = sigma(tn'). 
 	 * @param terms The set of terms to be unified
 	 * @return An optional of the most general unifier if it exists or an empty optional if there is no unifier.
 	 */

src/de/dhbwstuttgart/typeinference/unify/interfaces/UnifyTypeVisitor.java

@@ -0,0 +1,23 @@
+package de.dhbwstuttgart.typeinference.unify.interfaces;
+
+import java.util.HashMap;
+
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+
+public interface UnifyTypeVisitor<T> {
+
+	public ReferenceType visit(ReferenceType refty, T ht);
+	
+	public PlaceholderType visit(PlaceholderType phty, T ht);
+	
+	public FunNType visit(FunNType funnty, T ht);
+	
+	public SuperType visit(SuperType suty, T ht);
+	
+	public ExtendsType visit(ExtendsType extty, T ht);
+
+}

src/de/dhbwstuttgart/typeinference/unify/model/ExtendsType.java

@@ -2,21 +2,30 @@ package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * An extends wildcard type "? extends T". 
  */
 public final class ExtendsType extends WildcardType {
 	
+	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
+		return visitor.visit(this, ht);
+	}
+	
 	/**
 	 * Creates a new extends wildcard type.
 	 * @param extendedType The extended type e.g. Integer in "? extends Integer"
 	 */
 	public ExtendsType(UnifyType extendedType) {
-		super("? extends " + extendedType.getName(), extendedType); 
+		super("? extends " + extendedType.getName(), extendedType);
+		if (extendedType instanceof ExtendsType) {
+			System.out.print("");
+		}
 	}
 
 	/**
@@ -38,13 +47,13 @@ public final class ExtendsType extends WildcardType {
 	}
 
 	@Override
-	Set<UnifyType> smArg(IFiniteClosure fc) {
+	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.smArg(this);
+		return fc.smArg(this, fBounded);
 	}
 
 	@Override
-	Set<UnifyType> grArg(IFiniteClosure fc) {
+	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.grArg(this);
+		return fc.grArg(this, fBounded);
 	}
 
 	@Override

src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java

@@ -4,15 +4,21 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Hashtable;
 import java.util.Optional;
 import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
 
-//PL 18-02-05 Unifier durch Matcher ersetzt
+import com.google.common.collect.Ordering;
-//mus greater noch erstezt werden
+
+//PL 18-02-05/18-04-05 Unifier durch Matcher ersetzt
+//muss greater noch ersetzt werden ja erledigt 18--04-05
 import de.dhbwstuttgart.typeinference.unify.MartelliMontanariUnify;
 
 import de.dhbwstuttgart.typeinference.unify.Match;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
 
@@ -20,7 +26,7 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IUnify;
  * The finite closure for the type unification
  * @author Florian Steurer
  */
-public class FiniteClosure implements IFiniteClosure {
+public class FiniteClosure extends Ordering<UnifyType> implements IFiniteClosure  {
 
 	/**
 	 * A map that maps every type to the node in the inheritance graph that contains that type.
@@ -89,36 +95,43 @@ public class FiniteClosure implements IFiniteClosure {
 	 * @return The set of subtypes of the argument.
 	 */
 	@Override
-	public Set<UnifyType> smaller(UnifyType type) {
+	public Set<UnifyType> smaller(UnifyType type, Set<UnifyType> fBounded) {
 		if(type instanceof FunNType)
-			return computeSmallerFunN((FunNType) type);
+			return computeSmallerFunN((FunNType) type, fBounded);
 		
-		Set<UnifyType> ts = new HashSet<>();
+		Set<Pair<UnifyType,Set<UnifyType>>> ts = new HashSet<>();
-		ts.add(type);
+		ts.add(new Pair<>(type, fBounded));
 		return computeSmaller(ts);
 	}
 	
 	/**
 	 * Computes the smaller functions for every type except FunNTypes.
 	 */
-	private Set<UnifyType> computeSmaller(Set<UnifyType> types) {
+	private Set<UnifyType> computeSmaller(Set<Pair<UnifyType,Set<UnifyType>>> types) {
-		HashSet<UnifyType> result = new HashSet<>();
+		Set<Pair<UnifyType,Set<UnifyType>>> result = new HashSet<>();
 		
 		//PL 18-02-05 Unifier durch Matcher ersetzt
 		//IUnify unify = new MartelliMontanariUnify();
 		Match match = new Match();
 		
-		for(UnifyType t : types) {
+		for(Pair<UnifyType,Set<UnifyType>> pt : types) {
+			UnifyType t = pt.getKey();
+			Set<UnifyType> fBounded = pt.getValue().get();
 			
 			// if T = T' then T <* T'
-			result.add(t);
+			try {
+				result.add(new Pair<>(t, fBounded));
+			}
+			catch (StackOverflowError e) {
+				System.out.println("");
+			}
 			
 			// if C<...> <* C<...> then ... (third case in definition of <*)
 			if(t.getTypeParams().size() > 0) {
 				ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
 				for (int i = 0; i < t.getTypeParams().size(); i++)
-					paramCandidates.add(smArg(t.getTypeParams().get(i)));
+					paramCandidates.add(smArg(t.getTypeParams().get(i), fBounded));
-				permuteParams(paramCandidates).forEach(x -> result.add(t.setTypeParams(x)));
+				permuteParams(paramCandidates).forEach(x -> result.add(new Pair<>(t.setTypeParams(x), fBounded)));
 			}
 			
 			if(!strInheritanceGraph.containsKey(t.getName()))
@@ -144,19 +157,20 @@ public class FiniteClosure implements IFiniteClosure {
 				Set<UnifyType> theta1Set = candidate.getContentOfDescendants();
 				
 				for(UnifyType theta1 : theta1Set)
-					result.add(theta1.apply(sigma));
+					result.add(new Pair<>(theta1.apply(sigma), fBounded));
 			}
 		}
 		
-		if(result.equals(types))
+		HashSet<UnifyType> resut = result.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new));
-			return result;
+		if(resut.equals(types.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new))))
+			return resut;
 		return computeSmaller(result);
 	}
 	
 	/**
 	 * Computes the smaller-Function for FunNTypes.
 	 */
-	private Set<UnifyType> computeSmallerFunN(FunNType type) {
+	private Set<UnifyType> computeSmallerFunN(FunNType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<>();
 		
 		// if T = T' then T <=* T'
@@ -165,47 +179,152 @@ public class FiniteClosure implements IFiniteClosure {
 	    // Because real function types are implicitly variant
 	    // it is enough to permute the params with the values of greater / smaller.
 		ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
-		paramCandidates.add(smaller(type.getTypeParams().get(0)));
+		paramCandidates.add(smaller(type.getTypeParams().get(0), fBounded));
 		for (int i = 1; i < type.getTypeParams().size(); i++)
-			paramCandidates.add(greater(type.getTypeParams().get(i)));
+			paramCandidates.add(greater(type.getTypeParams().get(i), new HashSet<>()));
 	
 		permuteParams(paramCandidates).forEach(x -> result.add(type.setTypeParams(x)));
 		return result;
 	}
-
+	
 	/**
 	 * Returns all types of the finite closure that are supertypes of the argument.
 	 * @return The set of supertypes of the argument.
 	 */
 	@Override
-	public Set<UnifyType> greater(UnifyType type) {
+	//Eingefuegt PL 2018-05-24 F-Bounded Problematik
-		if(type instanceof FunNType)
+	public Set<UnifyType> greater(UnifyType type, Set<UnifyType> fBounded) {
-			return computeGreaterFunN((FunNType) type); 
 		
-		Set<UnifyType> ts = new HashSet<>();
+		if(type instanceof FunNType) {
-		ts.add(type);
+			return computeGreaterFunN((FunNType) type, fBounded); 
+		}
+		
+		Set<UnifyType> result = new HashSet<>();
+		Set<Pair<UnifyType,Set<UnifyType>>> PairResultFBounded = new HashSet<>();
+		
+		Match match = new Match();
+		
+		
+		// if T = T' then T <=* T'
+		result.add(type);
+		if(!strInheritanceGraph.containsKey(type.getName()))
+			return result;
+		
+		// if T <* T' then sigma(T) <* sigma(T')
+		Set<Node<UnifyType>> candidates = strInheritanceGraph.get(type.getName());
+		for(Node<UnifyType> candidate :  candidates) {
+			UnifyType theta1 = candidate.getContent();
+			
+			//PL 18-04-05 Unifier durch Matcher ersetzt ANFANG
+			ArrayList<UnifyPair> termList= new ArrayList<UnifyPair>();
+			termList.add(new UnifyPair(theta1,type, PairOperator.EQUALSDOT));
+			Optional<Unifier> optSigma = match.match(termList);
+			//PL 18-04-05 Unifier durch Matcher ersetzt ENDE
+			if(!optSigma.isPresent())
+				continue;
+			
+			Unifier sigma = optSigma.get();
+			sigma.swapPlaceholderSubstitutionsReverse(theta1.getTypeParams());
+			
+			Set<UnifyType> fBoundedNew = new HashSet<>(fBounded);
+			fBoundedNew.add(theta1);
+			Set<UnifyType> theta2Set = candidate.getContentOfPredecessors();
+			//System.out.println("");
+			for(UnifyType theta2 : theta2Set) {
+				result.add(theta2.apply(sigma));
+				PairResultFBounded.add(new Pair<>(theta2.apply(sigma), fBoundedNew));
+			}
+		}
+		
+		for(Pair<UnifyType,Set<UnifyType>> pt : PairResultFBounded) {
+			UnifyType t = pt.getKey();
+			Set<UnifyType> lfBounded = pt.getValue().get();
+			
+			// if C<...> <* C<...> then ... (third case in definition of <*)	
+			//TypeParams typeparams = t.getTypeParams();
+			if(t.getTypeParams().size() > 0) {
+				ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
+				
+				for (int i = 0; i < t.getTypeParams().size(); i++) {
+					//UnifyType parai = t.getTypeParams().get(i);
+					int i_ef = i;
+					BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
+					{
+						ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
+					    termList.add(new UnifyPair(y,t.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
+					    return ((match.match(termList).isPresent()) || x);
+					};
+					//if (parai.getName().equals("java.lang.Integer")) {
+					//	System.out.println("");
+					//}
+					BinaryOperator<Boolean> bo = (a,b) -> (a || b);
+					if (lfBounded.stream().reduce(false,f,bo)) {
+						//F-Bounded Endlosrekursion
+						HashSet<UnifyType> res = new HashSet<UnifyType>();
+						paramCandidates.add(res); 
+					}
+					else {
+						paramCandidates.add(grArg(t.getTypeParams().get(i), new HashSet<>(fBounded) ));
+					}
+				}
+				permuteParams(paramCandidates).forEach(x -> result.add(t.setTypeParams(x)));
+				//System.out.println("");
+			}
+		}
+		return result;
+	}
+	
+	/* auskommentiert PL 2018-05-24
+	/**
+	 * Returns all types of the finite closure that are supertypes of the argument.
+	 * @return The set of supertypes of the argument.
+	 *
+	//@Override
+	public Set<UnifyType> oldgreater(UnifyType type, Set<UnifyType> fBounded) {
+		if(type instanceof FunNType)
+			return computeGreaterFunN((FunNType) type, fBounded); 
+		
+		Set<Pair<UnifyType,Set<UnifyType>>> ts = new HashSet<>();
+		ts.add(new Pair<>(type, fBounded));
 		return computeGreater(ts);
 	}
  
 	/**
 	 * Computes the greater function for all types except function types.
-	 */
+	 *
-	protected Set<UnifyType> computeGreater(Set<UnifyType> types) {
+	protected Set<UnifyType> computeGreater(Set<Pair<UnifyType,Set<UnifyType>>> types) {
-		HashSet<UnifyType> result = new HashSet<>();
+		Set<Pair<UnifyType,Set<UnifyType>>> result = new HashSet<>();
 		
-		IUnify unify = new MartelliMontanariUnify();
+		//PL 18-04-05 Unifier durch Matcher ersetzt
+		//IUnify unify = new MartelliMontanariUnify();
+		Match match = new Match();
 		
-		for(UnifyType t : types) {
+		for(Pair<UnifyType,Set<UnifyType>> pt : types) {
-			
+			UnifyType t = pt.getKey();
+			Set<UnifyType> fBounded = pt.getValue().get();
 			// if T = T' then T <=* T'
-			result.add(t);
+			result.add(pt);
 			
 			// if C<...> <* C<...> then ... (third case in definition of <*)			
 			if(t.getTypeParams().size() > 0) {
 				ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
-				for (int i = 0; i < t.getTypeParams().size(); i++)
+				for (int i = 0; i < t.getTypeParams().size(); i++) {
-					paramCandidates.add(grArg(t.getTypeParams().get(i)));
+					UnifyType parai = t.getTypeParams().get(i);
-				permuteParams(paramCandidates).forEach(x -> result.add(t.setTypeParams(x)));
+					int i_ef = i;
+					BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
+					{
+						ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
+					    termList.add(new UnifyPair(y,t.getTypeParams().get(i_ef), PairOperator.EQUALSDOT));
+					    return ((match.match(termList).isPresent()) || x);
+					};
+					if (parai.getName().equals("java.lang.Integer")) {
+						System.out.println("");
+					}
+					BinaryOperator<Boolean> bo = (a,b) -> (a || b);
+					if (fBounded.stream().reduce(false,f,bo)) continue; //F-Bounded Endlosrekursion
+					paramCandidates.add(grArg(t.getTypeParams().get(i), new HashSet<>(fBounded) ));
+				}
+				permuteParams(paramCandidates).forEach(x -> result.add(new Pair<>(t.setTypeParams(x), new HashSet<>(fBounded))));
 			}
 			
 			if(!strInheritanceGraph.containsKey(t.getName()))
@@ -215,30 +334,40 @@ public class FiniteClosure implements IFiniteClosure {
 			Set<Node<UnifyType>> candidates = strInheritanceGraph.get(t.getName());
 			for(Node<UnifyType> candidate :  candidates) {
 				UnifyType theta1 = candidate.getContent();
-				Optional<Unifier> optSigma = unify.unify(theta1, t);
+				
+				//PL 18-04-05 Unifier durch Matcher ersetzt ANFANG
+				ArrayList<UnifyPair> termList= new ArrayList<UnifyPair>();
+				termList.add(new UnifyPair(theta1,t, PairOperator.EQUALSDOT));
+				Optional<Unifier> optSigma = match.match(termList);
+				//PL 18-04-05 Unifier durch Matcher ersetzt ENDE
 				if(!optSigma.isPresent())
 					continue;
 				
 				Unifier sigma = optSigma.get();
 				sigma.swapPlaceholderSubstitutionsReverse(theta1.getTypeParams());
 				
+				Set<UnifyType> fBoundedNew = new HashSet<>(fBounded);
+				fBoundedNew.add(theta1);
 				Set<UnifyType> theta2Set = candidate.getContentOfPredecessors();
 				
 				for(UnifyType theta2 : theta2Set)
-					result.add(theta2.apply(sigma));
+					result.add(new Pair<>(theta2.apply(sigma), fBoundedNew));
 			}
 			
 		}
 		
-		if(result.equals(types))
+		HashSet<UnifyType> resut = result.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new));
-			return result;
+		System.out.println(resut);
+		if(resut.equals(types.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new))))
+			return resut;
 		return computeGreater(result);
 	}
+	*/
 
 	/**
 	 * Computes the greater function for FunN-Types
 	 */
-	protected Set<UnifyType> computeGreaterFunN(FunNType type) {
+	protected Set<UnifyType> computeGreaterFunN(FunNType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<>();
 		
 		// if T = T' then T <=* T'
@@ -247,88 +376,88 @@ public class FiniteClosure implements IFiniteClosure {
 	    // Because real function types are implicitly variant
 	    // it is enough to permute the params with the values of greater / smaller.
 		ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
-		paramCandidates.add(greater(type.getTypeParams().get(0)));
+		paramCandidates.add(greater(type.getTypeParams().get(0), new HashSet<>()));
 		for (int i = 1; i < type.getTypeParams().size(); i++)
-				paramCandidates.add(smaller(type.getTypeParams().get(i)));
+				paramCandidates.add(smaller(type.getTypeParams().get(i), fBounded));
 		permuteParams(paramCandidates).forEach(x -> result.add(type.setTypeParams(x)));
 		return result;
 	}
 
 	
 	@Override	
-	public Set<UnifyType> grArg(UnifyType type) {
+	public Set<UnifyType> grArg(UnifyType type, Set<UnifyType> fBounded) {
-		return type.grArg(this);
+		return type.grArg(this, fBounded);
 	}
 
 	@Override
-	public Set<UnifyType> grArg(ReferenceType type) {
+	public Set<UnifyType> grArg(ReferenceType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);	
-        smaller(type).forEach(x -> result.add(new SuperType(x)));
+        smaller(type, fBounded).forEach(x -> result.add(new SuperType(x)));
-        greater(type).forEach(x -> result.add(new ExtendsType(x)));
+        greater(type,fBounded).forEach(x -> result.add(new ExtendsType(x)));
 		return result;
 	}
 	
 	@Override
-	public Set<UnifyType> grArg(FunNType type) {
+	public Set<UnifyType> grArg(FunNType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);	
-        smaller(type).forEach(x -> result.add(new SuperType(x)));
+        smaller(type, fBounded).forEach(x -> result.add(new SuperType(x)));
-        greater(type).forEach(x -> result.add(new ExtendsType(x)));
+        greater(type, fBounded).forEach(x -> result.add(new ExtendsType(x)));
 		return result;
 	}
 	
 	@Override
-	public Set<UnifyType> grArg(ExtendsType type) {
+	public Set<UnifyType> grArg(ExtendsType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);
 		UnifyType t = type.getExtendedType();
-		greater(t).forEach(x -> result.add(new ExtendsType(x)));
+		greater(t, fBounded).forEach(x -> result.add(new ExtendsType(x)));
 		return result;
 	}
 
 	@Override
-	public Set<UnifyType> grArg(SuperType type) {
+	public Set<UnifyType> grArg(SuperType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);
 		UnifyType t = type.getSuperedType();
-		smaller(t).forEach(x -> result.add(new SuperType(x)));
+		smaller(t, fBounded).forEach(x -> result.add(new SuperType(x)));
 		return result;
 	}
 	
 	@Override
-	public Set<UnifyType> grArg(PlaceholderType type) {
+	public Set<UnifyType> grArg(PlaceholderType type, Set<UnifyType> fBounded) {
 		HashSet<UnifyType> result = new HashSet<>();
 		result.add(type);
 		return result;
 	}
 
 	@Override	
-	public Set<UnifyType> smArg(UnifyType type) {
+	public Set<UnifyType> smArg(UnifyType type, Set<UnifyType> fBounded) {
-		return type.smArg(this);
+		return type.smArg(this, fBounded);
 	}
 	
 	@Override
-	public Set<UnifyType> smArg(ReferenceType type) {
+	public Set<UnifyType> smArg(ReferenceType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);	
 		return result;
 	}
 	
 	@Override
-	public Set<UnifyType> smArg(FunNType type) {
+	public Set<UnifyType> smArg(FunNType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);	
 		return result;
 	}
 	
 	@Override
-	public Set<UnifyType> smArg(ExtendsType type) {
+	public Set<UnifyType> smArg(ExtendsType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);
 		UnifyType t = type.getExtendedType();
 		result.add(t);	
-        smaller(t).forEach(x -> { 
+        smaller(t, fBounded).forEach(x -> { 
         	result.add(new ExtendsType(x));
         	result.add(x); 
         });
@@ -337,12 +466,13 @@ public class FiniteClosure implements IFiniteClosure {
 	
 
 	@Override
-	public Set<UnifyType> smArg(SuperType type) {
+	public Set<UnifyType> smArg(SuperType type, Set<UnifyType> fBounded) {
 		Set<UnifyType> result = new HashSet<UnifyType>();
 		result.add(type);
 		UnifyType t = type.getSuperedType();
 		result.add(t);	
-        greater(t).forEach(x -> { 
+//*** ACHTUNG das koennte FALSCH sein PL 2018-05-23 evtl. HashSet durch smArg durchschleifen	
+        greater(t, fBounded).forEach(x -> { 
         	result.add(new SuperType(x));
         	result.add(x); 
         });
@@ -350,7 +480,7 @@ public class FiniteClosure implements IFiniteClosure {
 	}
 	
 	@Override
-	public Set<UnifyType> smArg(PlaceholderType type) {
+	public Set<UnifyType> smArg(PlaceholderType type, Set<UnifyType> fBounded) {
 		HashSet<UnifyType> result = new HashSet<>();
 		result.add(type);
 		return result;
@@ -369,7 +499,7 @@ public class FiniteClosure implements IFiniteClosure {
 			return Optional.empty();
 		
 		for(UnifyPair pair : pairs)
-			if(pair.getLhsType().getName().equals(typeName))
+			if(pair.getLhsType().getName().equals(typeName) && pair.getLhsType().typeParams.arePlaceholders())
 					return Optional.of(pair.getLhsType());
 		
 		return Optional.empty();
@@ -430,4 +560,33 @@ public class FiniteClosure implements IFiniteClosure {
 	public String toString(){
 		return this.inheritanceGraph.toString();
 	}
+	
+	public int compare (UnifyType left, UnifyType right) {
+		return compare(left, right, PairOperator.SMALLERDOT);
+	}
+	
+	public int compare (UnifyType left, UnifyType right, PairOperator pairop) {
+		if ((left instanceof ExtendsType && right instanceof ReferenceType) 
+				|| (right instanceof ExtendsType && left instanceof ReferenceType))
+			System.out.println("");
+		UnifyPair up = new UnifyPair(left, right, pairop);
+		TypeUnifyTask unifyTask = new TypeUnifyTask();
+		HashSet<UnifyPair> hs = new HashSet<>();
+		hs.add(up);
+		Set<UnifyPair> smallerRes = unifyTask.applyTypeUnificationRules(hs, this);
+		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
+		long smallerLen = smallerRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
+		if (smallerLen == 0) return -1;
+		else {
+			up = new UnifyPair(right, left, pairop);
+			//TypeUnifyTask unifyTask = new TypeUnifyTask();
+			hs = new HashSet<>();
+			hs.add(up);
+			Set<UnifyPair> greaterRes = unifyTask.applyTypeUnificationRules(hs, this);
+			//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
+			long greaterLen = greaterRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType)).count();
+			if (greaterLen == 0) return 1;
+			else return 0;
+		}	
+	}
 }

src/de/dhbwstuttgart/typeinference/unify/model/FunNType.java

@@ -1,8 +1,12 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * A real function type in java.
@@ -10,6 +14,10 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
  */
 public class FunNType extends UnifyType {
 
+	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
+		return visitor.visit(this, ht);
+	}
+	
 	/**
 	 * Creates a FunN-Type with the specified TypeParameters.
 	 */
@@ -47,13 +55,13 @@ public class FunNType extends UnifyType {
 	}
 	
 	@Override
-	Set<UnifyType> smArg(IFiniteClosure fc) {
+	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.smArg(this);
+		return fc.smArg(this, fBounded);
 	}
 
 	@Override
-	Set<UnifyType> grArg(IFiniteClosure fc) {
+	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.grArg(this);
+		return fc.grArg(this, fBounded);
 	}
 	
 	@Override
@@ -67,11 +75,18 @@ public class FunNType extends UnifyType {
 		return new FunNType(newParams);
 	}
 
+	@Override
+	public Boolean wrongWildcard() {
+		return (new ArrayList<UnifyType>(Arrays.asList(getTypeParams()
+				.get())).stream().filter(x -> (x instanceof WildcardType)).findFirst().isPresent());
+	}
+	
 	@Override
 	public int hashCode() {
 		return 181 + typeParams.hashCode();
 	}
 	
+	
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof FunNType))

src/de/dhbwstuttgart/typeinference/unify/model/OrderingUnifyPair.java

@@ -0,0 +1,228 @@
+package de.dhbwstuttgart.typeinference.unify.model;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BinaryOperator;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.google.common.collect.Ordering;
+
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+
+
+
+public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
+	
+	protected IFiniteClosure fc;
+	
+	public OrderingUnifyPair(IFiniteClosure fc) {
+		this.fc = fc;
+	}
+	
+	/*
+	 * vergleicht Paare (a =. Theta) und (a =. Theta')
+	 * in dem compare(Theta, Theta') aufgerufen wird.
+	 */
+	public int compareEq (UnifyPair left, UnifyPair right) {
+		if (left.getRhsType() instanceof WildcardType || right.getRhsType() instanceof WildcardType) {
+			return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOTWC);
+		}
+			else	 {
+				return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOT);
+		}
+	}
+	/*
+	public int compareEq (UnifyPair left, UnifyPair right) {
+		if (left == null || right == null)
+			System.out.println("Fehler");
+		if (left.getLhsType() instanceof PlaceholderType) {
+			return fc.compare(left.getRhsType(), right.getRhsType(), left.getPairOp());
+		}
+		else {
+			return fc.compare(left.getLhsType(), right.getLhsType(), left.getPairOp());
+		}
+	}
+	*/
+	
+	public Pair<Integer,Set<UnifyPair>> compare (UnifyType left, UnifyType right) {
+		UnifyPair up;
+		if (left instanceof WildcardType || right instanceof WildcardType) {
+			up = new UnifyPair(left, right, PairOperator.SMALLERDOTWC);
+		}
+			else	 {
+				up = new UnifyPair(left, right, PairOperator.SMALLERDOT);
+		}
+		TypeUnifyTask unifyTask = new TypeUnifyTask();
+		HashSet<UnifyPair> hs = new HashSet<>();
+		hs.add(up);
+		Set<UnifyPair> smallerRes = unifyTask.applyTypeUnificationRules(hs, fc);
+		long smallerLen = smallerRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType && x.getRhsType() instanceof PlaceholderType)).count();
+		if (smallerLen == 0) return new Pair<>(-1, smallerRes);
+		else {
+			if (left instanceof WildcardType || right instanceof WildcardType) {
+				up = new UnifyPair(right, left, PairOperator.SMALLERDOTWC);
+			}
+				else	 {
+					up = new UnifyPair(right, left, PairOperator.SMALLERDOT);
+			}
+			//TypeUnifyTask unifyTask = new TypeUnifyTask();
+			hs = new HashSet<>();
+			hs.add(up);
+			Set<UnifyPair> greaterRes = unifyTask.applyTypeUnificationRules(hs, fc);
+			long greaterLen = greaterRes.stream().filter(x -> !(x.getLhsType() instanceof PlaceholderType && x.getRhsType() instanceof PlaceholderType)).count();
+			if (greaterLen == 0) return new Pair<>(1, greaterRes);
+			else return new Pair<>(0, new HashSet<>());
+		}	
+	}
+	
+	/* TODO muss noch verifiziert werden PL 2018-03-21
+	 * (non-Javadoc)
+	 * fuehrt zu Fehlern bei Arrays.sort (contract nicht erfuellt)
+	 * @see com.google.common.collect.Ordering#compare(java.lang.Object, java.lang.Object)
+	 */
+	public int compare (Set<UnifyPair> left, Set<UnifyPair> right) {
+		Set<UnifyPair> lefteq = left.stream()
+				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> righteq = right.stream()
+				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> leftle = left.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightle = right.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOT))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> leftlewc = left.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
+				.collect(Collectors.toCollection(HashSet::new));
+		Set<UnifyPair> rightlewc = right.stream()
+				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
+						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
+				.collect(Collectors.toCollection(HashSet::new));
+		//System.out.println(left.toString());
+		//Fall 2 und 3
+		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
+		//	System.out.print("");
+		//}
+		if (lefteq.size() == 1 && leftle.size() == 1  && righteq.size() == 0 && rightle.size() == 1) {
+			return 1;
+		}
+		//Fall 2 und 3
+		if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 1) {
+			return -1;
+		}
+		//Fall 5
+		if (lefteq.size() == 1 && leftle.size() == 0 && righteq.size() == 1 && rightle.size() == 1) {
+			return -1;
+		}
+		//Fall 5
+		if (lefteq.size() == 1 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 0) {
+			return 1;
+		}
+		//Fall 5
+		if (lefteq.size() == 1 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 1) {
+			return 0;
+		}
+		// Nur Paare a =. Theta
+		if (leftle.size() == 0 && rightle.size() == 0 && leftlewc.size() == 0 && rightlewc.size() ==0) {
+			Stream<UnifyPair> lseq = lefteq.stream(); //left.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT));
+			Stream<UnifyPair> rseq = righteq.stream(); //right.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT));
+			BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
+			HashMap<UnifyType,UnifyPair> hm = rseq.reduce(new HashMap<UnifyType,UnifyPair>(), (x, y)-> { x.put(y.getLhsType(),y); return x; }, combiner);
+			lseq = lseq.filter(x -> !(hm.get(x.getLhsType()) == null));//NOCHMALS UEBERPRUEFEN!!!!
+			lseq = lseq.filter(x -> !x.equals(hm.get(x.getLhsType()))); //Elemente die gleich sind muessen nicht verglichen werden
+			Optional<Integer> si = lseq.map(x -> compareEq(x, hm.get(x.getLhsType()))).reduce((x,y)-> { if (x == y) return x; else return 0; } );
+			if (!si.isPresent()) return 0;
+			else return si.get();
+		}
+		//Fall 1 und 4
+		if (lefteq.size() >= 1 && righteq.size() >= 1 && (leftlewc.size() > 0 || rightlewc.size() > 0)) {
+			if (lefteq.iterator().next().getLhsType().getName().equals("D")) 
+				System.out.print("");
+			//Set<PlaceholderType> varsleft = lefteq.stream().map(x -> (PlaceholderType)x.getLhsType()).collect(Collectors.toCollection(HashSet::new));
+			//Set<PlaceholderType> varsright = righteq.stream().map(x -> (PlaceholderType)x.getLhsType()).collect(Collectors.toCollection(HashSet::new));
+			//filtern des Paares a = Theta, das durch a <. Thata' generiert wurde (nur im Fall 1 relevant)  
+			lefteq.removeIf(x -> !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
+					              ||x.getLhsType().getName().equals(x.getBasePair().getRhsType().getName())));//removeIf(x -> !varsright.contains(x.getLhsType()));
+			righteq.removeIf(x -> !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
+		              	           ||x.getLhsType().getName().equals(x.getBasePair().getRhsType().getName())));//.removeIf(x -> !varsleft.contains(x.getLhsType()));
+			UnifyPair lseq = lefteq.iterator().next();
+			UnifyPair rseq = righteq.iterator().next();
+			if (lseq.getRhsType().getName().equals("Object")) {
+				if (rseq.getRhsType().getName().equals("Object")) return 0;
+				else return 1;
+			}
+			else {
+				if (rseq.getRhsType().getName().equals("Object")) return -1;
+			}
+			if (leftlewc.size() == rightlewc.size()) {
+				//TODO: Hier wird bei Wildcards nicht das richtige compare aufgerufen PL 18-04-20
+				Pair<Integer, Set<UnifyPair>> int_Unifier = compare(lseq.getRhsType(), rseq.getRhsType());
+				Unifier uni = new Unifier();
+				int_Unifier.getValue().get().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName()) 
+					|| leftlewc.size() == 0 || rightlewc.size() == 0) return int_Unifier.getKey();
+				else {
+					Set <UnifyPair> lsleuni = leftlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> rsleuni = rightlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
+				
+					HashMap<UnifyType,UnifyPair> hm;
+					Optional<Integer> si;
+					//1. Fall
+					if (leftlewc.iterator().next().getLhsType() instanceof PlaceholderType) {
+						hm = rsleuni.stream().reduce(new HashMap<UnifyType,UnifyPair>(), (x, y)-> { x.put(y.getLhsType(),y); return x; }, combiner);
+						Stream<UnifyPair> lslewcstr = lsleuni.stream().filter(x -> !(hm.get(x.getLhsType()) == null));
+					si = lslewcstr.map(x -> fc.compare(x.getRhsType(), hm.get(x.getLhsType()).getRhsType(), PairOperator.SMALLERDOTWC)).reduce((x,y)-> { if (x == y) return x; else return 0; } );
+					}
+					//4. Fall
+					else {
+						hm = rsleuni.stream().reduce(new HashMap<UnifyType,UnifyPair>(), (x, y)-> { x.put(y.getRhsType(),y); return x; }, combiner);
+						Stream<UnifyPair> lslewcstr = lsleuni.stream().filter(x -> !(hm.get(x.getRhsType()) == null));
+						si = lslewcstr.map(x -> fc.compare(x.getLhsType(), hm.get(x.getRhsType()).getLhsType(), PairOperator.SMALLERDOTWC)).reduce((x,y)-> { if (x == y) return x; else return 0; } );
+					}
+					if (!si.isPresent()) return 0;
+					else return si.get();
+				}
+			} else {
+				if (leftlewc.size() > 0) {
+					Set<UnifyPair> subst;
+					if (leftlewc.iterator().next().getLhsType() instanceof PlaceholderType) {
+						subst = leftlewc.stream().map(x -> new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					else {
+						subst = leftlewc.stream().map(x -> new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					Unifier uni = new Unifier();
+					subst.stream().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+					lseq = uni.apply(lseq);
+				}
+				else {
+					Set<UnifyPair> subst;
+					if (rightlewc.iterator().next().getLhsType() instanceof PlaceholderType) {
+						subst = rightlewc.stream().map(x -> new UnifyPair(x.getLhsType(), x.getRhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					else {
+						subst = rightlewc.stream().map(x -> new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT)).collect(Collectors.toCollection(HashSet::new));
+					}
+					Unifier uni = new Unifier();
+					subst.stream().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+					rseq = uni.apply(rseq);
+				}
+				return compareEq(lseq, rseq);
+			}
+		}
+		return 0;	
+	}		
+}
+

src/de/dhbwstuttgart/typeinference/unify/model/Pair.java

@@ -0,0 +1,21 @@
+package de.dhbwstuttgart.typeinference.unify.model;
+
+import java.util.Optional;
+
+public class Pair<T, T1> {
+    private final T key;
+    private final T1 value;
+
+    public Pair(T a, T1 b) {
+        this.value = b;
+        this.key = a;
+    }
+
+    public Optional<T1> getValue() {
+        return Optional.of(value);
+    }
+
+    public T getKey() {
+        return key;
+    }
+}

src/de/dhbwstuttgart/typeinference/unify/model/PairOperator.java

@@ -17,6 +17,12 @@ public enum PairOperator {
 	 */
 	SMALLERDOT,
 	
+	/**
+	 * The smallernedot operator for arguments (T <!=. P) is the same as SMALLERDOT without
+	 * T == P. It is used for operations + / - / * / < / > / ... with the Supertype Number
+	 */
+	SMALLERNEQDOT,
+	
 	/**
 	 * The smallerdot operator for arguments (T <.? P) is used to express that 
 	 * T is an element of smArg(P) (or P is an element of grArg(T)) in a CONSTRAINT 
@@ -35,6 +41,7 @@ public enum PairOperator {
 		switch (this) {
 			case SMALLER: return "<";
 			case SMALLERDOT: return "<.";
+			case SMALLERNEQDOT: return "<!=.";
 			case SMALLERDOTWC: return "<.?";
 			default: return "=."; // EQUALSDOT
 		}

src/de/dhbwstuttgart/typeinference/unify/model/PlaceholderType.java

@@ -2,11 +2,14 @@ package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Random;
 import java.util.Set;
 
+import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * An unbounded placeholder type.
@@ -35,6 +38,21 @@ public final class PlaceholderType extends UnifyType{
 	 */
 	private final boolean IsGenerated;
 	
+	
+	/**
+	 * isWildcardable gibt an, ob ein Wildcardtyp dem PlaceholderType zugeordnet werden darf 
+	 */
+	private boolean wildcardable = true;  
+	
+	/**
+     * variance shows the variance of the pair
+     * -1: contravariant
+     * 1 covariant
+     * 0 invariant
+     * PL 2018-03-21
+     */
+    private int variance = 0;
+	
 	/**
 	 * Creates a new placeholder type with the specified name.
 	 */
@@ -54,6 +72,10 @@ public final class PlaceholderType extends UnifyType{
 		IsGenerated = isGenerated;
 	}
 	
+	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
+		return visitor.visit(this, ht);
+	}
+	
 	/**
 	 * Creates a fresh placeholder type with a name that does so far not exist.
 	 * A user could later instantiate a type using the same name that is equivalent to this type.
@@ -67,6 +89,7 @@ public final class PlaceholderType extends UnifyType{
 		return new PlaceholderType(name, true);
 	}
 	
+	
 	/**
 	 * True if this placeholder is auto-generated, false if it is user-generated.
 	 */
@@ -74,14 +97,29 @@ public final class PlaceholderType extends UnifyType{
 		return IsGenerated;
 	}
 
+	public void setVariance(int v) {
+		variance = v;
+	}
+	
+	public int getVariance() {
+		return variance;
+	}
+	
+	public Boolean isWildcardable() {
+		return wildcardable;
+	}
+	public void disableWildcardtable() {
+		wildcardable = false;
+	}
+	
 	@Override
-	Set<UnifyType> smArg(IFiniteClosure fc) {
+	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.smArg(this);
+		return fc.smArg(this, fBounded);
 	}
 
 	@Override
-	Set<UnifyType> grArg(IFiniteClosure fc) {
+	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.grArg(this);
+		return fc.grArg(this, fBounded);
 	}
 	
 	@Override
@@ -96,8 +134,13 @@ public final class PlaceholderType extends UnifyType{
 	
 	@Override
 	UnifyType apply(Unifier unif) {
-		if(unif.hasSubstitute(this))
+		if(unif.hasSubstitute(this)) {
-			return unif.getSubstitute(this);
+			UnifyType ret = unif.getSubstitute(this);
+			//PL 2018-05-17 Auskommentierung muesste korrekt sein,
+			//bereits in JavaTXComplier Variancen gesetzt werden.
+			//ret.accept(new distributeVariance(), this.getVariance());
+			return ret;
+		}
 		return this;
 	}
 	

src/de/dhbwstuttgart/typeinference/unify/model/ReferenceType.java

@@ -1,8 +1,10 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.HashMap;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * A reference type e.q. Integer or List<T>.
@@ -16,6 +18,11 @@ public final class ReferenceType extends UnifyType {
 	 */
 	private final int hashCode;
 	
+
+	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
+		return visitor.visit(this, ht);
+	}
+	
 	public ReferenceType(String name, UnifyType... params) {
 		super(name, new TypeParams(params));
 		hashCode = 31 + 17 * typeName.hashCode() + 17 * typeParams.hashCode();
@@ -27,13 +34,13 @@ public final class ReferenceType extends UnifyType {
 	}
 
 	@Override
-	Set<UnifyType> smArg(IFiniteClosure fc) {
+	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.smArg(this);
+		return fc.smArg(this, fBounded);
 	}
 
 	@Override
-	Set<UnifyType> grArg(IFiniteClosure fc) {
+	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.grArg(this);
+		return fc.grArg(this, fBounded);
 	}
 
 	@Override

src/de/dhbwstuttgart/typeinference/unify/model/SuperType.java

@@ -1,8 +1,10 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import java.util.HashMap;
 import java.util.Set;
 
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * A super wildcard type e.g. ? super Integer.
@@ -10,6 +12,10 @@ import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
  */
 public final class SuperType extends WildcardType {
 	
+	public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht) {
+		return visitor.visit(this, ht);
+	}
+	
 	/**
 	 * Creates a new instance "? extends superedType"
 	 * @param superedType The type that is supered e.g. Integer in "? super Integer"
@@ -42,13 +48,13 @@ public final class SuperType extends WildcardType {
 	}
 	
 	@Override
-	Set<UnifyType> smArg(IFiniteClosure fc) {
+	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.smArg(this);
+		return fc.smArg(this, fBounded);
 	}
 
 	@Override
-	Set<UnifyType> grArg(IFiniteClosure fc) {
+	Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
-		return fc.grArg(this);
+		return fc.grArg(this, fBounded);
 	}
 	
 	@Override

src/de/dhbwstuttgart/typeinference/unify/model/TypeParams.java

@@ -115,6 +115,14 @@ public final class TypeParams implements Iterable<UnifyType>{
 		return typeParams[i];
 	}
 	
+	/**
+	 * Returns the parameters of this object.
+	 * PL 2018-03-17
+	 */
+	public UnifyType[] get() {
+		return typeParams;
+	}
+	
 	/**
 	 * Sets the the type t as the i-th parameter and returns a new object
 	 * that equals this object, except for the i-th type.

src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java

@@ -1,8 +1,10 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Map.Entry;
+import java.util.Set;
 import java.util.function.Function;
 
 /**
@@ -63,7 +65,44 @@ public class Unifier implements Function<UnifyType, UnifyType>, Iterable<Entry<P
 	 * @return A new pair where the left and right-hand side are applied
 	 */
 	public UnifyPair apply(UnifyPair p) {
-		return new UnifyPair(this.apply(p.getLhsType()), this.apply(p.getRhsType()), p.getPairOp());
+		UnifyType newLhs = this.apply(p.getLhsType());
+		UnifyType newRhs = this.apply(p.getRhsType());
+		return new UnifyPair(newLhs, newRhs, p.getPairOp());
+	}
+	
+	/**
+	 * Applies the unifier to the two terms of the pair.
+	 * works only for single subsitution
+	 * @return A new pair where the left and right-hand side are applied
+	 */
+	public UnifyPair apply(UnifyPair thisAsPair, UnifyPair p) {
+		UnifyType newLhs = this.apply(p.getLhsType());
+		UnifyType newRhs = this.apply(p.getRhsType());
+		//Varianceweitergabe wird nicht benoetigt.
+		//PlaceholderType lhsph = (PlaceholderType)thisAsPair.getLhsType();
+		//if (lhsph.getVariance() != 0) {
+		//	if (p.getLhsType().equals(lhsph)) {
+		//		if (p.getRhsType() instanceof PlaceholderType) {
+		//			((PlaceholderType)p.getRhsType()).setVariance(lhsph.getVariance());
+		//		}
+		//	}
+		//	if (p.getRhsType().equals(lhsph)) {
+		//		if (p.getLhsType() instanceof PlaceholderType) {
+		//			((PlaceholderType)p.getLhsType()).setVariance(lhsph.getVariance());
+		//		}
+		//	}
+		//}
+		if (!(p.getLhsType().equals(newLhs)) || !(p.getRhsType().equals(newRhs))) {//Die Anwendung von this hat was veraendert PL 2018-04-01
+			Set<UnifyPair> suniUnifyPair = new HashSet<>();
+			suniUnifyPair.addAll(thisAsPair.getAllSubstitutions());
+			suniUnifyPair.add(thisAsPair);
+			if (p.getLhsType() instanceof PlaceholderType //&& newLhs instanceof PlaceholderType entfernt PL 2018-04-13
+					&& p.getPairOp() == PairOperator.EQUALSDOT) {
+				suniUnifyPair.add(p); //p koennte auch subsitution sein
+			}
+			return new UnifyPair(newLhs, newRhs, p.getPairOp(), suniUnifyPair, p);
+		}
+		return new UnifyPair(newLhs, newRhs, p.getPairOp(), p.getSubstitution(), p.getBasePair(), p.getfBounded());
 	}
 	
 	/**

src/de/dhbwstuttgart/typeinference/unify/model/UnifyPair.java

@@ -2,7 +2,10 @@ package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
+
 
 /**
  * A pair which contains two types and an operator, e.q. (Integer <. a).
@@ -25,6 +28,36 @@ public class UnifyPair {
 	 */
 	private PairOperator pairOp;
 	
+	/** wieder loesecn wird nicht mehr benoetigt PL 2018-03-31
+     * variance shows the variance of the pair
+     * -1: contravariant
+     * 1 covariant
+     * 0 invariant
+     * PL 2018-03-21
+     */
+    private byte variance = 0;
+    
+    private boolean undefinedPair = false;
+    
+    /**
+     * Unifier/substitute that generated this pair
+     * PL 2018-03-15
+     */
+    private Set<UnifyPair> substitution;
+    
+    /**
+     * Base on which the the unifier is applied
+     * PL 2018-03-15
+     */
+    private UnifyPair basePair;
+    
+    /**
+     * For pairs a <. Theta generated in the rule reduceTphSup
+     * to store the f-Bouned Elements to avoid endless recursion 
+     * PL 2018-03-15
+     */
+    private Set<UnifyType> fBounded = new HashSet<>();
+	
 	private final int hashCode;
 	
 	/**
@@ -37,11 +70,31 @@ public class UnifyPair {
 		this.lhs = lhs;
 		this.rhs = rhs;
 		pairOp = op;
+		substitution = new HashSet<>();
 		
 		// Caching hashcode
 		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
 	}	
 	
+	public UnifyPair(UnifyType lhs, UnifyType rhs, PairOperator op, Set<UnifyPair> uni, UnifyPair base) {
+		this.lhs = lhs;
+		this.rhs = rhs;
+		pairOp = op;
+		substitution = uni;
+		basePair = base;
+		this.variance = variance;
+		
+		
+		// Caching hashcode
+		hashCode = 17 + 31 * lhs.hashCode() + 31 * rhs.hashCode() + 31 * pairOp.hashCode();
+	}	
+	
+	public UnifyPair(UnifyType lhs, UnifyType rhs, PairOperator op, Set<UnifyPair> uni, UnifyPair base, Set<UnifyType> fBounded) {
+		this(lhs, rhs, op, uni, base);
+		
+		this.fBounded = fBounded;
+	}
+		
 	/**
 	 * Returns the type on the left hand side of the pair.
 	 */
@@ -63,6 +116,45 @@ public class UnifyPair {
 		return pairOp;
 	}
 	
+	public byte getVariance() {
+		return variance;
+	}
+	
+	public void setVariance(byte v) {
+		variance = v;
+	}
+	
+	public void setUndefinedPair() {
+		undefinedPair = true;
+	}
+	public Set<UnifyPair> getSubstitution() {
+		return substitution;
+	}
+	
+	public UnifyPair getBasePair() {
+		return basePair;
+	}
+	public boolean isUndefinedPair() {
+		return undefinedPair;
+	}
+	
+	public Set<UnifyPair> getAllSubstitutions () {
+		Set<UnifyPair> ret = new HashSet<>();
+		ret.addAll(getSubstitution());
+		if (basePair != null) {
+			ret.addAll(basePair.getAllSubstitutions());
+		}
+		return ret;
+	}
+	
+	public Boolean wrongWildcard() {
+		return lhs.wrongWildcard() || rhs.wrongWildcard();
+	}
+	
+	public Set<UnifyType> getfBounded() {
+		return this.fBounded;
+	}
+	
 	@Override
 	public boolean equals(Object obj) {
 		if(!(obj instanceof UnifyPair))
@@ -73,6 +165,16 @@ public class UnifyPair {
 
 		UnifyPair other = (UnifyPair) obj;
 		
+		if (isUndefinedPair()) {
+			if (other.getBasePair() != basePair || (other.getBasePair() == null && basePair == null)) { 
+				return false;
+			}
+			if (!other.getBasePair().equals(basePair) ||
+				!other.getAllSubstitutions().equals(getAllSubstitutions())) {
+				return false;
+			}
+		}
+		
 		return other.getPairOp() == pairOp 
 				&& other.getLhsType().equals(lhs) 
 				&& other.getRhsType().equals(rhs);
@@ -85,7 +187,14 @@ public class UnifyPair {
 	
 	@Override
 	public String toString() {
-		return "(" + lhs + " " + pairOp + " " + rhs + ")";
+		String ret = "";
+		if (lhs instanceof PlaceholderType) {
+			ret = new Integer(((PlaceholderType)lhs).getVariance()).toString();
+		}
+		if (rhs instanceof PlaceholderType) {
+			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString();
+		}
+		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ", [" + getfBounded().toString()+ "])";
 	}
 
 	/*

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

@@ -2,10 +2,13 @@ package de.dhbwstuttgart.typeinference.unify.model;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Set;
 
+import de.dhbwstuttgart.syntaxtree.StatementVisitor;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
 
 /**
  * Represents a java type.
@@ -33,6 +36,9 @@ public abstract class UnifyType {
 		typeParams = p;
 	}
 	
+
+	abstract public <T> UnifyType accept(UnifyTypeVisitor<T> visitor, T ht); 
+	
 	/**
 	 * Returns the name of the type.
 	 * @return The name e.q. List for List<T>, Integer or ? extends Integer
@@ -62,7 +68,7 @@ public abstract class UnifyType {
 	 * @param fc The FC that is called.
 	 * @return The set that is smArg(this)
 	 */
-	abstract Set<UnifyType> smArg(IFiniteClosure fc);
+	abstract Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded);
 	
 	/**
 	 * Implementation of the visitor-pattern. Returns the set of grArg
@@ -70,7 +76,7 @@ public abstract class UnifyType {
 	 * @param fc The FC that is called.
 	 * @return The set that is grArg(this)
 	 */
-	abstract Set<UnifyType> grArg(IFiniteClosure fc);
+	abstract Set<UnifyType> grArg(IFiniteClosure fc, Set<UnifyType> fBounded);
 	
 	/**
 	 * Applies a unifier to this object.
@@ -96,6 +102,10 @@ public abstract class UnifyType {
 		ret.addAll(typeParams.getInvolvedPlaceholderTypes());
 		return ret;
 	}
+	
+	public Boolean wrongWildcard() {//default
+		return false;
+	}
 
 	@Override
 	public int hashCode() {

src/de/dhbwstuttgart/typeinference/unify/model/WildcardType.java

@@ -40,6 +40,11 @@ public abstract class WildcardType extends UnifyType {
 		return wildcardedType.getTypeParams();
 	}
 	
+	@Override
+	public Boolean wrongWildcard () {//This is an error
+		return (wildcardedType instanceof WildcardType);
+	}
+	
 	@Override
 	public int hashCode() {
 		return wildcardedType.hashCode() + getName().hashCode() + 17;

src/de/dhbwstuttgart/typeinference/unify/visitUnifyTypeVisitor.java

@@ -0,0 +1,47 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.stream.Collectors;
+
+import de.dhbwstuttgart.typeinference.unify.interfaces.UnifyTypeVisitor;
+import de.dhbwstuttgart.typeinference.unify.model.ExtendsType;
+import de.dhbwstuttgart.typeinference.unify.model.FunNType;
+import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
+import de.dhbwstuttgart.typeinference.unify.model.ReferenceType;
+import de.dhbwstuttgart.typeinference.unify.model.SuperType;
+import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
+
+public class visitUnifyTypeVisitor<T> implements UnifyTypeVisitor<T> {
+
+	public ReferenceType visit(ReferenceType refty, T ht) {
+		return new ReferenceType(refty.getName(),
+				new TypeParams(
+						Arrays.stream(refty.getTypeParams().get())
+						.map(x -> x.accept(this, ht))
+						.collect(Collectors.toCollection(ArrayList::new))));
+	}
+	
+	public PlaceholderType visit(PlaceholderType phty, T ht) {
+		return phty;
+	}
+	
+	public FunNType visit(FunNType funnty, T ht) {
+		return FunNType.getFunNType(
+				new TypeParams(
+						Arrays.stream(funnty.getTypeParams().get())
+						.map(x -> x.accept(this, ht))
+						.collect(Collectors.toCollection(ArrayList::new)))
+				);	
+	}
+	
+	public SuperType visit(SuperType suty, T ht) {
+		return new SuperType(suty.getWildcardedType().accept(this, ht));
+	}
+	
+	public ExtendsType visit(ExtendsType extty, T ht) {
+		return new ExtendsType(extty.getWildcardedType().accept(this, ht));
+	}
+}

target/repository/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

test/bytecode/ATest.java

@@ -1,8 +0,0 @@
-package bytecode;
-
-public class ATest extends JavaTXCompilerTest {
-	public ATest() {
-		fileName = "Example";
-	}
-
-}

test/bytecode/AssignToLitTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class AssignToLitTest extends JavaTXCompilerTest {
-	public AssignToLitTest() {
-		this.fileName = "AssignToLit";
-	}
-}

test/bytecode/BinaryTest.java

@@ -0,0 +1,40 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class BinaryTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/BinaryInMeth.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("BinaryInMeth");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() {
+		fail("Not yet implemented");
+	}
+
+}

test/bytecode/DuMethodTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class DuMethodTest extends JavaTXCompilerTest{
-	public DuMethodTest() {
-		this.fileName = "DuMethod";
-	}
-}

test/bytecode/FacTest.java

@@ -0,0 +1,44 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class FacTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Fac.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Fac");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method getFac = classToTest.getDeclaredMethod("getFac", Integer.class);
+		Double result = (Double) getFac.invoke(instanceOfClass,3);
+		assertEquals(result, 6.0);
+	}
+
+}

test/bytecode/Faculty.jav

@@ -1,14 +0,0 @@
-class Faculty {
-
-  Integer mul(Integer x, Integer y) {
-  	return x;
-   }
-
-  m () {
-	  
-   var fact = (Integer x) -> {
-        return mul(x, x);
-   };
-   return fact;
-  }
-}

test/bytecode/FacultyTest.java

@@ -0,0 +1,44 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class FacultyTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Faculty.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		compiler.generateBytecode(pathToClassFile);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Fac");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method getFac = classToTest.getDeclaredMethod("getFac", Integer.class);
+		Integer result = (Integer) getFac.invoke(instanceOfClass,3);
+		assertEquals(result, 6);
+	}
+
+}

test/bytecode/ForTest.java

@@ -1,11 +0,0 @@
-package bytecode;
-
-import org.objectweb.asm.Opcodes;
-
-public class ForTest extends JavaTXCompilerTest {
-	
-	public ForTest() {
-		this.fileName = "For";
-	}
-
-}

test/bytecode/GenTest.java

@@ -0,0 +1,41 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class GenTest {
+
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Gen.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Gen");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() {
+		fail("Not yet implemented");
+	}
+
+}

test/bytecode/Generics2Test.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class Generics2Test extends JavaTXCompilerTest{
-	public Generics2Test() {
-		this.fileName = "Generics2";
-	}
-}

test/bytecode/GenericsTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class GenericsTest extends JavaTXCompilerTest {
-	public GenericsTest() {
-		this.fileName = "Generics";
-	}
-}

test/bytecode/GreaterEqualTest.java

@@ -0,0 +1,140 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class GreaterEqualTest {
+
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/GreaterEqual.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("File://"+pathToClassFile)});
+		classToTest = loader.loadClass("GreaterEqual");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testName() {
+		assertEquals("GreaterEqual", classToTest.getName());
+	}
+	@Test
+	public void testIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Integer.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 7, 5);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testIntegers2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Integer.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5, 7);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testEqIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Integer.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5, 5);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testLongs() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Long.class, Long.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 10L,7L);
+		assertTrue(result);
+	}
+
+	@Test
+	public void testFloats() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Float.class, Float.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5F,7F);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testDoubles() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Double.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5.0,7.0);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLongInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Long.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 15L,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Float.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5F,7);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testDoubleInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Integer.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 25.0,17);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Float.class, Long.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 75F,70L);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Long.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 5.0,7L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testEqDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Float.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 7.0,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Float.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 15.0,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleFloat3() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gE = classToTest.getDeclaredMethod("gE", Double.class, Float.class);
+		Boolean result = (Boolean) gE.invoke(instanceOfClass, 9.0,17F);
+		assertFalse(result);
+	}
+
+}

test/bytecode/GreaterThanTest.java

@@ -0,0 +1,139 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class GreaterThanTest {
+
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/GreaterThan.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("File://"+pathToClassFile)});
+		classToTest = loader.loadClass("GreaterThan");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testName() {
+		assertEquals("GreaterThan", classToTest.getName());
+	}
+	
+	public void testIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Integer.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 7, 5);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testIntegers2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Integer.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5, 7);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testEqIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Integer.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLongs() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Long.class, Long.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 10L,7L);
+		assertTrue(result);
+	}@Test
+	
+	public void testFloats() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Float.class, Float.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5F,7F);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testDoubles() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Double.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5.0,7.0);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLongInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Long.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 15L,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Float.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5F,7);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testDoubleInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Integer.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 25.0,17);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Float.class, Long.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 75F,70L);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Long.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 5.0,7L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testEqDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Float.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 7.0,7F);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Float.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 15.0,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleFloat3() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method gT = classToTest.getDeclaredMethod("gT", Double.class, Float.class);
+		Boolean result = (Boolean) gT.invoke(instanceOfClass, 9.0,17F);
+		assertFalse(result);
+	}
+
+}

test/bytecode/ImportTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class ImportTest extends JavaTXCompilerTest{
-	public ImportTest() {
-		this.fileName = "Import";
-	}
-}

test/bytecode/InterfaceTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class InterfaceTest extends JavaTXCompilerTest{
-	public InterfaceTest() {
-		this.fileName = "Interface1";
-	}
-}

test/bytecode/JavaTXCompilerTest.java

@@ -1,90 +0,0 @@
-package bytecode;
-
-import de.dhbwstuttgart.bytecode.BytecodeGen;
-import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.typeinference.result.ResultPair;
-import de.dhbwstuttgart.typeinference.result.ResultSet;
-import org.junit.Test;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-import static org.junit.Assert.*;
-
-public class JavaTXCompilerTest  {
-
-    private static final String rootDirectory = System.getProperty("user.dir")+"/test/bytecode/";
-    private static final List<File> filesToTest = new ArrayList<>();
-    
-    protected String fileName = "";
-    
-    @Test
-    public void test() throws IOException, java.lang.ClassNotFoundException {
-    		System.out.println(rootDirectory);
-        filesToTest.add(new File(rootDirectory+fileName+".jav"));
-        System.out.println(rootDirectory+fileName+".jav");
-        JavaTXCompiler compiler = new JavaTXCompiler(filesToTest);
-        for(File f : filesToTest){
-            String content = readFile(f.getPath(), StandardCharsets.UTF_8);
-            List<ResultSet> typeinferenceResult = compiler.typeInference();
-            HashMap<String,byte[]> bytecode = this.getBytecode(compiler.sourceFiles.get(f), typeinferenceResult.get(0));
-            
-//            for(ResultPair ep : typeinferenceResult.get(0).results) {
-//            		System.out.println(ep.getLeft() + " ->" + ep.getRight());
-//            }
-            
-            String name;
-            int pos = f.getName().lastIndexOf(".");
-            if(pos != -1) {
-               name = f.getName().substring(0, pos);
-            }
-            this.writeClassFile(bytecode);
-        }
-
-    }
-    
-
-    public HashMap<String,byte[]> getBytecode(SourceFile sf, ResultSet resultSet) {
-    		HashMap<String,byte[]> classFiles = new HashMap<>();
-    		BytecodeGen bytecodeGen = new BytecodeGen(classFiles,resultSet);
-    		bytecodeGen.visit(sf);
-    		return bytecodeGen.getClassFiles();
-	}
-    
-    public void writeClassFile(HashMap<String,byte[]> classFiles) {
-    		FileOutputStream output;
-    		for(String name : classFiles.keySet()) {
-    			byte[] bytecode = classFiles.get(name);
-    			try {
-    				System.out.println("generating "+name+ ".class file ...");
-    				output = new FileOutputStream(new File(System.getProperty("user.dir") + "/testBytecode/generatedBC/" +name+".class"));
-    				output.write(bytecode);
-    				output.close();
-    				System.out.println(name+".class file generated");
-    			} catch (FileNotFoundException e) {
-    				e.printStackTrace();
-    			} catch (IOException e) {
-    				e.printStackTrace();
-    			}
-    		}
-    		
-    }
-
-	static String readFile(String path, Charset encoding)
-            throws IOException
-    {
-        byte[] encoded = Files.readAllBytes(Paths.get(path));
-        return new String(encoded, encoding);
-    }
-
-}

test/bytecode/LamAssignTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class LamAssignTest extends JavaTXCompilerTest{
-	public LamAssignTest() {
-		this.fileName = "LamAssign";
-	}
-}

test/bytecode/LambdaTest.java

@@ -0,0 +1,47 @@
+package bytecode;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class LambdaTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@Test
+	public void generateBC() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Lambda.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		compiler.generateBytecode(System.getProperty("user.dir")+"/testBytecode/generatedBC/");
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Lambda");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+
+		Method m = classToTest.getDeclaredMethod("m");
+		Class<?> lambda = m.invoke(instanceOfClass).getClass();
+		Method apply = lambda.getMethod("apply", Object.class);
+		apply.setAccessible(true);
+
+		Integer i = 77;
+		// result = 77*77 = 5929
+		Integer result = (Integer) apply.invoke(m.invoke(instanceOfClass), i); 
+		assertEquals(5929, result);
+	}
+
+
+}

test/bytecode/LessEqualTest.java

@@ -0,0 +1,133 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class LessEqualTest {
+	
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/LessEqual.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("LessEqual");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testName() {
+		assertEquals("LessEqual", classToTest.getName());
+	}
+	
+	@Test
+	public void testIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Integer.class, Integer.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testEqualIntegers() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Integer.class, Integer.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5,5);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testLongs() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Long.class, Long.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5L,7L);
+		assertTrue(result);
+	}@Test
+	
+	public void testFloats() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Float.class, Float.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5F,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubles() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Double.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5.0,7.0);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testLongInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Long.class, Integer.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5L,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Float.class, Integer.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5F,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Integer.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5.0,7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testFloatLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Float.class, Long.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5F,7L);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Long.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5.0,7L);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testEqDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Float.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 7.0,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Float.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 5.0,7F);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testDoubleFloat3() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessEqual = classToTest.getDeclaredMethod("lessEqual", Double.class, Float.class);
+		Boolean result = (Boolean) lessEqual.invoke(instanceOfClass, 9.0,7F);
+		assertFalse(result);
+	}
+
+}

test/bytecode/LessThanTest.java

@@ -0,0 +1,141 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class LessThanTest {
+	
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/LessThan.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("LessThan");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testClassName() {
+		assertEquals("LessThan", classToTest.getName());
+	}
+	
+	@Test
+	public void testLessThanInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Integer.class,Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 5, 7);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testLessThanInt2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Integer.class, Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanInt3() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Integer.class, Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 5, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Long.class,Long.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 5L, 7L);
+		assertTrue(result);
+	}
+	
+	@Test
+	public void testLessThanLong2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Long.class, Long.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7L, 5L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanLong3() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Long.class, Long.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 5L, 5L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Float.class, Float.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7F, 5F);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Double.class, Double.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7.0, 5.0);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanLongInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Long.class, Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7L, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanFloatInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Float.class, Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7F, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanDoubleInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Double.class, Integer.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7.0, 5);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanFloatLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Float.class, Long.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7F, 5L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanDoubleLong() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Double.class, Long.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7.0, 5L);
+		assertFalse(result);
+	}
+	
+	@Test
+	public void testLessThanDoubleFloat() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method lessThan = classToTest.getDeclaredMethod("lessThan", Double.class, Float.class);
+		Boolean result = (Boolean) lessThan.invoke(instanceOfClass, 7.0, 5F);
+		assertFalse(result);
+	}
+
+}

test/bytecode/MatrixTest.java

@@ -0,0 +1,93 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class MatrixTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass_m1;
+	private static Object instanceOfClass_m2;
+	private static Object instanceOfClass_m3;
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, IOException, InstantiationException {	
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Matrix.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Matrix"); 
+		
+		instanceOfClass_m1 = classToTest.getDeclaredConstructor().newInstance(); //Matrix m1 = new Matrix();
+		//Vector<Vector<Integer>> vv = new Vector<Vector<Integer>>();
+		Vector<Integer> v1 = new Vector<Integer> ();
+		v1.addElement(2);
+		v1.addElement(2);
+		Vector<Integer> v2 = new Vector<Integer> ();
+		v2.addElement(3);
+		v2.addElement(3);
+		//Method[] ms = classToTest.getSuperclass().getDeclaredMethods();
+		Method addElement = classToTest.getSuperclass().getDeclaredMethod("addElement", Object.class);
+		addElement.invoke(instanceOfClass_m1, v1); //m1.addElement(v1);
+		addElement.invoke(instanceOfClass_m1, v2); //m1.addElement(v2);
+		//vv.addElement(v1);
+		//vv.addElement(v2);
+		//instanceOfClass_m1 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv);  //Matrix m1 = new Matrix(vv);
+		
+		Vector<Vector<Integer>> vv1 = new Vector<Vector<Integer>>();
+		Vector<Integer> v3 = new Vector<Integer> ();
+		v3.addElement(2);
+		v3.addElement(2);
+		Vector<Integer> v4 = new Vector<Integer> ();
+		v4.addElement(3);
+		v4.addElement(3);
+		//Matrix m2 = new Matrix();
+		//m2.addElement(v3);
+		//m2.addElement(v4);
+		vv1.addElement(v3);
+		vv1.addElement(v4);
+		instanceOfClass_m2 = classToTest.getDeclaredConstructor(Vector.class).newInstance(vv1);//Matrix m2 = new Matrix(vv1);
+		
+		 
+
+		//Matrix m3 = m1.mul(vv1);
+		Method mul = classToTest.getDeclaredMethod("mul", Vector.class);
+		Object result = mul.invoke(instanceOfClass_m1, instanceOfClass_m2);
+		System.out.println(instanceOfClass_m1.toString() + " * " + instanceOfClass_m1.toString() + " = " + result.toString());
+			
+		Vector<Vector<Integer>> res = new Vector<Vector<Integer>>();
+		Vector<Integer> v5 = new Vector<Integer> ();
+		v5.addElement(10);
+		v5.addElement(10);
+		Vector<Integer> v6 = new Vector<Integer> ();
+		v6.addElement(15);
+		v6.addElement(15);
+		//Matrix m2 = new Matrix();
+		//m2.addElement(v3);
+		//m2.addElement(v4);
+		res.addElement(v5);
+		res.addElement(v6);
+		instanceOfClass_m3 = classToTest.getDeclaredConstructor(Vector.class).newInstance(res);
+		assertEquals(result, instanceOfClass_m3);
+		
+	}
+
+}

test/bytecode/MethodsTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class MethodsTest extends JavaTXCompilerTest {
-	public MethodsTest() {
-		this.fileName = "Methods";
-	}
-}

test/bytecode/OLTest.java

@@ -0,0 +1,92 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class OLTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static Class<?> classToTest1;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	private static Object instanceOfClass1;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/OL.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("OL");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+		classToTest1 = loader.loadClass("OLMain");
+		instanceOfClass1 = classToTest1.getDeclaredConstructor().newInstance();
+	}
+	
+	@Test
+	public void testOLClassName() {
+		assertEquals("OL", classToTest.getName());
+	}
+	
+	@Test
+	public void testmInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", Integer.class);
+		Integer result = (Integer) m.invoke(instanceOfClass, 5);
+		assertEquals(10, result);
+	}
+	
+	@Test
+	public void testmDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", Double.class);
+		Double result = (Double) m.invoke(instanceOfClass, 5.0);
+		assertEquals(10.0, result);
+	}
+	
+	@Test
+	public void testmString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", String.class);
+		String result = (String) m.invoke(instanceOfClass, "xxx");
+		assertEquals("xxxxxx", result);
+	}
+	
+	@Test
+	public void testOLMainClassName() {
+		assertEquals("OLMain", classToTest1.getName());
+	}
+	
+	@Test
+	public void testmainInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", Integer.class);
+		Integer result = (Integer) main.invoke(instanceOfClass1, 5);
+		assertEquals(10, result);
+	}
+	
+	@Test
+	public void testmainDouble() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", Double.class);
+		Double result = (Double) main.invoke(instanceOfClass1, 5.0);
+		assertEquals(10.0, result);
+	}
+	
+	@Test
+	public void testmainString() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method main = classToTest1.getDeclaredMethod("main", String.class);
+		String result = (String) main.invoke(instanceOfClass1, "xxx");
+		assertEquals("xxxxxx", result);
+	}
+}

test/bytecode/Op.jav

@@ -1,12 +0,0 @@
-import java.lang.Integer;
-
-class Op {
-	m(Integer a, Integer b) {
-		Integer c = a+b;
-//		d = a-b;
-//		e = a*b;
-//		f = a/b;
-		
-		return c;
-	}
-}

test/bytecode/OpTest.java

@@ -1,7 +1,61 @@
 package bytecode;
 
-public class OpTest extends JavaTXCompilerTest {
+import static org.junit.Assert.*;
-	public OpTest() {
+
-		this.fileName = "Op";
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.objectweb.asm.Opcodes;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class OpTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Op.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Op");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}
+
+	@Test
+	public void testAddString() throws NoSuchMethodException, SecurityException, IllegalAccessException, 
+						IllegalArgumentException, InvocationTargetException, InstantiationException {
+		
+		Method m = classToTest.getDeclaredMethod("m", String.class,String.class);
+		
+		String result = (String) m.invoke(instanceOfClass, "Byte","Code");
+		
+		assertEquals("ByteCode", result);
+	}
+	
+	@Test
+	public void testAddInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, 
+						IllegalArgumentException, InvocationTargetException, InstantiationException {
+		
+		Method m = classToTest.getDeclaredMethod("m", Integer.class,Integer.class);
+		
+		Integer result = (Integer) m.invoke(instanceOfClass, 7,3);
+		
+		assertEquals(10, result);
+	}
+	
+
 }

test/bytecode/OverlaodGenTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class OverlaodGenTest extends JavaTXCompilerTest {
-	public OverlaodGenTest() {
-		this.fileName = "OverlaodGen";
-	}
-}

test/bytecode/OverloadingTest.java

@@ -0,0 +1,57 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class OverloadingTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	private static Class<?> classOL2;
+	private static Object instanceOfClassOL2;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Overloading.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Overloading");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+		
+		classOL2 = loader.loadClass("Overloading2");
+		instanceOfClassOL2 = classOL2.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method meth = classToTest.getDeclaredMethod("test", classToTest);
+		String res = (String) meth.invoke(instanceOfClass, instanceOfClass);
+		assertEquals("Overloading", res);
+	}
+	
+	@Test
+	public void test2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method meth = classToTest.getDeclaredMethod("test", classOL2);
+		String res = (String) meth.invoke(instanceOfClass, instanceOfClassOL2);
+		assertEquals("Overloading2", res);
+	}
+
+}

test/bytecode/PlusTest.java

@@ -0,0 +1,53 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class PlusTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Plus.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("Plus");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testAddInt() throws NoSuchMethodException, SecurityException, IllegalAccessException, 
+						IllegalArgumentException, InvocationTargetException, InstantiationException {
+		Method addInt = classToTest.getDeclaredMethod("m", Integer.class,Integer.class);
+		Number result = (Number) addInt.invoke(instanceOfClass, 7,3);
+		assertEquals(10, result);
+	}
+	
+	@Test
+	public void testAddString() throws NoSuchMethodException, SecurityException, IllegalAccessException, 
+						IllegalArgumentException, InvocationTargetException, InstantiationException {
+		Method addString = classToTest.getDeclaredMethod("m", String.class,String.class);
+		String result = (String) addString.invoke(instanceOfClass, "Byte","Code");
+		assertEquals("ByteCode", result);
+	}
+
+}

test/bytecode/PostIncTest.java

@@ -0,0 +1,65 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class PostIncTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/PostIncDec.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("PostIncDec");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testM1() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(1, res);
+	}
+	
+	@Test
+	public void testM2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m2");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(0, res);
+	}
+	
+	@Test
+	public void testD1() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("d");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(-1, res);
+	}
+	
+	@Test
+	public void testD2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("d2");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(0, res);
+	}
+
+}

test/bytecode/PreIncTest.java

@@ -0,0 +1,65 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class PreIncTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/PreInc.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://" + pathToClassFile)});
+		classToTest = loader.loadClass("PreInc");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void testM() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(1, res);
+	}
+	
+	@Test
+	public void testM2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m2");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(1, res);
+	}
+	
+	@Test
+	public void testD() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("d");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(-1, res);
+	}
+	
+	@Test
+	public void testD2() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("d2");
+		Integer res = (Integer) m.invoke(instanceOfClass);
+		assertEquals(-1, res);
+	}
+
+}

test/bytecode/RelOpsTest.java

@@ -0,0 +1,44 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class RelOpsTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/RelOps.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
+		classToTest = loader.loadClass("RelOps");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		Method m = classToTest.getDeclaredMethod("m", Integer.class,Integer.class);
+		Boolean result = (Boolean) m.invoke(instanceOfClass, 7,3);
+		assertFalse(result);
+	}
+
+}

test/bytecode/StaticTest.java

@@ -0,0 +1,41 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class StaticTest {
+	
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static ClassLoader loader;
+	private static Class<?> classToTest;
+	private static String pathToClassFile;
+	private static Object instanceOfClass;
+	
+	@BeforeClass
+	public static void setUpBeforeClass() throws Exception {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/StaticM.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+		loader = new URLClassLoader(new URL[] {new URL("file://" + pathToClassFile)});
+		classToTest = loader.loadClass("StaticM");
+		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
+	}
+
+	@Test
+	public void test() {
+		fail("Not yet implemented");
+	}
+
+}

test/bytecode/SubMatTest.java

@@ -0,0 +1,27 @@
+package bytecode;
+
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.junit.Test;
+
+import de.dhbwstuttgart.core.JavaTXCompiler;
+
+public class SubMatTest {
+	private static String path;
+	private static File fileToTest;
+	private static JavaTXCompiler compiler;
+	private static String pathToClassFile;
+	
+	@Test
+	public void test() throws ClassNotFoundException, IOException {
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/SubMatrix.jav";
+		fileToTest = new File(path);
+		compiler = new JavaTXCompiler(fileToTest);
+		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+		compiler.generateBytecode(pathToClassFile);
+	}
+
+}

test/bytecode/TestIfTest.java

@@ -1,7 +0,0 @@
-package bytecode;
-
-public class TestIfTest extends JavaTXCompilerTest{
-	public TestIfTest() {
-		this.fileName = "IfTest";
-	}
-}