Merge remote-tracking branch 'origin/plugin' into plugin

# Conflicts:
#	src/main/java/de/dhbwstuttgart/bytecode/BytecodeGenMethod.java
#	src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
#	src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify.java
#	src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnify2Task.java
#	src/main/java/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
#	src/main/java/de/dhbwstuttgart/typeinference/unify/UnifyResultModel.java

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

@@ -140,8 +140,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 	}
 
 	public BytecodeGenMethod(LambdaExpression lambdaExpression, ArrayList<String> usedVars, ResultSet resultSet, MethodVisitor mv,
-			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf,HashMap<String, String> genericsAndBoundsMethod,
+			int indexOfFirstParamLam, boolean isInterface, HashMap<String, byte[]> classFiles, String path, int lamCounter, SourceFile sf) {
-			HashMap<String, String> genericsAndBounds) {
 
 		this.resultSet = resultSet;
 		this.mv = mv;
@@ -150,9 +149,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		this.path = path;
 		this.lamCounter = lamCounter;
 		this.sf = sf;
-		this.genericsAndBoundsMethod = genericsAndBoundsMethod;
-		this.genericsAndBounds = genericsAndBounds;
-		
 		Iterator<FormalParameter> itr = lambdaExpression.params.iterator();
 		int i = indexOfFirstParamLam;
 		
@@ -648,8 +644,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			ArrayList<String> usedVars = kindOfLambda.getUsedVars();
 			
 			new BytecodeGenMethod(lambdaExpression, usedVars,this.resultSet, mvLambdaBody, indexOfFirstParamLam, isInterface,
-					classFiles,this.path, lamCounter, sf, genericsAndBoundsMethod,
+					classFiles,this.path, lamCounter, sf);
-					genericsAndBounds);
 	
 			mvLambdaBody.visitMaxs(0, 0);
 			mvLambdaBody.visitEnd();
@@ -749,13 +744,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 		statement = new IfStatement(ifStmt.expr, ifStmt.then_block, ifStmt.else_block);
 		isBinaryExp = statement.isExprBinary();
 		ifStmt.expr.accept(this);
-		if(!(ifStmt.expr instanceof BinaryExpr)) {
-			doUnboxing(getResolvedType(ifStmt.expr.getType()));
-			Label branchLabel = new Label();
-			Label endLabel = new Label();
-			mv.visitJumpInsn(Opcodes.IFEQ, branchLabel);
-			statement.genBCForRelOp(mv, branchLabel, endLabel, this);
-		}
 		statement = null;
 	}
 
@@ -770,90 +758,86 @@ public class BytecodeGenMethod implements StatementVisitor {
 		System.out.println("In MethodCall = " + methodCall.name);
 		String receiverName = getResolvedType(methodCall.receiver.getType());
 		System.out.println("Methods of " + receiverName + " ");
+		ClassLoader cLoader = ClassLoader.getSystemClassLoader();
+		// This will be used if the class is not standard class (not in API)
+		ClassLoader cLoader2;
 		java.lang.reflect.Method methodRefl = null;
 		String clazz = receiverName.replace("/", ".");
-//		if(!receiverName.equals(className)) {
+		String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
-			ClassLoader cLoader = ClassLoader.getSystemClassLoader();
+		String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
-			// This will be used if the class is not standard class (not in API)
+		try {
-			ClassLoader cLoader2;
+			if(receiverName.contains("<")) {
+				clazz = clazz.substring(0, receiverName.indexOf("<"));
+			}
 			
-			String methCallType = resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor());
+			java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
-			String[] typesOfParams = getTypes(methodCall.arglist.getArguments());
+			System.out.println("Methods of " + receiverName + " ");
-			try {
+			methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methods);
-				if(receiverName.contains("<")) {
+			
-					clazz = clazz.substring(0, receiverName.indexOf("<"));
+		} catch (Exception e) {
-				}
+//			try {
-				
+//				cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
-				java.lang.reflect.Method[] methods = cLoader.loadClass(clazz).getMethods();
+//				java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
-				System.out.println("Methods of " + receiverName + " ");
+//				System.out.println("Methods of " + receiverName + " ");
-				methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methods);
+//				for(int i = 0; i<methods.length; i++) {
-				
+//					System.out.println(methods[i]);
-			} catch (Exception e) {
+//				}
-//				try {
+//				methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
-//					cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+//			}catch (Exception e2) {
-//					java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+				String superClass = "";
-//					System.out.println("Methods of " + receiverName + " ");
+				// TODO: Test SubMatrix.jav
-//					for(int i = 0; i<methods.length; i++) {
+				while(true) {
-//						System.out.println(methods[i]);
+					for(ClassOrInterface cl : sf.getClasses()) {
-//					}
+						if(receiverName.equals(cl.getClassName().toString())) {
-//					methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
+							superClass = cl.getSuperClass().getName().toString();
-//				}catch (Exception e2) {
+							break;
-					String superClass = "";
+						}
-					// TODO: Test SubMatrix.jav
+					}
-					while(true) {
+					System.out.println(superClass);
-						for(ClassOrInterface cl : sf.getClasses()) {
+					
-							if(receiverName.equals(cl.getClassName().toString())) {
+					if(superClass.equals(""))
-								superClass = cl.getSuperClass().getName().toString();
+						break;
+					
+					try {
+						String superClazz = superClass.replace("/", ".");
+						if(superClass.contains("<")) {
+							superClazz = superClazz.substring(0, superClass.indexOf("<"));
+						}
+						java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
+						System.out.println("Methods of " + superClass + " ");
+						
+						for(java.lang.reflect.Method m : methods) {
+							if(methodCall.name.equals(m.getName())) {
+								methodRefl = m;
 								break;
 							}
 						}
-						System.out.println(superClass);
 						
-						if(superClass.equals(""))
+						break;
-							break;
+					} catch (Exception e3) {
-						
+						receiverName = superClass;
-						try {
+						continue;
-							String superClazz = superClass.replace("/", ".");
-							if(superClass.contains("<")) {
-								superClazz = superClazz.substring(0, superClass.indexOf("<"));
-							}
-							java.lang.reflect.Method[] methods = cLoader.loadClass(superClazz).getMethods();
-							System.out.println("Methods of " + superClass + " ");
-							
-							for(java.lang.reflect.Method m : methods) {
-								if(methodCall.name.equals(m.getName())) {
-									methodRefl = m;
-									break;
-								}
-							}
-							
-							break;
-						} catch (Exception e3) {
-							receiverName = superClass;
-							continue;
-						}
 					}
-//				}
+				}
-				
+//			}
-			}
 			
-			if(methodRefl == null) {
+		}
-				try {
-					cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
-					java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
-					System.out.println("Methods of " + receiverName + " ");
-					for(int i = 0; i<methods.length; i++) {
-						System.out.println(methods[i]);
-					}
-					methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
-				}
-				catch (Exception e2) {
-					System.out.println("");
-					//do nothing
-				}
-			}
-//		}
 		
+		if(methodRefl == null) {
+			try {
+				cLoader2 = new URLClassLoader(new URL[] {new URL("file://"+path)});
+				java.lang.reflect.Method[] methods = cLoader2.loadClass(clazz).getMethods();
+				System.out.println("Methods of " + receiverName + " ");
+				for(int i = 0; i<methods.length; i++) {
+					System.out.println(methods[i]);
+				}
+				methodRefl = getMethod(methodCall.name,methodCall.arglist.getArguments().size(),methCallType, typesOfParams,methods);
+			}
+			catch (Exception e2) {
+				System.out.println("");
+				//do nothing
+			}
+		}
 		methodCall.receiver.accept(this);
 		
 		System.out.println("Methodcall type : " + resultSet.resolveType(methodCall.getType()).resolvedType.acceptTV(new TypeToDescriptor()));
@@ -866,7 +850,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 			mDesc = method.accept(new DescriptorToString(resultSet));
 			methodCall.arglist.accept(this);
 		} else {
-			System.out.println(methodCall.name + " -> Refl != null");
 			receiverRefl = methodRefl.getAnnotatedReceiverType().getType().toString();
 			for(Parameter p:methodRefl.getParameters()) {
 				System.out.println(p.getName() + " und is Primitive = " + p.getType().isPrimitive());
@@ -882,7 +865,7 @@ public class BytecodeGenMethod implements StatementVisitor {
 			}
 		}
 		
-		System.out.println("Methodcall ("+ methodCall.name +") Desc : " + mDesc);
+		System.out.println("Methodcall Desc : " + mDesc);
 		
 		
 //		methodCall.arglist.accept(this);
@@ -1214,7 +1197,6 @@ public class BytecodeGenMethod implements StatementVisitor {
 
 			break;
 		case "java/lang/Boolean":
-			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Boolean", "booleanValue", "()Z", false);
 			break;
 		case "java/lang/Byte":
 			mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Byte", "byteValue", "()B", false);

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

@@ -34,15 +34,13 @@ import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
 
 import java.io.File;
 import java.io.FileOutputStream;
-import java.io.FileWriter;
+//import java.io.FileWriter;
 import java.io.IOException;
-import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.util.*;
 import java.util.function.Function;
@@ -50,7 +48,6 @@ import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.antlr.v4.parse.ANTLRParser.throwsSpec_return;
-import org.apache.commons.io.output.NullOutputStream;
 
 public class JavaTXCompiler {
 
@@ -278,7 +275,7 @@ public class JavaTXCompiler {
 	}
 	*/
     
-    public UnifyResultModel typeInferenceAsync(UnifyResultListener resultListener) throws ClassNotFoundException {
+    public UnifyResultModel typeInferenceAsync() throws ClassNotFoundException {
     	List<ClassOrInterface> allClasses = new ArrayList<>();//environment.getAllAvailableClasses();
         //Alle Importierten Klassen in allen geparsten Sourcefiles kommen ins FC
         for(SourceFile sf : this.sourceFiles.values()) {
@@ -288,14 +285,17 @@ public class JavaTXCompiler {
 
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
-        UnifyResultModel urm = new UnifyResultModel();
+        UnifyResultModel urm = null;
-        urm.addUnifyResultListener(resultListener);
         try {
-			Writer logFile = new OutputStreamWriter(new NullOutputStream());
+			Writer logFile = new Writer() {//new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
-					//new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName()));
+				public void  close() {}
+				public void  flush() {}
+				public void  write(char[] cbuf, int off, int len) { }
+			};
 			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
+			urm = new UnifyResultModel(cons, finiteClosure);
 			ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(cons);
 			
 			Function<UnifyPair, UnifyPair> distributeInnerVars = 
@@ -407,7 +407,7 @@ public class JavaTXCompiler {
 				}
 				return ret;
 			}).collect(Collectors.toCollection(ArrayList::new));
-			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
+			unify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
         }
     	catch (IOException e) { 
         	System.err.println("kein LogFile");
@@ -427,8 +427,11 @@ public class JavaTXCompiler {
         final ConstraintSet<Pair> cons = getConstraints();
         Set<Set<UnifyPair>> results = new HashSet<>();
         try {
-			Writer logFile = new OutputStreamWriter(new NullOutputStream());
+			Writer logFile = new Writer() {//new FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"log_"+sourceFiles.keySet().iterator().next().getName()));
-				//new FileWriter(new File("log_"+sourceFiles.keySet().iterator().next().getName()));	
+				public void  close() {}
+				public void  flush() {}
+				public void  write(char[] cbuf, int off, int len) { }
+			};
 			
 			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses,logFile);
 			System.out.println(finiteClosure);
@@ -545,10 +548,10 @@ public class JavaTXCompiler {
 			}).collect(Collectors.toCollection(ArrayList::new));
 			if (resultmodel) {
 				/* UnifyResultModel Anfang */
-				UnifyResultModel urm = new UnifyResultModel();
+				UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
 				UnifyResultListenerImpl li = new UnifyResultListenerImpl();
 				urm.addUnifyResultListener(li);
-				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons, urm);
+				unify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, urm);
 				System.out.println("RESULT Final: " + li.getResults());
 				logFile.write("RES_FINAL: " + li.getResults().toString()+"\n");
 				logFile.flush();
@@ -556,8 +559,8 @@ public class JavaTXCompiler {
 			}
 			/* UnifyResultModel End */
 			else {
-				Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
+				Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
-				//Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, cons);
+				//Set<Set<UnifyPair>> result = unify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons, finiteClosure));
 				System.out.println("RESULT: " + result);
 				logFile.write("RES: " + result.toString()+"\n");
 				logFile.flush();

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

@@ -6,6 +6,7 @@ import de.dhbwstuttgart.typeinference.unify.GuavaSetOperations;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 import java.util.*;
+import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -53,4 +54,29 @@ public class ConstraintSet<A> {
         ret.oderConstraints = newOder;
         return ret;
     }
+    
+    public void forEach (Consumer<? super A> c) {
+        undConstraints.stream().forEach(c);
+        for(Set<Constraint<A>> oderConstraint : oderConstraints){
+            oderConstraint.parallelStream().forEach((Constraint<A> as) ->
+                            as.stream().forEach(c));
+        }
+    }
+    
+    public Set<A> getAll () {
+    	Set<A> ret = new HashSet<>();
+        ret.addAll(undConstraints);
+        for(Set<Constraint<A>> oderConstraint : oderConstraints){
+            oderConstraint.parallelStream().forEach((Constraint<A> as) -> ret.addAll(as));
+        }
+        return ret;
+    }
+    
+    public List<Set<Constraint<A>>> getOderConstraints() {
+    	return oderConstraints;
+    }
+    
+    public Set<A> getUndConstraints() {
+    	return undConstraints;
+    }
 }

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

@@ -1,3 +1,4 @@
+//PL 2018-12-19: Merge chekcen
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -228,6 +229,13 @@ public class TYPEStmt implements StatementVisitor{
                 binary.operation.equals(BinaryExpr.Operator.ADD)||
                 binary.operation.equals(BinaryExpr.Operator.SUB)){
             Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
+
+// TODO PL 2018-11-06
+            
+            //            Auf importierte Typen einschraenken
+            //         	 pruefen, ob  Typen richtig bestimmt werden.
+            
+
             
             //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

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

@@ -22,6 +22,8 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 public class Match implements IMatch {
 
 	@Override
+	//A<X> =. A<Integer> ==> True
+	//A<Integer> =. A<X> ==> False
 	public Optional<Unifier> match(ArrayList<UnifyPair> termsList) {
 		
 		// Start with the identity unifier. Substitutions will be added later.

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

@@ -4,10 +4,12 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
 import java.util.Stack;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import de.dhbwstuttgart.exceptions.DebugException;
@@ -620,8 +622,12 @@ public class RuleSet implements IRuleSet{
 		return succ ? permutation : new int[0];
 	}
 
-	@Override
 	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs) {
+		return subst(pairs, new ArrayList<>());
+	}
+	
+	@Override
+	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Set<UnifyPair>>> oderConstraints) {
 		HashMap<UnifyType, Integer> typeMap = new HashMap<>();
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
@@ -661,13 +667,35 @@ public class RuleSet implements IRuleSet{
 			if(lhsType != null 
 					//&& !((rhsType = pair.getRhsType()) instanceof PlaceholderType) //PL geloescht am 2017-09-29 Begründung: auch Typvariablen muessen ersetzt werden.
 					&& typeMap.get(lhsType) > 1  // The type occurs in more pairs in the set than just the recent pair.
-					&& !rhsType.getTypeParams().occurs(lhsType)) {
+					&& !rhsType.getTypeParams().occurs(lhsType) 
+					&& !((rhsType instanceof WildcardType) && ((WildcardType)rhsType).getWildcardedType().equals(lhsType))) //PL eigefuegt 2018-02-18
+			{
 				Unifier uni = new Unifier(lhsType,  rhsType);
 				result = result.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(ArrayList::new));
 				result1 = result1.stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(LinkedList::new));
+				
+				Function<? super Set<UnifyPair>,? extends HashSet<UnifyPair>> applyUni = b -> b.stream().map(
+						x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new));
+				List<Set<Set<UnifyPair>>> oderConstraintsRet = new ArrayList<>();
+				for(Set<Set<UnifyPair>> oc : oderConstraints) {
+					//Set<Set<UnifyPair>> ocRet = new HashSet<>();
+					//for(Set<UnifyPair> cs : oc) {
+						Set<Set<UnifyPair>> csRet = oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new));
+						oderConstraintsRet.add(csRet);
+					//}
+				}
+				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
+				/*
+						oderConstraints = oderConstraints.stream().map(
+						a -> a.stream().map(applyUni
+								//b -> b.stream().map(
+								//		x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new) )
+								).collect(Collectors.toCollection(HashSet::new))
+						).collect(Collectors.toList(ArrayList::new));
+				}
+				*/
 				applied = true;
 			}
-			
 			result.add(pair);
 		}
 		
@@ -946,6 +974,8 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType extendedType = ((ExtendsType)lhsType).getExtendedType();
 		
+		if (extendedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? extends a <.? a
+		
 		boolean isGen = extendedType instanceof PlaceholderType && !((PlaceholderType) extendedType).isGenerated();
 		
 		Set<UnifyPair> result = new HashSet<>();
@@ -972,6 +1002,8 @@ public class RuleSet implements IRuleSet{
 		
 		UnifyType superedType = ((SuperType)lhsType).getSuperedType();
 		
+		if (superedType.equals(rhsType)) return Optional.empty(); //PL 2019-02-18 eingefügt ? super a <.? a
+		
 		boolean isGen = superedType instanceof PlaceholderType && !((PlaceholderType) superedType).isGenerated();
 		
 		Set<UnifyPair> result = new HashSet<>();

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

@@ -14,23 +14,56 @@ import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class TypeUnify {
-	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons) {
+	
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, new UnifyResultModel(), cons);
+	/**
+	 * unify parallel ohne result modell
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @return
+	 */
+	public Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
 		return res;
 	}
 	
-	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+	/**
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons);
+	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @param ret
+	 * @return
+	 */
+	public UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		return ret;
 	}
 	
-	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, ConstraintSet<Pair> cons, UnifyResultModel ret) {
+	/**
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret, cons);
+	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @param ret
+	 * @return
+	 */
+	public UnifyResultModel unifyParallel(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, true, logFile, log, 0, ret);
 		ForkJoinPool pool = new ForkJoinPool();
 		pool.invoke(unifyTask);
 		Set<Set<UnifyPair>> res =  unifyTask.join();
@@ -45,8 +78,18 @@ public class TypeUnify {
 	}
 	*/
 	
-	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, FileWriter logFile, Boolean log, ConstraintSet<Pair> cons) {
+	/**
-		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, false, logFile, log, 0, new UnifyResultModel(), cons);
+	 * unify sequentiell mit oderconstraints
+	 * @param undConstrains
+	 * @param oderConstraints
+	 * @param fc
+	 * @param logFile
+	 * @param log
+	 * @param cons
+	 * @return
+	 */
+	public Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, Writer logFile, Boolean log, UnifyResultModel ret) {
+		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, false, logFile, log, 0, ret);
 		Set<Set<UnifyPair>> res = unifyTask.compute();
 		return res;
 	}

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

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.io.FileWriter;
+import java.io.IOException;
 import java.io.Writer;
 import java.util.HashSet;
 import java.util.List;
@@ -16,9 +17,14 @@ public class TypeUnify2Task extends TypeUnifyTask {
        
        Set<Set<UnifyPair>> setToFlatten;
 
-       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet<Pair> cons) {
+       public TypeUnify2Task(Set<Set<UnifyPair>> setToFlatten, Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, Set<UnifyPair> nextSetElement, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) {
-               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
+               super(eq, oderConstraints, fc, parallel, logFile, log, rekTiefe, urm);
                this.setToFlatten = setToFlatten;
+               this.nextSetElement = nextSetElement;
+       }
+       
+       Set<UnifyPair> getNextSetElement() {
+    	   return nextSetElement;
        }
        
        @Override
@@ -33,6 +39,17 @@ public class TypeUnify2Task extends TypeUnifyTask {
                else
                */ 
                noOfThread--;
-                       return res;
+               return res;
+       }
+       
+       public void closeLogFile() {
+
+           try {
+				logFile.close();
+			}
+			catch (IOException ioE) {
+				System.err.println("no log-File" + thNo);
+			}
+           
        }
 }

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

@@ -42,7 +42,7 @@ import de.dhbwstuttgart.typeinference.unify.model.OrderingUnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.Pair;
 
 import java.io.File;
-import java.io.FileWriter;
+//import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 
@@ -60,11 +60,15 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	private boolean printtag = false;
 	Boolean log = true; //gibt an ob ein Log-File nach System.getProperty("user.dir")+"/test/logFiles/log" geschrieben werden soll?
 	
+	/**
+	 * Element, das aus dem nextSet den Gleichunen dieses Threads hinzugefuegt wurde
+	 */
+	Set<UnifyPair> nextSetElement;
+	
 	/**
 	 * Fuer die Threads
 	 */
 	UnifyResultModel urm;
-	ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons;
 	protected static int noOfThread = 0;
 	private static int totalnoOfThread = 0;
 	int thNo;
@@ -129,7 +133,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	}
 	*/
 	
-	public TypeUnifyTask(Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm, ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons2) {
+	public TypeUnifyTask(Set<UnifyPair> eq, List<Set<Set<UnifyPair>>> oderConstraints, IFiniteClosure fc, boolean parallel, Writer logFile, Boolean log, int rekTiefe, UnifyResultModel urm) {
 		synchronized (this) { 
 			this.eq = eq;
 			//this.oderConstraints = oderConstraints.stream().map(x -> x.stream().map(y -> new HashSet<>(y)).collect(Collectors.toSet(HashSet::new))).collect(Collectors.toList(ArrayList::new));
@@ -143,21 +147,31 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			 */
 		
 			//x.stream().map(y -> new HashSet<>(y)).collect(Collectors.toSet(HashSet::new))).collect(Collectors.toList(ArrayList::new));
+			this.nextSetElement = nextSetElement;
 			this.fc = fc;
 			this.oup = new OrderingUnifyPair(fc);
 			this.parallel = parallel;
 			this.logFile = logFile;
 			this.log = log;
+			
+			noOfThread++; 
+			totalnoOfThread++;
+			//writeLog("thNo1 " + thNo);
+			thNo = totalnoOfThread;
+			writeLog("thNo2 " + thNo);
+			try {
+				this.logFile = new Writer() {//FileWriter(new File(System.getProperty("user.dir")+"/src/test/java/logFiles/"+"Thread_"+thNo));
+					public void  close() {}
+					public void  flush() {}
+					public void  write(char[] cbuf, int off, int len) { }
+				};
+			}
+			catch (Exception e) { 
+				System.err.println("log-File nicht vorhanden");
+			}
 			rules = new RuleSet(logFile);
 			this.rekTiefeField = rekTiefe;
 			this.urm = urm;
-			this.cons = cons2;
-		
-			noOfThread++; 
-			totalnoOfThread++;
-			writeLog("thNo1 " + thNo);
-			thNo = totalnoOfThread;
-			writeLog("thNo2 " + thNo);
 		}
 	}
 	
@@ -209,6 +223,12 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				.collect(Collectors.toCollection(ArrayList::new));
 		Set<Set<UnifyPair>> res = unify(neweq, remainingOderconstraints, fc, parallel, rekTiefeField);
 		noOfThread--;
+		try {
+			logFile.close();
+		}
+		catch (IOException ioE) {
+			System.err.println("no log-File");
+		}
 		if (isUndefinedPairSetSet(res)) { return new HashSet<>(); }
 		else return res;
 	}
@@ -543,6 +563,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		}
 
 		// Add the set of [a =. Theta | (a=. Theta) in Eq2']
+		//TODO: Occurscheck anwenden als Fehler identifizieren
 		Set<UnifyPair> bufferSet = eq2s.stream() 
 				.filter(x -> x.getPairOp() == PairOperator.EQUALSDOT && x.getLhsType() instanceof PlaceholderType)
 				.collect(Collectors.toSet());
@@ -651,9 +672,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			 * Step 5: Substitution
 			 */
 			//writeLog("vor Subst: " + eqPrime);
-			Optional<Set<UnifyPair>> eqPrimePrime = rules.subst(eqPrime);
+			writeLog("vor Subst: " + oderConstraints);
+			String ocString = oderConstraints.toString();
+			List<Set<Set<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
+			Optional<Set<UnifyPair>> eqPrimePrime = rules.subst(eqPrime, newOderConstraints);
 			Set<Set<UnifyPair>> unifyres1 = null;
 			Set<Set<UnifyPair>> unifyres2 = null;
+			if (!ocString.equals(newOderConstraints.toString())) writeLog("nach Subst: " + newOderConstraints);
 			//writeLog("nach Subst: " + eqPrimePrime);
 			/*
 			 * Step 6 a) Restart (fork) for pairs where subst was applied
@@ -687,36 +712,24 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 																			  //PL 2017-09-29 dies ersetzt //(!eqPrimePrime.isPresent()) 
 																			  //PL 2018-05-18 beide Bedingungen muessen gelten, da eqPrime Veränderungen in allem ausser subst
 																			  //eqPrimePrime Veraenderungen in subst repraesentieren.
-					try {
+					//try {
 						if (isSolvedForm(eqPrime)) {
-							logFile.write("eqPrime:" + eqPrime.toString()+"\n");
+							writeLog("eqPrime:" + eqPrime.toString()+"\n");
-							logFile.flush();
 						}
-					}
+					//}
-					catch (IOException e) { 
+					//catch (IOException e) { 
-						System.err.println("log-File nicht vorhanden");
+					//	System.err.println("log-File nicht vorhanden");
-					}
+					//}
 					eqPrimePrimeSet.add(eqPrime);
-					Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
+					urm.notify(eqPrimePrimeSet);
-						Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> { 
-							if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
-							return y; //alle Paare a <.? b erden durch a =. b ersetzt
-						}).collect(Collectors.toCollection(HashSet::new)));
-						if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
-							return new TypeUnifyTask().applyTypeUnificationRules(res.get(), fc);
-						}
-						else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
-					}).collect(Collectors.toCollection(HashSet::new));
-					urm.notify(eqPrimePrimeSetRet.stream().map((unifyPairs ->
-		               new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons))))).collect(Collectors.toList()));
 				}
 				else if(eqPrimePrime.isPresent()) {
-					Set<Set<UnifyPair>> unifyres = unifyres1 = unify(eqPrimePrime.get(), oderConstraints, fc, parallel, rekTiefe);
+					Set<Set<UnifyPair>> unifyres = unifyres1 = unify(eqPrimePrime.get(), newOderConstraints, fc, parallel, rekTiefe);
 					
 					eqPrimePrimeSet.addAll(unifyres);
 				}
 				else {
-					Set<Set<UnifyPair>> unifyres = unifyres2 = unify(eqPrime, oderConstraints, fc, parallel, rekTiefe);
+					Set<Set<UnifyPair>> unifyres = unifyres2 = unify(eqPrime, newOderConstraints, fc, parallel, rekTiefe);
 					
 					
 					eqPrimePrimeSet.addAll(unifyres);
@@ -919,15 +932,16 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				//writeLog("Vor unify2 Aufruf: " + elems.toString());
 			Set<Set<UnifyPair>> res = new HashSet<>();
 			Set<Set<Set<UnifyPair>>> add_res = new HashSet<>();
+			Set<Set<UnifyPair>> aParDef = new HashSet<>();
 			if(parallel && (variance == 1) && noOfThread <= MaxNoOfThreads) {
-				Set<TypeUnifyTask> forks = new HashSet<>();
+				Set<TypeUnify2Task> forks = new HashSet<>();
 				Set<UnifyPair> newEqOrig = new HashSet<>(eq);
 				Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
 				List<Set<Set<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
 				newElemsOrig.add(a);
 				
 				/* FORK ANFANG */
-				TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, fc, parallel, logFile, log, rekTiefe, urm, cons);
+				TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, parallel, logFile, log, rekTiefe, urm);
 				//forks.add(forkOrig);
 				forkOrig.fork();
 				/* FORK ENDE */
@@ -945,7 +959,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
 					List<Set<Set<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
 					newElems.add(nSaL);
-					TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
+					TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, parallel, logFile, log, rekTiefe, urm);
 					forks.add(fork);
 					fork.fork();
 				}
@@ -953,7 +967,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				
 				/* FORK ANFANG */
 				synchronized (this) {
+					noOfThread--;
+					writeLog("wait "+ forkOrig.thNo);
 					res = forkOrig.join();
+					forkOrig.writeLog("final Orig 1");
+					forkOrig.closeLogFile();
 					//Set<Set<UnifyPair>> fork_res = forkOrig.join();
 					writeLog("JoinOrig " + new Integer(forkOrig.thNo).toString());
 					//noOfThread--; an das Ende von compute verschoben 
@@ -961,24 +979,33 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				};
 				/* FORK ENDE */
 				
-				for(TypeUnifyTask fork : forks) {
+				forks.forEach(x -> writeLog("wait: " + x.thNo));
+				for(TypeUnify2Task fork : forks) {
 					synchronized (this) {
 						Set<Set<UnifyPair>> fork_res = fork.join();
 						writeLog("Join " + new Integer(fork.thNo).toString());
-						//noOfThread--; an das Ende von compute verschoben 
+						//noOfThread--; an das Ende von compute verschoben
+						writeLog("fork_res: " + fork_res.toString());
+						writeLog(new Boolean((isUndefinedPairSetSet(fork_res))).toString());
 						add_res.add(fork_res);
+						if (!isUndefinedPairSetSet(fork_res)) {
+							aParDef.add(fork.getNextSetElement());
+						}
+						fork.writeLog("final 1");
+						fork.closeLogFile();
 					};
-				}	
+				}
+				noOfThread++;
 			} else {
 			if(parallel && (variance == -1) && noOfThread <= MaxNoOfThreads) {
-				Set<TypeUnifyTask> forks = new HashSet<>();
+				Set<TypeUnify2Task> forks = new HashSet<>();
 				Set<UnifyPair> newEqOrig = new HashSet<>(eq);
 				Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
 				List<Set<Set<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
 				newElemsOrig.add(a);
 				
 				/* FORK ANFANG */
-				TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, fc, parallel, logFile, log, rekTiefe, urm, cons);
+				TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, parallel, logFile, log, rekTiefe, urm);
 				//forks.add(forkOrig);
 				forkOrig.fork();
 				/* FORK ENDE */
@@ -996,7 +1023,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
 					List<Set<Set<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
 					newElems.add(nSaL);
-					TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
+					TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, parallel, logFile, log, rekTiefe, urm);
 					forks.add(fork);
 					fork.fork();
 				}
@@ -1004,7 +1031,11 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				
 				/* FORK ANFANG */
 				synchronized (this) {
+					noOfThread--;
+					writeLog("wait "+ forkOrig.thNo);
 					res = forkOrig.join();
+					forkOrig.writeLog("final Orig -1");
+					forkOrig.closeLogFile();
 					//Set<Set<UnifyPair>> fork_res = forkOrig.join();
 					writeLog("JoinOrig " + new Integer(forkOrig.thNo).toString());
 					//noOfThread--; an das Ende von compute verschoben 
@@ -1012,25 +1043,34 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				};
 				/* FORK ENDE */
 				
-				for(TypeUnifyTask fork : forks) {
+				forks.forEach(x -> writeLog("wait: " + x.thNo));
+				for(TypeUnify2Task fork : forks) {
 					synchronized (this) {
 						Set<Set<UnifyPair>> fork_res = fork.join();
 						writeLog("Join " + new Integer(fork.thNo).toString());
 						//noOfThread--; an das Ende von compute verschoben 
+						writeLog("fork_res: " + fork_res.toString());
+						writeLog(new Boolean((isUndefinedPairSetSet(fork_res))).toString());
 						add_res.add(fork_res);
+						if (!isUndefinedPairSetSet(fork_res)) {
+							aParDef.add(fork.getNextSetElement());
+						}
+						fork.writeLog("final -1");
+						fork.closeLogFile();
 					};
 				}
+				noOfThread++;
 		    } else {
 		    if(parallel && (variance == 2) && noOfThread <= MaxNoOfThreads) {
 		    	writeLog("var2einstieg");
-		    	Set<TypeUnifyTask> forks = new HashSet<>();
+		    	Set<TypeUnify2Task> forks = new HashSet<>();
 		    	Set<UnifyPair> newEqOrig = new HashSet<>(eq);
 		    	Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
 		    	List<Set<Set<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
 		    	newElemsOrig.add(a);
 				
 				/* FORK ANFANG */
-		    	TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, fc, parallel, logFile, log, rekTiefe, urm, cons);
+		    	TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, parallel, logFile, log, rekTiefe, urm);
 		    	//forks.add(forkOrig);
 		    	forkOrig.fork();
 		    	/* FORK ENDE */
@@ -1046,7 +1086,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		    		Set<Set<UnifyPair>> newElems = new HashSet<>(elems);
 		    		List<Set<Set<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
 		    		newElems.add(nSaL);
-		    		TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, fc, parallel, logFile, log, rekTiefe, urm, cons);
+		    		TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, parallel, logFile, log, rekTiefe, urm);
 		    		forks.add(fork);
 		    		fork.fork();
 		    	}
@@ -1054,23 +1094,30 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 		    	
 		    	/* FORK ANFANG */
 		    	synchronized (this) {
+		    		noOfThread--;
+		    		writeLog("wait "+ forkOrig.thNo);
 					res = forkOrig.join();
+					forkOrig.writeLog("final Orig 2");
+					forkOrig.closeLogFile();
 					//Set<Set<UnifyPair>> fork_res = forkOrig.join();
 					writeLog("JoinOrig " + new Integer(forkOrig.thNo).toString());
 					//noOfThread--; an das Ende von compute verschoben 
 					//add_res.add(fork_res); //vermutlich falsch
 				};
 				/* FORK ENDE */
-		    	
+		    	forks.forEach(x -> writeLog("wait: " + x.thNo));
-		    	for(TypeUnifyTask fork : forks) {
+		    	for(TypeUnify2Task fork : forks) {
 		    		synchronized (this) {
 						Set<Set<UnifyPair>> fork_res = fork.join();
 						writeLog("Join " + new Integer(fork.thNo).toString());
 						//noOfThread--; an das Ende von compute verschoben 
 						add_res.add(fork_res);
+						fork.writeLog("final 2");
+						fork.closeLogFile();
 					};
-				}}
+				} 
-		    else {
+		    	noOfThread++;	
+		    } else {
 		    	//parallel = false; //Wenn MaxNoOfThreads erreicht ist, sequentiell weiterarbeiten
 				elems.add(a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
 				res = unify2(elems, eq, oderConstraints, fc, parallel, rekTiefe);
@@ -1197,7 +1244,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 				}
 				
 			/* auskommentiert um alle Max und min Betrachtung auszuschalten ANFANG */
-			if (!result.isEmpty() && !isUndefinedPairSetSet(res)) {
+			if (!result.isEmpty() && (!isUndefinedPairSetSet(res) || !aParDef.isEmpty())) {
 				if (nextSetasList.iterator().hasNext() && nextSetasList.iterator().next().stream().filter(x -> x.getLhsType().getName().equals("B")).findFirst().isPresent() && nextSetasList.size()>1) 
 					System.out.print("");
 				Iterator<Set<UnifyPair>> nextSetasListIt = new ArrayList<Set<UnifyPair>>(nextSetasList).iterator();
@@ -1231,18 +1278,24 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 
 					System.out.println("");
 					writeLog("a: " + rekTiefe + " variance: " + variance + a.toString());
-					while (nextSetasListIt.hasNext()) {
+					writeLog("aParDef: " + aParDef.toString());
-						Set<UnifyPair> a_next = nextSetasListIt.next();
+					aParDef.add(a);
-						if (a.equals(a_next) || 
+					Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
-							(oup.compare(a, a_next) == 1)) {
+					while(aParDefIt.hasNext()) {
-							writeLog("Removed: " + a_next.toString());
+						Set<UnifyPair> a_new = aParDefIt.next();
-							nextSetasList.remove(a_next);
+						while (nextSetasListIt.hasNext()) {
+							Set<UnifyPair> a_next = nextSetasListIt.next();
+							if (a_new.equals(a_next) || 
+									(oup.compare(a_new, a_next) == 1)) {
+								writeLog("Removed: " + a_next.toString());
+								nextSetasList.remove(a_next);
+							}
+							else { 
+								writeLog("Not Removed: " + a_next.toString());
+								System.out.println("");
+							}
 						}
-						else { 
+					}	
-							writeLog("Not Removed: " + a_next.toString());
-							System.out.println("");
-						}
-					}
 				}
 				else { if (variance == -1) {
 					/* vorgezogen vor das if
@@ -1273,19 +1326,25 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 					
 					System.out.println("");
 					writeLog("a: " + rekTiefe + " variance: " + variance + a.toString());
-					while (nextSetasListIt.hasNext()) {
+					writeLog("aParDef: " + aParDef.toString());
-						Set<UnifyPair> a_next = nextSetasListIt.next();
+					aParDef.add(a);
-						if (a.equals(a_next) || 
+					Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
-								(oup.compare(a, a_next) == -1)) {
+					while(aParDefIt.hasNext()) {
-							writeLog("Removed: " + a_next.toString());
+						Set<UnifyPair> a_new = aParDefIt.next();
-							nextSetasList.remove(a_next); //PL geaendert 2019-01-09
+						while (nextSetasListIt.hasNext()) {
-						}
+							Set<UnifyPair> a_next = nextSetasListIt.next();
-						else { 
+							if (a_new.equals(a_next) || 
-							System.out.println("");
+									(oup.compare(a_new, a_next) == -1)) {
-							writeLog("Not Removed: " + a_next.toString());
+								writeLog("Removed: " + a_next.toString());
+								nextSetasList.remove(a_next); //PL geaendert 2019-01-09
+							}
+							else { 
+								System.out.println("");
+								writeLog("Not Removed: " + a_next.toString());
 						}
 					}
 				}
+				}
 				else { if (variance == 0) {
 					writeLog("a: " + rekTiefe + " variance: " + variance + a.toString());
 					break; } 
@@ -1319,7 +1378,7 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			}
 			 /* auskommentiert um alle Max und min Betrachtung auszuschalten ENDE */ 
 			
-			if (isUndefinedPairSetSet(res)) {
+			if (isUndefinedPairSetSet(res) && aParDef.isEmpty()) {
 				int nofstred= 0;
 				Set<UnifyPair> abhSubst = res.stream()
 							   .map(b -> 

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

@@ -0,0 +1,7 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+public interface UnifyResultListener {
+
+	void onNewTypeResultFound(UnifyResultEvent evt);
+
+}

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

@@ -1,13 +1,31 @@
 package de.dhbwstuttgart.typeinference.unify;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
+import java.util.stream.Collectors;
 
+import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
+import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
+import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
+import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
+import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
 public class UnifyResultModel {
 	
+	ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons;
+	
+	IFiniteClosure fc;
+	
+	public UnifyResultModel(ConstraintSet<de.dhbwstuttgart.typeinference.constraints.Pair> cons,
+					 IFiniteClosure fc) {
+		this.cons = cons;
+		this.fc = fc;
+	}
+	
 	private List<UnifyResultListener> listeners = new ArrayList<>();
 	
 	public void addUnifyResultListener(UnifyResultListener listenerToAdd) {
@@ -18,7 +36,20 @@ public class UnifyResultModel {
 		listeners.remove(listenerToRemove);
 	}
 	
-	public void notify(List<ResultSet> newResult) {
+	public void notify(Set<Set<UnifyPair>> eqPrimePrimeSet) {
+		Set<Set<UnifyPair>> eqPrimePrimeSetRet = eqPrimePrimeSet.stream().map(x -> {
+			Optional<Set<UnifyPair>> res = new RuleSet().subst(x.stream().map(y -> { 
+				if (y.getPairOp() == PairOperator.SMALLERDOTWC) y.setPairOp(PairOperator.EQUALSDOT);
+				return y; //alle Paare a <.? b erden durch a =. b ersetzt
+			}).collect(Collectors.toCollection(HashSet::new)));
+			if (res.isPresent()) {//wenn subst ein Erg liefert wurde was veraendert
+				return new TypeUnifyTask().applyTypeUnificationRules(res.get(), fc);
+			}
+			else return x; //wenn nichts veraendert wurde wird x zurueckgegeben
+		}).collect(Collectors.toCollection(HashSet::new));
+		List<ResultSet> newResult = eqPrimePrimeSetRet.stream().map(unifyPairs ->
+           new ResultSet(UnifyTypeFactory.convert(unifyPairs, de.dhbwstuttgart.typeinference.constraints.Pair.generateTPHMap(cons))))
+           .collect(Collectors.toList());
 		UnifyResultEvent evt = new UnifyResultEvent(newResult);
 		
 		for (UnifyResultListener listener : listeners) {

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

@@ -17,6 +17,7 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
  */
 public interface IFiniteClosure {
 	
+	public void setLogTrue();
 	/**
 	 * Returns all types of the finite closure that are subtypes of the argument.
 	 * @return The set of subtypes of the argument.

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.typeinference.unify.interfaces;
 
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
@@ -85,6 +86,13 @@ public interface IRuleSet {
 	public Optional<UnifyPair> adaptExt(UnifyPair pair, IFiniteClosure fc);
 	public Optional<UnifyPair> adaptSup(UnifyPair pair, IFiniteClosure fc);
 	
+	/**
+	 * Applies the subst-Rule to a set of pairs (usually Eq').
+	 * @param pairs The set of pairs where the subst rule should apply.
+	 * @return An optional of the modified set, if there were any substitutions. An empty optional if there were no substitutions.
+	 */
+	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Set<UnifyPair>>> oderConstraints);
+	
 	/**
 	 * Applies the subst-Rule to a set of pairs (usually Eq').
 	 * @param pairs The set of pairs where the subst rule should apply.

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

@@ -13,6 +13,7 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import com.google.common.collect.Ordering;
@@ -657,11 +658,16 @@ implements IFiniteClosure  {
 		if (left.getName().equals("Matrix") || right.getName().equals("Matrix")) 
 			System.out.println("");
 		/*
+		pairop = PairOperator.SMALLERDOTWC;
 		List<UnifyType> al = new ArrayList<>();
 		PlaceholderType xx =new PlaceholderType("xx");
 		al.add(xx);
 		left = new ExtendsType(new ReferenceType("Vector", new TypeParams(al)));
-		right = new ReferenceType("Vector", new TypeParams(new ArrayList<>(al)));
+		
+		List<UnifyType> alr = new ArrayList<>();
+		UnifyType exx = new ExtendsType(xx);
+		alr.add(exx);
+		right = new ExtendsType(new ReferenceType("Vector", new TypeParams(alr)));
 		*/
 		/*
 		List<UnifyType> al = new ArrayList<>();
@@ -712,8 +718,13 @@ implements IFiniteClosure  {
 		}
 		catch (IOException e) {
 			System.err.println("no LogFile");}}
-		//Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok. 
+		//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();
+		Predicate<UnifyPair> delFun = x -> !((x.getLhsType() instanceof PlaceholderType || 
+											 x.getRhsType() instanceof PlaceholderType)
+								 			 && !((x.getLhsType() instanceof WildcardType) &&   //? extends/super a <.? a 
+													 ((WildcardType)x.getLhsType()).getWildcardedType().equals(x.getRhsType()))
+											 );
+		long smallerLen = smallerRes.stream().filter(delFun).count();
 		if (smallerLen == 0) return -1;
 		else {
 			up = new UnifyPair(right, left, pairop);
@@ -729,7 +740,7 @@ implements IFiniteClosure  {
 			catch (IOException e) {
 				System.err.println("no LogFile");}}
 			//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();
+			long greaterLen = greaterRes.stream().filter(delFun).count();
 			if (greaterLen == 0) return 1;
 			else return 0;
 		}	

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

@@ -4,6 +4,7 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.BinaryOperator;
@@ -30,7 +31,8 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 	 * in dem compare(Theta, Theta') aufgerufen wird.
 	 */
 	public int compareEq (UnifyPair left, UnifyPair right) {
-		if (left.getRhsType() instanceof WildcardType || right.getRhsType() instanceof WildcardType) {
+		//if (left.getRhsType() instanceof WildcardType || right.getRhsType() instanceof WildcardType) {//PL 2019-01-12 ausgetauscht
+		if (((PlaceholderType)left.getLhsType()).isInnerType() && ((PlaceholderType)right.getLhsType()).isInnerType()) {
 			return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOTWC);
 		}
 			else	 {
@@ -54,6 +56,20 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 		UnifyPair up;
 		if (left instanceof WildcardType || right instanceof WildcardType) {
 			up = new UnifyPair(left, right, PairOperator.SMALLERDOTWC);
+			if (((left instanceof ExtendsType) 
+					&& (((ExtendsType)left).getExtendedType().getName().equals("java.util.Vector"))
+					&& (((ReferenceType)((ExtendsType)left).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)) ||
+				((right instanceof ExtendsType) 
+						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
+						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
+				{
+					System.out.println("");
+				}
+				if (((right instanceof SuperType) && (((SuperType)right).getSuperedType().getName().equals("java.lang.Object")))
+		||((left instanceof SuperType) && (((SuperType)left).getSuperedType().getName().equals("java.lang.Object"))))
+{
+						System.out.println("");
+					}
 		}
 			else	 {
 				up = new UnifyPair(left, right, PairOperator.SMALLERDOT);
@@ -67,6 +83,19 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 		else {
 			if (left instanceof WildcardType || right instanceof WildcardType) {
 				up = new UnifyPair(right, left, PairOperator.SMALLERDOTWC);
+				if (((left instanceof ExtendsType) 
+					&& (((ExtendsType)left).getExtendedType().getName().equals("java.util.Vector"))
+					&& (((ReferenceType)((ExtendsType)left).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)) ||
+				((right instanceof ExtendsType) 
+						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
+						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
+				{
+					System.out.println("");
+				}
+				if (right instanceof SuperType) 
+					{
+						System.out.println("");
+					}
 			}
 				else	 {
 					up = new UnifyPair(right, left, PairOperator.SMALLERDOT);
@@ -87,6 +116,53 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 	 * @see com.google.common.collect.Ordering#compare(java.lang.Object, java.lang.Object)
 	 */
 	public int compare (Set<UnifyPair> left, Set<UnifyPair> right) {
+		/*
+		//pairop = PairOperator.SMALLERDOTWC;
+		List<UnifyType> al = new ArrayList<>();
+		PlaceholderType xx = PlaceholderType.freshPlaceholder();
+		al.add(xx);
+		UnifyType t1 = new ExtendsType(new ReferenceType("Vector", new TypeParams(al)));
+		
+		//PlaceholderType yy =new PlaceholderType("yy");
+		List<UnifyType> alr = new ArrayList<>();
+		UnifyType exx = new ExtendsType(xx);
+		alr.add(exx);
+		UnifyType t2 = new ExtendsType(new ReferenceType("Vector", new TypeParams(alr)));
+		
+		PlaceholderType a = PlaceholderType.freshPlaceholder();
+		a.setInnerType(true);
+		UnifyPair p1 = new UnifyPair(a, t1, PairOperator.SMALLERDOTWC); 
+		PlaceholderType b = PlaceholderType.freshPlaceholder();
+		b.setInnerType(true);
+		UnifyPair p2 = new UnifyPair(b, t2, PairOperator.SMALLERDOTWC);
+		
+		List<UnifyType> al3 = new ArrayList<>();
+		al3.add(a);
+		
+		List<UnifyType> al4 = new ArrayList<>();
+		al4.add(b);
+		
+		UnifyPair p3 = new UnifyPair(new PlaceholderType("c"), new ReferenceType("Vector", new TypeParams(al3)), PairOperator.EQUALSDOT);
+		UnifyPair p4 = new UnifyPair(new PlaceholderType("c"), new ReferenceType("Vector", new TypeParams(al4)), PairOperator.EQUALSDOT);
+		
+		right = new HashSet<>();
+		right.add(p1);
+		right.add(p3);
+		left = new HashSet<>();
+		left.add(p2);
+		left.add(p4);
+		*/
+		
+		if ((left.size() == 1) && right.size() == 1) { 
+			if (left.iterator().next().getLhsType().getName().equals("AFS")) {
+				System.out.println("");
+			}
+		if (((right.iterator().next().getRhsType() instanceof SuperType) && (((SuperType)right.iterator().next().getRhsType()).getSuperedType().getName().equals("java.lang.Object")))
+				||((left.iterator().next().getRhsType() instanceof SuperType) && (((SuperType)left.iterator().next().getRhsType()).getSuperedType().getName().equals("java.lang.Object"))))
+		{
+								System.out.println("");
+							}
+				}
 		Set<UnifyPair> lefteq = left.stream()
 				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
 				.collect(Collectors.toCollection(HashSet::new));
@@ -110,17 +186,25 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
 				.collect(Collectors.toCollection(HashSet::new));
 		//System.out.println(left.toString());
-		//Fall 2 und 3
+		//Fall 2
 		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
 		//	System.out.print("");
 		//}
-		if (lefteq.size() == 1 && leftle.size() == 1  && righteq.size() == 0 && rightle.size() == 1) {
+		if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof ExtendsType && leftle.size() == 1  && righteq.size() == 0 && rightle.size() == 1) {
 			return 1;
 		}
-		//Fall 2 und 3
+		//Fall 2
-		if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 1) {
+		if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && righteq.iterator().next().getRhsType() instanceof ExtendsType && rightle.size() == 1) {
 			return -1;
 		}
+		//Fall 3
+		if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof SuperType && leftle.size() == 1  && righteq.size() == 0 && rightle.size() == 1) {
+			return -1;
+		}
+		//Fall 3
+		if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && righteq.iterator().next().getRhsType() instanceof SuperType && rightle.size() == 1) {
+			return 1;
+		}
 		//Fall 5
 		if (lefteq.size() == 1 && leftle.size() == 0 && righteq.size() == 1 && rightle.size() == 1) {
 			return -1;
@@ -152,9 +236,9 @@ public class OrderingUnifyPair extends Ordering<Set<UnifyPair>> {
 			//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)  andere Substitutioen werden rausgefiltert
-			lefteq.removeIf(x -> !(x.getLhsType().getName().equals(x.getBasePair().getLhsType().getName())
+			lefteq.removeIf(x -> (x.getBasePair()!=null) && !(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())
+			righteq.removeIf(x -> (x.getBasePair()!=null) && !(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();

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

@@ -46,6 +46,11 @@ public final class PlaceholderType extends UnifyType{
 	 */
 	private boolean wildcardable = true;  
 	
+	/**
+	 * is innerType gibt an, ob der Type des PlaceholderType innerhalb eines Typkonstruktorsverwendet wird
+	 */
+	private boolean innerType = false;  
+	
 	/**
      * variance shows the variance of the pair
      * -1: contravariant
@@ -108,6 +113,15 @@ public final class PlaceholderType extends UnifyType{
 		return variance;
 	}
 	
+	public void reversVariance() {
+		if (variance == 1) {
+			setVariance(-1);
+		} else {
+	    if (variance == -1) {
+			setVariance(1);
+		}}
+	}
+	
 	public Boolean isWildcardable() {
 		return wildcardable;
 	}
@@ -115,6 +129,22 @@ public final class PlaceholderType extends UnifyType{
 		wildcardable = false;
 	}
 	
+	public void enableWildcardtable() {
+		wildcardable = true;
+	}
+	
+	public void setWildcardtable(Boolean wildcardable) {
+		this.wildcardable = wildcardable;
+	}
+	
+	public Boolean isInnerType() {
+		return innerType;
+	}
+	
+	public void setInnerType(Boolean innerType) {
+		this.innerType = innerType;
+	}
+	
 	@Override
 	Set<UnifyType> smArg(IFiniteClosure fc, Set<UnifyType> fBounded) {
 		return fc.smArg(this, fBounded);
@@ -157,7 +187,7 @@ public final class PlaceholderType extends UnifyType{
 	
 
 	@Override
-	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+	public Collection<PlaceholderType> getInvolvedPlaceholderTypes() {
 		ArrayList<PlaceholderType> ret = new ArrayList<>();
 		ret.add(this);
 		return ret;

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

@@ -121,6 +121,10 @@ public class UnifyPair {
 		pairOp = po;
 	}
 	
+	public void addSubstitutions(Set<UnifyPair> sup) {
+		substitution.addAll(sup);
+	}
+	
 	public byte getVariance() {
 		return variance;
 	}
@@ -152,6 +156,15 @@ public class UnifyPair {
 		return ret;
 	}
 	
+	public Set<UnifyPair> getAllBases () {
+		Set<UnifyPair> ret = new HashSet<>();
+		if (basePair != null) {
+			ret.add(getBasePair());
+			ret.addAll(basePair.getAllBases());
+		}
+		return ret;
+	}
+	
 	public UnifyPair getGroundBasePair () {
 		if (basePair == null) {
 			return this;
@@ -206,12 +219,12 @@ public class UnifyPair {
 	public String toString() {
 		String ret = "";
 		if (lhs instanceof PlaceholderType) {
-			ret = new Integer(((PlaceholderType)lhs).getVariance()).toString();
+			ret = new Integer(((PlaceholderType)lhs).getVariance()).toString() + " " + ((PlaceholderType)lhs).isInnerType();
 		}
 		if (rhs instanceof PlaceholderType) {
-			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString();
+			ret = ret + ", " + new Integer(((PlaceholderType)rhs).getVariance()).toString() + " " + ((PlaceholderType)rhs).isInnerType();
 		}
-		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ", [" + getfBounded().toString()+ "])";
+		return "(" + lhs + " " + pairOp + " " + rhs + ", " + ret + ")"; //+ ", [" + getfBounded().toString()+ "])";
 	}
 
 	/*

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

@@ -97,7 +97,7 @@ public abstract class UnifyType {
 		return typeName + params;
 	}
 
-	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+	public Collection<PlaceholderType> getInvolvedPlaceholderTypes() {
 		ArrayList<PlaceholderType> ret = new ArrayList<>();
 		ret.addAll(typeParams.getInvolvedPlaceholderTypes());
 		return ret;

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

@@ -64,7 +64,7 @@ public abstract class WildcardType extends UnifyType {
 	
 
 	@Override
-	public Collection<? extends PlaceholderType> getInvolvedPlaceholderTypes() {
+	public Collection<PlaceholderType> getInvolvedPlaceholderTypes() {
 		ArrayList<PlaceholderType> ret = new ArrayList<>();
 		ret.addAll(wildcardedType.getInvolvedPlaceholderTypes());
 		return ret;

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

@@ -0,0 +1,25 @@
+package de.dhbwstuttgart.typeinference.unify.model;
+
+public class hashKeyType {
+	UnifyType realType;
+	
+	hashKeyType(UnifyType realType) {
+		this.realType= realType;
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof hashKeyType) {
+			return realType.equals(((hashKeyType)obj).realType);
+		}
+		else
+		{
+			return false;
+		}
+	}
+	
+	@Override
+	public int hashCode() {
+		return realType.hashCode();
+	}
+}

src/test/java/asp/gencay/GeneratorTest.java

@@ -17,8 +17,6 @@ import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
-
-import org.junit.Ignore;
 import org.junit.Test;
 
 import java.io.File;

src/test/java/bytecode/YTest.java

@@ -26,8 +26,8 @@ public class YTest {
 		path = System.getProperty("user.dir")+"/src/test/resources/bytecode/javFiles/Y.jav";
 		fileToTest = new File(path);
 //		compiler = new JavaTXCompiler(fileToTest);
-//		compiler.generateBytecode(System.getProperty("user.dir")+"/testBytecode/generatedBC/");
+//		compiler.generateBytecode(System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/");
-//		pathToClassFile = System.getProperty("user.dir")+"/testBytecode/generatedBC/";
+//		pathToClassFile = System.getProperty("user.dir")+"/src/test/resources/testBytecode/generatedBC/";
 //		loader = new URLClassLoader(new URL[] {new URL("file://"+pathToClassFile)});
 //		classToTest = loader.loadClass("Y");
 		/*

src/test/java/javFiles/AddLong.jav

@@ -1,9 +0,0 @@
-import java.lang.Integer;
-import java.lang.Long;
-
-public class AddLong{
-		 Long add(Integer a, Long b) {
-    		Long c = a+b;
-    		return c;
-    	}
-}

src/test/java/javFiles/EmptyClass.jav

@@ -1,3 +0,0 @@
-public class EmptyClass{
-	
-}

src/test/java/javFiles/EmptyMethod.jav

@@ -1,37 +0,0 @@
-public class EmptyMethod{
-	static String s1 ="";
-	String s2;
-	public void m1(){
-		//String s = "";
-		System.out.println("test");
-		//Integer ab = Math.abs(1);
-		//Math.abs(1);
-		//String lV = "local";
-		//s1 = "1";
-		//s1.concat("2");
-		s2 = s1;
-		//m2();
-		Clazz i = new Clazz();
-		Integer i = new Integer(1);
-	}
-	
-	public void m2(){}
-}
-
-class Clazz{}
-/*
-public class EmptyMethod2{
-	public static test = "5";
-	public void m1(Integer i, String j, Boolean b){
-		//String s = "";
-		EmptyMethod em = new EmptyMethod();
-		em.m1();
-		em.s1 = "";
-		//Integer ab = Math.abs(1);
-		//Math.abs(1);
-		//String lV = "local";
-		//s1 = "1";
-		//s1.concat("2");
-		//s2 = s1;
-	}
-}*/

src/test/java/javFiles/Expressions.jav

@@ -1,8 +0,0 @@
-class Expressions{
-
-void test(){
-  var x = 2;
-  x = x + 2;
-}
-
-}

src/test/java/javFiles/FC_Matrix.jav

@@ -1,10 +0,0 @@
-import java.util.Vector;
-
-class Matrix extends Vector<Vector<Integer>> {
- 
- methode(m) {
- 	m.add(1);
-    Matrix i;
-    methode(i);
- }
- }

src/test/java/javFiles/Faculty.jav

@@ -1,15 +0,0 @@
-import java.lang.Integer;
-
-class Faculty {
-
-  Integer mul(Integer x, Integer y) {
-  	return x;
-   }
-
-  m () {
-   var fact = (Integer x) -> {
-        return mul(x, fact.apply(x));
-   };
-   return fact;
-  }
-}

src/test/java/javFiles/FacultyIf.jav

@@ -1,17 +0,0 @@
-import java.lang.Integer;
-
-class Faculty {
-
-  m () {
-	  
-   var fact = (Integer x) -> {
-   	  if (x == 1) {
-        return x;
-      }
-      else {
-        return x * (fact.apply(x-1));
-      }
-   };
-   return fact;
-  }
-}

src/test/java/javFiles/FacultyTyped.jav

@@ -1,19 +0,0 @@
-import java.lang.Integer;
-
-class Faculty {
-
-  Integer mul(Integer x, Integer y) {
-  	return x;
-   }
-
-  Fun1<java.lang.Integer,java.lang.Integer> m () {
-   var fact = (Integer x) -> {
-        return mul(x, fact.apply(x));
-   };
-   return fact;
-  }
-}
-
-interface Fun1<A,B>{
-    B apply(A a);
-}

src/test/java/javFiles/Fields.jav

@@ -1,11 +0,0 @@
-import java.lang.String;
-
-class Fields{
-test2 = "test";
-test;
-m(){
-    var test3;
-    return test;
-}
-
-}

src/test/java/javFiles/Generics.jav

@@ -1,22 +0,0 @@
-import java.lang.String;
-
-class Generics<B> {
-    //<A extends B> A mt1(A a, B b){
-    B mt1(B a, B b){
-        return mt1(a, a);
-    }
-}
-
-class Test {
-    methode(String s){
-        return new Generics<String>().mt1(s,s);
-    }
-}
-
-/*
-Problem:
-auto test = new List<String>();
-auto test2 = new List<Integer>();
-... //code, welcher möglicherweise test und test2 vertauscht
-test.add("hallo");
-*/

src/test/java/javFiles/IfTest.jav

@@ -1,14 +0,0 @@
-import java.lang.Integer;
-import java.lang.Boolean;
-import java.lang.Object;
-
-public class IfTest{
-	Object m1(b) {
-		Integer i;
-		if(b) {
-			return i; 
-		}else{
-		    return b;
-		}
-	}
-}

src/test/java/javFiles/Import.jav

@@ -1,8 +0,0 @@
-import java.util.Vector;
-
-class Import {
-    void methode(){
-        Vector v;
-        v.add(v);
-    }
-}

src/test/java/javFiles/Lambda.jav

@@ -1,13 +0,0 @@
-
-class Apply { }
-
-public class Lambda {
-
-  m () {
-   var lam1 = (x) -> {
-        return x;
-   };
-   return lam1.apply(new Apply());
-  }
-}
-

src/test/java/javFiles/Lambda2.jav

@@ -1,33 +0,0 @@
-import java.lang.String;
-
-public class Lambda2
-{
-   public static void main(List<String> args){
-       var listOfStrings = new List<String>();
-       var listOfObjects;
-       listOfObjects = map(listOfStrings, (a) -> a);
-}
-
-public map(a , b){
-    b.apply(a);
-    return a;
-}
-
-/*
-public static <I,O> List<O> map(List<I> input, Function<I,O> func) {
-  List<O> output;
-   output = new List<O>();
-    output.add(func.apply(input.get()));
-  return output;
-}
-*/
-}
-
-class List<A>{
-    A get();
-    void add(A);
-}
-
-class Function<A,B>{
-    B apply(A a);
-}

src/test/java/javFiles/Lambda3.jav

@@ -1,24 +0,0 @@
-import java.lang.String;
-
-public class Lambda2
-{
-    /*
-    public static <A> List<A> map(List<? extends A> input,
-    Function<? super A, ? extends A> func){
-      input.add(func.apply(input.get()));
-    }
-    */
-    public map(input,func){
-       input.add(func.apply(input.get()));
-       return map(new List<String>(), func);
-    }
-}
-
-class List<A>{
-    A get();
-    void add(A);
-}
-
-class Function<A,B>{
-    B apply(A a);
-}

src/test/java/javFiles/LambdaField.jav

@@ -1,6 +0,0 @@
-public class LambdaField {
-
-	f = x -> x;
-	
-}
-

src/test/java/javFiles/LambdaRunnable.jav

@@ -1,14 +0,0 @@
-import java.lang.Runnable;
-import java.lang.String;
-import java.lang.System;
-
-public class LamRunnable{
-
-	public LamRunnable(){
-
-	
-		Runnable lam = () -> {System.out.println("lambda");};
-		lam.run();
-	}
-}
-

src/test/java/javFiles/ListenerOverload.jav

@@ -1,20 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-
-class ListenerOverload{
-
-call(p){
-    call(p.left);
-    call(p.right);
-}
-
-call(Integer i){}
-
-call(String s){}
-
-}
-
-class Pair<A,B>{
-    A left;
-    B right;
-}

src/test/java/javFiles/Matrix.jav

@@ -1,28 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-
-class Matrix extends Vector<Vector<Integer>> {
-	Integer mul1(Integer x, Integer y) { return x;}
-	Integer add1(Integer x, Integer y) { return x;}
-    mul(m) {
-        var ret = new Matrix();
-        var i = 0;
-        while(i < size()) {
-            var v1 = this.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                  erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                  //erg = add1(erg, mul1(v1.elementAt(k),
-                  //           m.elementAt(k).elementAt(j)));
-                    k++; }
-                v2.addElement(new Integer(erg));
-                j++; }
-            ret.addElement(v2);
-            i++; }
-        return ret;
-    }
-}

src/test/java/javFiles/Meth_Gen.jav

@@ -1,11 +0,0 @@
-class Meth_Gen {
-
-    m1(x, y) {
-		m2(x);
-		x = y;
-    }
-
-    m2(y) { 
-    		m1(y, y);
-    }
-}

src/test/java/javFiles/MethodCallGenerics.jav

@@ -1,14 +0,0 @@
-import java.lang.String;
-
-class Generics<B> {
-    //<A extends B> A mt1(A a, B b){
-    B mt1(B a, B b){
-        return mt1(a, a);
-    }
-}
-
-class Test {
-    methode(String s){
-        return new Generics<String>().mt1(s,s);
-    }
-}

src/test/java/javFiles/Methods.jav

@@ -1,17 +0,0 @@
-
-class Methods {
-    mt4(a,b,c) { return a.add(b).sub(c) ; }
-
-    mt1(a) {return a;}
-
-    mt2(a) {return a.f; }
-
-    mt3(a) {return a.add();  }
-}
-
-class Test {
-    java.lang.Object f;
-    add(){}
-    add(b){return b;}
-    sub(b){}
-}

src/test/java/javFiles/MethodsEasy.jav

@@ -1,7 +0,0 @@
-
-class Methods {
-    mt4(a,b,c) { return a.mt3(b).mt3(c) ; }
-
-    mt3(a) {return a.mt3(a);  }
-}
-

src/test/java/javFiles/Op1.jav

@@ -1,11 +0,0 @@
-public class Op1{
-	public Op1() {
-		
-		Runnable lam = () -> {
-				String test = "";
-					String b = "b";
-					test = b;
-				System.out.println(test);};
-		//lam.run();
-	}
-}

src/test/java/javFiles/Package.jav

@@ -1,5 +0,0 @@
-package strucType.input;
-
-class Neu
-{
-}

src/test/java/javFiles/Sorting.jav

@@ -1,8 +0,0 @@
-import java.util.List;
-import java.util.Collection;
-
-class Sorting{
-    void merge(a, b){
-        a.addAll(b);
-    }
-}

src/test/java/javFiles/Subclass.jav

@@ -1,6 +0,0 @@
-public class Subclass extends Superclass {
-
-    	public void printMethod() {
-       	 	super.printMethod();
-	}
-}

src/test/java/javFiles/Superclass.jav

@@ -1,6 +0,0 @@
-public class Superclass {
-
-    public void printMethod() {
-        System.out.println("Printed in Superclass.");
-    }
-}

src/test/java/javFiles/Vector.jav

@@ -1,23 +0,0 @@
-import java.util.ArrayList;
-import java.util.Vector;
-import java.lang.Object;
-
-class MyVector{
-
-id(x){
-  Object i;
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  x.add(i);
-  return x;
-}
-}

src/test/java/javFiles/fc.jav

@@ -1,18 +0,0 @@
-import java.util.List;
-
-class Test{
- methode(param1, param2, param3) {
-    param2.add(param3);
-    return param1.meth(param2);
- }
-}
-
-interface Klasse1{
-    Klasse1 meth(List p);
-    Klasse1 meth(Klasse2 p);
-}
-
-interface Klasse2{
-    Klasse1 meth(Klasse1 p);
-    Klasse2 meth(Klasse2 p);
-}

src/test/java/javFiles/mathStruc.jav

@@ -1,13 +0,0 @@
-
-class mathStruc<A> {
-
-mathStruc(A a) { }
-
-A model(){ A a; return a; }
-
-methode(){
-var innerOp = o -> ms ->
- new mathStruc<A>(o.apply(this.model(),ms.model()));
- return innerOp;
- }
-}

src/test/java/javFiles/test.jav

@@ -1,15 +0,0 @@
-class Test{
- methode(param1, param2, param3) {
-    return param1.meth(param2.meth(param3));
- }
-}
-
-interface Klasse1{
-    Klasse1 meth(Klasse1 p);
-    Klasse1 meth(Klasse2 p);
-}
-
-interface Klasse2{
-    Klasse1 meth(Klasse1 p);
-    Klasse2 meth(Klasse2 p);
-}

src/test/java/javFiles/test1.jav

@@ -1,7 +0,0 @@
-class Faculty {
-
-  int a;
-  m (int x) {
-   return a+x;
-  }
-}

src/test/resources/bytecode/LambdaCapturetest.java

@@ -1,43 +0,0 @@
-/**
- * 
- */
-package bytecode;
-
-import static org.junit.Assert.*;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-import java.net.URLClassLoader;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import de.dhbwstuttgart.core.JavaTXCompiler;
-
-/**
- * @author fayez
- *
- */
-public class LambdaCapturetest {
-	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/LambdaCapture.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("LambdaCapture");
-		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
-	}
-
-}

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

@@ -1,8 +1,8 @@
 import java.util.Vector;
 import java.lang.Integer;
-//import java.lang.Float;
+import java.lang.Float;
 //import java.lang.Byte;
-import java.lang.Boolean;
+//import java.lang.Boolean;
 
 public class Matrix   extends Vector<Vector<Integer>> {
    
@@ -19,7 +19,7 @@ public class Matrix   extends Vector<Vector<Integer>> {
 	  }
     }
 
-	mul(m) {
+    mul(m) {
         var ret = new Matrix();
         var i = 0;
         while(i < size()) {

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

@@ -1,8 +1,8 @@
 import java.util.List;
 import java.lang.Integer;
-import java.util.Collection;
+//import java.util.Collection;
 
-class Merge {
+class Merge  {
 
 	merge(a, b) {
      	a.addAll(b);

src/test/resources/bytecode/simplifyalgo/CycleTest.java

@@ -1,76 +0,0 @@
-/**
- * 
- */
-package bytecode.simplifyalgo;
-
-import static org.junit.Assert.*;
-
-import java.util.HashMap;
-import java.util.HashSet;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.objectweb.asm.Type;
-
-import de.dhbwstuttgart.bytecode.TPHExtractor;
-import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
-import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
-import de.dhbwstuttgart.bytecode.utilities.Simplify;
-
-/**
- * @author Fayez Abu Alia
- *
- */
-public class CycleTest {
-	
-	private static TPHExtractor tphExtractor;
-	private static String methName;
-
-	/**
-	 * @throws java.lang.Exception
-	 */
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		tphExtractor = new TPHExtractor();
-		// A < B
-		TPHConstraint c1 = new ExtendsConstraint("A", "B", Relation.EXTENDS);
-		// B < C
-		TPHConstraint c2 = new ExtendsConstraint("B", "C", Relation.EXTENDS);
-		// C < D
-		TPHConstraint c3 = new ExtendsConstraint("C", "D", Relation.EXTENDS);
-		// D < A
-		TPHConstraint c4 = new ExtendsConstraint("D", "A", Relation.EXTENDS);
-		// name
-		methName = "m";
-		MethodAndTPH mtph = new MethodAndTPH("m");
-		mtph.getTphs().add("A");
-		mtph.getTphs().add("B");
-		mtph.getTphs().add("C");
-		mtph.getTphs().add("D");
-		tphExtractor.ListOfMethodsAndTph.add(mtph);
-		tphExtractor.allCons.add(c1);
-		tphExtractor.allCons.add(c2);
-		tphExtractor.allCons.add(c3);
-		tphExtractor.allCons.add(c4);
-		
-	}
-
-	@Test
-	public void test() {
-		HashMap<TPHConstraint, HashSet<String>> result = new HashMap<>();
-		HashSet<String> equals = new HashSet<>();
-		equals.add("A");
-		equals.add("B");
-		equals.add("C");
-		equals.add("D");
-		TPHConstraint k = new ExtendsConstraint("A", Type.getInternalName(Object.class), Relation.EXTENDS);
-		result.put(k, equals);
-		
-		HashMap<TPHConstraint, HashSet<String>> sim = Simplify.simplifyConstraints(methName, tphExtractor);
-		boolean areEquals = SimpleCycle.areMapsEqual(result, sim);
-		assertTrue(areEquals);
-	}
-
-}

src/test/resources/bytecode/simplifyalgo/SameLeftSide.java

@@ -1,97 +0,0 @@
-package bytecode.simplifyalgo;
-
-import static org.junit.Assert.*;
-
-import java.util.HashMap;
-import java.util.HashSet;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.objectweb.asm.Type;
-
-import de.dhbwstuttgart.bytecode.TPHExtractor;
-import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
-import de.dhbwstuttgart.bytecode.utilities.MethodAndTPH;
-import de.dhbwstuttgart.bytecode.utilities.Simplify;
-import de.dhbwstuttgart.typedeployment.TypeInsertPlacer;
-
-/**
-* 
-* @author Fayez Abu Alia
-*
-*/
-public class SameLeftSide {
-	// Typeplaceholders können nicht definiert werden, da die Konstruktor
-	// private ist => Test geht nicht
-	private static TPHExtractor tphExtractor;
-	private static String methName;
-	private static String methName2;
-	
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		tphExtractor = new TPHExtractor();
-		// A < B
-		TPHConstraint c1 = new ExtendsConstraint("A", "B", Relation.EXTENDS);
-		// A < C
-		TPHConstraint c2 = new ExtendsConstraint("A", "C", Relation.EXTENDS);
-		// B < D
-		TPHConstraint c3 = new ExtendsConstraint("B", "D", Relation.EXTENDS);
-		// C < E
-		TPHConstraint c4 = new ExtendsConstraint("C", "E", Relation.EXTENDS);
-		// name
-		methName = "m1";
-		MethodAndTPH m1 = new MethodAndTPH("m1");
-		
-		methName2 = "m2";
-		MethodAndTPH m2 = new MethodAndTPH("m2");
-		
-		m1.getTphs().add("A");
-		m1.getTphs().add("B");
-		m1.getTphs().add("D");
-		
-		m2.getTphs().add("C");
-		m2.getTphs().add("E");
-		
-		tphExtractor.ListOfMethodsAndTph.add(m1);
-		tphExtractor.ListOfMethodsAndTph.add(m2);
-		
-		tphExtractor.allCons.add(c1);
-		tphExtractor.allCons.add(c2);
-		tphExtractor.allCons.add(c3);
-		tphExtractor.allCons.add(c4);
-	}
-
-	@Test
-	public void testM1() {
-		HashMap<TPHConstraint, HashSet<String>> result = new HashMap<>();
-		
-		TPHConstraint d = new ExtendsConstraint("D", Type.getInternalName(Object.class), Relation.EXTENDS);
-		TPHConstraint a = new ExtendsConstraint("A", "D", Relation.EXTENDS);
-		TPHConstraint b = new ExtendsConstraint("B", "D", Relation.EXTENDS);
-		result.put(d, null);
-		result.put(a, null);
-		result.put(b, null);
-		
-		HashMap<TPHConstraint, HashSet<String>> sim = Simplify.simplifyConstraints(methName, tphExtractor);
-		boolean areEquals = SimpleCycle.areMapsEqual(result, sim);
-		assertTrue(areEquals);
-	}
-	
-	@Test
-	public void testM2() {
-		HashMap<TPHConstraint, HashSet<String>> result = new HashMap<>();
-		
-		TPHConstraint e = new ExtendsConstraint("E", Type.getInternalName(Object.class), Relation.EXTENDS);
-		TPHConstraint c = new ExtendsConstraint("C", "E", Relation.EXTENDS);
-		
-		result.put(e, null);
-		result.put(c, null);
-		
-		HashMap<TPHConstraint, HashSet<String>> sim = Simplify.simplifyConstraints(methName2, tphExtractor);
-		boolean areEquals = SimpleCycle.areMapsEqual(result, sim);
-		assertTrue(areEquals);
-	}
-
-}

src/test/resources/bytecode/simplifyalgo/SimpleCycle.java

@@ -1,79 +0,0 @@
-package bytecode.simplifyalgo;
-
-import static org.junit.Assert.*;
-
-import java.util.HashMap;
-import java.util.HashSet;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.objectweb.asm.Type;
-
-import de.dhbwstuttgart.bytecode.TPHExtractor;
-import de.dhbwstuttgart.bytecode.constraint.ExtendsConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint;
-import de.dhbwstuttgart.bytecode.constraint.TPHConstraint.Relation;
-import de.dhbwstuttgart.bytecode.utilities.Simplify;
-/**
- * 
- * @author Fayez Abu Alia
- *
- */
-public class SimpleCycle {
-	private static TPHExtractor tphExtractor;
-	private static String methName;
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		tphExtractor = new TPHExtractor();
-		// A < B
-		TPHConstraint c1 = new ExtendsConstraint("A", "B", Relation.EXTENDS);
-		// B < A
-		TPHConstraint c2 = new ExtendsConstraint("B", "A", Relation.EXTENDS);
-		// name
-		methName = "m";
-		tphExtractor.allCons.add(c1);
-		tphExtractor.allCons.add(c2);
-		
-	}
-
-	@Test
-	public void test() {
-		HashMap<TPHConstraint, HashSet<String>> result = new HashMap<>();
-		HashSet<String> equals = new HashSet<>();
-		equals.add("A");
-		equals.add("B");
-		TPHConstraint k = new ExtendsConstraint("B", Type.getInternalName(Object.class), Relation.EXTENDS);
-		result.put(k, equals);
-		
-		HashMap<TPHConstraint, HashSet<String>> sim = Simplify.simplifyConstraints(methName, tphExtractor);
-		boolean areEquals = areMapsEqual(result, sim);
-		assertTrue(areEquals);
-	}
-	
-	public static boolean areMapsEqual(HashMap<TPHConstraint, HashSet<String>> m1, HashMap<TPHConstraint, HashSet<String>> m2) {
-		
-		for(TPHConstraint c : m1.keySet()) {
-			for(TPHConstraint c2 : m2.keySet()) {
-				if(c.getLeft().equals(c2.getLeft()) && c.getRight().equals(c2.getRight()) && c.getRel()==c2.getRel()) {
-					HashSet<String> eq1 = m1.get(c);
-					HashSet<String> eq2 = m2.get(c2);
-					
-					if((eq1 == null && eq2 != null) || (eq1 != null && eq2 == null))
-						return false;
-					if(eq1 != null) {
-						if(eq1.size() != eq2.size())
-							return false;
-						
-						for(String tph:eq1) {
-							if(!eq2.contains(tph))
-								return false;
-						}
-					}
-				}
-			}
-			
-		}
-		return true;
-	}
-
-}

src/test/resources/javFiles/Faculty.jav

@@ -5,7 +5,7 @@ class Faculty {
   Integer mul(Integer x, Integer y) {
   	return x;
    }
-
+ 
   m () {
    var fact = (Integer x) -> {
         return mul(x, fact.apply(x));

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

@@ -1,30 +0,0 @@
-import java.lang.Integer;
-import java.lang.Boolean;
-import java.lang.String;
-import java.lang.Byte;
-import java.lang.Short;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-import java.lang.Character;
-
-class AssignToLit {
-	void m(){
-//		String s = "Test";
-//		Boolean b = false;
-//		Byte byte1 = 5;
-//		Byte byte2 = 55;
-//		Short short1 = 5;
-//		Short short2 = 55;
-//		Integer int1 = 5;
-//		Integer int2 = 8888888;
-//		Long long1 = 1;
-//		Long long2 = 5;
-//		Long long3 = 89989898;
-//		Float float1 = 1;
-//		Float float2 = 55;
-//		Double d1 = 1;
-//		Double d2 = 55;
-		Character c = 'A';
-	}
-}

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

@@ -1,17 +0,0 @@
-import java.lang.Integer;
-import java.lang.Double;
-
-public class BinaryInMeth {
-	
-	m(a){
-		return ++a;
-	}
-	
-	m2(a,b){
-		return m(a+b);
-	}
-	
-	m3(a) {
-		return m(++a);
-	}
-}

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

@@ -1,11 +0,0 @@
-public class DuMethod{
-	
-	method(a){
-		return a+a;
-	}
-	
-	method(a){
-		return a;
-	}
-	
-}

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

@@ -1,8 +0,0 @@
-public class EmptyMethod{
-	
-	public void m1(){
-		System.out.println("test");
-	}
-	
-	public void m2(){}
-}

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

@@ -1,9 +0,0 @@
-import java.lang.String;
-
-public class Example {
-	
-	public m() {
-		String x = "X";
-		return x;
-	}
-}

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

@@ -1,3 +0,0 @@
-public class Exceptions {
-//	m(Integer i) throws 
-}

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

@@ -1,15 +0,0 @@
-import java.lang.Integer;
-//import java.lang.Double;
-
-public class Fac  {
-	
-	getFac(n){
-		var res = 1;
-		var i = 1;
-		while(i<=n) {
-			res = res * i;
-			i++;
-		}
-		return res;
-	}
-}

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

@@ -1,48 +0,0 @@
-import java.lang.Integer;
-
-public class Faculty {
-	public fact;
-	Faculty() {
-		fact = (x) -> {
-			if (x == 1) {
-				return 1;
-			}
-			else {
-			  return x * (fact.apply(x-1));
-			}
-		};
-	}
-	
-	
-	public getFact(x) {
-		return fact.apply(x);
-	}
-//  m (x) {
-//	  
-////   var fact = (x) -> {
-////   	  if (x == 1) {
-////        return x;
-////      }
-////      else {
-////        return x * (fact.apply(x-1));
-////      }
-////   };
-////   return fact;
-////	  var x = 13;
-////	  if(x>22) {
-////			return 0;
-////		}else if(x <1){
-////			return x;
-////		}else {
-////			return 1;
-////		}
-//	  
-//	  if (x < 0) {
-//	        return 0;
-//	  }else if(x<2) {
-//		  return x;
-//	  } else {
-//		  return x * m(x-1);
-//	  }
-//  }
-}

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

@@ -1,10 +0,0 @@
-class Faculty2 {
-
-  m () {
-	  
-   var fact = (Integer x) -> {
-        return x;
-   };
-   return fact;
-  }
-}

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

@@ -1,9 +0,0 @@
-import java.lang.Integer;
-
-public class Field {
-	public Integer x = 5;
-	
-	m(){
-		return x;
-	}
-}

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

@@ -1,30 +0,0 @@
-import java.lang.Integer;
-import java.lang.Boolean;
-
-class For{
-	Integer m(Integer x){
-		var c = x + 2;
-//		Boolean b = true;
-//		c = 5;
-//		c++;
-//		++c;
-//		c--;
-//		--c;
-//		while(x<2){
-//			x = x +1;
-//			b = false;
-//		}
-		return c;
-//		for(int i = 0;i<10;i++) {
-//			x = x + 5;
-//		}
-	}
-	
-//	m2(Integer x){
-//		if(x<2) {
-//			return 1;
-//		}else {
-//			return 2;
-//		}
-//	}
-}

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

@@ -1,12 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-import java.lang.String;
-//import java.lang.Byte;
-//import java.lang.Boolean;
-
-public class FunOL   {
-
-	add(f, y) {
-        return f.apply() + y;
-    }
-}

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

@@ -1,8 +0,0 @@
-import java.lang.Integer;
-import java.util.Vector;
-
-public class Gen{
-	Vector<Integer> m(Vector<Integer> v){
-		return v;
-	}
-}

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

@@ -1,17 +0,0 @@
-
-class Generics<B> {
-	Generics(B b){
-    }
-    B mt1(B b){
-        return mt1(b);
-    }
-}
-
-
-/*
-Problem:
-auto test = new List<String>();
-auto test2 = new List<Integer>();
-... //code, welcher möglicherweise test und test2 vertauscht
-test.add("hallo");
-*/

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

@@ -1,6 +0,0 @@
-class Generics2<B extends String>{
-	<B extends Integer> B m1(B b){
-		return b;
-	}
-
-}

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

@@ -1,57 +0,0 @@
-import java.lang.Integer;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-
-public class GreaterEqual {
-	
-	gE(Integer a, Integer b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Long a, Long b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Float a, Float b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Double a, Double b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Long a, Integer b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Float a, Integer b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Double a, Integer b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Float a, Long b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Double a, Long b){
-		var c = a>=b;
-		return c;
-	}
-	
-	gE(Double a, Float b){
-		var c = a>=b;
-		return c;
-	}
-}

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

@@ -1,56 +0,0 @@
-import java.lang.Integer;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-
-public class GreaterThan {
-	gT(Integer a, Integer b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Long a, Long b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Float a, Float b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Double a, Double b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Long a, Integer b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Float a, Integer b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Double a, Integer b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Float a, Long b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Double a, Long b){
-		var c = a>b;
-		return c;
-	}
-	
-	gT(Double a, Float b){
-		var c = a>b;
-		return c;
-	}
-}

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

@@ -1,15 +0,0 @@
-import java.lang.Integer;
-import java.lang.Boolean;
-import java.lang.String;
-
-public class IfTest{
-	Integer m1(Boolean b) {
-		Integer i;
-		String b;
-		if(b) {
-			return i; 
-		}else{
-		    return b;
-		}
-	}
-}

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

@@ -1,8 +0,0 @@
-import java.util.Vector;
-
-class Import {
-    void methode(){
-        Vector v = new Vector<>();
-        v.add("X");
-    }
-}

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

@@ -1,3 +0,0 @@
-public interface Interface1{
-	public void test();
-}

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

@@ -1,9 +0,0 @@
-public class LamRunnable{
-
-	public LamRunnable(){
-	
-		Runnable lam = () -> {System.out.println("lambda");};
-		lam.run();
-	}
-}
- 

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

@@ -1,10 +0,0 @@
-import java.lang.Integer;
-
-public class Lambda {
-
-  m () {
-   var lam1 = (x) -> {
-        return x;
-   };
-   return lam1;
-}

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

@@ -1,35 +0,0 @@
-import java.lang.String;
-
-public class Lambda2
-{
-   public static void main(List<String> args){
-       var listOfStrings = new List<String>();
-       var listOfObjects;
-       listOfObjects = map(listOfStrings, (a) -> a);
-}
-
-public map(a , b){
-    b.apply(a);
-    return a;
-}
-
-/*
-public static <I,O> List<O> map(List<I> input, Function<I,O> func) {
-  List<O> output;
-   output = new List<O>();
-    output.add(func.apply(input.get()));
-  return output;
-}
-*/
-}
-
-class List<A>{
- /*   A get();
-    void add(A);
-    */
-}
-/*
-class Function<A,B>{
-    B apply(A a);
-}
-*/

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

@@ -1,23 +0,0 @@
-
-public class Lambda2
-{
-    /*
-    public static <A> List<A> map(List<? extends A> input,
-    Function<? super A, ? extends A> func){
-      input.add(func.apply(input.get()));
-    }
-    */
-    public map(input,func){
-       input.add(func.apply(input.get()));
-       return map(new List<String>(), func);
-    }
-}
-
-class List<A>{
-    A get();
-    void add(A);
-}
-
-class Function<A,B>{
-    B apply(A a);
-}

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

@@ -1,18 +0,0 @@
-class Lambda{
-
-methode(){
-    return ((f) -> f);
-}
-}
-/*
-interface Fun0<A>{
-    A apply();
-}
-
-interface Fun1<A,B>{
-    A apply(B b);
-}
-*/
-interface Fun2<A,B,C>{
-    A apply(B b, C c);
-}

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

@@ -1,12 +0,0 @@
-import java.lang.Integer;
-public class LambdaCapture {
-	Integer i = 8;
-	f;
-	public LambdaCapture(){
-		Integer w = 7;
-		f = j ->{
-			return w+i;};
-
-	}
-
-}

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

@@ -1,9 +0,0 @@
-import java.lang.Integer;
-
-public class Lambda {
-
-  m () {
-   var lam1 = (x) -> { };
-   return lam1;
-  }
-}

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

@@ -1,56 +0,0 @@
-import java.lang.Integer;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-
-public class LessEqual {
-	lessEqual(Integer a, Integer b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Long a, Long b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Float a, Float b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Double a, Double b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Long a, Integer b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Float a, Integer b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Double a, Integer b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Float a, Long b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Double a, Long b){
-		var c = a<=b;
-		return c;
-	}
-	
-	lessEqual(Double a, Float b){
-		var c = a<=b;
-		return c;
-	}
-}

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

@@ -1,57 +0,0 @@
-import java.lang.Integer;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-
-public class LessThan {
-	
-	lessThan(Integer a, Integer b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Long a, Long b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Float a, Float b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Double a, Double b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Long a, Integer b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Float a, Integer b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Double a, Integer b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Float a, Long b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Double a, Long b){
-		var c = a<b;
-		return c;
-	}
-	
-	lessThan(Double a, Float b){
-		var c = a<b;
-		return c;
-	}
-}

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

@@ -1,44 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-//import java.lang.Float;
-//import java.lang.Byte;
-import java.lang.Boolean;
-
-public class Matrix   extends Vector<Vector<Integer>> {
-   
-	Matrix () {
-    }
-
-	Matrix(vv) {
-    	Integer i;
-    	i = 0;
-	  while(i < vv.size()) {
-//	    	Boolean a = this.add(vv.elementAt(i));
-		  this.add(vv.elementAt(i));
-		  i=i+1;
-	  }
-    }
-
-	mul(m) {
-        var ret = new Matrix();
-        var i = 0;
-        while(i < size()) {
-            var v1 = this.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                    erg = erg + v1.elementAt(k)
-                             * m.elementAt(k).elementAt(j);
-                    k++; }
-//                v2.addElement(new Integer(erg));
-                v2.addElement(erg);
-                j++; }
-            ret.addElement(v2);
-            i++; 
-         }
-        return ret;
-    }
-}

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

@@ -1,43 +0,0 @@
-import java.util.Vector;
-import java.lang.Integer;
-//import java.lang.Byte;
-import java.lang.Boolean;
-
-public class MatrixOP extends Vector<Vector<Integer>> {
-   
-	MatrixOP () {
-    }
-
-	MatrixOP(vv) {
-    	Integer i;
-    	i = 0;
-	  while(i < vv.size()) {
-//	    	Boolean a = this.add(vv.elementAt(i));
-		  this.add(vv.elementAt(i));
-		  i=i+1;
-	  }
-    }
-
-	mul = (m1, m2) -> {
-        var ret = new MatrixOP();
-        var i = 0;
-        while(i < size()) {
-            var v1 = m1.elementAt(i);
-            var v2 = new Vector<Integer>();
-            var j = 0;
-            while(j < v1.size()) {
-                var erg = 0;
-                var k = 0;
-                while(k < v1.size()) {
-                    erg = erg + v1.elementAt(k)
-                             * m2.elementAt(k).elementAt(j);
-                    k++; }
-//                v2.addElement(new Integer(erg));
-                v2.addElement(erg);
-                j++; }
-            ret.addElement(v2);
-            i++; 
-         }
-        return ret;
-    };
-}

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

@@ -1,20 +0,0 @@
-import java.util.List;
-import java.lang.Integer;
-import java.util.Collection;
-
-class Merge {
-
-	merge(a, b) {
-     	a.addAll(b);
-		return a;
-	}
-
-
-
-  	sort(in){
-		var firstHalf = in.subList(1,2);
-    	var secondHalf = in.subList(1,2);
-    	return merge(sort(firstHalf), sort(secondHalf));
-    }
-    
-}

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

@@ -1,14 +0,0 @@
-import java.lang.Integer;
-
-class Methods {
-	
-	m(a,b){
-		var c=a+b;
-		return c;
-	}
-	
-	method2(x){
-		Integer i = this.m(x,2);
-		return i;
-	}
-}

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

@@ -1,22 +0,0 @@
-import java.lang.String;
-import java.lang.Integer;
-import java.lang.Double; 
-
-
-
-public class OL     {
-
-     m(x) { return x + x; }
-	
-}
-
-         
-
-public class OLMain   {
-
-	main(x) { 
-		var ol;
-		ol = new OL(); 
-		return ol.m(x); 
-	}  
-}

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

@@ -1,16 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-import java.lang.Long;
-import java.lang.Float;
-import java.lang.Double;
-import java.lang.Boolean;
-import java.lang.Short;
-import java.lang.Byte;
-
-public class Op {
-	
-	m(a, b) {
-		//var c = a+b;		
-		return a+b;
-	}
-}

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

@@ -1,11 +0,0 @@
-import java.lang.Integer;
-import java.lang.String;
-
-public class Op2 {
-	m(){
-		var x = "";
-		var a = 5+x;
-		
-		return a;
-	}
-}