Merge branch 'master' into feat/unify-server-mergeMaster

modified:   ../src/main/java/de/dhbwstuttgart/core/JavaTXCompiler.java
	modified:   ../src/test/java/TestComplete.java

.gitea/workflows/build_and_test.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
-          java-version: '23'
+          java-version: '24'
           cache: 'maven'
       - name: Compile project
         run: |

independentTest.sh

@@ -10,6 +10,7 @@ mkdir $TDIR
 cd $TDIR
 git clone $REPO .
 git checkout feat/unify-server
+# git checkout 93e1a8787cd94c73f4538f6a348f58613893a584
 # git checkout dad468368b86bdd5a3d3b2754b17617cee0a9107 # 1:55
 # git checkout a0c11b60e8c9d7addcbe0d3a09c9ce2924e9d5c0 # 2:25
 # git checkout 4cddf73e6d6c9116d3e1705c4b27a8e7f18d80c3 # 2:27
@@ -19,15 +20,14 @@ git checkout feat/unify-server
 # git checkout 1391206dfe59263cdb22f93371cfd1dd5465d97f # 1:29
 
 date "+%Y.%m.%d %H:%M:%S"
-
-# mvn clean compile -DskipTests package
-## prefix each stderr line with " | "
-# exec 2> >(trap "" INT TERM; sed 's/^/ | /' >&2)
-# echo -e "\nMatrix test:\n |"
-# time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav >/dev/null;
+# sed -i -e 's/source>21/source>23/g' pom.xml
+# sed -i -e 's/target>21/target>23/g' pom.xml
 
 
-mvn clean compile test
+mvn clean compile -DskipTests package
+time java -jar target/JavaTXcompiler-0.1-jar-with-dependencies.jar resources/bytecode/javFiles/Matrix.jav;
+
+# mvn clean compile test
 
 
 echo -e "\nCleanup... "

pom.xml

@@ -12,37 +12,37 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 	<url>http://maven.apache.org</url>
 	<dependencies>
 		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.13.2</version>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>5.13.2</version>
 			<scope>test</scope>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.antlr/antlr4 -->
 		<dependency>
 			<groupId>org.antlr</groupId>
 			<artifactId>antlr4</artifactId>
-			<version>4.11.1</version>
+			<version>4.13.2</version>
 		</dependency>
 		<dependency>
 			<groupId>commons-io</groupId>
 			<artifactId>commons-io</artifactId>
-			<version>2.16.1</version>
+			<version>2.19.0</version>
 		</dependency>
 		<dependency>
 			<groupId>io.github.classgraph</groupId>
 			<artifactId>classgraph</artifactId>
-			<version>4.8.172</version>
+			<version>4.8.180</version>
 		</dependency>
 		<dependency>
 			<groupId>com.google.guava</groupId>
 			<artifactId>guava</artifactId>
-			<version>33.2.0-jre</version>
+			<version>33.4.8-jre</version>
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
 		<dependency>
 			<groupId>org.ow2.asm</groupId>
 			<artifactId>asm</artifactId>
-			<version>9.5</version>
+			<version>9.8</version>
 		</dependency>
 		<dependency>
 			<groupId>org.java-websocket</groupId>
@@ -59,6 +59,11 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<artifactId>jackson-databind</artifactId>
 			<version>2.17.2</version>
 		</dependency>
+		<dependency>
+			<groupId>com.diogonunes</groupId>
+			<artifactId>JColor</artifactId>
+			<version>5.5.1</version>
+		</dependency>
 	</dependencies>
 
 	<build>
@@ -66,17 +71,17 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-compiler-plugin</artifactId>
-				<version>3.11.0</version>
+				<version>3.14.0</version>
 				<configuration>
 					<compilerArgs>--enable-preview</compilerArgs>
-                    <source>23</source>
-                    <target>23</target>
+                    <source>24</source>
+                    <target>24</target>
                 </configuration>
 			</plugin>
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>3.1.0</version>
+				<version>3.5.3</version>
 				<configuration>
 					<redirectTestOutputToFile>true</redirectTestOutputToFile>
 					<reportsDirectory>${project.build.directory}/test-reports</reportsDirectory>
@@ -92,7 +97,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.antlr</groupId>
 				<artifactId>antlr4-maven-plugin</artifactId>
-				<version>4.11.1</version>
+				<version>4.13.2</version>
 				<executions>
 					<execution>
 						<id>antlr</id>
@@ -105,7 +110,7 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-jar-plugin</artifactId>
-				<version>3.3.0</version>
+				<version>3.4.2</version>
 				<configuration>
 					<archive>
 						<manifest>

resources/bytecode/javFiles/Bug325.jav

@@ -6,7 +6,7 @@ import java.util.stream.Stream;
 
 public class Bug325 {
     public main() {
-      List<Integer> list = new ArrayList<>(List.of(1,2,3,4,5));
+      var list = new ArrayList<>(List.of(1,2,3,4,5));
       var func = x -> x*2;
       return list.stream().map(func).toList();
    }

resources/bytecode/javFiles/Bug363.jav

@@ -0,0 +1,22 @@
+import java.lang.String;
+
+
+public class Bug363 {
+  uncurry (f){
+    return x -> f.apply(x);
+  }
+
+  uncurry (f){
+    return (x, y) -> f.apply(x).apply(y);
+  }
+
+  uncurry (f){
+    return (x, y, z) -> f.apply(x).apply(y).apply(z);
+  }
+
+  public test(){
+    var f = x -> y -> z -> x + y + z;
+    var g = uncurry(f);
+    return g.apply("A", "B", "C"); // Outputs: 6
+  }
+}

resources/bytecode/javFiles/Bug364.jav

@@ -0,0 +1,8 @@
+import java.lang.String;
+
+public class Bug364{
+  public main(){
+    var f = x -> y -> z -> x + y + z;
+    return f.apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug365.jav

@@ -0,0 +1,21 @@
+import java.lang.String;
+import java.lang.Object;
+
+public class Bug365{
+  swap(f){
+    return x -> y -> f.apply(y).apply(x);
+  }
+
+  swap(Fun1$$<String, Fun1$$<String, Fun1$$<String, Object>>> f){
+    return x -> y -> z -> f.apply(z).apply(y).apply(x);
+  }
+
+  public ex1() {
+    var func = x -> y -> z -> x + y + z;
+    return func.apply("A").apply("B").apply("C");
+  }
+  public ex2() {
+    var func = x -> y -> z -> x + y + z;
+    return swap(func).apply("A").apply("B").apply("C");
+  }
+}

resources/bytecode/javFiles/Bug366.jav

@@ -0,0 +1,12 @@
+import java.lang.Integer;
+
+public class Bug366 {
+    public static lambda() {
+        return (a, b) -> a + b;
+    }
+
+    public static test() {
+        var l = lambda();
+        return l.apply(10, 20);
+    }
+}

resources/bytecode/javFiles/Bug371.jav

@@ -0,0 +1,10 @@
+import java.lang.Boolean;
+
+public class Bug371 {
+    static m1(x, y) { return x || y; }
+    static m2(x, y) { return x && y; }
+
+    public static test() {
+        return m2(m1(true, false), true);
+    }
+}

resources/bytecode/javFiles/Bug373.jav

@@ -0,0 +1,17 @@
+import java.lang.Boolean;
+import java.lang.Integer;
+import java.lang.System;
+import java.io.PrintStream;
+import java.lang.Character;
+
+public class Bug373 {
+    public static main() {
+        System.out.println(true);
+        System.out.println(false);
+        System.out.println(1);
+        System.out.println(1l);
+        System.out.println(1.0);
+        System.out.println(1.0f);
+        System.out.println('a');
+    }
+}

resources/bytecode/javFiles/BugXXX.jav

@@ -1,16 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-import java.lang.String;
-import java.util.stream.Stream;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.lang.Integer;
-
-class BugXXX {
-    public main() {
-        List<Integer> i = new ArrayList<>(List.of(1,2,3,4,5,6,7,8,9,10));
-        Optional<Integer> tmp = i.stream().filter(x -> x == 5).map(x -> x*2).findFirst();
-        return tmp;
-    }
-}

resources/bytecode/javFiles/Main.jav

@@ -0,0 +1,14 @@
+import java.lang.Object;
+import java.lang.System;
+import java.lang.Iterable;
+import java.io.PrintStream;
+import java.util.List;
+import java.lang.String;
+
+class Main {
+    static main(args) {
+        for (var arg : args) {
+            System.out.println(arg);
+        }
+    }
+}

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

@@ -8,17 +8,21 @@ import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
+import de.dhbwstuttgart.util.Logger;
 import org.objectweb.asm.*;
 
 import java.lang.invoke.*;
 import java.lang.reflect.Modifier;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import static org.objectweb.asm.Opcodes.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetBinaryOp.*;
 import static de.dhbwstuttgart.target.tree.expression.TargetLiteral.*;
 
 public class Codegen {
+    public static Logger logger = new Logger("codegen");
+
     private final TargetStructure clazz;
     private final ClassWriter cw;
     public final String className;
@@ -84,14 +88,16 @@ public class Codegen {
         int localCounter;
         MethodVisitor mv;
         TargetType returnType;
+        boolean isStatic = false;
 
         Stack<BreakEnv> breakStack = new Stack<>();
         Stack<Integer> switchResultValue = new Stack<>();
 
-        State(TargetType returnType, MethodVisitor mv, int localCounter) {
+        State(TargetType returnType, MethodVisitor mv, int localCounter, boolean isStatic) {
             this.returnType = returnType;
             this.mv = mv;
             this.localCounter = localCounter;
+            this.isStatic = isStatic;
         }
 
         void enterScope() {
@@ -229,9 +235,9 @@ public class Codegen {
         if (source.equals(dest))
             return;
         if (source.equals(TargetType.Long)) {
-            if (dest.equals(TargetType.Integer)) {
+            if (dest.equals(TargetType.Integer))
                 mv.visitInsn(L2I);
-            } else if (dest.equals(TargetType.Float))
+            else if (dest.equals(TargetType.Float))
                 mv.visitInsn(L2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(L2D);
@@ -274,6 +280,8 @@ public class Codegen {
                 mv.visitInsn(I2F);
             else if (dest.equals(TargetType.Double))
                 mv.visitInsn(I2D);
+        } else if (source.equals(TargetType.Boolean)) {
+            unboxPrimitive(state, dest);
         } else if (isFunctionalInterface(source) && isFunctionalInterface(dest) &&
                 !(source instanceof TargetFunNType && dest instanceof TargetFunNType)) {
             boxFunctionalInterface(state, source, dest);
@@ -757,6 +765,16 @@ public class Codegen {
         }
     }
 
+    private static TargetType removeGenerics(TargetType param) {
+        return switch (param) {
+            case null -> null;
+            case TargetFunNType funNType -> new TargetFunNType(funNType.name(), funNType.funNParams(), List.of(), funNType.returnArguments());
+            case TargetRefType refType -> new TargetRefType(refType.name());
+            case TargetGenericType targetGenericType -> TargetType.Object;
+            default -> param;
+        };
+    }
+
     private void generateLambdaExpression(State state, TargetLambdaExpression lambda) {
         var mv = state.mv;
 
@@ -768,7 +786,8 @@ public class Codegen {
 
         var parameters = new ArrayList<>(lambda.captures());
         parameters.addAll(signature.parameters());
-        var implSignature = new TargetMethod.Signature(Set.of(), parameters, lambda.signature().returnType());
+        parameters = parameters.stream().map(param -> param.withType(removeGenerics(param.pattern().type()))).collect(Collectors.toCollection(ArrayList::new));
+        var implSignature = new TargetMethod.Signature(Set.of(), parameters, removeGenerics(lambda.signature().returnType()));
 
         TargetMethod impl;
         if (lambdas.containsKey(lambda)) {
@@ -776,20 +795,21 @@ public class Codegen {
         } else {
             var name = "lambda$" + lambdaCounter++;
 
-            impl = new TargetMethod(0, name, lambda.block(), implSignature, null);
-            generateMethod(impl);
+            impl = new TargetMethod(state.isStatic ? ACC_STATIC : 0, name, lambda.block(), implSignature, null);
+            generateMethod(impl, state);
             lambdas.put(lambda, impl);
         }
 
         var mt = MethodType.methodType(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);
 
         var bootstrap = new Handle(H_INVOKESTATIC, "java/lang/invoke/LambdaMetafactory", "metafactory", mt.toMethodDescriptorString(), false);
-        var handle = new Handle(H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
+        var handle = new Handle(state.isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL, clazz.getName(), impl.name(), implSignature.getDescriptor(), false);
 
         var params = new ArrayList<TargetType>();
-        params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
+        if(!state.isStatic) params.add(new TargetRefType(clazz.qualifiedName().getClassName()));
         params.addAll(lambda.captures().stream().map(mp -> mp.pattern().type()).toList());
 
+        if (!state.isStatic)
             mv.visitVarInsn(ALOAD, 0);
         for (var index = 0; index < lambda.captures().size(); index++) {
             var capture = lambda.captures().get(index);
@@ -1317,7 +1337,7 @@ public class Codegen {
                 types.add(Type.getObjectType(guard.inner().type().getInternalName()));
                 // TODO Same here we need to evaluate constant;
             } else {
-                System.out.println(label);
+                logger.info(label);
                 throw new NotImplementedException();
             }
         }
@@ -1518,7 +1538,7 @@ public class Codegen {
         MethodVisitor mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "<clinit>", "()V", null, null);
         mv.visitCode();
 
-        var state = new State(null, mv, 0);
+        var state = new State(null, mv, 0, true);
         generate(state, constructor.block());
 
         mv.visitInsn(RETURN);
@@ -1532,7 +1552,7 @@ public class Codegen {
             mv.visitAttribute(new JavaTXSignatureAttribute(constructor.getTXSignature()));
         
         mv.visitCode();
-        var state = new State(null, mv, 1);
+        var state = new State(null, mv, 1, false);
         for (var param : constructor.parameters()) {
             var pattern = param.pattern();
             if (pattern instanceof TargetTypePattern tp)
@@ -1578,9 +1598,31 @@ public class Codegen {
             }
         }
     }
-
     private void generateMethod(TargetMethod method) {
+        generateMethod(method, null);
+    }
+
+    private void generateMainMethod() {
+        var mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(ALOAD, 0);
+        mv.visitMethodInsn(INVOKESTATIC, "java/util/List", "of", "([Ljava/lang/Object;)Ljava/util/List;", true);
+        mv.visitMethodInsn(INVOKESTATIC, className, "main", "(Ljava/util/List;)V", false);
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 0);
+        mv.visitEnd();
+    }
+
+    private void generateMethod(TargetMethod method, State parent) {
         var access = method.access();
+
+        var params = method.signature().parameters();
+        if (method.name().equals("main") && method.isStatic() && params.size() == 1 &&
+            params.getFirst().pattern().type().equals(new TargetRefType("java.util.List", List.of(new TargetRefType("java.lang.String"))))) {
+
+            generateMainMethod();
+        }
+
         if (method.block() == null)
             access |= ACC_ABSTRACT;
         if (clazz instanceof TargetInterface)
@@ -1594,7 +1636,10 @@ public class Codegen {
 
         if (method.block() != null) {
             mv.visitCode();
-            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1);
+            var state = new State(method.signature().returnType(), mv, method.isStatic() ? 0 : 1, method.isStatic());
+            if (parent != null) {
+                state.scope.parent = parent.scope;
+            }
             var offset = 1;
             for (var param : method.signature().parameters()) {
                 state.createVariable(param.pattern().name(), param.pattern().type());
@@ -1604,6 +1649,8 @@ public class Codegen {
                     bindLocalVariables(state, cp, offset);
                 offset++;
             }
+            //if (parent != null) System.out.println("parent: " + parent.scope.locals.keySet());
+            //System.out.println(state.scope.locals.keySet());
             generate(state, method.block());
             if (method.signature().returnType() == null)
                 mv.visitInsn(RETURN);
@@ -1710,7 +1757,7 @@ public class Codegen {
 
             // Generate wrapper method
             var mv = cw2.visitMethod(ACC_PUBLIC, toMethod.name, toDescriptor, null, null);
-            var state = new State(null, mv, 0);
+            var state = new State(null, mv, 0, false);
 
             mv.visitVarInsn(ALOAD, 0);
             mv.visitFieldInsn(GETFIELD, className, "wrapped", pair.from.toDescriptor());
@@ -1742,7 +1789,7 @@ public class Codegen {
                 converter.classLoader.findClass(className);
             } catch (ClassNotFoundException e) {
                 try {
-                    converter.classLoader.loadClass(bytes);
+                    converter.classLoader.loadClass(className, bytes);
                 } catch (LinkageError ignored) {}
             }
         }

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

@@ -39,6 +39,10 @@ public class FunNGenerator {
         public final List<TargetType> inParams;
         public final List<TargetType> realParams;
 
+        public GenericParameters(TargetFunNType funNType) {
+            this(funNType.funNParams(), funNType.returnArguments());
+        }
+
         public GenericParameters(List<TargetType> params, int numReturns) {
             this.realParams = params;
             this.inParams = flattenTypeParams(params);
@@ -120,7 +124,7 @@ public class FunNGenerator {
             superFunNMethodDescriptor.append(")V");
         }
 
-        System.out.println(superFunNMethodSignature);
+        Codegen.logger.info(superFunNMethodSignature);
 
         ClassWriter classWriter = new ClassWriter(0);
         MethodVisitor methodVisitor;

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

@@ -1,13 +1,19 @@
 package de.dhbwstuttgart.core;
 
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.util.Logger;
 import java.io.File;
 import java.io.IOException;
-import java.io.OutputStream;
-import java.io.PrintStream;
 import java.util.*;
 
 public class ConsoleInterface {
-  private static final String directory = System.getProperty("user.dir");
+
+  /**
+   * Leave the argument configurations here for the rest of the code to read
+   */
+  public static Logger.LogLevel logLevel = Logger.LogLevel.ERROR;
+  public static boolean writeLogFiles = false;
+  public static Optional<String> unifyServerUrl = Optional.empty();
 
   public static void main(String[] args) throws IOException, ClassNotFoundException {
     List<File> input = new ArrayList<>();
@@ -15,7 +21,6 @@ public class ConsoleInterface {
     String outputPath = null;
     Iterator<String> it = Arrays.asList(args).iterator();
     Optional<Integer> serverPort = Optional.empty();
-    Optional<String> unifyServer = Optional.empty();
 
     if (args.length == 0) {
       System.out.println("No input files given. Get help with --help");
@@ -25,7 +30,9 @@ public class ConsoleInterface {
         "\t-cp\tSet Classpath\n" +
         "\t-d\tSet destination directory\n" +
         "\t[--server-mode <port>]\n" +
-        "\t[--unify-server <url>]\n");
+        "\t[--unify-server <url>]\n" +
+        "\t[--write-logs]\n" +
+        "\t[-v|-vv-|-vvv]");
       System.exit(1);
     }
     while (it.hasNext()) {
@@ -42,22 +49,31 @@ public class ConsoleInterface {
       } else if (arg.equals("--server-mode")) {
         serverPort = Optional.of(Integer.parseInt(it.next()));
       } else if (arg.equals("--unify-server")) {
-        unifyServer = Optional.of(it.next());
+        unifyServerUrl = Optional.of(it.next());
+      } else if (arg.equals("--write-logs")) {
+        ConsoleInterface.writeLogFiles = true;
+      } else if (arg.startsWith("-v")) {
+        logLevel = switch (arg) {
+          case "-v" -> Logger.LogLevel.WARNING;
+          case "-vv" -> Logger.LogLevel.INFO;
+          case "-vvv" -> Logger.LogLevel.DEBUG;
+          default -> throw new IllegalArgumentException("Argument " + arg + " is not a valid verbosity level");
+        };
       } else {
         input.add(new File(arg));
       }
     }
 
     if (serverPort.isPresent()) {
-      if (unifyServer.isPresent()) throw new RuntimeException("Cannot use unifyServer when in server mode!");
-
+      if (unifyServerUrl.isPresent()) throw new RuntimeException("Cannot use unifyServer when in server mode!");
       JavaTXServer server = new JavaTXServer(serverPort.get());
       server.listen();
     }
     else {
-      JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null, unifyServer);
+      JavaTXCompiler compiler = new JavaTXCompiler(input, classpath, outputPath != null ? new File(outputPath) : null);
       //compiler.typeInference();
       compiler.generateBytecode();
+      SocketClient.closeIfOpen();
     }
   }
 

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

@@ -13,6 +13,10 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser.SourceFileContext;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.packet.SetAutoclosePacket;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
+import de.dhbwstuttgart.server.packet.UnifyResultPacket;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.Method;
@@ -53,6 +57,7 @@ import de.dhbwstuttgart.typeinference.unify.UnifyResultListenerImpl;
 import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
 import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
 
+import de.dhbwstuttgart.util.Logger;
 import java.io.*;
 import java.lang.reflect.Modifier;
 import java.nio.file.Path;
@@ -67,47 +72,35 @@ public class JavaTXCompiler {
 
 	// do not use this in any code, that can be executed serverside!
 	public static PlaceholderRegistry defaultClientPlaceholderRegistry = new PlaceholderRegistry();
+	public static Logger defaultLogger = new Logger();
 
 	// public static JavaTXCompiler INSTANCE;
 	final CompilationEnvironment environment;
 	Boolean resultmodel = true;
 	public final Map<File, SourceFile> sourceFiles = new HashMap<>();
 
-	Boolean log = false; //gibt an ob ein Log-File nach System.getProperty("user.dir")+""/logFiles/"" geschrieben werden soll?
 	public volatile UnifyTaskModel usedTasks = new UnifyTaskModel();
 	public final DirectoryClassLoader classLoader;
 
 	public final List<File> classPath;
 	private final File outputPath;
 
-	private final Optional<String> unifyServer;
-
 	public DirectoryClassLoader getClassLoader() {
 		return classLoader;
 	}
 
 	public JavaTXCompiler(File sourceFile) throws IOException, ClassNotFoundException {
-		this(Arrays.asList(sourceFile), List.of(), new File("."), Optional.empty());
-	}
-
-	public JavaTXCompiler(File sourceFile, Boolean log) throws IOException, ClassNotFoundException {
-		this(sourceFile);
-		this.log = log;
+		this(Collections.singletonList(sourceFile), List.of(), new File("."));
 	}
 
 	public JavaTXCompiler(List<File> sourceFiles) throws IOException, ClassNotFoundException {
-		this(sourceFiles, List.of(), new File("."), Optional.empty());
+		this(sourceFiles, List.of(), new File("."));
 	}
 
 	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath) throws IOException, ClassNotFoundException {
-		this(sources, contextPath, outputPath, Optional.empty());
-	}
-
-	public JavaTXCompiler(List<File> sources, List<File> contextPath, File outputPath, Optional<String> unifyServer) throws IOException, ClassNotFoundException {
 		// ensure new default placeholder registry for tests
 		defaultClientPlaceholderRegistry = new PlaceholderRegistry();
 
-		this.unifyServer = unifyServer;
 		var path = new ArrayList<>(contextPath);
 		if (contextPath.isEmpty()) {
 			// When no contextPaths are given, the working directory is the sources root
@@ -317,11 +310,12 @@ public class JavaTXCompiler {
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		UnifyResultModel urm = null;
 		// urm.addUnifyResultListener(resultListener);
-		UnifyContext context = new UnifyContext(logFile, log, true, urm, usedTasks, defaultClientPlaceholderRegistry);
-		try {
-			logFile = logFile == null ? new FileWriter(new File("log_" + sourceFiles.keySet().iterator().next().getName())) : logFile;
-			IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logFile, getClassLoader(), this, context.placeholderRegistry());
-			System.out.println(finiteClosure);
+		logFile = logFile == null ? new FileWriter("log_" + sourceFiles.keySet().iterator().next().getName()) : logFile;
+		Logger logger = new Logger(logFile, "TypeInferenceAsync");
+		UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, defaultClientPlaceholderRegistry);
+
+		IFiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses, logger, getClassLoader(), this, context.placeholderRegistry());
+		logger.info(finiteClosure.toString());
 		urm = new UnifyResultModel(cons, finiteClosure);
 		urm.addUnifyResultListener(resultListener);
 		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, context.placeholderRegistry());
@@ -335,13 +329,13 @@ public class JavaTXCompiler {
 			return x;
 
 		};
-			logFile.write(unifyCons.toString());
+		logger.debug(unifyCons.toString());
 		unifyCons = unifyCons.map(distributeInnerVars);
-			logFile.write(unifyCons.toString());
+		logger.debug(unifyCons.toString());
 		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
+		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
 		for (SourceFile f : this.sourceFiles.values()) {
-				logFile.write(ASTTypePrinter.print(f));
+			logger.debug(ASTTypePrinter.print(f));
 		}
 		// logFile.flush();
 		Set<PlaceholderType> varianceTPHold;
@@ -360,9 +354,7 @@ public class JavaTXCompiler {
 																							 * .stream().map(x -> { Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors. toCollection(ArrayList::new))
 																							 */;
 		TypeUnify.unifyAsync(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-		} catch (IOException e) {
-			System.err.println("kein LogFile");
-		}
+
 		return urm;
 	}
 
@@ -383,14 +375,16 @@ public class JavaTXCompiler {
 		final ConstraintSet<Pair> cons = getConstraints(file);
 		Set<Set<UnifyPair>> results = new HashSet<>();
 		PlaceholderRegistry placeholderRegistry = new PlaceholderRegistry();
-		try {
+
 		var logFolder = new File(System.getProperty("user.dir") + "/logFiles/");
-			if (log) logFolder.mkdirs();
-			Writer logFile = log ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
-			FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logFile, classLoader, this, placeholderRegistry);
-			System.out.println(finiteClosure);
+		if (ConsoleInterface.writeLogFiles && !logFolder.mkdirs()) throw new RuntimeException("Could not creat directoy for log files: " + logFolder);
+		Writer logFile = ConsoleInterface.writeLogFiles ? new FileWriter(new File(logFolder, "log_" + sourceFiles.keySet().iterator().next().getName())) : new OutputStreamWriter(new NullOutputStream());
+		Logger logger = new Logger(logFile, "TypeInference");
+
+		FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(allClasses.stream().toList(), logger, classLoader, this, placeholderRegistry);
+		logger.info(finiteClosure.toString());
 		ConstraintSet<UnifyPair> unifyCons = UnifyTypeFactory.convert(this, cons, placeholderRegistry);
-			System.out.println("xxx1");
+		logger.info("xxx1");
 		Function<UnifyPair, UnifyPair> distributeInnerVars = x -> {
 			UnifyType lhs, rhs;
 			if (((lhs = x.getLhsType()) instanceof PlaceholderType) && ((rhs = x.getRhsType()) instanceof PlaceholderType) && (((PlaceholderType) lhs).isInnerType() || ((PlaceholderType) rhs).isInnerType())) {
@@ -401,16 +395,20 @@ public class JavaTXCompiler {
 
 		};
 
-			logFile.write("Unify:" + unifyCons.toString());
-			System.out.println("Unify:" + unifyCons.toString());
+    logger.debug("Unify:" + unifyCons.toString());
+    logger.info("Unify:" + unifyCons.toString());
     unifyCons = unifyCons.map(distributeInnerVars);
-			logFile.write("\nUnify_distributeInnerVars: " + unifyCons.toString());
+    logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
     // Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-			logFile.write("FC:\\" + finiteClosure.toString() + "\n");
-			logFile.write(ASTTypePrinter.print(sf));
-			System.out.println(ASTTypePrinter.print(sf));
+    logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+    logger.info(ASTTypePrinter.print(sf));
     // logFile.flush();
-			System.out.println("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
+    List<UnifyPair> andConstraintsSorted = unifyCons.getUndConstraints().stream()
+        .sorted(Comparator.comparing(UnifyPair::getPairOp).thenComparing(UnifyPair::getLhsType, Comparator.comparing(UnifyType::getName)))
+        .collect(Collectors.toList());
+
+    logger.info(andConstraintsSorted);
+
     Set<PlaceholderType> varianceTPHold;
     Set<PlaceholderType> varianceTPH = new HashSet<>();
     varianceTPH = varianceInheritanceConstraintSet(unifyCons);
@@ -427,24 +425,30 @@ public class JavaTXCompiler {
     /*
      * Set<Set<UnifyPair>> ret = new HashSet<>(); for (Constraint<UnifyPair> y : x) { ret.add(new HashSet<>(y)); } return ret; }).collect(Collectors.toCollection(ArrayList::new))
      */;
-
-		  if (unifyServer.isPresent()) {
+    if (ConsoleInterface.unifyServerUrl.isPresent()) {
         UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-				UnifyContext context = new UnifyContext(logFile, log, true, urm, usedTasks, placeholderRegistry);
-				SocketClient socketClient = new SocketClient(unifyServer.get());
-				return socketClient.execute(finiteClosure, cons, unifyCons, context);
+        UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
+        SocketFuture<UnifyResultPacket> future = SocketClient.execute(
+          UnifyRequestPacket.create(finiteClosure, cons, unifyCons, context.placeholderRegistry())
+        );
+        SocketClient.execute(SetAutoclosePacket.create());
+        return future.get().getResultSet(context);
     }
     else if (resultmodel) {
         /* UnifyResultModel Anfang */
         UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
         UnifyResultListenerImpl li = new UnifyResultListenerImpl();
         urm.addUnifyResultListener(li);
-				UnifyContext context = new UnifyContext(logFile, log, true, urm, usedTasks, placeholderRegistry);
+				UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
 				TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-				System.out.println("RESULT Final: " + li.getResults());
-				System.out.println("Constraints for Generated Generics: " + " ???");
-				logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
-				// logFile.flush();
+        var finalResults = li.getResults().stream().sorted().toList();
+        int i = 0;
+        logger.info("RESULT Final: ");
+        for (var result : finalResults){
+          logger.info("Result: " + i++);
+          logger.info(result.getSortedResults());
+        }
+        logger.info("RES_FINAL: " + li.getResults().toString() + "\n");
         return li.getResults();
     }
     /* UnifyResultModel End */
@@ -452,11 +456,9 @@ public class JavaTXCompiler {
         // Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
         // oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
         // finiteClosure));
-				UnifyContext context = new UnifyContext(logFile, log, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
+        UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
         Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-				System.out.println("RESULT: " + result);
-				logFile.write("RES: " + result.toString() + "\n");
-				// logFile.flush();
+        logger.info("RESULT: " + result);
         results.addAll(result);
 
         results = results.stream().map(x -> {
@@ -470,16 +472,14 @@ public class JavaTXCompiler {
           } else
             return x; // wenn nichts veraendert wurde wird x zurueckgegeben
         }).collect(Collectors.toCollection(HashSet::new));
-				System.out.println("RESULT Final: " + results);
-				System.out.println("Constraints for Generated Generics: " + " ???");
-				logFile.write("RES_FINAL: " + results.toString() + "\n");
+        logger.info("RESULT Final: " + results);
+        logger.info("Constraints for Generated Generics: " + " ???");
+        logger.debug("RES_FINAL: " + results.toString() + "\n");
         // logFile.flush();
-				logFile.write("PLACEHOLDERS: " + placeholderRegistry);
+        logger.debug("PLACEHOLDERS: " + placeholderRegistry);
         // logFile.flush();
 		}
-		} catch (IOException e) {
-			System.err.println("kein LogFile");
-		}
+
 		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), placeholderRegistry)))).collect(Collectors.toList());
 	}
 
@@ -653,12 +653,12 @@ public class JavaTXCompiler {
 			var codegen = new Codegen(converter.convert(clazz), this, converter);
 			var code = codegen.generate();
 			generatedClasses.put(clazz.getClassName(), code);
-			converter.auxiliaries.forEach((name, source) -> {
-				generatedClasses.put(new JavaClassName(name), source);
-			});
 		}
 		generatedGenerics.put(sf, converter.javaGenerics());
 		converter.generateFunNTypes();
+		converter.auxiliaries.forEach((name, source) -> {
+			generatedClasses.put(new JavaClassName(name), source);
+		});
 		return generatedClasses;
 	}
 
@@ -666,15 +666,15 @@ public class JavaTXCompiler {
 		FileOutputStream output;
 		for (JavaClassName name : classFiles.keySet()) {
 			byte[] bytecode = classFiles.get(name);
-			System.out.println("generating " + name + ".class file ...");
+			defaultLogger.info("generating " + name + ".class file ...");
 			var subPath = preserveHierarchy ? path : Path.of(path.toString(), name.getPackageName().split("\\.")).toFile();
 			File outputFile = new File(subPath, name.getClassName() + ".class");
 			outputFile.getAbsoluteFile().getParentFile().mkdirs();
-			System.out.println(outputFile);
+			defaultLogger.info(outputFile.toString());
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();
-			System.out.println(name + ".class file generated");
+			defaultLogger.success(name + ".class file generated");
 		}
 	}
 

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

@@ -10,10 +10,10 @@ public class JavaTXServer {
 
   public JavaTXServer(int port) {
     this.socketServer = new SocketServer(port);
-    isRunning = true;
   }
 
   public void listen() {
+    isRunning = true;
     socketServer.start();
   }
 

src/main/java/de/dhbwstuttgart/environment/ByteArrayClassLoader.java

@@ -1,13 +0,0 @@
-package de.dhbwstuttgart.environment;
-
-public class ByteArrayClassLoader extends ClassLoader implements IByteArrayClassLoader {
-    @Override
-    public Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError {
-        return defineClass(name, code, i, length);
-    }
-
-    @Override
-    public Class<?> findClass(String name) throws ClassNotFoundException {
-        return super.findClass(name);
-    }
-}

src/main/java/de/dhbwstuttgart/environment/IByteArrayClassLoader.java

@@ -6,18 +6,22 @@ import java.nio.file.Path;
 
 public interface IByteArrayClassLoader {
 
-    Class loadClass(String path) throws ClassNotFoundException;
+    Class<?> loadClass(String path) throws ClassNotFoundException;
 
-    default Class loadClass(byte[] code) {
-        return this._defineClass(null, code, 0, code.length);
+    default Class<?> loadClass(byte[] code) {
+        return this.loadClass(null, code);
     }
 
-    default Class loadClass(Path path) throws IOException {
+    default Class<?> loadClass(String name, byte[] code) {
+        return this._defineClass(name, code, 0, code.length);
+    }
+
+    default Class<?> loadClass(Path path) throws IOException {
         var code = Files.readAllBytes(path);
         return this._defineClass(null, code, 0, code.length);
     }
 
     public Class<?> findClass(String name) throws ClassNotFoundException;
 
-    Class _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
+    Class<?> _defineClass(String name, byte[] code, int i, int length) throws ClassFormatError;
 }

src/main/java/de/dhbwstuttgart/parser/JavaTXParser.java

@@ -7,6 +7,7 @@ import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.JavaClassRegistry;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 
+import de.dhbwstuttgart.util.Logger;
 import org.antlr.v4.runtime.CharStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
@@ -17,6 +18,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class JavaTXParser {
+
+    public static Logger logger = new Logger("Parser");
+
     public static Java17Parser.SourceFileContext parse(File source) throws IOException, java.lang.ClassNotFoundException {
         InputStream stream = new FileInputStream(source);
         // DEPRECATED: ANTLRInputStream input = new ANTLRInputStream(stream);

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.parser.SyntaxTreeGenerator;
 
+import de.dhbwstuttgart.parser.JavaTXParser;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -259,7 +260,7 @@ public class StatementGenerator {
             ret.setStatement();
             return ret;
         default:
-            System.out.println(stmt.getClass());
+            JavaTXParser.logger.info(stmt.getClass());
             throw new NotImplementedException();
         }
     }
@@ -1099,9 +1100,9 @@ public class StatementGenerator {
             block = lambdaGenerator.convert(expression.lambdaBody().block(), true);
         }
         List<RefTypeOrTPHOrWildcardOrGeneric> funNParams = new ArrayList<>();
-        funNParams.add(TypePlaceholder.fresh(expression.getStart()));// ret-Type
+        funNParams.add(TypePlaceholder.fresh(expression.getStart(), -1, false));// ret-Type
         params.getFormalparalist().forEach(formalParameter -> // Für jeden Parameter einen TPH anfügen:
-        funNParams.add(TypePlaceholder.fresh(expression.getStart())));
+        	funNParams.add(TypePlaceholder.fresh(expression.getStart(), 1, false)));
         RefTypeOrTPHOrWildcardOrGeneric lambdaType = TypePlaceholder.fresh(expression.getStart());
         // RefType lambdaType = new
         // RefType(reg.getName("Fun"+params.getFormalparalist().size()),

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

@@ -74,7 +74,7 @@ public class TypeGenerator {
                 throw new NotImplementedException();
             }
         } else if (!typeContext.LBRACK().isEmpty()) { // ArrayType über eckige Klammer prüfen
-            // System.out.println(unannTypeContext.getText());
+            // JavaTXParser.logger.info(unannTypeContext.getText());
             throw new NotImplementedException();
         }
         /*

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

@@ -7,7 +7,7 @@ import java.util.*;
 /**
  * Speichert die Klassen f<>r einen bestimmten Projektscope
  */
-public class JavaClassRegistry {
+public class JavaClassRegistry{
     final Map<JavaClassName, Integer> existingClasses = new HashMap<>();
 
     public JavaClassRegistry(Map<String, Integer> initialNames) {
@@ -22,6 +22,10 @@ public class JavaClassRegistry {
         }
     }
 
+    public Set<JavaClassName> getAllClassNames(){
+        return existingClasses.keySet();
+    }
+
     public void addName(String className, int numberOfGenerics) {
         existingClasses.put(new JavaClassName(className), numberOfGenerics);
     }

src/main/java/de/dhbwstuttgart/server/ServerTaskLogger.java

@@ -0,0 +1,41 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.util.Logger;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import org.java_websocket.WebSocket;
+
+public class ServerTaskLogger extends Logger {
+
+  private final WebSocket webSocket;
+  private final SocketServer socketServer;
+  private final LogLevel customLogLevel;
+
+  public ServerTaskLogger(WebSocket webSocket, SocketServer socketServer, LogLevel customLogLevel) {
+    this.webSocket = webSocket;
+    this.socketServer = socketServer;
+    this.customLogLevel = customLogLevel;
+  }
+
+  @Override
+  public boolean isLogLevelActive(LogLevel logLevel) {
+    return logLevel.isHigherOrEqualTo(customLogLevel);
+  }
+
+  @Override
+  protected void print(String s, LogLevel logLevel) {
+    String coloredPrefix = this.getPrefix(logLevel);
+    if (logLevel.isHigherOrEqualTo(LogLevel.ERROR)) {
+      socketServer.sendError(webSocket, coloredPrefix + s, false);
+    }
+    else {
+      socketServer.sendMessage(webSocket, coloredPrefix + s);
+    }
+  }
+
+  @Override
+  protected void write(String s) {
+    // under no circumstances write anything to a file
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketClient.java

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
 import de.dhbwstuttgart.server.packet.IServerToClientPacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
@@ -12,10 +14,12 @@ import de.dhbwstuttgart.typeinference.result.ResultSet;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
+import de.dhbwstuttgart.util.Logger;
 import java.net.URI;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -29,39 +33,33 @@ import org.java_websocket.handshake.ServerHandshake;
  */
 public class SocketClient extends WebSocketClient {
 
-  // use a latch to wait until the connection is closed by the remote host
-  private final CountDownLatch closeLatch = new CountDownLatch(1);
-  // temporarily: The received unify result
-  // TODO: replace with uuid and future system, such that responses can be mapped by a uuid to fulfill a Future
-  private UnifyResultPacket unifyResultPacket;
+  public static Logger logger = new Logger("SocketClient");
 
-  public SocketClient(String url) {
-    super(URI.create(url), Map.of(
+  /**
+   * The singleton object
+   */
+  private static SocketClient socketClient = null;
+
+  /**
+   * List of futures that are still waiting to be fulfilled
+   */
+  private final Map<String, SocketFuture<?>> responseFutures = new HashMap<>();
+
+  private SocketClient(String url) {
+    super(
+      URI.create(url), // target url
+      //SocketServer.perMessageDeflateDraft, // enable compression
+      Map.of( // headers
         "packetProtocolVersion", SocketServer.packetProtocolVersion
-    ));
-    // make sure, the url is in a valid format
+      )
+    );
+
+    // make sure the url is in a valid format
     final String regex = "^wss?://(\\w+(\\.\\w+)?)*:(\\d+)$";
     final Matcher matcher = Pattern.compile(regex).matcher(url);
     if (!matcher.find()) {
       throw new RuntimeException("Provided string \"" + url + "\" is not a valid server URL! Use pattern ws(s?)://<host.name>:<port>");
     }
-  }
-
-  public SocketClient(String host, int port, boolean secure) {
-    super(URI.create(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port)));
-  }
-
-  /**
-   * The main method for connecting, requesting and waiting for the server to unify.
-   * This is synchronized to prevent multiple webSockets connections at the moment, but it is not called from any
-   * thread except the main thread right now and is not necessary at all, probably. Maybe remove it later
-   */
-  synchronized public List<ResultSet> execute(
-    FiniteClosure finiteClosure,
-    ConstraintSet<Pair> constraintSet,
-    ConstraintSet<UnifyPair> unifyConstraintSet,
-    UnifyContext context
-  ) throws JsonProcessingException {
 
     try {
       // wait for the connection to be set up
@@ -70,89 +68,135 @@ public class SocketClient extends WebSocketClient {
       if (this.getReadyState() != ReadyState.OPEN) {
         throw new RuntimeException("WebSocket Client could not connect to remote host at " + this.uri);
       }
-
-      // send the unify task request
-      UnifyRequestPacket packet = new UnifyRequestPacket(finiteClosure, constraintSet, unifyConstraintSet, context.placeholderRegistry());
-      String json = PacketContainer.serialize(packet);
-      this.send(json);
-
-      // block the thread, until the connection is closed by the remote host (usually after sending the results)
-      this.waitUntilClosed();
-      // wait for the connection to fully close
-      this.closeBlocking();
     } catch (InterruptedException exception) {
-      System.err.println("Server connection interrupted: " + exception);
-      this.notifyAll();
-      throw new RuntimeException("Aborted server connection", exception);
+      throw new RuntimeException(exception);
     }
-    catch (Exception exception) {
+
+    // add a shutdown hook to close the connection when the process ends or is stopped by a SIGINT signal
+    Runtime.getRuntime().addShutdownHook(new Thread(this::close));
+  }
+
+  private SocketClient(String host, int port, boolean secure) throws InterruptedException {
+    this(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port));
+  }
+
+  /**
+   * Singleton access method, creates one if none is available
+   *
+   * @return The one and only socketClient
+   */
+  private static SocketClient initializeClient() {
+    if (socketClient == null) {
+      socketClient = new SocketClient(ConsoleInterface.unifyServerUrl.get());
+    }
+    return socketClient;
+  }
+
+  /**
+   * Send a packet to the server (connection will be created, if none is found) and return a future
+   * for the response packet
+   */
+  synchronized public static <T extends IServerToClientPacket> SocketFuture<T> execute(IClientToServerPacket<T> packet) {
+    SocketClient client = initializeClient();
+
+    /*
+     * Create a future that will be associated with the packet and eventually completed
+     */
+    SocketFuture<T> future = packet.getFuture();
+    if (!future.isDone()) {
+      client.responseFutures.put(future.futureId, future);
+    }
+
+    /*
+     * Establish connection, if not already done.
+     * Serialize the packet and send it to the server.
+     * Return the future to be handled by the caller.
+     */
+    try {
+      String json = PacketContainer.serialize(packet);
+      client.send(json);
+    } catch (Exception exception) {
+      logger.exception(exception);
       throw new RuntimeException("Exception occurred in server connection: ", exception);
     }
 
-    // detect error cases, in which no error was thrown, but also no result was sent back from the server
-    if (this.unifyResultPacket == null) {
-      throw new RuntimeException("Did not receive server response but closed connection already");
+    return future;
   }
 
-    return unifyResultPacket.getResultSet(context);
+  /**
+   * Shortcut for waiting and retrieving the response immediately
+   *
+   * @param packet The packet to send
+   * @param <T>    The type of response packet to await
+   * @return The response packet, once it is received
+   */
+  public static <T extends IServerToClientPacket> T executeAndGet(IClientToServerPacket<T> packet) {
+    return SocketClient.execute(packet).get();
   }
 
   /**
    * Specific client-side implementations to handle incoming packets
    */
   protected void handleReceivedPacket(IPacket packet) {
-    if (packet instanceof IServerToClientPacket serverToClientPacket) {
-
-      try {
-        serverToClientPacket.onHandle(this.getConnection(), this);
-      }
-      catch (Exception exception) {
-        this.closeLatch.countDown();
+    if (!(packet instanceof IServerToClientPacket serverToClientPacket)) {
+      System.err.println("Received package of invalid type + " + packet.getClass().getName());
       this.close();
-        throw exception;
-      }
-
       return;
     }
 
-    System.err.println("Received package of invalid type + " + packet.getClass().getName());
-    this.close();
+    serverToClientPacket.onHandle(this.getConnection(), this);
   }
 
-  public void setUnifyResultSets(UnifyResultPacket unifyResultPacket) {
-    this.unifyResultPacket = unifyResultPacket;
+  /**
+   * Complete a registered future, so it can be handled by whoever executed the creator task
+   *
+   * @param id      The associated id for this future
+   * @param trigger The object triggering the completion
+   */
+  public void completeResponseFuture(String id, IServerToClientPacket trigger) {
+    SocketFuture<?> future = this.responseFutures.remove(id);
+    if (future == null) return;
+    if (!future.accept(trigger)) {
+      throw new RuntimeException("Packet " + trigger.getClass().getName() + " tried to complete future, but was not allowed to");
+    }
+  }
+
+  public static void closeIfOpen() {
+    if (socketClient != null && socketClient.isOpen()) {
+      socketClient.close();
+    }
   }
 
   @Override
   public void onOpen(ServerHandshake handshakedata) {
-    System.out.println("Connected to server with status " + handshakedata.getHttpStatus());
+    logger.success("Connected to server with status " + handshakedata.getHttpStatus());
   }
 
   @Override
   public void onMessage(String message) {
-    // System.out.println("received: " + message);
+    // logger.info("received: " + message);
     IPacket packet = PacketContainer.deserialize(message);
     this.handleReceivedPacket(packet);
   }
 
   @Override
   public void onClose(int code, String reason, boolean remote) {
-    System.out.println(
+    logger.info(
       "Disconnected from server " +
         "with code " + code + " " +
         (reason.isEmpty() ? "" : "and reason " + reason + " ") +
         "(closed by remote: " + remote + ")"
     );
-    this.closeLatch.countDown();
+
+    if (!this.responseFutures.isEmpty()) {
+      throw new RuntimeException("Server closed before all required tasks were answered");
+    }
   }
 
   @Override
   public void onError(Exception e) {
-    System.out.println("Error: " + e.getMessage());
-    e.printStackTrace();
+    logger.exception(e);
+    throw new RuntimeException(e);
   }
 
-  public void waitUntilClosed() throws InterruptedException {
-    closeLatch.await();
-  }
 }

src/main/java/de/dhbwstuttgart/server/SocketFuture.java

@@ -0,0 +1,48 @@
+package de.dhbwstuttgart.server;
+
+import de.dhbwstuttgart.server.packet.IServerToClientPacket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class SocketFuture<T extends IServerToClientPacket> extends CompletableFuture<T> {
+
+  public final String futureId = UUID.randomUUID().toString();
+
+  public final List<Class<T>> allowedTriggers;
+
+  public SocketFuture(List<Class<T>> allowedTriggers) {
+    this.allowedTriggers = allowedTriggers;
+  }
+
+  public boolean accept(IServerToClientPacket trigger) {
+    if (this.allowedTriggers.contains(trigger.getClass())) {
+      this.complete((T)trigger);
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public T get() {
+    try {
+      return super.get();
+    }
+    catch (InterruptedException | ExecutionException exception) {
+      throw new RuntimeException(exception);
+    }
+  }
+
+  /**
+   * Special case where the future is immediately fulfilled without a response package similar to
+   * <code>CompletableFuture.completedFuture()</code> but without a value
+   */
+  public static <R extends IServerToClientPacket> SocketFuture<R> completedFuture() {
+    SocketFuture<R> dummyFuture = new SocketFuture<>(new ArrayList<>(0));
+    dummyFuture.complete(null);
+    return dummyFuture;
+  }
+
+}

src/main/java/de/dhbwstuttgart/server/SocketServer.java

@@ -6,76 +6,104 @@ import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
 import de.dhbwstuttgart.server.packet.MessagePacket;
 import de.dhbwstuttgart.server.packet.PacketContainer;
+import de.dhbwstuttgart.util.Logger;
 import java.net.InetSocketAddress;
-import java.util.Objects;
+import java.util.Collections;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.java_websocket.WebSocket;
+import org.java_websocket.drafts.Draft;
+import org.java_websocket.drafts.Draft_6455;
+import org.java_websocket.extensions.permessage_deflate.PerMessageDeflateExtension;
 import org.java_websocket.handshake.ClientHandshake;
 import org.java_websocket.server.WebSocketServer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 public class SocketServer extends WebSocketServer {
 
+  public static Logger logger = new Logger("SocketServer");
+  public static final int maxTasksPerSession = 100;
+  private static boolean serverRunning = false;
+
   /**
    * Increase this every time a breaking change to the server communication is done.
-   * This will prevent errors when server version and client version do not match.
+   * This will prevent errors when the server version and client version do not match.
    */
   public static final String packetProtocolVersion = "1";
 
-  public static final Logger log = LoggerFactory.getLogger(SocketServer.class);
+  // create an executor for tasks that will always keep at least one task around
+  private final ThreadPoolExecutor taskExecutor = new ThreadPoolExecutor(1, Integer.MAX_VALUE,60L, TimeUnit.SECONDS, new SynchronousQueue<>());
+  // create an executor for scheduling timeouts
+  private final ScheduledExecutorService timeoutExecutor = Executors.newSingleThreadScheduledExecutor();
 
   public SocketServer(int port) {
     super(new InetSocketAddress(port));
+    this.setConnectionLostTimeout(30);
+
+    serverRunning = true;
+    // add a shutdown hook to close all connections when the process ends or is stopped by a SIGINT signal
+    Runtime.getRuntime().addShutdownHook(new Thread(this::onShutdown));
+  }
+
+  public static boolean isServerRunning() {
+    return serverRunning;
+  }
+
+  private void onShutdown() {
+    serverRunning = false;
+    try {
+      for (var webSocket : this.getConnections()) {
+        this.sendError(webSocket, "Sorry, i am shutting down. You are now on your own, good Luck!", true);
+        webSocket.close();
+      }
+      this.stop();
+      taskExecutor.shutdown();
+      timeoutExecutor.shutdown();
+    } catch (InterruptedException exception) {
+      // we are shutting down anyway
+    }
   }
 
   @Override
   public void onOpen(WebSocket webSocket, ClientHandshake clientHandshake) {
     String ppv = clientHandshake.getFieldValue("packetProtocolVersion");
     if (!ppv.equals(packetProtocolVersion)) {
-      try {
-        ErrorPacket errorPacket = ErrorPacket.create(
-          "Mismatch in packet protocol version! Client (you): " + ppv + " and Server (me): " + packetProtocolVersion,
+      this.sendError(webSocket,
+        "Mismatch in packet protocol version! Client (you): \"" + ppv + "\" and Server (me): \"" + packetProtocolVersion + "\"",
         true
       );
-        webSocket.send(PacketContainer.serialize(errorPacket));
-      }
-      catch (JsonProcessingException exception) {
-        System.err.println("Failed to serialize json: " + exception);
-      }
       webSocket.close(1);
       return;
     }
 
-
-    SocketData socketData = new SocketData(UUID.randomUUID().toString());
-    webSocket.setAttachment(socketData);
-    System.out.println("New connection: " + socketData.id + " (with ppv " + ppv + ")");
+    SocketData socketData = new SocketData(webSocket);
+    logger.info("New connection: " + socketData.id + " (with ppv " + ppv + ")");
 
     try {
       sendMessage(webSocket, "Welcome to the server!");
 
       // wait 10 seconds for the client to send a task and close the connection if nothing has been received until then
-      try (ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor()) {
-        Runnable task = () -> {
-          if (webSocket.<SocketData>getAttachment().unhandledTasks.get() == 0 || !webSocket.isOpen()) {
+      final int secondsUntilTimeout = 10;
+      timeoutExecutor.schedule(() -> {
+          if (webSocket.<SocketData>getAttachment().totalTasks.get() > 0 || !webSocket.isOpen()) {
             return;
           }
-          sendMessage(webSocket, "No task received after 10 seconds. Closing connection...");
+          sendMessage(webSocket, "No task received after " + secondsUntilTimeout + " seconds. Closing connection...");
           webSocket.close();
-        };
-        executor.schedule(task, 10, TimeUnit.SECONDS);
-        executor.shutdown();
-      }
+        },
+        secondsUntilTimeout,
+        TimeUnit.SECONDS
+      );
 
       // and finally, when your program wants to exit
     } catch (Exception e) {
-      log.error("e: ", e);
+      logger.exception(e);
       webSocket.close(1, e.getMessage());
     }
   }
@@ -83,8 +111,8 @@ public class SocketServer extends WebSocketServer {
   @Override
   public void onClose(WebSocket webSocket, int code, String reason, boolean remote) {
     SocketData socketData = webSocket.getAttachment();
-    System.out.println("Connection closed: " + socketData.id);
-    System.out.println(
+    logger.info("Connection closed: " + socketData.id);
+    logger.info(
       "Disconnected client " + socketData.id + " " +
         "with code " + code + " " +
         (reason.isEmpty() ? "" : "and reason " + reason + " ") +
@@ -95,24 +123,28 @@ public class SocketServer extends WebSocketServer {
 
   @Override
   public void onMessage(WebSocket webSocket, String s) {
-    // System.out.println("Received: " + s.substring(0, 50));
+    // logger.info("Received: " + s.substring(0, 50));
     IPacket reconstructedPacket = PacketContainer.deserialize(s);
     try {
       this.onPacketReceived(webSocket, reconstructedPacket);
     } catch (JsonProcessingException e) {
-      this.log("Error on processing incoming package: " + e.getMessage(), webSocket);
+      logger.exception(e);
+      this.log(webSocket, "Error on processing incoming package: " + e.getMessage());
     }
   }
 
   @Override
   public void onError(WebSocket webSocket, Exception e) {
-    log(e.getMessage(), webSocket);
+    if (webSocket != null) {
+      log(webSocket, e.getMessage());
       webSocket.close();
     }
+    logger.exception(e);
+  }
 
   @Override
   public void onStart() {
-    System.out.println("Websocket server started on port " + this.getPort());
+    logger.success("Websocket server started on port " + this.getPort());
   }
 
   /**
@@ -120,26 +152,24 @@ public class SocketServer extends WebSocketServer {
    */
   public void sendMessage(WebSocket webSocket, String text) {
     try {
-      MessagePacket message = new MessagePacket();
-      message.message = text;
+      MessagePacket message = MessagePacket.create(text);
       webSocket.send(PacketContainer.serialize(message));
     } catch (Exception e) {
       System.err.println("Failed to send message: " + text);
-      log.error("e: ", e);
+      logger.exception(e);
     }
   }
 
   /**
    * A shorthand method for sending error messages to the client
    */
-  public void sendError(WebSocket webSocket, String text) {
+  public void sendError(WebSocket webSocket, String text, boolean isFatal) {
     try {
-      ErrorPacket error = new ErrorPacket();
-      error.error = text;
+      ErrorPacket error = ErrorPacket.create(text, isFatal);
       webSocket.send(PacketContainer.serialize(error));
     } catch (Exception e) {
-      System.err.println("Failed to send error: " + text);
-      log.error("e: ", e);
+      logger.exception(e);
+      log(webSocket, "Failed to send error: " + text);
     }
   }
 
@@ -149,16 +179,15 @@ public class SocketServer extends WebSocketServer {
   private void onPacketReceived(WebSocket webSocket, IPacket packet) throws JsonProcessingException {
     SocketData socketData = webSocket.getAttachment();
 
-    // limit the amount of tasks per connection
-    final int maxTasks = 100;
-    if (socketData.totalTasks.get() >= maxTasks) {
-      sendError(webSocket, "Exceeded the maximum amount of " + maxTasks + " tasks per session");
+    // limit the number of tasks per connection
+    if (socketData.totalTasks.get() >= maxTasksPerSession) {
+      sendError(webSocket, "Exceeded the maximum amount of " + maxTasksPerSession + " tasks per session", true);
       webSocket.close();
       return;
     }
 
-    // only allow packets, that are meant to be handled by the server
-    if (!(packet instanceof IClientToServerPacket clientToServerPacket)) {
+    // only allow packets that are meant to be handled by the server
+    if (!(packet instanceof IClientToServerPacket<?> clientToServerPacket)) {
       sendMessage(webSocket, "The package of type " + packet.getClass().getName() + " is not handled by the server!");
       return;
     }
@@ -167,22 +196,24 @@ public class SocketServer extends WebSocketServer {
     socketData.unhandledTasks.incrementAndGet();
     socketData.totalTasks.incrementAndGet();
 
-    // add the packet to the queue, so it can be started by the worker
+    // add the packet to the queue so it can be started by the worker
     CompletableFuture.runAsync(() -> {
       clientToServerPacket.onHandle(webSocket, this);
-
-      // if the websocket has 0 unhandled Tasks, close the connection
       int remainingUnhandledTasks = socketData.unhandledTasks.decrementAndGet();
+
+      if (socketData.closeIfNoTasksLeft) {
+        // if the websocket has 0 unhandled Tasks, close the connection
         if (remainingUnhandledTasks <= 0) {
           sendMessage(webSocket, "All requested tasks finished! Closing connection...");
           webSocket.close();
         }
-    });
+      }
+    }, taskExecutor);
   }
 
-  public void log(String msg, WebSocket webSocket) {
-    SocketData socketData = webSocket == null ? new SocketData("???") : webSocket.getAttachment();
-    System.out.println("["+socketData.id+"] " + msg);
+  public void log(WebSocket webSocket, String msg) {
+    String socketId = (webSocket == null) ? "???" : webSocket.<SocketData>getAttachment().id;
+    logger.info("[" + socketId + "] " + msg);
   }
 
   /**
@@ -194,10 +225,11 @@ public class SocketServer extends WebSocketServer {
     public final String id;
     public final AtomicInteger unhandledTasks = new AtomicInteger(0);
     public final AtomicInteger totalTasks = new AtomicInteger(0);
+    public boolean closeIfNoTasksLeft = false;
 
-    public SocketData(String id) {
-      this.id = id;
+    public SocketData(WebSocket webSocket) {
+      this.id = UUID.randomUUID().toString();
+      webSocket.setAttachment(this);
     }
   }
-
 }

src/main/java/de/dhbwstuttgart/server/packet/DebugPacket.java

@@ -2,6 +2,7 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.ISerialNode;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
@@ -10,7 +11,7 @@ import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import org.java_websocket.WebSocket;
 
-public class DebugPacket implements IClientToServerPacket, IServerToClientPacket {
+public class DebugPacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   public SerialUUID a1;
   public SerialUUID a2;
@@ -22,9 +23,13 @@ public class DebugPacket implements IClientToServerPacket, IServerToClientPacket
   public SerialValue<?> d2;
 
   @JsonIgnore
-  public void onHandle(WebSocket webSocket, SocketClient socketServer) {}
+  public void onHandle(WebSocket webSocket, SocketClient socketClient) {}
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {}
 
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/ErrorPacket.java

@@ -2,16 +2,17 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send simple error messages between the client and the server
  */
-public class ErrorPacket implements IClientToServerPacket, IServerToClientPacket {
+public class ErrorPacket implements IServerToClientPacket {
 
   /**
-   * The error endpoint for messages from the server, that should be logged out outputted
+   * The error endpoint for messages from the server that should be logged out as errors and possibly abort the process
    */
   public String error;
   public boolean isFatal;
@@ -27,15 +28,9 @@ public class ErrorPacket implements IClientToServerPacket, IServerToClientPacket
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + "ErrorPacket: " + this.error);
+    SocketClient.logger.exception(new RuntimeException(this.error));
     if (this.isFatal) {
-      throw new RuntimeException("Received fatal error from server: " + this.error);
+      socketClient.close(1, "Received fatal error from server");
     }
   }
-
-  @JsonIgnore
-  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log("ErrorPacket: " + this.error, webSocket);
-  }
-
 }

src/main/java/de/dhbwstuttgart/server/packet/IClientToServerPacket.java

@@ -1,12 +1,26 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
-public interface IClientToServerPacket extends IPacket {
+/**
+ * A packet that will be sent to the server. Use <code>Void</code> Sub-Interface for packets without response
+ *
+ * @param <T>   The response packet that will fulfill the future.
+ */
+public interface IClientToServerPacket<T extends IServerToClientPacket> extends IPacket {
 
   @JsonIgnore
   void onHandle(WebSocket webSocket, SocketServer socketServer);
 
+  @JsonIgnore
+  SocketFuture<T> getFuture();
+
+  /**
+   * Special case, where the packet will remain unanswered by the server
+   */
+  interface Void extends IClientToServerPacket<IServerToClientPacket> {}
 }
+

src/main/java/de/dhbwstuttgart/server/packet/InvalidPacket.java

@@ -2,13 +2,14 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
- * A fallback packet that is generated, if the received json could not be mapped to an existing package
+ * A fallback packet that is generated if the received JSON could not be mapped to an existing package
  */
-public class InvalidPacket implements IClientToServerPacket, IServerToClientPacket {
+public class InvalidPacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
    * If available, the error that caused this package to appear
@@ -18,12 +19,17 @@ public class InvalidPacket implements IClientToServerPacket, IServerToClientPack
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + "InvalidPacket: " + this.error);
+    SocketClient.logger.error("InvalidPacket: " + this.error);
   }
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log("InvalidPacket: " + this.error, webSocket);
+    socketServer.log(webSocket, "InvalidPacket: " + this.error);
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
   }
 
 }

src/main/java/de/dhbwstuttgart/server/packet/MessagePacket.java

@@ -2,16 +2,17 @@ package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send simple informational messages between the client and the server
  */
-public class MessagePacket implements IClientToServerPacket, IServerToClientPacket {
+public class MessagePacket implements IClientToServerPacket.Void, IServerToClientPacket {
 
   /**
-   * The informational message from the server, that should be logged out outputted
+   * The informational message from the server that should be logged out outputted
    */
   public String message;
 
@@ -24,13 +25,16 @@ public class MessagePacket implements IClientToServerPacket, IServerToClientPack
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.err.println("[socket] " + this.message);
-
+    SocketClient.logger.info("SocketMessage: " + this.message);
   }
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
-    socketServer.log(this.message, webSocket);
+    socketServer.log(webSocket, this.message);
   }
 
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
 }

src/main/java/de/dhbwstuttgart/server/packet/PacketContainer.java

@@ -3,6 +3,7 @@ package de.dhbwstuttgart.server.packet;
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import de.dhbwstuttgart.util.Logger;
 
 /**
  * A wrapper for the packet to ensure correct serialization/deserialization and make it possible to detect the matching
@@ -24,13 +25,14 @@ public class PacketContainer {
   public UnifyRequestPacket unifyRequestPacket = null;
   public UnifyResultPacket unifyResultPacket = null;
   public DebugPacket debugPacket = null;
+  public SetAutoclosePacket setAutoclosePacket = null;
 
 
   /**
    * Generate the JSON string for the given packet
    *
    * @param packet The packet to serialize
-   * @return The json representation of the packet
+   * @return The JSON representation of the packet
    */
   public static String serialize(IPacket packet) throws JsonProcessingException {
     objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
@@ -46,7 +48,11 @@ public class PacketContainer {
       container.unifyResultPacket = (UnifyResultPacket) packet;
     else if (packet instanceof DebugPacket)
       container.debugPacket = (DebugPacket) packet;
+    else if (packet instanceof SetAutoclosePacket)
+      container.setAutoclosePacket = (SetAutoclosePacket) packet;
     // Add new packets here and in the deserialize method
+    else
+      throw new RuntimeException("Cannot map packet to any known packet class");
 
     return objectMapper.writeValueAsString(container);
   }
@@ -75,11 +81,13 @@ public class PacketContainer {
         return container.unifyResultPacket;
       if (container.debugPacket != null)
         return container.debugPacket;
+      if (container.setAutoclosePacket != null)
+        return container.setAutoclosePacket;
       // Add new packets here and in the serialize method
 
       throw new RuntimeException("Cannot map received json to any known packet class");
     } catch (Exception e) {
-      System.out.println(e);
+      (new Logger()).exception(e);
       InvalidPacket packet = new InvalidPacket();
       packet.error = e.getMessage();
       return packet;

src/main/java/de/dhbwstuttgart/server/packet/SetAutoclosePacket.java

@@ -0,0 +1,32 @@
+package de.dhbwstuttgart.server.packet;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.SocketFuture;
+import de.dhbwstuttgart.server.SocketServer;
+import org.java_websocket.WebSocket;
+
+/**
+ * Normally, a connection stays open until either the client or the server process ends.
+ * Send this packet to inform the server that the connection can be closed once all tasks are done
+ */
+public class SetAutoclosePacket implements IClientToServerPacket.Void {
+
+  public int dummyProperty = 1;
+
+  @JsonIgnore
+  public static SetAutoclosePacket create() {
+    return new SetAutoclosePacket();
+  }
+
+  @JsonIgnore
+  public void onHandle(WebSocket webSocket, SocketServer socketServer) {
+    webSocket.<SocketServer.SocketData>getAttachment().closeIfNoTasksLeft = true;
+    socketServer.log(webSocket, "Marked connection as autoclose");
+  }
+
+  @JsonIgnore
+  public SocketFuture<IServerToClientPacket> getFuture() {
+    return SocketFuture.completedFuture();
+  }
+}

src/main/java/de/dhbwstuttgart/server/packet/UnifyRequestPacket.java

@@ -1,6 +1,9 @@
 package de.dhbwstuttgart.server.packet;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.ServerTaskLogger;
+import de.dhbwstuttgart.server.SocketFuture;
 import de.dhbwstuttgart.server.SocketServer;
 import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
@@ -19,18 +22,17 @@ import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
+import de.dhbwstuttgart.util.Logger;
 import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.concurrent.ForkJoinPool;
 import org.java_websocket.WebSocket;
 
 /**
  * A packet to send all required data for the unification algorithm to the server and request the unification
  */
-public class UnifyRequestPacket implements IClientToServerPacket {
+public class UnifyRequestPacket implements IClientToServerPacket<UnifyResultPacket> {
 
   public SerialMap finiteClosure;
   public SerialMap constraintSet;
@@ -38,30 +40,33 @@ public class UnifyRequestPacket implements IClientToServerPacket {
   public SerialMap serialKeyStorage;
   public SerialValue<?> placeholders;
   public SerialList<SerialMap> factoryplaceholders;
+  public String futureId;
+  public int logLevel;
 
   @JsonIgnore
   private KeyStorage keyStorage = new KeyStorage();
   @JsonIgnore
   private boolean keyStorageLoaded = false;
 
-  public UnifyRequestPacket() {}
-
-  public UnifyRequestPacket(
+  public static UnifyRequestPacket create(
     FiniteClosure finiteClosure,
     ConstraintSet<Pair> constraintSet,
     ConstraintSet<UnifyPair> unifyConstraintSet,
     PlaceholderRegistry placeholderRegistry
   ) {
-    // store contraint and finite closure
-    this.finiteClosure = finiteClosure.toSerial(keyStorage);
-    this.constraintSet = constraintSet.toSerial(keyStorage);
-    this.unifyConstraintSet = unifyConstraintSet.toSerial(keyStorage);
+    UnifyRequestPacket packet = new UnifyRequestPacket();
+    // store constraint and finite closure
+    packet.finiteClosure = finiteClosure.toSerial(packet.keyStorage);
+    packet.constraintSet = constraintSet.toSerial(packet.keyStorage);
+    packet.unifyConstraintSet = unifyConstraintSet.toSerial(packet.keyStorage);
     // store placeholder registry
-    var serialRegistry = placeholderRegistry.toSerial(keyStorage);
-    this.placeholders = serialRegistry.getValue("ph");
-    this.factoryplaceholders = serialRegistry.getList("factoryPh").assertListOfMaps();
+    var serialRegistry = placeholderRegistry.toSerial(packet.keyStorage);
+    packet.placeholders = serialRegistry.getValue("ph");
+    packet.factoryplaceholders = serialRegistry.getList("factoryPh").assertListOfMaps();
     // store referenced objects separately
-    this.serialKeyStorage = keyStorage.toSerial(keyStorage);
+    packet.serialKeyStorage = packet.keyStorage.toSerial(packet.keyStorage);
+    packet.logLevel = ConsoleInterface.logLevel.getValue();
+    return packet;
   }
 
 
@@ -94,15 +99,22 @@ public class UnifyRequestPacket implements IClientToServerPacket {
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketServer socketServer) {
     socketServer.sendMessage(webSocket, "You requested a unify! Please wait until I calculated everything...");
-    System.out.println("Client " + webSocket.<SocketServer.SocketData>getAttachment().id + " requested a unification. Starting now...");
+    socketServer.log(webSocket, "Client requested a unification. Starting now...");
 
     try {
       var placeholderRegistry = new PlaceholderRegistry();
       ArrayList<String> existingPlaceholders = (ArrayList) this.placeholders.getOf(ArrayList.class);
       existingPlaceholders.forEach(placeholderRegistry::addPlaceholder);
 
-      var unifyContext = new UnifyContext(Writer.nullWriter(), false, true,
-        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), null, placeholderRegistry)),
+      Logger logger = new ServerTaskLogger(
+        webSocket,
+        socketServer,
+        Logger.LogLevel.fromValue(
+          Math.max(this.logLevel, Logger.LogLevel.INFO.getValue())
+        )
+      );
+      var unifyContext = new UnifyContext(logger, true,
+        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), logger, placeholderRegistry)),
         new UnifyTaskModel(), ForkJoinPool.commonPool(), placeholderRegistry
       );
 
@@ -129,17 +141,24 @@ public class UnifyRequestPacket implements IClientToServerPacket {
 
       var resultSets = resultListener.getResults();
 
-      System.out.println("Finished unification for client " + webSocket.<SocketServer.SocketData>getAttachment().id);
+      socketServer.log(webSocket, "Finished unification");
       socketServer.sendMessage(webSocket, "Unification finished. Found " + resultSets.size() + " result sets");
 
       if (webSocket.isOpen()) {
-        UnifyResultPacket resultPacket = UnifyResultPacket.create(resultSets);
+        UnifyResultPacket resultPacket = UnifyResultPacket.create(resultSets, futureId);
         webSocket.send(PacketContainer.serialize(resultPacket));
       }
     } catch (Exception e) {
-      System.err.println(e);
-      SocketServer.log.error("e: ", e);
+      SocketServer.logger.exception(e);
+      socketServer.log(webSocket, e.getMessage());
     }
   }
 
+  @JsonIgnore
+  public SocketFuture<UnifyResultPacket> getFuture() {
+    var future = new SocketFuture<>(List.of(UnifyResultPacket.class));
+    futureId = future.futureId;
+    return future;
+  }
+
 }

src/main/java/de/dhbwstuttgart/server/packet/UnifyResultPacket.java

@@ -18,12 +18,14 @@ public class UnifyResultPacket implements IServerToClientPacket {
 
   public SerialList<ISerialNode> results;
   public SerialMap keyStorage;
+  public String futureId;
 
-  public static UnifyResultPacket create(List<ResultSet> resultSets) {
+  public static UnifyResultPacket create(List<ResultSet> resultSets, String futureId) {
     UnifyResultPacket serialized = new UnifyResultPacket();
     KeyStorage keyStorage = new KeyStorage();
     serialized.results = SerialList.fromMapped(resultSets, resultSet -> resultSet.toSerial(keyStorage));
     serialized.keyStorage = keyStorage.toSerial(keyStorage);
+    serialized.futureId = futureId;
     return serialized;
   }
 
@@ -35,8 +37,8 @@ public class UnifyResultPacket implements IServerToClientPacket {
 
   @JsonIgnore
   public void onHandle(WebSocket webSocket, SocketClient socketClient) {
-    System.out.println("[socket] Received unify result");
-    socketClient.setUnifyResultSets(this);
+    SocketClient.logger.info("Received unify result");
+    socketClient.completeResponseFuture(futureId, this);
   }
 
 

src/main/java/de/dhbwstuttgart/server/packet/dataContainers/serialized/SerialMap.java

@@ -3,7 +3,7 @@ package de.dhbwstuttgart.server.packet.dataContainers.serialized;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import java.util.HashMap;
 import java.util.Map;
-import javax.annotation.Nullable;
+import org.jspecify.annotations.Nullable;
 
 public class SerialMap extends HashMap<String, ISerialNode> implements ISerialNode {
 

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

@@ -0,0 +1,8 @@
+package de.dhbwstuttgart.syntaxtree;
+
+import de.dhbwstuttgart.util.Logger;
+
+public class SyntaxTree {
+
+  public static Logger logger = new Logger("SyntaxTree");
+}

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

@@ -1,6 +1,8 @@
 package de.dhbwstuttgart.syntaxtree.factory;
 
+import de.dhbwstuttgart.syntaxtree.SyntaxTree;
 import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.util.Logger;
 import java.io.Writer;
 import java.lang.reflect.Modifier;
 import java.util.*;
@@ -34,7 +36,7 @@ public class UnifyTypeFactory {
 	
     public static FiniteClosure generateFC(
       List<ClassOrInterface> fromClasses,
-      Writer logFile,
+      Logger logger,
       ClassLoader classLoader,
       JavaTXCompiler compiler,
       PlaceholderRegistry placeholderRegistry
@@ -49,7 +51,7 @@ public class UnifyTypeFactory {
         Generell dürfen sie immer die gleichen Namen haben.
         TODO: die transitive Hülle bilden
          */
-        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader, placeholderRegistry), logFile, compiler, placeholderRegistry);
+        return new FiniteClosure(FCGenerator.toUnifyFC(compiler, fromClasses, classLoader, placeholderRegistry), logger, compiler, placeholderRegistry);
     }
 
     public static UnifyPair generateSmallerPair(UnifyType tl, UnifyType tr, SourceLoc location){
@@ -132,7 +134,7 @@ public class UnifyTypeFactory {
 
     public static UnifyType convert(JavaTXCompiler compiler, TypePlaceholder tph, Boolean innerType, PlaceholderRegistry placeholderRegistry) {
     	if (tph.getName().equals("AFR")) {
-    		System.out.println("XXX"+innerType);
+          SyntaxTree.logger.info("XXX"+innerType);
     	}
     	PlaceholderType ntph = new PlaceholderType(tph.getName(), tph.getVariance(), placeholderRegistry);
     	ntph.setVariance(tph.getVariance());
@@ -199,7 +201,7 @@ public class UnifyTypeFactory {
         		&& ((PlaceholderType)lhs).isWildcardable() 
         		&&	(rhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (lhs.getName().equals("AQ")) {
-        		// System.out.println("");
+        		// SyntaxTree.logger.info("");
         	}
         	((PlaceholderType)rhs).enableWildcardtable();
         }
@@ -208,7 +210,7 @@ public class UnifyTypeFactory {
         		&& ((PlaceholderType)rhs).isWildcardable()
         		&&	(lhs = ret.getLhsType()) instanceof PlaceholderType) {
         	if (rhs.getName().equals("AQ")) {
-        		// System.out.println("");
+        		// SyntaxTree.logger.info("");
         	}
         	((PlaceholderType)lhs).enableWildcardtable();
         }

src/main/java/de/dhbwstuttgart/target/Target.java

@@ -0,0 +1,8 @@
+package de.dhbwstuttgart.target;
+
+import de.dhbwstuttgart.util.Logger;
+
+public class Target {
+  public static Logger logger = new Logger("Target");
+
+}

src/main/java/de/dhbwstuttgart/target/generate/ASTToTargetAST.java

@@ -2,7 +2,6 @@ package de.dhbwstuttgart.target.generate;
 
 import de.dhbwstuttgart.bytecode.FunNGenerator;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
 import de.dhbwstuttgart.exceptions.DebugException;
 import de.dhbwstuttgart.parser.NullToken;
@@ -12,6 +11,9 @@ import de.dhbwstuttgart.syntaxtree.Record;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
+import de.dhbwstuttgart.syntaxtree.visual.OutputGenerator;
+import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.*;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
@@ -66,11 +68,11 @@ public class ASTToTargetAST {
     public IByteArrayClassLoader classLoader;
     protected SourceFile sourceFile;
 
-    public ASTToTargetAST(List<ResultSet> resultSets) {
-        this(null, resultSets);
+    public ASTToTargetAST(List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+        this(null, resultSets, classLoader);
     }
-    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets) {
-        this(compiler, resultSets, null, new ByteArrayClassLoader());
+    public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, IByteArrayClassLoader classLoader) {
+        this(compiler, resultSets, null, classLoader);
     }
 
     public ASTToTargetAST(JavaTXCompiler compiler, List<ResultSet> resultSets, SourceFile sourceFile, IByteArrayClassLoader classLoader) {
@@ -337,10 +339,10 @@ public class ASTToTargetAST {
 
         var result = r0.stream().map(l -> l.stream().toList()).toList();
 
-        System.out.println("============== OUTPUT ==============");
+        Target.logger.info("============== OUTPUT ==============");
         for (var l : result) {
-            for (var m : l) System.out.println(m.name() + " " + m.getSignature());
-            System.out.println();
+            for (var m : l) Target.logger.info(m.name() + " " + m.getSignature());
+            Target.logger.info("");
         }
         return result;
     }
@@ -781,7 +783,15 @@ public class ASTToTargetAST {
         return TargetFunNType.fromParams(params, filteredParams, gep.getReturnType() != null ? 1 : 0);
     }
 
+    private FunNGenerator.GenericParameters convertToParameters(TargetFunNType input) {
+        return null;
+    }
+
     private boolean isSubtype(TargetType test, TargetType other) {
+        if (other.equals(TargetType.Object)) return true;
+        if (test instanceof TargetFunNType tfun && other instanceof TargetFunNType ofun)
+            return isSubtype(new FunNGenerator.GenericParameters(tfun), new FunNGenerator.GenericParameters(ofun));
+
         var testClass = compiler.getClass(new JavaClassName(test.name()));
         var otherClass = compiler.getClass(new JavaClassName(other.name()));
         if (testClass == null) return false;
@@ -818,14 +828,6 @@ public class ASTToTargetAST {
                 .toList();
 
             var code = FunNGenerator.generateSpecializedBytecode(gep, superInterfaces);
-
-            try {
-                classLoader.findClass(entry.getKey());
-            } catch (ClassNotFoundException e) {
-                try {
-                    classLoader.loadClass(code);
-                } catch (LinkageError ignored) {}
-            }
             auxiliaries.put(entry.getKey(), code);
         }
     }
@@ -856,7 +858,7 @@ public class ASTToTargetAST {
                             classLoader.findClass(superClassName);
                         } catch (ClassNotFoundException e) {
                             try {
-                                classLoader.loadClass(code);
+                                classLoader.loadClass(superClassName, code);
                             } catch (LinkageError ignored) {}
                         }
                         auxiliaries.put(superClassName, code);

src/main/java/de/dhbwstuttgart/target/generate/GenerateGenerics.java

@@ -1,10 +1,12 @@
 package de.dhbwstuttgart.target.generate;
 
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.syntaxtree.type.Void;
+import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.type.TargetGenericType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
 import de.dhbwstuttgart.typeinference.result.PairTPHEqualTPH;
@@ -138,17 +140,17 @@ public abstract class GenerateGenerics {
         this.astToTargetAST = astToTargetAST;
         for (var constraint : constraints.results) {
             if (constraint instanceof PairTPHsmallerTPH p) {
-                System.out.println(p.left + " " + p.left.getVariance());
+                Target.logger.info(p.left + " " + p.left.getVariance());
                 simplifiedConstraints.add(new PairLT(new TPH(p.left), new TPH(p.right)));
             } else if (constraint instanceof PairTPHEqualTPH p) {
                 equality.put(p.getLeft(), p.getRight());
             } else if (constraint instanceof PairTPHequalRefTypeOrWildcardType p) {
-                System.out.println(p.left + " = " + p.right);
+                Target.logger.info(p.left + " = " + p.right);
                 concreteTypes.put(new TPH(p.left), p.right);
             }
         }
 
-        System.out.println("Simplified constraints: " + simplifiedConstraints);
+        Target.logger.info("Simplified constraints: " + simplifiedConstraints);
     }
 
     /*public record GenericsState(Map<TPH, RefTypeOrTPHOrWildcardOrGeneric> concreteTypes, Map<TypePlaceholder, TypePlaceholder> equality) {}
@@ -248,7 +250,7 @@ public abstract class GenerateGenerics {
                 equality.put(entry.getKey(), to);
             }
         }
-        System.out.println(from + " -> " + to + " " + from.getVariance());
+        Target.logger.info(from + " -> " + to + " " + from.getVariance());
         //from.setVariance(to.getVariance());
         equality.put(from, to);
         referenced.remove(new TPH(from));
@@ -317,7 +319,7 @@ public abstract class GenerateGenerics {
                     Set<TPH> T2s = new HashSet<>();
                     findTphs(superType, T2s);
 
-                    System.out.println("T1s: " + T1s + " T2s: " + T2s);
+                    Target.logger.info("T1s: " + T1s + " T2s: " + T2s);
                     //Ende
 
                     superType = methodCall.receiverType;
@@ -332,7 +334,7 @@ public abstract class GenerateGenerics {
                             var optMethod = astToTargetAST.findMethod(owner, methodCall.name, methodCall.signatureArguments().stream().map(astToTargetAST::convert).toList());
                             if (optMethod.isEmpty()) return;
                             var method2 = optMethod.get();
-                            System.out.println("In: " + method.getName() + " Method: " + method2.getName());
+                            Target.logger.info("In: " + method.getName() + " Method: " + method2.getName());
                             var generics = family(owner, method2);
 
                             // transitive and
@@ -365,7 +367,7 @@ public abstract class GenerateGenerics {
                                                     if (!T1s.contains(R1) || !T2s.contains(R2)) continue;
 
                                                     var newPair = new PairLT(R1, R2);
-                                                    System.out.println("New pair: " + newPair);
+                                                    Target.logger.info("New pair: " + newPair);
                                                     newPairs.add(newPair);
 
                                                     if (!containsRelation(result, newPair))
@@ -567,7 +569,7 @@ public abstract class GenerateGenerics {
     Set<Pair> generics(ClassOrInterface owner, Method method) {
         if (computedGenericsOfMethods.containsKey(method)) {
             var cached = computedGenericsOfMethods.get(method);
-            System.out.println("Cached " + method.getName() + ": " + cached);
+            Target.logger.info("Cached " + method.getName() + ": " + cached);
             return cached;
         }
 
@@ -596,7 +598,7 @@ public abstract class GenerateGenerics {
 
         normalize(result, classGenerics, usedTphs);
 
-        System.out.println(this.getClass().getSimpleName() + " " + method.name + ": " + result);
+        Target.logger.info(this.getClass().getSimpleName() + " " + method.name + ": " + result);
         return result;
     }
 
@@ -675,7 +677,7 @@ public abstract class GenerateGenerics {
 
         normalize(javaResult, null, referencedByClass);
 
-        System.out.println(this.getClass().getSimpleName() + " Class " + classOrInterface.getClassName().getClassName() + ": " + javaResult);
+        Target.logger.info(this.getClass().getSimpleName() + " Class " + classOrInterface.getClassName().getClassName() + ": " + javaResult);
         return javaResult;
     }
 
@@ -726,7 +728,7 @@ public abstract class GenerateGenerics {
                     if (!added) break;
                 }
 
-                System.out.println(chain + " " + chain.stream().map(e -> e.resolve().getVariance()).toList());
+                Target.logger.info(chain + " " + chain.stream().map(e -> e.resolve().getVariance()).toList());
                 var variance = chain.get(0).resolve().getVariance();
                 if (variance != 1) continue;
                 var index = 0;
@@ -764,7 +766,7 @@ public abstract class GenerateGenerics {
         }
 
         for (var pair : elementsToAddToEquality) {
-            System.out.println(pair);
+            Target.logger.info(pair);
             addToEquality(pair.left, pair.right, referenced);
         }
     }
@@ -917,11 +919,11 @@ public abstract class GenerateGenerics {
                     }
                 }
                 if (infima.size() > 1) {
-                    System.out.println(infima);
+                    Target.logger.info(infima);
                     for (var pair : infima) {
                         var returnTypes = findTypeVariables(method.getReturnType());
                         var chain = findConnectionToReturnType(returnTypes, input, new HashSet<>(), pair.left);
-                        System.out.println("Find: " + pair.left + " " + chain);
+                        Target.logger.info("Find: " + pair.left + " " + chain);
                         chain.remove(pair.left);
                         if (chain.size() > 0) {
                             for (var tph : chain)
@@ -959,8 +961,8 @@ public abstract class GenerateGenerics {
                         }
                     }
                     newTph.setVariance(variance);
-                    System.out.println(infima + " " + infima.stream().map(i -> i.right.resolve().getVariance()).toList());
-                    System.out.println("Infima new TPH " + newTph + " variance " + variance);
+                    Target.logger.info(infima + " " + infima.stream().map(i -> i.right.resolve().getVariance()).toList());
+                    Target.logger.info("Infima new TPH " + newTph + " variance " + variance);
 
                     //referenced.add(newTph);
                     addToPairs(input, new PairLT(left, new TPH(newTph)));

src/main/java/de/dhbwstuttgart/target/generate/StatementToTargetExpression.java

@@ -8,12 +8,14 @@ import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
 import de.dhbwstuttgart.syntaxtree.statement.*;
 import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.target.Target;
 import de.dhbwstuttgart.target.tree.MethodParameter;
 import de.dhbwstuttgart.target.tree.TargetMethod;
 import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.*;
 
 import java.lang.reflect.Modifier;
+import java.sql.Array;
 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.StreamSupport;
@@ -32,19 +34,17 @@ public class StatementToTargetExpression implements ASTVisitor {
         throw new NotImplementedException();
     }
 
-    @Override
-    public void visit(LambdaExpression lambdaExpression) {
-        var parameters = StreamSupport.stream(lambdaExpression.params.spliterator(), false)
-                .map(p -> (FormalParameter) p)
-                .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
-                .toList();
+    private class LambdaCaptureFinder extends TracingStatementVisitor {
 
-        List<MethodParameter> captures = new ArrayList<>();
-        lambdaExpression.methodBody.accept(new TracingStatementVisitor() {
         // TODO The same mechanism is implemented in Codegen, maybe use it from there?
         final Stack<Set<String>> localVariables = new Stack<>();
-            {
+        private final List<MethodParameter> parameters;
+        private final List<MethodParameter> captures;
+
+        LambdaCaptureFinder(List<MethodParameter> parameters, List<MethodParameter> captures) {
             localVariables.push(new HashSet<>());
+            this.parameters = parameters;
+            this.captures = captures;
         }
 
         boolean hasLocalVar(String name) {
@@ -78,8 +78,27 @@ public class StatementToTargetExpression implements ASTVisitor {
 
         @Override
         public void visit(LambdaExpression lambda) {
-            } // Don't look at lambda expressions
-        });
+            var newCaptures = new ArrayList<MethodParameter>();
+            var captureFinder = new LambdaCaptureFinder(createParameters(lambda), newCaptures);
+            lambda.methodBody.accept(captureFinder);
+            newCaptures.removeAll(parameters);
+            captures.addAll(newCaptures);
+        }
+    }
+
+    private List<MethodParameter> createParameters(LambdaExpression lambda) {
+        return StreamSupport.stream(lambda.params.spliterator(), false)
+            .map(p -> (FormalParameter) p)
+            .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
+            .toList();
+    }
+
+    @Override
+    public void visit(LambdaExpression lambdaExpression) {
+        var parameters = createParameters(lambdaExpression);
+        List<MethodParameter> captures = new ArrayList<>();
+        var visitor = new LambdaCaptureFinder(parameters, captures);
+        lambdaExpression.methodBody.accept(visitor);
 
         TargetMethod.Signature signature = new TargetMethod.Signature(Set.of(), parameters, converter.convert(lambdaExpression.getReturnType()));;
         var tpe = converter.convert(lambdaExpression.getType());
@@ -120,7 +139,10 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(BoolExpression bool) {
-        System.out.println("BoolExpression");
+        result = switch(bool.operation) {
+        case OR -> new TargetBinaryOp.Or(converter.convert(bool.getType()), converter.convert(bool.lexpr), converter.convert(bool.rexpr));
+        case AND -> new TargetBinaryOp.And(converter.convert(bool.getType()), converter.convert(bool.lexpr), converter.convert(bool.rexpr));
+        };
     }
 
     @Override
@@ -234,7 +256,7 @@ public class StatementToTargetExpression implements ASTVisitor {
             isInterface = receiverClass.isInterface();
         }
 
-        System.out.println(argList);
+        Target.logger.info(argList);
         result = new TargetMethodCall(converter.convert(methodCall.getType()), returnType, argList, converter.convert(methodCall.receiver), methodCall.getArgumentList().getArguments().stream().map(converter::convert).toList(), receiverType, methodCall.name, isStatic, isInterface, isPrivate);
     }
 

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

@@ -19,11 +19,11 @@ public class MethodAssumption extends Assumption{
     private ClassOrInterface receiver;
     private RefTypeOrTPHOrWildcardOrGeneric retType;
     List<? extends RefTypeOrTPHOrWildcardOrGeneric> params;
-    private final Boolean isInherited;
-    private final Boolean isOverridden;
+    private final boolean isInherited;
+    private final boolean isOverridden;
 
     public MethodAssumption(ClassOrInterface receiver, RefTypeOrTPHOrWildcardOrGeneric retType,
-                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, Boolean isInherited, Boolean isOverridden){
+                            List<? extends RefTypeOrTPHOrWildcardOrGeneric> params, TypeScope scope, boolean isInherited, boolean isOverridden){
         super(scope);
         this.receiver = receiver;
         this.retType = retType;
@@ -73,11 +73,11 @@ public class MethodAssumption extends Assumption{
         return TYPEStmt.getReceiverType(receiver, resolver);
     }
     
-    public Boolean isInherited() {
+    public boolean isInherited() {
     	return isInherited;
     }
     
-    public Boolean isOverridden() {
+    public boolean isOverridden() {
     	return isOverridden;
     }
 }

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

@@ -9,21 +9,16 @@ import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 
-import java.util.ArrayList;
 import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import javax.annotation.Nullable;
 
-public class Constraint<A extends IConstraintElement> extends HashSet<A> implements ISerializableData {
+public class Constraint<A extends IConstraintElement> extends HashSet<A> implements Comparable<Constraint<A>>, ISerializableData {
 	private static final long serialVersionUID = 1L;
-  private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
-  private Boolean isImplemented = false;
+	private boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
+	private boolean isImplemented = false;
 	
 	/*
 	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
@@ -37,27 +32,31 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
 		super();
 	}
 
-  public Constraint(Boolean isInherited, Boolean isImplemented) {
+  public Constraint(int initialCapacity) {
+    super(initialCapacity);
+  }
+
+	public Constraint(boolean isInherited, boolean isImplemented) {
 		this.isInherited = isInherited;
 		this.isImplemented = isImplemented;
 	}
 	
-  public Constraint(Boolean isInherited, Boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
+	public Constraint(boolean isInherited, boolean isImplemented, Constraint<A> extendConstraint, Set<A> methodSignatureConstraint) {
 		this.isInherited = isInherited;
 		this.isImplemented = isImplemented;
 		this.extendConstraint = extendConstraint;
 		this.methodSignatureConstraint = methodSignatureConstraint;
 	}
 	
-  public void setIsInherited(Boolean isInherited) {
+	public void setIsInherited(boolean isInherited) {
 		this.isInherited = isInherited;
 	}
 	
-  public Boolean isInherited() {
+	public boolean isInherited() {
 		return isInherited;
 	}
 	
-  public Boolean isImplemented() {
+	public boolean isImplemented() {
 		return isImplemented;
 	}
 	
@@ -77,6 +76,14 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
 		methodSignatureConstraint = c;
 	}
 
+  public <B extends IConstraintElement> Constraint<B> createdMapped(Function<A,B> mapper) {
+    Constraint<B> result = new Constraint<>(this.size());
+    for (A element : this) {
+      result.add(mapper.apply(element));
+    }
+    return result;
+  }
+
 	public String toString() {
     return super.toString() + "\nisInherited = " + isInherited
       + " isOveridden = " + isImplemented
@@ -89,6 +96,12 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
 		return super.toString();
 	}
 
+
+  @Override
+  public int compareTo(Constraint<A> o) {
+    return this.toString().compareTo(o.toString());
+  }
+
   private String serialUUID = null;
 
   @Override
@@ -155,5 +168,4 @@ public class Constraint<A extends IConstraintElement> extends HashSet<A> impleme
 
     return keyStorage.getUnserialized(uuid, Constraint.class);
   }
-
 }

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

@@ -21,7 +21,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
   private SourceLoc location;
 
   private PairOperator eOperator = PairOperator.SMALLER;
-  private Boolean noUnification = false;
+  private boolean noUnification = false;
 
 
   private Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2) {
@@ -43,7 +43,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
     this.location = location;
   }
 
-  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, Boolean noUnification) {
+  public Pair(RefTypeOrTPHOrWildcardOrGeneric TA1, RefTypeOrTPHOrWildcardOrGeneric TA2, PairOperator eOp, boolean noUnification) {
     // Konstruktor
     this(TA1, TA2);
     this.eOperator = eOp;
@@ -161,7 +161,7 @@ public class Pair implements Serializable, IConstraintElement, ISerializableData
     String op = data.getValue("op").getOf(String.class);
     SerialMap ta1 = data.getMap("ta1");
     SerialMap ta2 = data.getMap("ta2");
-    Boolean noUnification = data.getValue("noUnification").getOf(Integer.class) == 1;
+    boolean noUnification = data.getValue("noUnification").getOf(Integer.class) == 1;
     SerialMap location = data.getMapOrNull("location");
 
     var pair = new Pair(

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

@@ -11,7 +11,7 @@ import de.dhbwstuttgart.typeinference.unify.UnifyContext;
  * Paare, welche das Unifikationsergebnis darstellen
  */
 public abstract class ResultPair<A extends RefTypeOrTPHOrWildcardOrGeneric,B extends RefTypeOrTPHOrWildcardOrGeneric>
-implements ISerializableData {
+  implements Comparable<ResultPair<A,B>>, ISerializableData {
     private final A left;
     private final B right;
 
@@ -65,6 +65,16 @@ implements ISerializableData {
 		return true;
 	}
 
+	@Override
+	public int compareTo(ResultPair<A, B> o) {
+		if (o == null) {
+			return 1; // this is greater than null
+		}
+
+		return o.left.toString().compareTo(this.left.toString());
+	}
+
+
 
 	@Override
 	public SerialMap toSerial(KeyStorage keyStorage) {

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

@@ -5,10 +5,13 @@ import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
 import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.util.Logger;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import de.dhbwstuttgart.exceptions.NotImplementedException;
@@ -21,14 +24,14 @@ import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
 import java.util.stream.Collectors;
 
 @SuppressWarnings("rawtypes")
-public class ResultSet implements ISerializableData {
+public class ResultSet implements Comparable<ResultSet>, ISerializableData {
 
   public final Set<ResultPair> results;
   public Set<ResultPair<TypePlaceholder, TypePlaceholder>> genIns;
 
-  public ResultSet(Set<ResultPair> set) {
+    public ResultSet(Set<ResultPair> set){
         this.results = set;
-    this.genIns = new HashSet<>();
+        this.genIns = TypeUnifyTaskHelper.getPresizedHashSet(results.size());
         results.forEach(x -> {
           if (x instanceof PairTPHsmallerTPH) {
             this.genIns.add(x);
@@ -36,6 +39,10 @@ public class ResultSet implements ISerializableData {
         });
     }
 
+    public List<ResultPair> getSortedResults() {
+      return results.stream().sorted().toList();
+    }
+
     public boolean contains(ResultPair toCheck) {
     	return this.results.contains(toCheck);
     }
@@ -90,6 +97,21 @@ public class ResultSet implements ISerializableData {
 		return results.hashCode();
 	}
 
+  @Override
+  public int compareTo(ResultSet o) {
+    List<ResultPair> thisSorted = this.getSortedResults();
+    List<ResultPair> otherSorted = o.getSortedResults();
+    int sizeCompare = Integer.compare(thisSorted.size(), otherSorted.size());
+    if (sizeCompare != 0) return sizeCompare;
+
+    for (int i = 0; i < thisSorted.size(); i++) {
+      int cmp = thisSorted.get(i).compareTo(otherSorted.get(i));
+      if (cmp != 0) return cmp;
+    }
+
+    return 0;
+  }
+
   @Override
   public SerialMap toSerial(KeyStorage keyStorage) {
     SerialMap serialized = new SerialMap();;
@@ -110,6 +132,8 @@ class Resolver implements ResultSetVisitor {
   private final Set<GenericInsertPair> additionalTPHs = new HashSet<>();
   private ResultPair<?, ?> currentPair;
 
+  public static Logger logger = new Logger("Resolver");
+
   public Resolver(ResultSet resultPairs) {
     this.result = resultPairs;
   }
@@ -117,7 +141,7 @@ class Resolver implements ResultSetVisitor {
   public ResolvedType resolve(TypePlaceholder tph) {
     toResolve = tph;
     resolved = null;
-    System.out.println(tph.toString());
+    logger.info(tph.toString());
     for (ResultPair<?, ?> resultPair : result.results) {
       if (resultPair instanceof PairTPHEqualTPH && ((PairTPHEqualTPH) resultPair).getLeft().equals(toResolve)) {
         currentPair = resultPair;

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

@@ -1,6 +1,7 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.exceptions.DebugException;
+import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.parser.antlr.Java17Parser;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
@@ -9,15 +10,19 @@ import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.statement.Statement;
 import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.typeinference.assumptions.FieldAssumption;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceBlockInformation;
 import de.dhbwstuttgart.typeinference.assumptions.TypeInferenceInformation;
+import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
 import de.dhbwstuttgart.typeinference.constraints.Pair;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.model.PairOperator;
 import de.dhbwstuttgart.util.BiRelation;
 import org.antlr.v4.runtime.Token;
 
+import java.lang.reflect.Modifier;
 import java.util.*;
 
 public class TYPE {
@@ -33,7 +38,7 @@ public class TYPE {
     public ConstraintSet getConstraints() {
         ConstraintSet ret = new ConstraintSet();
         for (ClassOrInterface cl : sf.KlassenVektor) {
-            var allClasses = new HashSet<ClassOrInterface>();
+            Set<ClassOrInterface> allClasses = TypeUnifyTaskHelper.getPresizedHashSet(allAvailableClasses.size() + sf.availableClasses.size());
             allClasses.addAll(allAvailableClasses);
             allClasses.addAll(sf.availableClasses);
             ret.addAll(getConstraintsClass(cl, new TypeInferenceInformation(allClasses)));
@@ -68,7 +73,7 @@ public class TYPE {
 
             for(SourceFile sourceFile : sfs){
                 for(JavaClassName importName : sourceFile.imports){
-                    System.out.println(importName);
+                    context.logger().info(importName);
                     try {
                         classes.add(ASTFactory.createClass(classLoader.loadClass(importName.toString())));
                     } catch (ClassNotFoundException e) {
@@ -87,12 +92,25 @@ public class TYPE {
         TypeInferenceBlockInformation blockInfo = new TypeInferenceBlockInformation(info.getAvailableClasses(), currentClass, m);
         TYPEStmt methodScope = new TYPEStmt(blockInfo);
         ConstraintSet constraintSet = new ConstraintSet();
-        m.getParameterList().getFormalparalist().forEach(el -> {
-            if(el instanceof RecordPattern){
-                constraintSet.addAll(addRecursiveParameterConstraints((RecordPattern) el, blockInfo));
 
+        if (m.name.equals("main") && Modifier.isStatic(m.modifier) && m.getParameterList().getFormalparalist().size() == 1) {
+            // Add constraint for main method
+            var firstParam = m.getParameterList().getParameterAt(0);
+
+            constraintSet.addUndConstraint(new Pair(firstParam.getType(),
+                new RefType(new JavaClassName("java.util.List"),
+                    List.of(new RefType(new JavaClassName("java.lang.String"), new NullToken())),
+                    new NullToken()),
+                PairOperator.EQUALSDOT));
+        } else {
+            m.getParameterList().getFormalparalist().forEach(el -> {
+                if (el instanceof RecordPattern rp){
+                    constraintSet.addAll(addRecursiveParameterConstraints(rp, blockInfo));
                 }
             });
+        }
+
+
         m.block.accept(methodScope);
         constraintSet.addAll(methodScope.getConstraints());
         return constraintSet;

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

@@ -2,6 +2,7 @@
 package de.dhbwstuttgart.typeinference.typeAlgo;
 
 import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -74,7 +75,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(LambdaExpression lambdaExpression) {
-        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken());
+        TypePlaceholder tphRetType = TypePlaceholder.fresh(new NullToken(), -1, false);
         List<RefTypeOrTPHOrWildcardOrGeneric> lambdaParams = lambdaExpression.params.getFormalparalist().stream().map((formalParameter -> formalParameter.getType())).collect(Collectors.toList());
         lambdaParams.add(tphRetType);
         // lambdaParams.add(0,tphRetType);
@@ -117,17 +118,18 @@ public class TYPEStmt implements StatementVisitor {
     @Override
     public void visit(FieldVar fieldVar) {
         fieldVar.receiver.accept(this);
-        Set<Constraint> oderConstraints = new HashSet<>();
+        List<FieldAssumption> fieldAssumptions = info.getFields(fieldVar.fieldVarName);
+        Set<Constraint> oderConstraints = TypeUnifyTaskHelper.getPresizedHashSet(fieldAssumptions.size());
 
 
-        for (FieldAssumption fieldAssumption : info.getFields(fieldVar.fieldVarName)) {
+        for (FieldAssumption fieldAssumption : fieldAssumptions) {
             Constraint constraint = new Constraint();
             GenericsResolver resolver = getResolverInstance();
             constraint.add(new Pair(fieldVar.receiver.getType(), fieldAssumption.getReceiverType(resolver), PairOperator.SMALLERDOT, loc(fieldVar.getOffset()))); // PL 2019-12-09: SMALLERDOT eingefuegt, EQUALSDOT entfernt, wenn ds Field privat ist muesste es EQUALSDOT lauten
             constraint.add(new Pair(fieldVar.getType(), fieldAssumption.getType(resolver), PairOperator.EQUALSDOT, loc(fieldVar.getOffset())));
             oderConstraints.add(constraint);
         }
-        if (oderConstraints.size() == 0)
+        if (oderConstraints.isEmpty())
             throw new TypeinferenceException("Kein Feld " + fieldVar.fieldVarName + " gefunden", fieldVar.getOffset());
         constraintsSet.addOderConstraint(oderConstraints);
     }
@@ -142,7 +144,7 @@ public class TYPEStmt implements StatementVisitor {
 
     @Override
     public void visit(ForEachStmt forEachStmt) {
-        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), Arrays.asList(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
+        var iterableType = new RefType(ASTFactory.createClass(java.lang.Iterable.class).getClassName(), List.of(new ExtendsWildcardType(forEachStmt.statement.getType(), new NullToken())), new NullToken());
         constraintsSet.addUndConstraint(new Pair(forEachStmt.expression.getType(), iterableType, PairOperator.SMALLERDOT, loc(forEachStmt.getOffset())));
         forEachStmt.statement.accept(this);
         forEachStmt.expression.accept(this);
@@ -190,7 +192,7 @@ public class TYPEStmt implements StatementVisitor {
         methodCall.receiver.accept(this);
         // Overloading:
         Set<Constraint<Pair>> methodConstraints = new HashSet<>();
-        for (MethodAssumption m : this.getMethods(methodCall.name, methodCall.arglist, info)) {
+        for (MethodAssumption m : TYPEStmt.getMethods(methodCall.name, methodCall.arglist, info)) {
             GenericsResolver resolver = getResolverInstance();
             Set<Constraint<Pair>> oneMethodConstraints = generateConstraint(methodCall, m, info, resolver);
             methodConstraints.addAll(oneMethodConstraints);
@@ -200,7 +202,7 @@ public class TYPEStmt implements StatementVisitor {
              * oneMethodConstraint.setExtendConstraint(extendsOneMethodConstraint); extendsOneMethodConstraint.setExtendConstraint(oneMethodConstraint); methodConstraints.add(extendsOneMethodConstraint);
              */
         }
-        if (methodConstraints.size() < 1) {
+        if (methodConstraints.isEmpty()) {
             throw new TypeinferenceException("Methode " + methodCall.name + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -213,7 +215,7 @@ public class TYPEStmt implements StatementVisitor {
         for (MethodAssumption m : this.getConstructors(info, (RefType) methodCall.getType(), methodCall.getArgumentList())) {
             methodConstraints.add(generateConstructorConstraint(methodCall, m, info, getResolverInstance()));
         }
-        if (methodConstraints.size() < 1) {
+        if (methodConstraints.isEmpty()) {
             throw new TypeinferenceException("Konstruktor in Klasse " + methodCall.getType().toString() + " ist nicht vorhanden!", methodCall.getOffset());
         }
         constraintsSet.addOderConstraint(methodConstraints);
@@ -283,8 +285,13 @@ public class TYPEStmt implements StatementVisitor {
             // see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
             // Expression muss zu Numeric Convertierbar sein. also von Numeric erben
             Constraint<Pair> numeric;
+            HashSet<JavaClassName> classNames = TypeUnifyTaskHelper.getPresizedHashSet(info.getAvailableClasses().size());
+            for (var classEl : info.getAvailableClasses()) {
+                classNames.add(classEl.getClassName());
+            }
+
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(bytee.getName())) {
+            if (classNames.contains(bytee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -292,7 +299,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(shortt.getName())) {
+            if (classNames.contains(shortt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), shortt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -300,7 +307,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(integer.getName())) {
+            if (classNames.contains(integer.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), integer, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -308,7 +315,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(longg.getName())) {
+            if (classNames.contains(longg.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), longg, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -316,7 +323,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(floatt.getName())) {
+            if (classNames.contains(floatt.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), floatt, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -324,7 +331,7 @@ public class TYPEStmt implements StatementVisitor {
                 numericAdditionOrStringConcatenation.add(numeric);
             }
             // PL eingefuegt 2018-07-17
-            if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(doublee.getName())) {
+            if (classNames.contains(doublee.getName())) {
                 numeric = new Constraint<>();
                 numeric.add(new Pair(binary.lexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
                 numeric.add(new Pair(binary.rexpr.getType(), doublee, PairOperator.SMALLERDOT, loc(binary.getOffset())));
@@ -339,7 +346,7 @@ public class TYPEStmt implements StatementVisitor {
 
             if (binary.operation.equals(BinaryExpr.Operator.ADD)) {
                 // Dann kann der Ausdruck auch das aneinanderfügen zweier Strings sein: ("a" + "b") oder (1 + 2)
-                if (info.getAvailableClasses().stream().map(x -> x.getClassName()).collect(Collectors.toCollection(HashSet::new)).contains(string.getName())) {
+                if (classNames.contains(string.getName())) {
                     Constraint<Pair> stringConcat = new Constraint<>();
                     stringConcat.add(new Pair(binary.lexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
                     stringConcat.add(new Pair(binary.rexpr.getType(), string, PairOperator.EQUALSDOT, loc(binary.getOffset())));
@@ -347,7 +354,7 @@ public class TYPEStmt implements StatementVisitor {
                     numericAdditionOrStringConcatenation.add(stringConcat);
                 }
             }
-            if (numericAdditionOrStringConcatenation.size() < 1) {
+            if (numericAdditionOrStringConcatenation.isEmpty()) {
                 throw new TypeinferenceException("Kein Typ für " + binary.operation.toString() + " vorhanden", binary.getOffset());
             }
             constraintsSet.addOderConstraint(numericAdditionOrStringConcatenation);
@@ -636,6 +643,7 @@ public class TYPEStmt implements StatementVisitor {
             params.add(resolver.resolve(new GenericRefType(gtv.getName(), new NullToken())));
         }
         RefTypeOrTPHOrWildcardOrGeneric receiverType;
+        
         if (receiver instanceof FunNClass) {
             receiverType = new RefType(new JavaClassName(receiver.getClassName().toString() + "$$"), params, new NullToken()); // new FunN(params);
         } else {
@@ -694,8 +702,8 @@ public class TYPEStmt implements StatementVisitor {
 
         Set<Pair> methodSignatureConstraint = generatemethodSignatureConstraint(forMethod, assumption, info, resolver);
 
-        //System.out.println("methodSignatureConstraint: " + methodSignatureConstraint);
-        //System.out.println("methodConstraint: " + methodConstraint);
+        //context.logger().info("methodSignatureConstraint: " + methodSignatureConstraint);
+        //context.logger().info("methodConstraint: " + methodConstraint);
 
         methodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
         extendsMethodConstraint.setmethodSignatureConstraint(methodSignatureConstraint);
@@ -733,7 +741,7 @@ public class TYPEStmt implements StatementVisitor {
         }
 
         // Zuordnung von MethodCall.signature(ReturnType) zu dem ReturnType der ausgewaehlten Methode (assumption.returnType)
-        ret.add(new Pair(foMethod.signature.get(foMethod.signature.size() - 1), assumption.getReturnType(), PairOperator.EQUALSDOT));
+        ret.add(new Pair(foMethod.signature.getLast(), assumption.getReturnType(), PairOperator.EQUALSDOT));
         return ret;
     }
 
@@ -746,8 +754,8 @@ public class TYPEStmt implements StatementVisitor {
                 // funNParams.add(TypePlaceholder.fresh(new NullToken()));
                 funNParams.add(new GenericRefType(NameGenerator.makeNewName(), new NullToken()));
             }
-            funNParams.get(funNParams.size() - 1);
-            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.get(funNParams.size() - 1), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
+            funNParams.getLast();
+            ret.add(new MethodAssumption(new FunNClass(funNParams), funNParams.getLast(), funNParams.subList(0, funNParams.size() - 1), new TypeScope() {
                 @Override
                 public Iterable<? extends GenericTypeVar> getGenerics() {
                     throw new NotImplementedException();
@@ -842,7 +850,7 @@ public class TYPEStmt implements StatementVisitor {
             for (var child : switchStmt.getBlocks()) {
                 for (var label : child.getLabels()) {
                     if (label.getPattern() == null) {
-                        //System.out.println("DefaultCase");
+                        //context.logger().info("DefaultCase");
                     } else {
                         constraintsSet.addUndConstraint(
                                 new Pair(
@@ -883,13 +891,9 @@ public class TYPEStmt implements StatementVisitor {
 
             child.getLabels().forEach(el -> {
                 if (el.getType() instanceof RefType) {
-                    var recType = el;
-
-                    if (el.getPattern() instanceof RecordPattern) {
-                        var pattern = (RecordPattern) recType.getPattern();
+                  if (el.getPattern() instanceof RecordPattern pattern) {
                     recursivelyAddRecordConstraints(pattern);
                   }
-
                 }
             });
 
@@ -905,13 +909,13 @@ public class TYPEStmt implements StatementVisitor {
 
         var allClasses = info.getAvailableClasses();
         var interestingClasses = allClasses.stream().filter(as -> as.getClassName().equals(((RefType) pattern.getType()).getName())).toList();
-        var constructors = interestingClasses.get(0).getConstructors();
+        var constructors = interestingClasses.getFirst().getConstructors();
 
         int counter = 0;
 
         for (var subPattern : pattern.getSubPattern()) {
             for (Constructor con : constructors) {
-                //System.out.println("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
+                //context.logger().info("----------------------\n" + subPattern.getType() + " | " + con.getParameterList().getParameterAt(counter).getType() + "\n----------------------\n");
                 constraintsSet.addUndConstraint(new Pair(subPattern.getType(), con.getParameterList().getParameterAt(counter).getType(), PairOperator.SMALLERDOT, loc(con.getParameterList().getParameterAt(counter).getOffset())));
             }
             if (subPattern instanceof RecordPattern) recursivelyAddRecordConstraints((RecordPattern) subPattern);

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

@@ -0,0 +1,91 @@
+package de.dhbwstuttgart.typeinference.unify;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.RecursiveTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * An intermediate class for the recursive steps of the TypeUnifyTask:
+ * This allows canceling parts of the recursion tree, instead of only  the whole execution as before. But in
+ * order for that to work, all cancellable child tasks must be added when they are created
+ *
+ * @param <T>
+ */
+public abstract class CancellableTask<T> extends RecursiveTask<T> {
+
+  private final AtomicBoolean executionCancelled = new AtomicBoolean(false);
+  private final List<CancellableTask<?>> childTasks = new LinkedList<>();
+  private CancellableTask<?> parentTask = null;
+
+  /**
+   * Set the execution for this task and all its (recursive) children to be canceled
+   */
+  protected void cancelExecution() {
+    // is this branch already canceled? Then do nothing
+    if (this.executionCancelled.getAndSet(true)) return;
+    this.cancelChildExecution();
+  }
+
+  private void cancelChildExecution() {
+    synchronized (this.childTasks) {
+      for (var childTask : childTasks) {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+      }
+    }
+  }
+
+  private void cancelChildExecutionAfter(CancellableTask<?> checkpointTask) {
+    boolean reachedCheckpoint = false;
+    int i = 0;
+    for (var childTask : childTasks) {
+      if (!reachedCheckpoint) {
+        reachedCheckpoint = childTask == checkpointTask;
+      }
+      else {
+        // no need to cancel a branch that is already finished
+        if (!childTask.isDone()) {
+          childTask.cancelExecution();
+        }
+        i++;
+      }
+    }
+    System.out.println("Skipped " + i + " younger siblings");
+  }
+
+  protected void cancelSiblingTasks() {
+    if (this.parentTask != null) {
+      boolean thisWasCancelledBefore = this.executionCancelled.get();
+      this.parentTask.cancelChildExecution();
+      this.executionCancelled.set(thisWasCancelledBefore);
+    }
+  }
+
+  public void cancelYoungerSiblingTasks() {
+    if (this.parentTask != null) {
+      this.parentTask.cancelChildExecutionAfter(this);
+    }
+  }
+
+  public Boolean isExecutionCancelled() {
+    return executionCancelled.get();
+  }
+
+  public void addChildTask(CancellableTask<?> childTask) {
+    this.childTasks.add(childTask);
+    childTask.setParentTask(this);
+    if (this.executionCancelled.get()) {
+      childTask.executionCancelled.set(true);
+    }
+  }
+
+  private void setParentTask(CancellableTask<?> parentTask) {
+    this.parentTask = parentTask;
+  }
+
+}

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

@@ -37,9 +37,6 @@ public class ConcurrentSetMergeTask<T> extends RecursiveTask<Set<T>> {
       totalElements += list.get(i).size();
     }
 
-    System.out.println("ConcurrentSetMerge? -> " + (size <= LIST_THRESHOLD || totalElements < ELEMENT_THRESHOLD ? "true" : "false"));
-
-
     // size will always be at least one
     if (true || size <= LIST_THRESHOLD || totalElements < ELEMENT_THRESHOLD) {
       Set<T> result = this.list.get(start);

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

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

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

@@ -1,10 +1,12 @@
 package de.dhbwstuttgart.typeinference.unify;
 
+import de.dhbwstuttgart.util.Logger;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Optional;
 import java.util.Queue;
 import java.util.Set;
@@ -12,24 +14,16 @@ import java.util.Stack;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.DebugException;
-import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
-import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
-import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
 import de.dhbwstuttgart.typeinference.unify.model.*;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
-import de.dhbwstuttgart.typeinference.unify.distributeVariance;
 
-import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
 import java.io.OutputStreamWriter;
 
-import org.apache.commons.io.output.NullOutputStream;
-
 /**
  * Implementation of the type inference rules.
  * @author Florian Steurer
@@ -37,17 +31,17 @@ import org.apache.commons.io.output.NullOutputStream;
  */
 public class RuleSet implements IRuleSet{
 	
-	Writer logFile;
+	Logger logger;
 	final PlaceholderRegistry placeholderRegistry;
 	
 	public RuleSet(PlaceholderRegistry placeholderRegistry) {
 		super();
-		logFile = OutputStreamWriter.nullWriter();
+		logger = Logger.NULL_LOGGER;
 		this.placeholderRegistry = placeholderRegistry;
 	}
 	
-	RuleSet(Writer logFile, PlaceholderRegistry placeholderRegistry) {
-		this.logFile = logFile;
+	RuleSet(Logger logger, PlaceholderRegistry placeholderRegistry) {
+		this.logger = logger;
 		this.placeholderRegistry = placeholderRegistry;
 	}
 	
@@ -300,8 +294,8 @@ public class RuleSet implements IRuleSet{
 		
 		if(dFromFc == null || !dFromFc.getTypeParams().arePlaceholders() || dFromFc.getTypeParams().size() != cFromFc.getTypeParams().size())
 			return Optional.empty();
-		//System.out.println("cFromFc: " + cFromFc);
-		//System.out.println("dFromFc: " + dFromFc);
+		//context.logger().info("cFromFc: " + cFromFc);
+		//context.logger().info("dFromFc: " + dFromFc);
 		int[] pi = pi(cFromFc.getTypeParams(), dFromFc.getTypeParams());
 		
 		if(pi.length == 0)
@@ -510,17 +504,17 @@ public class RuleSet implements IRuleSet{
 		TypeParams typeDParams = typeD.getTypeParams();
 		TypeParams typeDgenParams = typeDgen.getTypeParams();
 		
-		//System.out.println("Pair: " +pair);
-		//System.out.println("typeD: " +typeD);
-		//System.out.println("typeDParams: " +typeDParams);
-		//System.out.println("typeDgen: " +typeD);
-		//System.out.println("typeDgenParams: " +typeDgenParams);
+		//context.logger().info("Pair: " +pair);
+		//context.logger().info("typeD: " +typeD);
+		//context.logger().info("typeDParams: " +typeDParams);
+		//context.logger().info("typeDgen: " +typeD);
+		//context.logger().info("typeDgenParams: " +typeDgenParams);
 		Unifier unif = Unifier.identity();
 		for(int i = 0; i < typeDParams.size(); i++) { 
-			//System.out.println("ADAPT" +typeDgenParams);
+			//context.logger().info("ADAPT" +typeDgenParams);
 			if (typeDgenParams.get(i) instanceof PlaceholderType) 
 				unif.add((PlaceholderType) typeDgenParams.get(i), typeDParams.get(i));
-			else System.out.println("ERROR");
+			else logger.exception(new Exception("ERROR in adapt rule: cannot add non placeholder type"));
 		}
 		return Optional.of(new UnifyPair(unif.apply(newLhs), typeDs, PairOperator.SMALLERDOT, pair.getSubstitution(), pair.getBasePair()));
 	}
@@ -655,9 +649,11 @@ public class RuleSet implements IRuleSet{
 	
 	@Override
 	public Optional<Set<UnifyPair>> subst(Set<UnifyPair> pairs, List<Set<Constraint<UnifyPair>>> oderConstraints) {
-		HashMap<UnifyType, Integer> typeMap = new HashMap<>();
+		// Statistically, typeMap will fill up quickly and resize multiple times. To reduce this, we start with a higher capacity
+		HashMap<UnifyType, Integer> typeMap = new HashMap<>(200);
 		
 		Stack<UnifyType> occuringTypes = new Stack<>();
+		occuringTypes.ensureCapacity(pairs.size() * 3);
 
 		for(UnifyPair pair : pairs) {
 			occuringTypes.push(pair.getLhsType());
@@ -675,9 +671,9 @@ public class RuleSet implements IRuleSet{
 			if(t1 instanceof SuperType)
 				occuringTypes.push(((SuperType) t1).getSuperedType());
 			else
-				t1.getTypeParams().forEach(x -> occuringTypes.push(x));	
+				t1.getTypeParams().forEach(occuringTypes::push);
 		}
-		Queue<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
+		LinkedList<UnifyPair> result1 = new LinkedList<UnifyPair>(pairs);
 		ArrayList<UnifyPair> result = new ArrayList<UnifyPair>();
 		boolean applied = false;
 
@@ -698,19 +694,30 @@ public class RuleSet implements IRuleSet{
 					&& !((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));
+				// apply unifier to result and result1 in place
+				result.replaceAll(p -> uni.apply(pair, p));
+				ListIterator<UnifyPair> result1Iterator = result1.listIterator();
+				while (result1Iterator.hasNext()) {
+					UnifyPair x = result1Iterator.next();
+					result1Iterator.set(uni.apply(pair, x));
+				}
 
 				Function<? super Constraint<UnifyPair>,? extends Constraint<UnifyPair>> applyUni = b -> b.stream().map(
 						x -> uni.apply(pair,x)).collect(Collectors.toCollection((b.getExtendConstraint() != null)
 								? () -> new Constraint<UnifyPair>(
 										  b.isInherited(),
 										  b.isImplemented(),
-										  b.getExtendConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(Constraint::new)),
+										  b.getExtendConstraint().createdMapped(x -> uni.apply(pair,x)),
 										  b.getmethodSignatureConstraint().stream().map(x -> uni.apply(pair,x)).collect(Collectors.toCollection(HashSet::new)))
 								: () -> new Constraint<UnifyPair>(b.isInherited(), b.isImplemented())
 									));
-				oderConstraints.replaceAll(oc -> oc.stream().map(applyUni).collect(Collectors.toCollection(HashSet::new)));
+				oderConstraints.replaceAll(oc -> {
+						HashSet<Constraint<UnifyPair>> mapped = new HashSet<>(oc.size());
+						for (var element : oc) {
+							mapped.add(applyUni.apply(element));
+						}
+						return mapped;
+				});
 				/*
 						oderConstraints = oderConstraints.stream().map(
 						a -> a.stream().map(applyUni
@@ -864,14 +871,11 @@ public class RuleSet implements IRuleSet{
         								   UnifyType r = x.getRhsType();
         								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 								     } );
-		try {
-			logFile.write("FUNgreater: " + pair + "\n");
-				logFile.write("FUNred: " + result + "\n");
-				// logFile.flush();
-			}
-		catch (IOException e) {
-			System.out.println("logFile-Error");
-		}
+
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNred: " + result);
+
+
 		return Optional.of(result);
 	}
 	
@@ -937,8 +941,8 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		Integer variance = ((PlaceholderType)rhsType).getVariance();
-		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		int variance = ((PlaceholderType)rhsType).getVariance();
+		int inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNLhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
@@ -960,14 +964,10 @@ public class RuleSet implements IRuleSet{
 									   UnifyType r = x.getRhsType();
 									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-		try {
-			logFile.write("FUNgreater: " + pair + "\n");
-			logFile.write("FUNgreater: " + result + "\n");
-			// logFile.flush();
-		}
-	catch (IOException e) {
-		System.out.println("lofFile-Error");
-	}
+
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNgreater: " + result);
+
 		return Optional.of(result);
 	}
 
@@ -986,8 +986,8 @@ public class RuleSet implements IRuleSet{
 
 		Set<UnifyPair> result = new HashSet<UnifyPair>();
 		
-		Integer variance = ((PlaceholderType)lhsType).getVariance();
-		Integer inversVariance = distributeVariance.inverseVariance(variance);
+		int variance = ((PlaceholderType)lhsType).getVariance();
+		int inversVariance = distributeVariance.inverseVariance(variance);
 		
 		UnifyType[] freshPlaceholders = new UnifyType[funNRhsType.getTypeParams().size()];
 		for(int i = 0; i < freshPlaceholders.length-1; i++) {
@@ -1010,14 +1010,11 @@ public class RuleSet implements IRuleSet{
 		   							   UnifyType r = x.getRhsType();
 		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
-		try {
-			logFile.write("FUNgreater: " + pair + "\n");
-			logFile.write("FUNsmaller: " + result + "\n");
-			// logFile.flush();
-		}
-	catch (IOException e) {
-		System.out.println("lofFile-Error");
-	}
+
+
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNsmaller: " + result);
+
 		return Optional.of(result);
 	}
 

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

@@ -29,17 +29,12 @@ public class TypeUnify {
 	 * unify parallel ohne result modell
 	 */
 	public static Set<Set<UnifyPair>> unify(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
-		ForkJoinPool pool = TypeUnify.createThreadPool();
+		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
 		UnifyContext context = unifyContext.newWithParallel(true).newWithExecutor(pool);
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
 		Set<Set<UnifyPair>> res = joinFuture(unifyTask.compute());
-		try {
-			unifyContext.logFile().write("\nnoShortendElements: " + TypeUnifyTask.noShortendElements + "\n");
-			// logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
+
+		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements + "\n");
 		return res;
 	}
 	
@@ -47,7 +42,7 @@ public class TypeUnify {
 	 * unify asynchron mit Rückgabe UnifyResultModel ohne dass alle results gesammelt sind
 	 */
 	public static UnifyResultModel unifyAsync(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
-		ForkJoinPool pool = TypeUnify.createThreadPool();
+		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
 		UnifyContext context = unifyContext.newWithExecutor(pool);
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
 		unifyTask.compute();
@@ -58,18 +53,12 @@ public class TypeUnify {
 	 * unify parallel mit Rückgabe UnifyResultModel nachdem alle results gesammelt sind
 	 */
 	public static Set<Set<UnifyPair>> unifyParallel(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
-		ForkJoinPool pool = TypeUnify.createThreadPool();
+		ForkJoinPool pool = TypeUnify.createThreadPool(unifyContext.logger());
 		UnifyContext context = unifyContext.newWithParallel(true).newWithExecutor(pool);
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, context, 0);
 		var result = joinFuture(unifyTask.compute());
 
-		try {
-			unifyContext.logFile().write("\nnoShortendElements: " + TypeUnifyTask.noShortendElements +"\n");
-			// logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
+		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements + "\n");
 		return result;
 	}
 	
@@ -87,18 +76,12 @@ public class TypeUnify {
 	public static Set<Set<UnifyPair>> unifyOderConstraints(Set<UnifyPair> undConstrains, List<Set<Constraint<UnifyPair>>> oderConstraints, IFiniteClosure fc, UnifyContext unifyContext) {
 		TypeUnifyTask unifyTask = new TypeUnifyTask(undConstrains, oderConstraints, fc, unifyContext.newWithParallel(false), 0);
 		Set<Set<UnifyPair>> res = joinFuture(unifyTask.compute());
-		try {
-			unifyContext.logFile().write("\nnoShortendElements: " + TypeUnifyTask.noShortendElements +"\n");
-			// logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no log-File");
-		}
+		unifyContext.logger().debug("\nnoShortendElements: " + TypeUnifyTask.noShortendElements +"\n");
 		return res;
 	}
 
-	private static ForkJoinPool createThreadPool() {
-		Logger.print("Available processors: " + Runtime.getRuntime().availableProcessors());
+	private static ForkJoinPool createThreadPool(Logger logger) {
+		logger.info("Available processors: " + Runtime.getRuntime().availableProcessors());
 		return new ForkJoinPool(
 			Runtime.getRuntime().availableProcessors(),
 			ForkJoinPool.defaultForkJoinWorkerThreadFactory,

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

@@ -34,7 +34,7 @@ public class TypeUnify2Task extends TypeUnifyTask {
   @Override
   public CompletableFuture<Set<Set<UnifyPair>>> compute() {
     if (one) {
-      System.out.println("two");
+      context.logger().info("two");
     }
     one = true;
     CompletableFuture<Set<Set<UnifyPair>>> res =
@@ -45,7 +45,7 @@ public class TypeUnify2Task extends TypeUnifyTask {
                */
     //writeLog("xxx");
     //noOfThread--;
-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
       return CompletableFuture.completedFuture(new HashSet<>());
     } else {
       return res;
@@ -53,12 +53,6 @@ public class TypeUnify2Task extends TypeUnifyTask {
   }
 
   public void closeLogFile() {
-
-    try {
-      context.logFile().close();
-    } catch (IOException ioE) {
-      System.err.println("no log-File");
-    }
-
+    context.logger().close();
   }
 }

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

@@ -3,6 +3,7 @@ package de.dhbwstuttgart.typeinference.unify;
 
 import de.dhbwstuttgart.exceptions.TypeinferenceException;
 import de.dhbwstuttgart.parser.NullToken;
+import de.dhbwstuttgart.server.ServerTaskLogger;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.cartesianproduct.VarianceCase;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
@@ -26,11 +27,7 @@ import de.dhbwstuttgart.typeinference.unify.model.WildcardType;
 import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Pair;
 import de.dhbwstuttgart.util.Tuple;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
 import java.io.Serial;
-import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -45,13 +42,10 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
 import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
-import org.apache.commons.io.output.NullOutputStream;
 
 
 /**
@@ -59,14 +53,14 @@ import org.apache.commons.io.output.NullOutputStream;
  *
  * @author Florian Steurer
  */
-public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<UnifyPair>>>> {
+public class TypeUnifyTask extends CancellableTask<CompletableFuture<Set<Set<UnifyPair>>>> {
 
   @Serial
   private static final long serialVersionUID = 1L;
   private static int i = 0;
   private final boolean printtag = false;
 
-  final UnifyContext context;
+  public final UnifyContext context;
 
   /**
    * Element, das aus dem nextSet den Gleichunen dieses Threads hinzugefuegt wurde
@@ -108,21 +102,19 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
   int rekTiefeField;
 
-  Integer nOfUnify = 0;
+  int nOfUnify = 0;
 
-  Integer noUndefPair = 0;
+  int noUndefPair = 0;
 
-  Integer noAllErasedElements = 0;
+  int noAllErasedElements = 0;
 
   // some statistics for local output (they will not make sense when executed on the server)
   public static int noBacktracking;
   public static int noShortendElements;
   public static int noou = 0;
 
-  Boolean myIsCanceled = false;
-
   public TypeUnifyTask(UnifyContext context) {
-    this.context = context.newWithLogFile(new OutputStreamWriter(NullOutputStream.INSTANCE));
+    this.context = context.newWithLogger(Logger.NULL_LOGGER);
     rules = new RuleSet(context.placeholderRegistry());
   }
 
@@ -157,24 +149,19 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     this.fc = fc;
     this.oup = new OrderingUnifyPair(fc, context);
 
-    Writer logFileWriter = OutputStreamWriter.nullWriter();
-    if (context.log()) {
-      try {
-        logFileWriter = new FileWriter(System.getProperty("user.dir") + "/logFiles/" + "Thread");
-        logFileWriter.write("");
-      } catch (IOException e) {
-        System.err.println("log-File nicht vorhanden");
-      }
-    }
-    this.context = context.newWithLogFile(logFileWriter);
-
+    this.context = (context.logger() instanceof ServerTaskLogger) ? context : context.newWithLogger(
+      Logger.forFile(
+        System.getProperty("user.dir") + "/logFiles/" + "Thread",
+        "Unify"
+      )
+    );
 
     /*Abbruchtest
     if (thNo > 10) {
-      System.out.println("cancel");
+      context.logger().info("cancel");
       usedTasks.cancel();
       writeLog(nOfUnify.toString() + "cancel");
-      System.out.println("cancel");
+      context.logger().info("cancel");
       try {
         logFile.write("Abbruch");
       }
@@ -183,7 +170,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       }
     }
     */
-    rules = new RuleSet(context.logFile(), context.placeholderRegistry());
+    rules = new RuleSet(context.logger(), context.placeholderRegistry());
     this.rekTiefeField = rekTiefe;
     context.usedTasks().add(this);
   }
@@ -220,17 +207,10 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 		}		
 }
 */
-  void myCancel(Boolean b) {
-    myIsCanceled = true;
-  }
-
-  public boolean myIsCancelled() {
-    return myIsCanceled;
-  }
 
   public CompletableFuture<Set<Set<UnifyPair>>> compute() {
     if (one) {
-      System.out.println("two");
+      context.logger().info("two");
     }
     one = true;
     Set<UnifyPair> neweq = new HashSet<>(eq);
@@ -247,11 +227,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       .collect(Collectors.toCollection(ArrayList::new));
     var unifyFuture = unify(neweq, remainingOderconstraints, fc, context.parallel(), rekTiefeField, methodSignatureConstraint);
     return unifyFuture.thenApply(res -> {
-      try {
-        context.logFile().close();
-      } catch (IOException ioE) {
-        System.err.println("no log-File");
-      }
+      context.logger().close();
       if (isUndefinedPairSetSet(res)) {
         //fuer debug-Zwecke
         ArrayList<ArrayList<UnifyPair>> al = res.stream()
@@ -260,7 +236,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         throw new TypeinferenceException("Unresolved constraints: " + res, new NullToken()); //return new HashSet<>();
       }
 
-      if (this.myIsCancelled()) {
+      if (this.isExecutionCancelled()) {
         return new HashSet<>();
       }
 
@@ -292,19 +268,19 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     //		).collect(Collectors.toCollection(HashSet::new));
     //writeLog(nOfUnify.toString() + " AA: " + aas.toString());
     //if (aas.isEmpty()) {
-    //	System.out.println("");
+    //	context.logger().info("");
     //}
 
     //.collect(Collectors.toCollection(HashSet::new)));
 
-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
       return CompletableFuture.completedFuture(new HashSet<>());
     }
 
     rekTiefe++;
     nOfUnify++;
-    writeLog(nOfUnify.toString() + " Unifikation: " + eq.toString());
-    writeLog(nOfUnify.toString() + " Oderconstraints: " + oderConstraints.toString());
+    context.logger().debug(() -> nOfUnify + " Unifikation: " + eq.toString());
+    context.logger().debug(() -> nOfUnify + " Oderconstraints: " + oderConstraints.toString());
 
     /*
      * Variancen auf alle Gleichungen vererben
@@ -326,15 +302,10 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     /*
      * Occurs-Check durchfuehren
      */
-    Set<UnifyPair> ocurrPairs = eq.stream().filter(x -> {
-        UnifyType lhs, rhs;
-        return (lhs = x.getLhsType()) instanceof PlaceholderType
-          && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-          && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-      })
-      .peek(UnifyPair::setUndefinedPair)
-      .collect(Collectors.toCollection(HashSet::new));
-    writeLog("ocurrPairs: " + ocurrPairs);
+    Set<UnifyPair> ocurrPairs = TypeUnifyTaskHelper.occursCheck(eq);
+
+    Set<UnifyPair> finalOcurrPairs = ocurrPairs;
+    context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs);
     if (!ocurrPairs.isEmpty()) {
       Set<Set<UnifyPair>> ret = new HashSet<>();
       ret.add(ocurrPairs);
@@ -355,15 +326,9 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       /* In commit dfd91b5f8b7fca1cb5f302eec4b0ba3330271c9b eingefuegt ANFANG */
       Set<UnifyPair> occurcheck = new HashSet<>(eq0);
       occurcheck.removeAll(eq0Prime);
-      ocurrPairs = occurcheck.stream().filter(x -> {
-          UnifyType lhs, rhs;
-          return (lhs = x.getLhsType()) instanceof PlaceholderType
-            && !((rhs = x.getRhsType()) instanceof PlaceholderType)
-            && rhs.getTypeParams().occurs((PlaceholderType) lhs);
-        })
-        .peek(UnifyPair::setUndefinedPair)
-        .collect(Collectors.toCollection(HashSet::new));
-      writeLog("ocurrPairs: " + ocurrPairs);
+      ocurrPairs = TypeUnifyTaskHelper.occursCheck(occurcheck);
+      Set<UnifyPair> finalOcurrPairs1 = ocurrPairs;
+      context.logger().debug(() -> "ocurrPairs: " + finalOcurrPairs1);
       if (!ocurrPairs.isEmpty()) {
         Set<Set<UnifyPair>> ret = new HashSet<>();
         ret.add(ocurrPairs);
@@ -375,8 +340,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     eq0.forEach(UnifyPair::disableCondWildcards);
 
-    writeLog(nOfUnify.toString() + " Unifikation nach applyTypeUnificationRules: " + eq.toString());
-    writeLog(nOfUnify.toString() + " Oderconstraints nach applyTypeUnificationRules: " + oderConstraints.toString());
+    context.logger().debug(() ->nOfUnify + " Unifikation nach applyTypeUnificationRules: " + eq.toString());
+    context.logger().debug(() -> nOfUnify + " Oderconstraints nach applyTypeUnificationRules: " + oderConstraints.toString());
 
     /*
      * Step 2 and 3: Create a subset eq1s of pairs where both sides are TPH and eq2s of the other pairs
@@ -396,7 +361,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     // cartesian product of the sets created by pattern matching.
     List<Set<? extends Set<UnifyPair>>> topLevelSets = new ArrayList<>();
 
-    //System.out.println(eq2s);
+    //context.logger().info(eq2s);
 
     if (!eq1s.isEmpty()) { // Do not add empty sets or the cartesian product will always be empty.
       Set<Set<UnifyPair>> wrap = new HashSet<>();
@@ -420,7 +385,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     // Sets that originate from pair pattern matching
     // Sets of the "second level"
     Set<UnifyPair> undefinedPairs = new HashSet<>();
-    if (printtag) System.out.println("eq2s " + eq2s);
+    if (printtag) context.logger().info("eq2s " + eq2s);
     //writeLog("BufferSet: " + bufferSet.toString()+"\n");
     List<Set<Constraint<UnifyPair>>> oderConstraintsOutput = new ArrayList<>();//new ArrayList<>(oderConstraints);
     Set<Set<Set<? extends Set<UnifyPair>>>> secondLevelSets = calculatePairSets(eq2s, oderConstraints, fc, undefinedPairs, oderConstraintsOutput);
@@ -428,21 +393,21 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     //nicht ausgewertet Faculty Beispiel im 1. Schritt
     //PL 2017-10-03 geloest, muesste noch mit FCs mit kleineren
     //Typen getestet werden.
-    writeLog(nOfUnify.toString() + " Oderconstraints2: " + oderConstraintsOutput.toString());
-    if (printtag) System.out.println("secondLevelSets:" + secondLevelSets);
+    context.logger().debug(() -> nOfUnify + " Oderconstraints2: " + oderConstraintsOutput.toString());
+    if (printtag) context.logger().info("secondLevelSets:" + secondLevelSets);
     // If pairs occured that did not match one of the cartesian product cases,
     // those pairs are contradictory and the unification is impossible.
     if (!undefinedPairs.isEmpty()) {
       noUndefPair++;
       for (UnifyPair up : undefinedPairs) {
-        writeLog(noUndefPair.toString() + " UndefinedPairs; " + up);
-        writeLog("BasePair; " + up.getBasePair());
+        context.logger().debug(() -> noUndefPair + " UndefinedPairs; " + up);
+        context.logger().debug(() -> "BasePair; " + up.getBasePair());
       }
       Set<Set<UnifyPair>> error = new HashSet<>();
       undefinedPairs = undefinedPairs.stream().peek(UnifyPair::setUndefinedPair)
         .collect(Collectors.toCollection(HashSet::new));
       error.add(undefinedPairs);
-      undefinedPairs.forEach(x -> writeLog("AllSubst: " + x.getAllSubstitutions().toString()));
+      undefinedPairs.forEach(x -> context.logger().debug(() -> "AllSubst: " + x.getAllSubstitutions().toString()));
       return CompletableFuture.completedFuture(error);
     }
 
@@ -452,16 +417,16 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     // Alternative: Sub cartesian products of the second level (pattern matched) sets
     // "the big (x)"
 		/* for(Set<Set<Set<UnifyPair>>> secondLevelSet : secondLevelSets) {
-			//System.out.println("secondLevelSet "+secondLevelSet.size());
+			//context.logger().info("secondLevelSet "+secondLevelSet.size());
 			List<Set<Set<UnifyPair>>> secondLevelSetList = new ArrayList<>(secondLevelSet);
 			Set<List<Set<UnifyPair>>> cartResult = setOps.cartesianProduct(secondLevelSetList);
-			//System.out.println("CardResult: "+cartResult.size());
+			//context.logger().info("CardResult: "+cartResult.size());
 			// Flatten and add to top level sets
 			Set<Set<UnifyPair>> flat = new HashSet<>();
 			int j = 0;
 			for(List<Set<UnifyPair>> s : cartResult) {
 				j++;
-				//System.out.println("s from CardResult: "+cartResult.size() + " " + j);
+				//context.logger().info("s from CardResult: "+cartResult.size() + " " + j);
 				Set<UnifyPair> flat1 = new HashSet<>();
 				for(Set<UnifyPair> s1 : s)
 					flat1.addAll(s1);
@@ -475,8 +440,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     for (Set<Set<? extends Set<UnifyPair>>> secondLevelSet : secondLevelSets) {
       topLevelSets.addAll(secondLevelSet);
     }
-    //System.out.println(topLevelSets);
-    //System.out.println();
+    //context.logger().info(topLevelSets);
+    //context.logger().info();
 
 
     //Aufruf von computeCartesianRecursive ANFANG
@@ -498,7 +463,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     //		.collect(Collectors.toCollection(HashSet::new));
     //Muss auskommentiert werden, wenn computeCartesianRecursive ENDE
 
-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
       return CompletableFuture.completedFuture(new HashSet<>());
     }
 
@@ -517,18 +482,18 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
      * Step 5: Substitution
      */
     //writeLog("vor Subst: " + eqPrime);
-    writeLog("vor Subst: " + oderConstraints);
+    context.logger().debug(() -> "vor Subst: " + oderConstraints);
     String ocString = oderConstraints.toString();
     List<Set<Constraint<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);
+      context.logger().debug(() -> "nach Subst: " + newOderConstraints);
 
 
     {// sequentiell (Step 6b is included)
-      if (printtag) System.out.println("nextStep: " + eqPrimePrime);
+      if (printtag) context.logger().info("nextStep: " + eqPrimePrime);
       if (eqPrime.equals(eq) && eqPrimePrime.isEmpty()
         && oderConstraints.isEmpty()) {                    //PL 2017-09-29 //(!eqPrimePrime.isPresent()) auskommentiert und durch
         //PL 2017-09-29 dies ersetzt //(!eqPrimePrime.isPresent())
@@ -547,12 +512,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
           return eqPrimePrimeSet;
         });
         if (finalresult && isSolvedForm(eqPrime)) {
-          writeLog("eqPrime:" + eqPrime.toString() + "\n");
+          context.logger().debug(() -> "eqPrime:" + eqPrime.toString() + "\n");
 
           /* methodconstraintsets werden zum Ergebnis hinzugefuegt
            * Anfang
            */
-          //System.out.println("methodSignatureConstraint Return: " + methodSignatureConstraint + "\n");
+          //context.logger().info("methodSignatureConstraint Return: " + methodSignatureConstraint + "\n");
           eqPrimePrimeSetFuture = eqPrimePrimeSetFuture.thenApply(eqPrimePrimeSet -> {
             eqPrimePrimeSet.forEach(x -> x.addAll(methodSignatureConstraint));
 
@@ -603,7 +568,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     return eqPrimePrimeSetFuture.thenApply(eqPrimePrimeSet -> {
       eqPrimePrimeSet = eqPrimePrimeSet.stream().filter(x -> isSolvedForm(x) || this.isUndefinedPairSet(x)).collect(Collectors.toCollection(HashSet::new));
       if (!eqPrimePrimeSet.isEmpty() && !isUndefinedPairSetSet(eqPrimePrimeSet)) {
-        writeLog("Result1 " + eqPrimePrimeSet);
+        Set<Set<UnifyPair>> finalEqPrimePrimeSet = eqPrimePrimeSet;
+        context.logger().debug(() -> "Result1 " + finalEqPrimePrimeSet);
       }
       return eqPrimePrimeSet;
     });
@@ -675,7 +641,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     } else {
       //Varianz-Bestimmung Oder-Constraints
       if (printtag) {
-        System.out.println("nextSetasList " + nextSetAsList);
+        context.logger().info("nextSetasList " + nextSetAsList);
       }
       variance = TypeUnifyTaskHelper.calculateOderConstraintVariance(nextSetAsList);
     }
@@ -691,14 +657,16 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
      */
     Set<UnifyPair> sameEqSet = new HashSet<>();
     //optOrigPair enthaelt ggf. das Paar a = ty \in  nextSet
-    Optional<UnifyPair> optOrigPair = Optional.empty();
+    Optional<UnifyPair> optOrigPair;
     if (!oderConstraint) {
       optOrigPair = TypeUnifyTaskHelper.findEqualityConstrainedUnifyPair(nextSetElement);
-      writeLog("optOrigPair: " + optOrigPair);
+      context.logger().debug(() -> "optOrigPair: " + optOrigPair);
 
       if (optOrigPair.isPresent()) {
         sameEqSet = TypeUnifyTaskHelper.findConstraintsWithSameTVAssociation(optOrigPair.get(), singleElementSets);
       }
+    } else {
+      optOrigPair = Optional.empty();
     }
 
 
@@ -708,7 +676,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     return resultFuture.thenApply(result -> {
       //2020-02-02: if (variance ==2) Hier Aufruf von filterOverriding einfuegen
-      writeLog("Return computeCR: " + result.toString());
+      context.logger().debug(() ->"Return computeCR: " + result.toString());
       return result;
     });
   }
@@ -735,23 +703,23 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     VarianceCase varianceCase = VarianceCase.createFromVariance(variance, oderConstraint, this, context);
 
-    writeLog("nextSet: " + nextSet.toString());
-    writeLog("nextSetasList: " + prevNextSetAsList.toString());
+    context.logger().debug(() -> "nextSet: " + nextSet.toString());
+    context.logger().debug(() -> "nextSetasList: " + prevNextSetAsList.toString());
 
     varianceCase.selectNextData(this, prevNextSetAsList, optOrigPair);
 
     if (oderConstraint) {//Methodconstraints werden abgespeichert für die Bytecodegenerierung von Methodenaufrufen
       methodSignatureConstraint.addAll(((Constraint<UnifyPair>) varianceCase.a).getmethodSignatureConstraint());
-      writeLog("ERSTELLUNG methodSignatureConstraint: " + methodSignatureConstraint);
-      //System.out.println("ERSTELLUNG methodSignatureConstraint: " +noOfThread+" "+methodSignatureConstraint);
-      //System.out.println("a: " +a);
-      //System.out.println("eq: " +eq);
-      //System.out.println();
+      context.logger().debug(() -> "ERSTELLUNG methodSignatureConstraint: " + methodSignatureConstraint);
+      //context.logger().info("ERSTELLUNG methodSignatureConstraint: " +noOfThread+" "+methodSignatureConstraint);
+      //context.logger().info("a: " +a);
+      //context.logger().info("eq: " +eq);
+      //context.logger().info();
     }
 
     i++;
     Set<Set<UnifyPair>> elems = new HashSet<>(singleElementSets);
-    writeLog("a1: " + rekTiefe + "  " + "variance:  " + variance + " " + varianceCase.a.toString() + "\n");
+    context.logger().debug(() -> "a1: " + rekTiefe + "  " + "variance:  " + variance + " " + varianceCase.a.toString() + "\n");
 
     Set<Set<UnifyPair>> aParDef = new HashSet<>();
 
@@ -772,7 +740,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     // Ergebnisvariable für die parallele Verabeitung: Tupel aus
     // - forkOrig result : currentThreadResult (frueher "res")
     // - fork results : forkResults (frueher "add_res")
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> parallelResultDataFuture;
+    CompletableFuture<VarianceCase.ComputationResults> parallelResultDataFuture;
+
 
     if (parallel) {
       parallelResultDataFuture = varianceCase.computeParallel(
@@ -783,13 +752,16 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       // same as variance = 0
       elems.add(varianceCase.a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
       parallelResultDataFuture =  this.unify2(elems, eq, oderConstraints, fc, false, rekTiefe, new HashSet<>(methodSignatureConstraint))
-        .thenApply(currentThreadResult -> new Tuple<>(currentThreadResult, new HashSet<>()));
+        .thenApply(VarianceCase.ComputationResults::new);
     }
 
+    if (this.isExecutionCancelled()) {
+      return CompletableFuture.completedFuture(new HashSet<>());
+    }
 
     return parallelResultDataFuture.thenCompose(parallelResultData -> {
-      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.getFirst();
-      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.getSecond();
+      Set<Set<UnifyPair>> currentThreadResult = parallelResultData.mainResult;
+      Set<Set<Set<UnifyPair>>> forkResults = parallelResultData.forkResults;
 
       Set<Set<UnifyPair>> result = prevResult;
       List<Set<UnifyPair>> nextSetAsList = prevNextSetAsList;
@@ -798,7 +770,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       //Ab hier alle parallele Berechnungen wieder zusammengeführt.
       if (oderConstraint) {//Wenn weiteres Element nextSetasList genommen wird, muss die vorherige methodsignatur geloescht werden
         methodSignatureConstraint.removeAll(((Constraint<UnifyPair>) varianceCase.a).getmethodSignatureConstraint());
-        //System.out.println("REMOVE: " +methodSignatureConstraint);
+        //context.logger().info("REMOVE: " +methodSignatureConstraint);
       }
       if (!isUndefinedPairSetSet(currentThreadResult) && isUndefinedPairSetSet(result)) {
         //wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
@@ -816,16 +788,16 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
             //Alle Variablen bestimmen die nicht hinzugefügt wurden in a
             //PL 2018-12-28: Hier gab es eine ClassCastException, war nicht reproduzierbar
-            // System.out.println("");
+            // context.logger().info("");
             List<PlaceholderType> vars_a = TypeUnifyTaskHelper.extractMatchingPlaceholderTypes(varianceCase.a);
             Set<UnifyPair> fstElemRes = currentThreadResult.iterator().next();
             Set<UnifyPair> compRes = fstElemRes.stream().filter(x -> vars_a.contains(((PlaceholderType) x.getLhsType()))).collect(Collectors.toCollection(HashSet::new));
 
             //Alle Variablen bestimmen die nicht hinzugefügt wurden in a_last
-            //System.out.println(a_last);
+            //context.logger().info(a_last);
 
             try {//PL eingefuegt 2019-03-06 da bei map mmer wieder Nullpointer kamen
-              a_last.forEach(x -> writeLog("a_last_elem:" + x + " basepair: " + x.getBasePair()));//PL 2019-05-13 ins try hinzugefuegt Nullpointer-Exception ist in der Zeile aufgetaucht.
+              a_last.forEach(x -> context.logger().debug(() -> "a_last_elem:" + x + " basepair: " + x.getBasePair()));//PL 2019-05-13 ins try hinzugefuegt Nullpointer-Exception ist in der Zeile aufgetaucht.
               List<PlaceholderType> varsLast_a = TypeUnifyTaskHelper.extractMatchingPlaceholderTypes(a_last);
               //[(java.util.Vector<java.lang.Integer> <. gen_aq, , 1), (CEK =. ? extends gen_aq, 1)] KANN VORKOMMEN
               //erstes Element genügt, da vars immer auf die gleichen Elemente zugeordnet werden muessen
@@ -834,11 +806,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
               varianceCase.applyComputedResults(result, currentThreadResult, compResult, compRes);
             } catch (NullPointerException e) {
-              writeLog("NullPointerException: " + a_last.toString());
+              context.logger().debug(() -> "NullPointerException: " + a_last.toString());
             }
           } else {
             //alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
-            writeLog("RES Fst: result: " + result.toString() + " currentThreadResult: " + currentThreadResult.toString());
+            Set<Set<UnifyPair>> finalResult = result;
+            context.logger().debug(() -> "RES Fst: result: " + finalResult.toString() + " currentThreadResult: " + currentThreadResult.toString());
             result.addAll(currentThreadResult);
           }
         }
@@ -856,14 +829,15 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             //wenn korrektes Ergebnis gefunden alle Fehlerfaelle loeschen
             result = par_res;
             if (!par_res.isEmpty() && par_res.iterator().next() instanceof WildcardType) {
-              // System.out.println();
+              // context.logger().info();
             }
           } else {
             if ((isUndefinedPairSetSet(par_res) && isUndefinedPairSetSet(result))
               || (!isUndefinedPairSetSet(par_res) && !isUndefinedPairSetSet(result))
               || result.isEmpty()) {
               //alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
-              writeLog("RES var1 ADD:" + result.toString() + " " + par_res.toString());
+              Set<Set<UnifyPair>> finalResult1 = result;
+              context.logger().debug(() ->"RES var1 ADD:" + finalResult1.toString() + " " + par_res.toString());
               result.addAll(par_res);
             }
           }
@@ -884,15 +858,15 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         // Iterator<Set<UnifyPair>> nextSetasListIt = new ArrayList<>(nextSetAsList).iterator();
         boolean shouldBreak = varianceCase.eraseInvalidSets(rekTiefe, aParDef, nextSetAsList);
         if (shouldBreak) {
+          // this.cancelYoungerSiblingTasks();
           return CompletableFuture.completedFuture(result);
         }
 
-        writeLog("a: " + rekTiefe + " variance: " + variance + varianceCase.a.toString());
+        context.logger().debug(() -> "a: " + rekTiefe + " variance: " + variance + varianceCase.a.toString());
       }
       /* auskommentiert um alle Max und min Betrachtung auszuschalten ENDE */
 
       if (isUndefinedPairSetSet(currentThreadResult) && aParDef.isEmpty()) {
-        int nofstred = 0;
         Set<UnifyPair> abhSubst = TypeUnifyTaskHelper.collectFromThreadResult(currentThreadResult, UnifyPair::getAllSubstitutions);
         abhSubst.addAll(
           TypeUnifyTaskHelper.collectFromThreadResult(currentThreadResult, UnifyPair::getThisAndAllBases)
@@ -922,9 +896,10 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         */
 
         if (currentThreadResult.size() > 1) {
-          // System.out.println();
+          // context.logger().info();
         }
-        writeLog("nextSetasList vor filter-Aufruf: " + nextSetAsList);
+        List<Set<UnifyPair>> finalNextSetAsList = nextSetAsList;
+        context.logger().debug(() -> "nextSetasList vor filter-Aufruf: " + finalNextSetAsList);
         if (!oderConstraint) {//PL 2023-02-08 eingefuegt: Bei oderconstraints sind Subststitutionen nicht als Substitutionen in idesem Sinne zu sehen
           nextSetAsList = nextSetAsList.stream().filter(x -> {
               //Boolean ret = false;
@@ -935,24 +910,29 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             })//.filter(y -> couldBecorrect(reducedUndefResSubstGroundedBasePair, y)) //fuer testzwecke auskommentiert um nofstred zu bestimmen PL 2018-10-10
             .collect(Collectors.toCollection(ArrayList::new));
         }
-        writeLog("nextSetasList nach filter-Aufruf: " + nextSetAsList);
-        nofstred = nextSetAsList.size();
+
+        if (context.logger().isLogLevelActive(Logger.LogLevel.DEBUG)) {
+          List<Set<UnifyPair>> finalNextSetAsList1 = nextSetAsList;
+          context.logger().debug(() -> "nextSetasList nach filter-Aufruf: " + finalNextSetAsList1);
+          int nofstred = nextSetAsList.size();
           //NOCH NICHT korrekt PL 2018-10-12
           //nextSetasList = nextSetasList.stream().filter(y -> couldBecorrect(reducedUndefResSubstGroundedBasePair, y))
           //			.collect(Collectors.toCollection(ArrayList::new));
-        writeLog("currentThreadResult (undef): " + currentThreadResult.toString());
-        writeLog("abhSubst: " + abhSubst.toString());
-        writeLog("a2: " + rekTiefe + " " + varianceCase.a.toString());
-        writeLog("Durchschnitt: " + durchschnitt.toString());
-        writeLog("nextSet: " + nextSet.toString());
-        writeLog("nextSetasList: " + nextSetAsList.toString());
-        writeLog("Number first erased Elements (undef): " + (len - nofstred));
-        writeLog("Number second erased Elements (undef): " + (nofstred - nextSetAsList.size()));
-        writeLog("Number erased Elements (undef): " + (len - nextSetAsList.size()));
+          context.logger().debug("currentThreadResult (undef): " + currentThreadResult.toString());
+          context.logger().debug("abhSubst: " + abhSubst.toString());
+          context.logger().debug("a2: " + rekTiefe + " " + varianceCase.a.toString());
+          context.logger().debug("Durchschnitt: " + durchschnitt.toString());
+          context.logger().debug("nextSet: " + nextSet.toString());
+          context.logger().debug("nextSetasList: " + nextSetAsList.toString());
+          context.logger().debug("Number first erased Elements (undef): " + (len - nofstred));
+          context.logger().debug("Number second erased Elements (undef): " + (nofstred - nextSetAsList.size()));
+          context.logger().debug("Number erased Elements (undef): " + (len - nextSetAsList.size()));
           noAllErasedElements += (len - nextSetAsList.size());
-        writeLog("Number of all erased Elements (undef): " + noAllErasedElements.toString());
-        writeLog("Number of Backtracking: " + noBacktracking++);
-        // System.out.println("");
+          context.logger().debug("Number of all erased Elements (undef): " + noAllErasedElements);
+          context.logger().debug("Number of Backtracking: " + noBacktracking++);
+        }
+
+        // context.logger().info("");
       }
       //if (nextSetasList.size() == 0 && isUndefinedPairSetSet(result) && nextSet.size() > 1) {
       //	return result;
@@ -961,7 +941,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       //	result.removeIf(y -> isUndefinedPairSet(y));
       //}
       //else result.stream().filter(y -> !isUndefinedPairSet(y));
-      writeLog("currentThreadResult: " + currentThreadResult.toString());
+      context.logger().debug(() -> "currentThreadResult: " + currentThreadResult.toString());
 
       return this.innerCartesianLoop(variance, rekTiefe, oderConstraint, parallel, result, varianceCase.a, nextSet,
         nextSetAsList, optOrigPair, methodSignatureConstraint, singleElementSets, sameEqSet, oderConstraints);
@@ -978,7 +958,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
    *                  the error constraints. Error constraints are added
    * @result contradiction of (a = ty) in sameEqSet
    */
-  public Boolean checkNoContradiction(Set<UnifyPair> a, Set<UnifyPair> sameEqSet, Set<Set<UnifyPair>> result) {
+  public boolean checkNoContradiction(Set<UnifyPair> a, Set<UnifyPair> sameEqSet, Set<Set<UnifyPair>> result) {
 
     //optAPair enthaelt ggf. das Paar a = ty' \in a
     //unterscheidet sich von optOrigPair, da dort a = ty
@@ -998,7 +978,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       UnifyPair aPair = optAPair.get();
       //writeLog("optOrigPair: " + optOrigPair + " " + "aPair: " + aPair+ " " + "aPair.basePair(): " + aPair.getBasePair());
 
-      writeLog("checkA: " + aPair + "sameEqSet: " + sameEqSet);
+      context.logger().debug(() ->"checkA: " + aPair + "sameEqSet: " + sameEqSet);
       for (UnifyPair sameEq : sameEqSet) {
         if (sameEq.getLhsType() instanceof PlaceholderType) {
           Set<UnifyPair> localEq = new HashSet<>();
@@ -1019,7 +999,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             if (result.isEmpty() || isUndefinedPairSetSet(result)) {
               result.addAll(localRes);
             }
-            writeLog("FALSE: " + aPair + "sameEqSet: " + sameEqSet);
+            context.logger().debug(() ->"FALSE: " + aPair + "sameEqSet: " + sameEqSet);
             return false;
           }
         } else {
@@ -1041,12 +1021,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             if (result.isEmpty() || isUndefinedPairSetSet(result)) {
               result.addAll(localRes);
             }
-            writeLog("FALSE: " + aPair + "sameEqSet: " + sameEqSet);
+            context.logger().debug(() ->"FALSE: " + aPair + "sameEqSet: " + sameEqSet);
             return false;
           }
         }
       }
-      writeLog("TRUE: " + aPair + "sameEqSet: " + sameEqSet);
+      context.logger().debug(() ->"TRUE: " + aPair + "sameEqSet: " + sameEqSet);
       return true;
     }
     return true;
@@ -1132,7 +1112,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             // Through application of the rules, every pair should have one of the above forms.
             // Pairs that do not have one of the aboves form are contradictory.
             else {
-              writeLog("Second erase:" + checkPair);
+              context.logger().debug(() ->"Second erase:" + checkPair);
               return false;
             }
             //*/
@@ -1331,7 +1311,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
    * (as in case 1 where sigma is added to the innermost set).
    */
   protected Set<Set<Set<? extends Set<UnifyPair>>>> calculatePairSets(Set<UnifyPair> eq2s, List<Set<Constraint<UnifyPair>>> oderConstraintsInput, IFiniteClosure fc, Set<UnifyPair> undefined, List<Set<Constraint<UnifyPair>>> oderConstraintsOutput) {
-    writeLog("eq2s: " + eq2s.toString());
+    context.logger().debug(() ->"eq2s: " + eq2s.toString());
     oderConstraintsOutput.addAll(oderConstraintsInput);
     List<Set<Set<? extends Set<UnifyPair>>>> result = new ArrayList<>(9);
 
@@ -1418,10 +1398,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       }
     }
 
-    writeLog("eq2s: " + eq2s);
-    writeLog("eq2sAsListFst: " + eq2sAsListFst);
-    writeLog("eq2sAsListSnd: " + eq2sAsListSnd);
-    writeLog("eq2sAsListBack: " + eq2sAsListBack);
+    if (context.logger().isLogLevelActive(Logger.LogLevel.DEBUG)) {
+      context.logger().debug("eq2s: " + eq2s);
+      context.logger().debug("eq2sAsListFst: " + eq2sAsListFst);
+      context.logger().debug("eq2sAsListSnd: " + eq2sAsListSnd);
+      context.logger().debug("eq2sAsListBack: " + eq2sAsListBack);
+    }
 
     eq2sAsList.addAll(eq2sAsListFst);
     eq2sAsList.addAll(eq2sAsListSnd);
@@ -1434,7 +1416,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       if (!oderConstraintsOutput.isEmpty()) {
         Set<Constraint<UnifyPair>> ret = oderConstraintsOutput.removeFirst();
         //if (ret.iterator().next().iterator().next().getLhsType().getName().equals("M"))
-        //	System.out.println("M");
+        //	context.logger().info("M");
         //Set<UnifyPair> retFlat = new HashSet<>();
         //ret.stream().forEach(x -> retFlat.addAll(x));
 
@@ -1474,7 +1456,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
       // Case 1: (a <. Theta')
       if (((pairOp == PairOperator.SMALLERDOT) || (pairOp == PairOperator.SMALLERNEQDOT)) && lhsType instanceof PlaceholderType) {
-        //System.out.println(pair);
+        //context.logger().info(pair);
         if (first) { //writeLog(pair.toString()+"\n");
           Set<Set<UnifyPair>> x1 = new HashSet<>();
           if (pair.getRhsType().getName().equals("void")) {
@@ -1496,7 +1478,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             x1.remove(remElem);
           }
 					/* ZU LOESCHEN ANFANG
-				//System.out.println(x1);
+				//context.logger().info(x1);
 					Set<UnifyPair> sameEqSet = eq2sAsList.stream()
 							  .filter(x -> ((x.getLhsType().equals(lhsType) || x.getRhsType().equals(lhsType)) && !x.equals(pair)))
 							  .collect(Collectors.toCollection(HashSet::new));
@@ -1714,11 +1696,11 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     //		&& ((ReferenceType)thetaPrime).getTypeParams().iterator().next() instanceof PlaceholderType) //.getName().equals("java.util.Vector"))
     //		&& ((ReferenceType)((ReferenceType)thetaPrime).getTypeParams().iterator().next()).getTypeParams().iterator().next().getName().equals("java.lang.Integer")) {
     //		{
-    //		System.out.println("");
+    //		context.logger().info("");
     //}
     Set<UnifyType> cs = fc.getAllTypesByName(thetaPrime.getName());//cs= [java.util.Vector<NP>, java.util.Vector<java.util.Vector<java.lang.Integer>>, ????java.util.Vector<gen_hv>???]
 
-    writeLog("cs: " + cs.toString());
+    context.logger().debug(() ->"cs: " + cs.toString());
     //PL 18-02-06 entfernt, kommt durch unify wieder rein
     //cs.add(thetaPrime);
     //PL 18-02-06 entfernt
@@ -1729,8 +1711,9 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         aa.putAll(b);
         return aa;
       };
-      HashMap<PlaceholderType, PlaceholderType> hm = x.getInvolvedPlaceholderTypes().stream()
-        .reduce(new HashMap<PlaceholderType, PlaceholderType>(),
+      var involvedPlaceholderTypes = x.getInvolvedPlaceholderTypes();
+      HashMap<PlaceholderType, PlaceholderType> hm = involvedPlaceholderTypes.stream()
+        .reduce(TypeUnifyTaskHelper.getPresizedHashMap(involvedPlaceholderTypes.size()),
           (aa, b) -> {
             aa.put(b, PlaceholderType.freshPlaceholder(context.placeholderRegistry()));
             return aa;
@@ -1750,7 +1733,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       if ((match.match(ml)).isEmpty()) {
         thetaQs.remove(c);
       }
-      writeLog("thetaQs von " + c + ": " + thetaQs.toString());
+      Set<UnifyType> finalThetaQs = thetaQs;
+      context.logger().debug(() ->"thetaQs von " + c + ": " + finalThetaQs.toString());
       //Set<UnifyType> thetaQs = fc.getChildren(c).stream().collect(Collectors.toCollection(HashSet::new));
       //thetaQs.add(thetaPrime); //PL 18-02-05 wieder geloescht
       //PL 2017-10-03: War auskommentiert habe ich wieder einkommentiert,
@@ -1774,7 +1758,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         for (TypeParams tp : permuteParams(candidateParams))
           thetaQPrimes.add(c.setTypeParams(tp));
       }
-      writeLog("thetaQPrimes von " + c + ": " + thetaQPrimes.toString());
+      context.logger().debug(() ->"thetaQPrimes von " + c + ": " + thetaQPrimes.toString());
       for (UnifyType tqp : thetaQPrimes) {//PL 2020-03-08 umbauen in der Schleife wird nur unifizierbarer Typ gesucht break am Ende
         Collection<PlaceholderType> tphs = tqp.getInvolvedPlaceholderTypes();
         Optional<Unifier> opt = stdUnify.unify(tqp, thetaPrime);
@@ -1847,7 +1831,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         }
       }
     }
-    writeLog("result von " + pair + ": " + result);
+    context.logger().debug(() ->"result von " + pair + ": " + result);
     return result;
   }
 
@@ -1958,7 +1942,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
           return ((match.match(termList).isPresent()) || x);
         };
         //if (parai.getName().equals("java.lang.Integer")) {
-        //	System.out.println("");
+        //	context.logger().info("");
         //}
         BinaryOperator<Boolean> bo = (x, y) -> (x || y);
         if (fBounded.stream().reduce(false, f, bo)) {
@@ -2048,22 +2032,4 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       permuteParams(candidates, idx + 1, result, current);
     }
   }
-
-  public void writeLog(String str) {
-    if (context.log() && finalresult) {
-      synchronized (context.logFile()) {
-        try {
-					/*
-					logFile.write("Thread no.:" + thNo + "\n");
-					logFile.write("noOfThread:" + noOfThread + "\n");
-					logFile.write("parallel:" + parallel + "\n");
-					 */
-          context.logFile().write(str + "\n\n");
-          // logFile.flush();
-        } catch (IOException e) {
-          System.err.println("kein LogFile");
-        }
-      }
-    }
-  }
 }

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

@@ -5,6 +5,7 @@ import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
@@ -185,4 +186,36 @@ public class TypeUnifyTaskHelper {
       .collect(Collectors.toCollection(ArrayList::new));
   }
 
+
+  public static Set<UnifyPair> occursCheck(final Set<UnifyPair> eq) {
+    Set<UnifyPair> ocurrPairs = new HashSet<>(eq.size());
+    for (UnifyPair x : eq) {
+      UnifyType lhs = x.getLhsType();
+      UnifyType rhs = x.getRhsType();
+      if (lhs instanceof PlaceholderType lhsPlaceholder &&
+        !(rhs instanceof PlaceholderType) &&
+        rhs.getTypeParams().occurs(lhsPlaceholder))
+      {
+        x.setUndefinedPair();
+        ocurrPairs.add(x);
+      }
+    }
+    return ocurrPairs;
+  }
+
+
+  public static <T> HashSet<T> getPresizedHashSet(int minElements) {
+    if (minElements < 16) return new HashSet<>();
+    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
+    int n = (int)(minElements * 1.5);
+    return new HashSet<>(n);
+  }
+
+  public static <S,T> HashMap<S,T> getPresizedHashMap(int minElements) {
+    if (minElements < 16) return new HashMap<>();
+    // HashSet and HashMap will resize at 75% load, so we account for that by multiplying with 1.5
+    int n = (int)(minElements * 1.5);
+    return new HashMap<>(n);
+  }
+
 }

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

@@ -1,17 +1,15 @@
 package de.dhbwstuttgart.typeinference.unify;
 
+import de.dhbwstuttgart.util.Logger;
 import java.io.Writer;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public record UnifyContext(
-  // main log file of a unification
-  Writer logFile,
-  // if logs should be made
-  Boolean log,
+  // main logger of a unification
+  Logger logger,
   // if the unify algorithm should run in parallel
-  Boolean parallel,
+  boolean parallel,
   // the model for storing calculated results
   UnifyResultModel resultModel,
   // the executor used for thread management in parallel execution
@@ -23,26 +21,24 @@ public record UnifyContext(
 ) {
 
   public UnifyContext(
-    Writer logFile,
-    Boolean log,
-    Boolean parallel,
+    Logger logger,
+    boolean parallel,
     UnifyResultModel resultModel,
     UnifyTaskModel usedTasks,
     ExecutorService executor,
     PlaceholderRegistry placeholderRegistry
   ) {
-    this(logFile, log, parallel, resultModel, executor, placeholderRegistry, usedTasks);
+    this(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
   }
 
   public UnifyContext(
-    Writer logFile,
-    Boolean log,
-    Boolean parallel,
+    Logger logger,
+    boolean parallel,
     UnifyResultModel resultModel,
     UnifyTaskModel usedTasks,
     PlaceholderRegistry placeholderRegistry
   ) {
-    this(logFile, log, parallel, resultModel, usedTasks, ForkJoinPool.commonPool(), placeholderRegistry);
+    this(logger, parallel, resultModel, usedTasks, ForkJoinPool.commonPool(), placeholderRegistry);
   }
 
 
@@ -51,20 +47,21 @@ public record UnifyContext(
    * causes the UnifyContext to be essentially handled as a
    */
 
-  public UnifyContext newWithLogFile(Writer logFile) {
-    return new UnifyContext(logFile, log, parallel, resultModel, executor, placeholderRegistry, usedTasks);
+  public UnifyContext newWithLogger(Logger logger) {
+    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
   }
 
   public UnifyContext newWithParallel(boolean parallel) {
-    return new UnifyContext(logFile, log, parallel, resultModel, executor, placeholderRegistry, usedTasks);
+    if (this.parallel == parallel) return this;
+    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
   }
 
   public UnifyContext newWithExecutor(ExecutorService executor) {
-    return new UnifyContext(logFile, log, parallel, resultModel, executor, placeholderRegistry, usedTasks);
+    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
   }
 
   public UnifyContext newWithResultModel(UnifyResultModel resultModel) {
-    return new UnifyContext(logFile, log, parallel, resultModel, executor, placeholderRegistry, usedTasks);
+    return new UnifyContext(logger, parallel, resultModel, executor, placeholderRegistry, usedTasks);
   }
 
 }

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

@@ -12,7 +12,7 @@ public class UnifyTaskModel {
     
     public synchronized void cancel() {
     	for(TypeUnifyTask t : usedTasks) {
-    		t.myCancel(true);
+    		t.cancelExecution();
     	}
     }
 }

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/ContravarianceCase.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
 
-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -17,11 +16,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
-public class Variance1Case extends VarianceCase {
+public class ContravarianceCase extends VarianceCase {
 
   protected final int variance = 1;
 
-  protected Variance1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected ContravarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
     super(isOderConstraint, typeUnifyTask, context);
   }
 
@@ -32,12 +31,12 @@ public class Variance1Case extends VarianceCase {
     Optional<UnifyPair> optOrigPair
   ) {
     a = typeUnifyTask.oup.max(nextSetAsList.iterator());
-    writeLog("Max: a in " + variance + " " + a);
+    context.logger().debug("Max: a in " + variance + " " + a);
     nextSetAsList.remove(a);
     if (this.isOderConstraint) {
       nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
     }
-    writeLog("nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);
+    context.logger().debug(() -> "nextSetasListOderConstraints 1: " + nextSetasListOderConstraints);
 
     //Alle maximale Elemente in nextSetasListRest bestimmen
     //nur für diese wird parallele Berechnung angestossen.
@@ -49,7 +48,7 @@ public class Variance1Case extends VarianceCase {
 
 
   @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
     Set<Set<UnifyPair>> elems,
     Set<UnifyPair> eq,
     List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -61,10 +60,6 @@ public class Variance1Case extends VarianceCase {
     Set<Set<UnifyPair>> result,
     Set<Set<UnifyPair>> aParDef
   ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
-      new HashSet<>(), new HashSet<>()
-    ));
-
     Set<UnifyPair> newEqOrig = new HashSet<>(eq);
     Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
     List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -72,27 +67,28 @@ public class Variance1Case extends VarianceCase {
 
     /* FORK ANFANG */
     TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
+    typeUnifyTask.addChildTask(forkOrig);
     // schedule compute() on another thread
     CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValues = resultValues.thenCombine(forkOrigFuture,
-      (prevResults, currentThreadResult) -> {
-        forkOrig.writeLog("final Orig 1");
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
+      (currentThreadResult) -> {
+        forkOrig.context.logger().debug("final Orig 1");
         forkOrig.closeLogFile();
-        return new Tuple<>(currentThreadResult, prevResults.getSecond());
+        return new ComputationResults(currentThreadResult);
       });
 
     //forks.add(forkOrig);
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return CompletableFuture.completedFuture(new ComputationResults());
     }
     /* FORK ENDE */
 
-    writeLog("a in " + variance + " " + a);
-    writeLog("nextSetasListRest: " + nextSetasListRest.toString());
+    context.logger().debug("a in " + variance + " " + a);
+    context.logger().debug("nextSetasListRest: " + nextSetasListRest.toString());
     while (!nextSetasListRest.isEmpty()) {
       Set<UnifyPair> nSaL = nextSetasListRest.removeFirst();
       nextSetAsList.remove(nSaL);
-      writeLog("1 RM" + nSaL.toString());
+      context.logger().debug("1 RM" + nSaL.toString());
 
       if (!this.isOderConstraint) {
         //ueberpruefung ob zu a =. ty \in nSaL in sameEqSet ein Widerspruch besteht
@@ -108,27 +104,28 @@ public class Variance1Case extends VarianceCase {
       List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
       newElems.add(nSaL);
       TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+      typeUnifyTask.addChildTask(fork);
       // schedule compute() on another thread
       CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
       resultValues = resultValues.thenCombine(forkFuture,
         (prevResults, fork_res) -> {
-          if (typeUnifyTask.myIsCancelled()) {
-            throw new UnifyCancelException();
+          if (typeUnifyTask.isExecutionCancelled()) {
+            return new ComputationResults();
           }
-          writeLog("fork_res: " + fork_res.toString());
-          writeLog(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.getSecond().add(fork_res);
+          context.logger().debug("fork_res: " + fork_res.toString());
+          context.logger().debug(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
+          prevResults.addForkResult(fork_res);
           if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
             aParDef.add(fork.getNextSetElement());
           }
-          fork.writeLog("final 1");
+          fork.context.logger().debug("final 1");
           fork.closeLogFile();
         return prevResults;
         }
       );
 
-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return CompletableFuture.completedFuture(new ComputationResults());
       }
     }
 
@@ -144,7 +141,7 @@ public class Variance1Case extends VarianceCase {
   ) {
     int resOfCompare = typeUnifyTask.oup.compare(compResult, compRes);
     if (resOfCompare == -1) {
-      writeLog("Geloescht result: " + result);
+      context.logger().debug("Geloescht result: " + result);
       result.clear();
       result.addAll(currentThreadResult);
     }
@@ -152,7 +149,7 @@ public class Variance1Case extends VarianceCase {
       result.addAll(currentThreadResult);
     }
     else if (resOfCompare == 1) {
-      writeLog("Geloescht currentThreadResult: " + currentThreadResult);
+      context.logger().debug("Geloescht currentThreadResult: " + currentThreadResult);
       //result = result;
     }
   }
@@ -163,35 +160,35 @@ public class Variance1Case extends VarianceCase {
     Set<Set<UnifyPair>> aParDef,
     List<Set<UnifyPair>> nextSetAsList
   ) {
-    // System.out.println("");
-    writeLog("a: " + rekTiefe + " variance: " + variance + a.toString());
-    writeLog("aParDef: " + aParDef.toString());
+    // context.logger().info("");
+    context.logger().debug("a: " + rekTiefe + " variance: " + variance + a.toString());
+    context.logger().debug("aParDef: " + aParDef.toString());
     aParDef.add(a);
     Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
     if (this.isOderConstraint) {
       nextSetAsList.removeAll(nextSetasListOderConstraints);
       nextSetasListOderConstraints = new ArrayList<>();
-      writeLog("Removed: " + nextSetasListOderConstraints);
+      context.logger().debug("Removed: " + nextSetasListOderConstraints);
       while (aParDefIt.hasNext()) {
         Set<UnifyPair> a_new = aParDefIt.next();
         List<Set<UnifyPair>> smallerSetasList = typeUnifyTask.oup.smallerThan(a_new, nextSetAsList);
-        writeLog("smallerSetasList: " + smallerSetasList);
+        context.logger().debug("smallerSetasList: " + smallerSetasList);
         List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
           .filter(x -> !((Constraint<UnifyPair>) x).isInherited() && !((Constraint<UnifyPair>) x).isImplemented())
           .collect(Collectors.toCollection(ArrayList::new));
-        writeLog("notInherited: " + notInherited + "\n");
+        context.logger().debug("notInherited: " + notInherited + "\n");
         List<Set<UnifyPair>> notErased = new ArrayList<>();
         notInherited.forEach(x -> {
           notErased.addAll(typeUnifyTask.oup.smallerEqThan(x, smallerSetasList));
         });
         List<Set<UnifyPair>> erased = new ArrayList<>(smallerSetasList);
-        writeLog("notErased: " + notErased + "\n");
+        context.logger().debug("notErased: " + notErased + "\n");
         erased.removeAll(notErased);
         nextSetAsList.removeAll(erased);
 
-        writeLog("Removed: " + erased);
+        context.logger().debug("Removed: " + erased);
 
-        writeLog("Not Removed: " + nextSetAsList);
+        context.logger().debug("Not Removed: " + nextSetAsList);
 
       }
     } else {
@@ -201,9 +198,9 @@ public class Variance1Case extends VarianceCase {
         List<Set<UnifyPair>> erased = typeUnifyTask.oup.smallerEqThan(a_new, nextSetAsList);
         nextSetAsList.removeAll(erased);
 
-        writeLog("Removed: " + erased);
+        context.logger().debug("Removed: " + erased);
 
-        writeLog("Not Removed: " + nextSetAsList);
+        context.logger().debug("Not Removed: " + nextSetAsList);
       }
     }
 

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/CovarianceCase.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
 
-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -17,11 +16,11 @@ import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
-public class VarianceM1Case extends VarianceCase {
+public class CovarianceCase extends VarianceCase {
 
   protected final int variance = -1;
 
-  protected VarianceM1Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected CovarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
     super(isOderConstraint, typeUnifyTask, context);
   }
 
@@ -32,11 +31,11 @@ public class VarianceM1Case extends VarianceCase {
     Optional<UnifyPair> optOrigPair
   ) {
     a = typeUnifyTask.oup.min(nextSetAsList.iterator());
-    writeLog("Min: a in " + variance + " " + a);
+    context.logger().debug(() -> "Min: a in " + variance + " " + a);
     if (this.isOderConstraint) {
       nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
     }
-    writeLog("nextSetasListOderConstraints -1: " + nextSetasListOderConstraints);
+    context.logger().debug(() -> "nextSetasListOderConstraints -1: " + nextSetasListOderConstraints);
     nextSetAsList.remove(a);
 
     //Alle minimalen Elemente in nextSetasListRest bestimmen
@@ -49,7 +48,7 @@ public class VarianceM1Case extends VarianceCase {
 
 
   @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
     Set<Set<UnifyPair>> elems,
     Set<UnifyPair> eq,
     List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -61,10 +60,6 @@ public class VarianceM1Case extends VarianceCase {
     Set<Set<UnifyPair>> result,
     Set<Set<UnifyPair>> aParDef
   ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValues = CompletableFuture.completedFuture(new Tuple<>(
-      new HashSet<>(), new HashSet<>()
-    ));
-
     Set<UnifyPair> newEqOrig = new HashSet<>(eq);
     Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
     List<Set<Constraint<UnifyPair>>> newOderConstraintsOrig = new ArrayList<>(oderConstraints);
@@ -72,28 +67,29 @@ public class VarianceM1Case extends VarianceCase {
 
     /* FORK ANFANG */
     TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, methodSignatureConstraint);
+    typeUnifyTask.addChildTask(forkOrig);
     // schedule compute() on another thread
     CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValues = resultValues.thenCombine(forkOrigFuture,
-      (prevResults, currentThreadResult) -> {
-        forkOrig.writeLog("final Orig -1");
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply(
+      (currentThreadResult) -> {
+        forkOrig.context.logger().debug("final Orig -1");
         forkOrig.closeLogFile();
-        return new Tuple<>(currentThreadResult, prevResults.getSecond());
+        return new ComputationResults(currentThreadResult);
       });
 
     //forks.add(forkOrig);
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return resultValues;
     }
     /* FORK ENDE */
 
-    writeLog("a in " + variance + " " + a);
-    writeLog("nextSetasListRest: " + nextSetasListRest.toString());
+    context.logger().debug(() -> "a in " + variance + " " + a);
+    context.logger().debug(() -> "nextSetasListRest: " + nextSetasListRest.toString());
 
     while (!nextSetasListRest.isEmpty()) {
       Set<UnifyPair> nSaL = nextSetasListRest.removeFirst();
       nextSetAsList.remove(nSaL);
-      writeLog("-1 RM" + nSaL.toString());
+      context.logger().debug(() -> "-1 RM" + nSaL.toString());
 
       if (!this.isOderConstraint) {
         //ueberpruefung ob zu a =. ty \in nSaL in sameEqSet ein Widerspruch besteht
@@ -109,27 +105,28 @@ public class VarianceM1Case extends VarianceCase {
       List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
       newElems.add(nSaL);
       TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+      typeUnifyTask.addChildTask(fork);
       // schedule compute() on another thread
       CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
       resultValues = resultValues.thenCombine(forkFuture,
         (prevResults, fork_res) -> {
-          if (typeUnifyTask.myIsCancelled()) {
-            throw new UnifyCancelException();
+          if (typeUnifyTask.isExecutionCancelled()) {
+            return prevResults;
           }
-          writeLog("fork_res: " + fork_res.toString());
-          writeLog(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.getSecond().add(fork_res);
+          context.logger().debug(() -> "fork_res: " + fork_res.toString());
+          context.logger().debug(() -> Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
+          prevResults.addForkResult(fork_res);
           if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
             aParDef.add(fork.getNextSetElement());
           }
-          fork.writeLog("final -1");
+          fork.context.logger().debug("final -1");
           fork.closeLogFile();
         return prevResults;
         }
       );
 
-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return resultValues;
       }
     }
 
@@ -146,13 +143,13 @@ public class VarianceM1Case extends VarianceCase {
   ) {
     int resOfCompare = typeUnifyTask.oup.compare(compResult, compRes);
     if (resOfCompare == 1) {
-      writeLog("Geloescht result: " + result);
+      context.logger().debug(() -> "Geloescht result: " + result);
       result.clear();
       result.addAll(currentThreadResult);
     } else if (resOfCompare == 0) {
       result.addAll(currentThreadResult);
     } else if (resOfCompare == -1) {
-      writeLog("Geloescht currentThreadResult: " + currentThreadResult);
+      context.logger().debug(() -> "Geloescht currentThreadResult: " + currentThreadResult);
       //result = result;
     }
   }
@@ -164,14 +161,14 @@ public class VarianceM1Case extends VarianceCase {
     List<Set<UnifyPair>> nextSetAsList
   ) {
 
-    // System.out.println("");
-    writeLog("a: " + rekTiefe + " variance: " + variance + a.toString());
-    writeLog("aParDef: " + aParDef.toString());
+    // context.logger().info("");
+    context.logger().debug(() -> "a: " + rekTiefe + " variance: " + variance + a.toString());
+    context.logger().debug(() -> "aParDef: " + aParDef.toString());
     aParDef.add(a);
     Iterator<Set<UnifyPair>> aParDefIt = aParDef.iterator();
     if (this.isOderConstraint) {
       nextSetAsList.removeAll(nextSetasListOderConstraints);
-      writeLog("Removed: " + nextSetasListOderConstraints);
+      context.logger().debug(() -> "Removed: " + nextSetasListOderConstraints);
       nextSetasListOderConstraints = new ArrayList<>();
       while (aParDefIt.hasNext()) {
         Set<UnifyPair> a_new = aParDefIt.next();
@@ -204,9 +201,9 @@ public class VarianceM1Case extends VarianceCase {
         erased.removeAll(notErased);
         nextSetAsList.removeAll(erased);
 
-        writeLog("Removed: " + erased);
+        context.logger().debug(() -> "Removed: " + erased);
 
-        writeLog("Not Removed: " + nextSetAsList);
+        context.logger().debug(() -> "Not Removed: " + nextSetAsList);
 
       }
     } else {
@@ -217,9 +214,9 @@ public class VarianceM1Case extends VarianceCase {
 
         nextSetAsList.removeAll(erased);
 
-        writeLog("Removed: " + erased);
+        context.logger().debug(() -> "Removed: " + erased);
 
-        writeLog("Not Removed: " + nextSetAsList);
+        context.logger().debug(() -> "Not Removed: " + nextSetAsList);
       }
     }
 

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/InvarianceOrConstraintCase.java

@@ -1,6 +1,5 @@
 package de.dhbwstuttgart.typeinference.unify.cartesianproduct;
 
-import de.dhbwstuttgart.exceptions.UnifyCancelException;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.unify.TypeUnify2Task;
 import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
@@ -15,11 +14,12 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 
-public class Variance2Case extends VarianceCase {
+public class InvarianceOrConstraintCase extends VarianceCase {
 
+  // either for invariance or for oderConstraints
   protected final int variance = 2;
 
-  protected Variance2Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected InvarianceOrConstraintCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
     super(isOderConstraint, typeUnifyTask, context);
   }
 
@@ -37,7 +37,7 @@ public class Variance2Case extends VarianceCase {
 
 
   @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
     Set<Set<UnifyPair>> elems,
     Set<UnifyPair> eq,
     List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -49,9 +49,7 @@ public class Variance2Case extends VarianceCase {
     Set<Set<UnifyPair>> result,
     Set<Set<UnifyPair>> aParDef
   ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValuesFuture;
-
-    writeLog("var2einstieg");
+    context.logger().debug("var2einstieg");
     Set<TypeUnify2Task> forks = new HashSet<>();
     Set<UnifyPair> newEqOrig = new HashSet<>(eq);
     Set<Set<UnifyPair>> newElemsOrig = new HashSet<>(elems);
@@ -60,19 +58,21 @@ public class Variance2Case extends VarianceCase {
 
     /* FORK ANFANG */
     TypeUnify2Task forkOrig = new TypeUnify2Task(newElemsOrig, newEqOrig, newOderConstraintsOrig, a, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraint));
+    typeUnifyTask.addChildTask(forkOrig);
     CompletableFuture<Set<Set<UnifyPair>>> forkOrigFuture = CompletableFuture.supplyAsync(forkOrig::compute, context.executor()).thenCompose(f -> f);
-    resultValuesFuture = forkOrigFuture.thenApply((currentThreadResult) -> {
-      forkOrig.writeLog("final Orig 2");
+    CompletableFuture<ComputationResults> resultValues = forkOrigFuture.thenApply((currentThreadResult) -> {
+      forkOrig.context.logger().debug("final Orig 2");
       forkOrig.closeLogFile();
-      return new Tuple<>(currentThreadResult, new HashSet<>());
+      return new ComputationResults(currentThreadResult);
     });
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
+
+    if (typeUnifyTask.isExecutionCancelled()) {
+      return resultValues;
     }
     /* FORK ENDE */
 
-    writeLog("a in " + variance + " " + a);
-    writeLog("nextSetasListRest: " + nextSetasListRest.toString());
+    context.logger().debug(() -> "a in " + variance + " " + a);
+    context.logger().debug(() -> "nextSetasListRest: " + nextSetasListRest.toString());
 
     //Fuer parallele Berechnung der Oder-Contraints wird methodSignature kopiert
     //und jeweils die methodSignature von a bzw. nSaL wieder gelöscht, wenn es keine Lösung ist.
@@ -89,27 +89,24 @@ public class Variance2Case extends VarianceCase {
       List<Set<Constraint<UnifyPair>>> newOderConstraints = new ArrayList<>(oderConstraints);
       newElems.add(nSaL);
       TypeUnify2Task fork = new TypeUnify2Task(newElems, newEq, newOderConstraints, nSaL, fc, context, rekTiefe, new HashSet<>(methodSignatureConstraintForParallel));
+      typeUnifyTask.addChildTask(fork);
       CompletableFuture<Set<Set<UnifyPair>>> forkFuture = CompletableFuture.supplyAsync(fork::compute, context.executor()).thenCompose(f -> f);
-      resultValuesFuture = resultValuesFuture.thenCombine(forkFuture, (resultValues, fork_res) -> {
-        if (typeUnifyTask.myIsCancelled()) {
-          throw new UnifyCancelException();
+      resultValues = resultValues.thenCombine(forkFuture, (prevResults, fork_res) -> {
+        if (typeUnifyTask.isExecutionCancelled()) {
+          return prevResults;
         }
-        resultValues.getSecond().add(fork_res);
-        fork.writeLog("final 2");
+        prevResults.addForkResult(fork_res);
+        fork.context.logger().debug("final 2");
         fork.closeLogFile();
-        return resultValues;
+        return prevResults;
       });
 
-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return resultValues;
       }
     }
 
-    if (typeUnifyTask.myIsCancelled()) {
-      throw new UnifyCancelException();
-    }
-
-    return resultValuesFuture;
+    return resultValues;
   }
 
   @Override

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/UnknownVarianceCase.java

@@ -13,14 +13,13 @@ import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 
-public class Variance0Case extends VarianceCase {
+public class UnknownVarianceCase extends VarianceCase {
 
   protected final int variance = 0;
 
-  protected Variance0Case(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
+  protected UnknownVarianceCase(boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
     super(isOderConstraint, typeUnifyTask, context);
   }
 
@@ -50,7 +49,7 @@ public class Variance0Case extends VarianceCase {
   }
 
   @Override
-  public CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public CompletableFuture<ComputationResults> computeParallel(
     Set<Set<UnifyPair>> elems,
     Set<UnifyPair> eq,
     List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -62,10 +61,9 @@ public class Variance0Case extends VarianceCase {
     Set<Set<UnifyPair>> result,
     Set<Set<UnifyPair>> aParDef
   ) {
-    elems.add(a); //PL 2019-01-16 muss das wirklich hin steht schon in Zeile 859 ja braucht man siehe Zeile 859
-    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint)).thenApply(
-      unify2Result -> new Tuple<>(unify2Result, new HashSet<>())
-    );
+    elems.add(a);
+    return typeUnifyTask.unify2(elems, eq, oderConstraints, fc, context.parallel(), rekTiefe, new HashSet<>(methodSignatureConstraint))
+      .thenApply(ComputationResults::new);
   }
 
   @Override
@@ -75,7 +73,7 @@ public class Variance0Case extends VarianceCase {
     Set<UnifyPair> compResult,
     Set<UnifyPair> compRes
   ) {
-    writeLog("RES var=1 ADD:" + result.toString() + " " + currentThreadResult.toString());
+    context.logger().debug("RES var=0 ADD:" + result.toString() + " " + currentThreadResult.toString());
     result.addAll(currentThreadResult);
   }
 
@@ -90,7 +88,7 @@ public class Variance0Case extends VarianceCase {
     } else {
       nextSetAsList.removeAll(nextSetasListOderConstraints);
       nextSetasListOderConstraints = new ArrayList<>();
-      writeLog("Removed: " + nextSetasListOderConstraints);
+      context.logger().debug("Removed: " + nextSetasListOderConstraints);
       List<Set<UnifyPair>> smallerSetasList = typeUnifyTask.oup.smallerThan(a, nextSetAsList);
       List<Set<UnifyPair>> notInherited = smallerSetasList.stream()
         .filter(x -> !((Constraint<UnifyPair>) x).isInherited())
@@ -101,9 +99,9 @@ public class Variance0Case extends VarianceCase {
       erased.removeAll(notErased);
       nextSetAsList.removeAll(erased);
 
-      writeLog("Removed: " + erased);
+      context.logger().debug("Removed: " + erased);
 
-      writeLog("Not Removed: " + nextSetAsList);
+      context.logger().debug("Not Removed: " + nextSetAsList);
 
     }
     return false;

src/main/java/de/dhbwstuttgart/typeinference/unify/cartesianproduct/VarianceCase.java

@@ -5,9 +5,9 @@ import de.dhbwstuttgart.typeinference.unify.TypeUnifyTask;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
 import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import de.dhbwstuttgart.util.Logger;
 import de.dhbwstuttgart.util.Tuple;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -17,10 +17,10 @@ public abstract class VarianceCase {
 
   public static VarianceCase createFromVariance(int variance, boolean isOderConstraint, TypeUnifyTask typeUnifyTask, UnifyContext context) {
     return switch (variance) {
-      case 0 -> new Variance0Case(isOderConstraint, typeUnifyTask, context);
-      case 1 -> new Variance1Case(isOderConstraint, typeUnifyTask, context);
-      case -1 -> new VarianceM1Case(isOderConstraint, typeUnifyTask, context);
-      case 2 -> new Variance2Case(isOderConstraint, typeUnifyTask, context);
+      case 0    -> new UnknownVarianceCase(isOderConstraint, typeUnifyTask, context);
+      case 1    -> new ContravarianceCase(isOderConstraint, typeUnifyTask, context);
+      case -1   -> new CovarianceCase(isOderConstraint, typeUnifyTask, context);
+      case 2    -> new InvarianceOrConstraintCase(isOderConstraint, typeUnifyTask, context);
       default   -> throw new RuntimeException("Invalid variance: " + variance);
     };
   }
@@ -72,7 +72,7 @@ public abstract class VarianceCase {
   /**
    *
    */
-  public abstract CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> computeParallel(
+  public abstract CompletableFuture<ComputationResults> computeParallel(
     Set<Set<UnifyPair>> elems,
     Set<UnifyPair> eq,
     List<Set<Constraint<UnifyPair>>> oderConstraints,
@@ -105,8 +105,28 @@ public abstract class VarianceCase {
     List<Set<UnifyPair>> nextSetAsList
   );
 
-  protected void writeLog(String s) {
-    typeUnifyTask.writeLog(s);
+  /**
+   * Wrapper class for the parallel computation results
+   */
+  public static class ComputationResults {
+    public Set<Set<UnifyPair>> mainResult;
+    public Set<Set<Set<UnifyPair>>> forkResults;
+
+    public ComputationResults() {
+      this(new HashSet<>(), new HashSet<>());
     }
 
+    public ComputationResults(Set<Set<UnifyPair>> mainResult) {
+      this(mainResult, new HashSet<>());
+    }
+
+    public ComputationResults(Set<Set<UnifyPair>> mainResult, Set<Set<Set<UnifyPair>>> forkResults) {
+      this.mainResult = mainResult;
+      this.forkResults = forkResults;
+    }
+
+    void addForkResult(Set<Set<UnifyPair>> forkResult) {
+      forkResults.add(forkResult);
+    }
+  }
 }

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

@@ -13,14 +13,11 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
 public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
 	
 	public static int inverseVariance(int variance) {
-		Integer ret = 0;
-		if (variance == 1) {
-		   ret = -1;
-		}
-		if (variance == -1) {
-			ret = 1;
-		}
-		return ret;
+		return switch (variance) {
+			case 1 -> -1;
+			case -1 -> 1;
+			default -> 0;
+		};
 	}
 
 
@@ -42,7 +39,7 @@ public class distributeVariance extends visitUnifyTypeVisitor<Integer> {
 		List<UnifyType> param = new ArrayList<>(funnty.getTypeParams().get().length);
 		param.addAll(Arrays.asList(funnty.getTypeParams().get()));
 		UnifyType resultType = param.remove(param.size()-1);
-		Integer htInverse = inverseVariance(ht);
+		int htInverse = inverseVariance(ht);
 		param = param.stream()
 				     .map(x -> x.accept(this, htInverse))
 				     .collect(Collectors.toCollection(ArrayList::new));

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

@@ -24,9 +24,6 @@ public final class ExtendsType extends WildcardType implements ISerializableData
 	 */
 	public ExtendsType(UnifyType extendedType) {
 		super("? extends " + extendedType.getName(), extendedType);
-		if (extendedType instanceof ExtendsType) {
-			System.out.print("");
-		}
 	}
 
 	/**

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

@@ -1,13 +1,17 @@
 package de.dhbwstuttgart.typeinference.unify.model;
 
+import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.server.packet.dataContainers.ISerializableData;
 import de.dhbwstuttgart.server.packet.dataContainers.KeyStorage;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialList;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialMap;
 import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
+import de.dhbwstuttgart.typeinference.unify.TypeUnifyTaskHelper;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
+import de.dhbwstuttgart.util.Logger;
 import java.io.IOException;
 import java.io.Writer;
+import java.util.*;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -35,15 +39,16 @@ import org.antlr.v4.runtime.Token;
 
 /**
  * The finite closure for the type unification
+ *
  * @author Florian Steurer
  */
-public class FiniteClosure implements IFiniteClosure, ISerializableData {
+public class FiniteClosure //extends Ordering<UnifyType> //entfernt PL 2018-12-11
+        implements IFiniteClosure, ISerializableData {
 
     final JavaTXCompiler compiler;
     final PlaceholderRegistry placeholderRegistry;
 
-	Writer logFile;
-
+    Logger logger;
     /**
      * A map that maps every type to the node in the inheritance graph that contains that type.
      */
@@ -73,10 +78,10 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
     /**
      * Creates a new instance using the inheritance tree defined in the pairs.
      */
-	public FiniteClosure(Set<UnifyPair> pairs, Writer logFile, JavaTXCompiler compiler, PlaceholderRegistry placeholderRegistry) {
+    public FiniteClosure(Set<UnifyPair> pairs, Logger logger, JavaTXCompiler compiler, PlaceholderRegistry placeholderRegistry) {
       this.compiler = compiler;
       this.placeholderRegistry = placeholderRegistry;
-		this.logFile = logFile;
+      this.logger = logger;
       this.pairs = new HashSet<>(pairs);
       inheritanceGraph = new HashMap<UnifyType, Node<UnifyType>>();
 
@@ -93,7 +98,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
         }
         */
 
-			if(pair.getPairOp() != PairOperator.SMALLER)
+            if (pair.getPairOp() != PairOperator.SMALLER)
                 continue;
 
             //VERSUCH PL 18-02-06
@@ -102,11 +107,11 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
             //if (!pair.getLhsType().getTypeParams().arePlaceholders()
             //		&& !pair.getRhsType().getTypeParams().arePlaceholders())
             //	continue;
-;			
+            ;
             // Add nodes if not already in the graph
-			if(!inheritanceGraph.containsKey(pair.getLhsType()))
+            if (!inheritanceGraph.containsKey(pair.getLhsType()))
                 inheritanceGraph.put(pair.getLhsType(), new Node<UnifyType>(pair.getLhsType()));
-			if(!inheritanceGraph.containsKey(pair.getRhsType()))
+            if (!inheritanceGraph.containsKey(pair.getRhsType()))
                 inheritanceGraph.put(pair.getRhsType(), new Node<UnifyType>(pair.getRhsType()));
 
             Node<UnifyType> childNode = inheritanceGraph.get(pair.getLhsType());
@@ -120,12 +125,54 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
             childNode.getDescendants().stream().forEach(x -> x.addPredecessor(parentNode));
 
             //PL eingefuegt 2020-05-07 File UnitTest InheritTest.java
-			this.inheritanceGraph.forEach((x,y) -> { if (y.getDescendants().contains(parentNode)) { y.addDescendant(childNode); y.addAllDescendant(childNode.getDescendants());};
-													 if (y.getPredecessors().contains(childNode)) { y.addPredecessor(parentNode); y.addAllPredecessor(parentNode.getPredecessors());};} );
+            this.inheritanceGraph.forEach((x, y) -> {
+                if (y.getDescendants().contains(parentNode)) {
+                    y.addDescendant(childNode);
+                    y.addAllDescendant(childNode.getDescendants());
+                }
+                ;
+                if (y.getPredecessors().contains(childNode)) {
+                    y.addPredecessor(parentNode);
+                    y.addAllPredecessor(parentNode.getPredecessors());
+                }
+                ;
+            });
+        }
+
+        List<String> classesToKeep = (compiler == null) ? new ArrayList<>() :
+          new ArrayList<>(compiler.classRegistry.getAllClassNames().stream().map(JavaClassName::toString).toList());
+
+        classesToKeep.add("java.lang.Object");
+        classesToKeep.add("java.lang.Number");
+        classesToKeep.add("java.util.Collection");
+        classesToKeep.add("java.lang.Iterable");
+
+        //filter out all types not imported
+        Iterator<Map.Entry<UnifyType, Node<UnifyType>>> iterator = inheritanceGraph.entrySet().iterator();
+
+        while (iterator.hasNext()) {
+            Map.Entry<UnifyType, Node<UnifyType>> entry = iterator.next();
+            var name = entry.getKey().getName();
+
+            if (!classesToKeep.contains(name)) {
+                iterator.remove();
+            } else {
+                Node<UnifyType> node = entry.getValue();
+
+                // Remove unwanted predecessors
+                node.getPredecessors().removeIf(pred ->
+                        !classesToKeep.contains(pred.getContent().getName())
+                );
+
+                // Remove unwanted descendants
+                node.getDescendants().removeIf(desc ->
+                        !classesToKeep.contains(desc.getContent().getName())
+                );
+            }
         }
 
       // Build the alternative representation with strings as keys
-		strInheritanceGraph = new HashMap<>();
+      strInheritanceGraph = TypeUnifyTaskHelper.getPresizedHashMap(inheritanceGraph.size());
       for(UnifyType key : inheritanceGraph.keySet()) {
         if(!strInheritanceGraph.containsKey(key.getName()))
           strInheritanceGraph.put(key.getName(), new HashSet<>());
@@ -134,8 +181,8 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
       }
     }
 
-	public FiniteClosure(Set<UnifyPair> constraints, Writer writer, PlaceholderRegistry placeholderRegistry) {
-		this(constraints, writer, null, placeholderRegistry);
+    public FiniteClosure(Set<UnifyPair> constraints, Logger logger, PlaceholderRegistry placeholderRegistry) {
+      this(constraints, logger, null, placeholderRegistry);
     }
 
     void testSmaller() {
@@ -152,6 +199,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     /**
      * Returns all types of the finite closure that are subtypes of the argument.
+     *
      * @return The set of subtypes of the argument.
      */
     @Override
@@ -159,14 +207,14 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
         Set<UnifyType> ret;
         if ((ret = smallerHash.get(new hashKeyType(type))) != null) {
-			//System.out.println(greaterHash);
+            //context.logger().info(greaterHash);
             return new HashSet<>(ret);
         }
 
-		if(type instanceof FunNType)
+        if (type instanceof FunNType)
             return computeSmallerFunN((FunNType) type, fBounded);
 
-		Set<Pair<UnifyType,Set<UnifyType>>> ts = new HashSet<>();
+        Set<Pair<UnifyType, Set<UnifyType>>> ts = new HashSet<>();
         ts.add(new Pair<>(type, fBounded));
         Set<UnifyType> result = computeSmaller(ts);
         smallerHash.put(new hashKeyType(type), result);
@@ -198,34 +246,33 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
             // if T = T' then T <* T'
             try {
                 result.add(new Pair<>(t, fBounded));
-			}
-			catch (StackOverflowError e) {
-				// System.out.println("");
+            } catch (StackOverflowError e) {
+                //System.out.println("");
             }
 
             // if C<...> <* C<...> then ... (third case in definition of <*)
-			if(t.getTypeParams().size() > 0) {
+            if (t.getTypeParams().size() > 0) {
                 ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
                 for (int i = 0; i < t.getTypeParams().size(); i++)
                     paramCandidates.add(smArg(t.getTypeParams().get(i), fBounded));
                 permuteParams(paramCandidates).forEach(x -> result.add(new Pair<>(t.setTypeParams(x), fBounded)));
             }
 
-			if(!strInheritanceGraph.containsKey(t.getName()))
+            if (!strInheritanceGraph.containsKey(t.getName()))
                 continue;
 
             // if T <* T' then sigma(T) <* sigma(T')
             Set<Node<UnifyType>> candidates = strInheritanceGraph.get(t.getName()); //cadidates= [???Node(java.util.Vector<java.util.Vector<java.lang.Integer>>)???
                                                                                    // , Node(java.util.Vector<gen_hv>)
                                                                                      //]
-			for(Node<UnifyType> candidate :  candidates) {
+            for (Node<UnifyType> candidate :  candidates) {
                 UnifyType theta2 = candidate.getContent();
                 //PL 18-02-05 Unifier durch Matcher ersetzt ANFANG
-				ArrayList<UnifyPair> termList= new ArrayList<UnifyPair>();
-				termList.add(new UnifyPair(theta2,t, PairOperator.EQUALSDOT));
+                ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
+                termList.add(new UnifyPair(theta2, t, PairOperator.EQUALSDOT));
                 Optional<Unifier> optSigma = match.match(termList);
                 //PL 18-02-05 Unifier durch Matcher ersetzt ENDE
-				if(!optSigma.isPresent())
+                if (optSigma.isEmpty())
                     continue;
 
                 Unifier sigma = optSigma.get();
@@ -233,13 +280,13 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
                 Set<UnifyType> theta1Set = candidate.getContentOfDescendants();
 
-				for(UnifyType theta1 : theta1Set)
+                for (UnifyType theta1 : theta1Set)
                     result.add(new Pair<>(theta1.apply(sigma), fBounded));
             }
         }
 
         HashSet<UnifyType> resut = result.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new));
-		if(resut.equals(types.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new))))
+        if (resut.equals(types.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new))))
             return resut;
         return computeSmaller(result);
     }
@@ -271,26 +318,26 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
       @Override
       //Eingefuegt PL 2018-05-24 F-Bounded Problematik
       public Set<UnifyType> greater(UnifyType type, Set<UnifyType> fBounded, SourceLoc location) {
-		Set<UnifyType> ret;
-		if ((ret = greaterHash.get(new hashKeyType(type))) != null) {
-			//System.out.println(greaterHash);
+        Set<UnifyType> ret = greaterHash.get(new hashKeyType(type));
+        if (ret != null) {
+            //context.logger().info(greaterHash);
             return new HashSet<>(ret);
         }
 
 
-		if(type instanceof FunNType) {
+        if (type instanceof FunNType) {
             return computeGreaterFunN((FunNType) type, fBounded);
         }
 
         Set<UnifyType> result = new HashSet<>();
-		Set<Pair<UnifyType,Set<UnifyType>>> PairResultFBounded = new HashSet<>();
+        Set<Pair<UnifyType, Set<UnifyType>>> PairResultFBounded = new HashSet<>();
 
         Match match = new Match();
 
 
         // if T = T' then T <=* T'
         result.add(type);
-		if(!strInheritanceGraph.containsKey(type.getName()))
+        if (!strInheritanceGraph.containsKey(type.getName()))
             return result;
 
         // if T <* T' then sigma(T) <* sigma(T')
@@ -306,15 +353,15 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
         }
         */
 
-		for(Node<UnifyType> candidate :  candidates) {
+        for (Node<UnifyType> candidate : candidates) {
             UnifyType theta1 = candidate.getContent();
 
             //PL 18-04-05 Unifier durch Matcher ersetzt ANFANG
-			ArrayList<UnifyPair> termList= new ArrayList<UnifyPair>();
-			termList.add(new UnifyPair(theta1,type, PairOperator.EQUALSDOT, location));
+            ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
+            termList.add(new UnifyPair(theta1, type, PairOperator.EQUALSDOT, location));
             Optional<Unifier> optSigma = match.match(termList);
             //PL 18-04-05 Unifier durch Matcher ersetzt ENDE
-			if(!optSigma.isPresent()) {
+            if (optSigma.isEmpty()) {
                 continue;
             }
             Unifier sigma = optSigma.get();
@@ -323,8 +370,8 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
             Set<UnifyType> fBoundedNew = new HashSet<>(fBounded);
             fBoundedNew.add(theta1);
             Set<UnifyType> theta2Set = candidate.getContentOfPredecessors();
-			//System.out.println("");
-			for(UnifyType theta2 : theta2Set) {
+            //context.logger().info("");
+            for (UnifyType theta2 : theta2Set) {
                 result.add(theta2.apply(sigma));
                 PairResultFBounded.add(new Pair<>(theta2.apply(sigma), fBoundedNew));
             }
@@ -344,33 +391,32 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
             // if C<...> <* C<...> then ... (third case in definition of <*)
             //TypeParams typeparams = t.getTypeParams();
-			if(t.getTypeParams().size() > 0) {
+            if (t.getTypeParams().size() > 0) {
                 ArrayList<Set<UnifyType>> paramCandidates = new ArrayList<>();
 
                 for (int i = 0; i < t.getTypeParams().size(); i++) {
                     //UnifyType parai = t.getTypeParams().get(i);
                     int i_ef = i;
-					BiFunction<Boolean,UnifyType,Boolean> f = (x,y) -> 
+                    BiFunction<Boolean, UnifyType, Boolean> f = (x, y) ->
                     {
                         ArrayList<UnifyPair> termList = new ArrayList<UnifyPair>();
                         termList.add(new UnifyPair(y,t.getTypeParams().get(i_ef), PairOperator.EQUALSDOT, location));
                         return ((match.match(termList).isPresent()) || x);
                     };
                     //if (parai.getName().equals("java.lang.Integer")) {
-					//	System.out.println("");
+                    //	context.logger().info("");
                     //}
                     BinaryOperator<Boolean> bo = (a,b) -> (a || b);
                     if (lfBounded.stream().reduce(false,f,bo)) {
                         //F-Bounded Endlosrekursion
                         HashSet<UnifyType> res = new HashSet<UnifyType>();
                         paramCandidates.add(res);
-					}
-					else {
+                    } else {
                         paramCandidates.add(grArg(t.getTypeParams().get(i), new HashSet<>(fBounded) ));
                     }
                 }
                 permuteParams(paramCandidates).forEach(x -> result.add(t.setTypeParams(x)));
-				//System.out.println("");
+                //context.logger().info("");
             }
         }
 
@@ -430,7 +476,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 					    return ((match.match(termList).isPresent()) || x);
 					};
 					if (parai.getName().equals("java.lang.Integer")) {
-						System.out.println("");
+						context.logger().info("");
 					}
 					BinaryOperator<Boolean> bo = (a,b) -> (a || b);
 					if (fBounded.stream().reduce(false,f,bo)) continue; //F-Bounded Endlosrekursion
@@ -469,7 +515,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 		}
 		
 		HashSet<UnifyType> resut = result.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new));
-		System.out.println(resut);
+		context.logger().info(resut);
 		if(resut.equals(types.stream().map(x -> x.getKey()).collect(Collectors.toCollection(HashSet::new))))
 			return resut;
 		return computeGreater(result);
@@ -506,34 +552,40 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
         Set<UnifyType> result = new HashSet<UnifyType>();
         result.add(type);
             smaller(type, fBounded).forEach(x -> result.add(new SuperType(x)));
-        greater(type,fBounded).forEach(x -> result.add(new ExtendsType(x)));
-		return result;
-	}
-	
-	@Override
-	public Set<UnifyType> grArg(FunNType type, Set<UnifyType> fBounded) {
-		Set<UnifyType> result = new HashSet<UnifyType>();
-		result.add(type);	
-        smaller(type, fBounded).forEach(x -> result.add(new SuperType(x)));
             greater(type, fBounded).forEach(x -> result.add(new ExtendsType(x)));
         return result;
     }
 	
     @Override
-	public Set<UnifyType> grArg(ExtendsType type, Set<UnifyType> fBounded) {
-		Set<UnifyType> result = new HashSet<UnifyType>();
+    public Set<UnifyType> grArg(FunNType type, Set<UnifyType> fBounded) {
+        Set<UnifyType> smaller = smaller(type, fBounded);
+        Set<UnifyType> greater = greater(type, fBounded);
+        Set<UnifyType> result = TypeUnifyTaskHelper.getPresizedHashSet(1 + smaller.size() + greater.size());
         result.add(type);
+        smaller.forEach(x -> result.add(new SuperType(x)));
+        greater.forEach(x -> result.add(new ExtendsType(x)));
+        return result;
+    }
+	
+    @Override
+    public Set<UnifyType> grArg(ExtendsType type, Set<UnifyType> fBounded) {
         UnifyType t = type.getExtendedType();
-		greater(t, fBounded).forEach(x -> result.add(new ExtendsType(x)));
+        Set<UnifyType> greater = greater(t, fBounded);
+
+        Set<UnifyType> result = TypeUnifyTaskHelper.getPresizedHashSet(1 + greater.size());
+        result.add(type);
+        greater.forEach(x -> result.add(new ExtendsType(x)));
         return result;
     }
 
     @Override
     public Set<UnifyType> grArg(SuperType type, Set<UnifyType> fBounded) {
-		Set<UnifyType> result = new HashSet<UnifyType>();
-		result.add(type);
       UnifyType t = type.getSuperedType();
-		smaller(t, fBounded).forEach(x -> result.add(new SuperType(x)));
+      Set<UnifyType> smaller = smaller(t, fBounded);
+
+      Set<UnifyType> result = TypeUnifyTaskHelper.getPresizedHashSet(1 + smaller.size());
+      result.add(type);
+      smaller.forEach(x -> result.add(new SuperType(x)));
       return result;
     }
 	
@@ -565,11 +617,13 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 	
     @Override
     public Set<UnifyType> smArg(ExtendsType type, Set<UnifyType> fBounded) {
-		Set<UnifyType> result = new HashSet<UnifyType>();
-		result.add(type);
         UnifyType t = type.getExtendedType();
+        Set<UnifyType> smaller = smaller(t, fBounded);
+
+        Set<UnifyType> result = TypeUnifyTaskHelper.getPresizedHashSet(2 * (1 + smaller.size()));
+        result.add(type);
         result.add(t);
-        smaller(t, fBounded).forEach(x -> { 
+        smaller.forEach(x -> {
             result.add(new ExtendsType(x));
             result.add(x);
         });
@@ -579,12 +633,14 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     @Override
     public Set<UnifyType> smArg(SuperType type, Set<UnifyType> fBounded) {
-		Set<UnifyType> result = new HashSet<UnifyType>();
-		result.add(type);
         UnifyType t = type.getSuperedType();
+        Set<UnifyType> greater = greater(t, fBounded);
+
+        Set<UnifyType> result = TypeUnifyTaskHelper.getPresizedHashSet(2 * (1 + greater.size()));
+        result.add(type);
         result.add(t);
-//*** ACHTUNG das koennte FALSCH sein PL 2018-05-23 evtl. HashSet durch smArg durchschleifen	
-        greater(t, fBounded).forEach(x -> { 
+        //*** ACHTUNG das koennte FALSCH sein PL 2018-05-23 evtl. HashSet durch smArg durchschleifen
+        greater.forEach(x -> {
             result.add(new SuperType(x));
             result.add(x);
         });
@@ -600,18 +656,18 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 	
     @Override
     public Set<UnifyType> getAllTypesByName(String typeName) {
-		if(!strInheritanceGraph.containsKey(typeName))
+        if (!strInheritanceGraph.containsKey(typeName))
             return new HashSet<>();
         return strInheritanceGraph.get(typeName).stream().map(x -> x.getContent()).collect(Collectors.toCollection(HashSet::new));
     }
 
     @Override
     public Optional<UnifyType> getLeftHandedType(String typeName) {
-		if(!strInheritanceGraph.containsKey(typeName))
+        if (!strInheritanceGraph.containsKey(typeName))
             return Optional.empty();
 
-		for(UnifyPair pair : pairs)
-			if(pair.getLhsType().getName().equals(typeName) && pair.getLhsType().typeParams.arePlaceholders())
+        for (UnifyPair pair : pairs)
+            if (pair.getLhsType().getName().equals(typeName) && pair.getLhsType().typeParams.arePlaceholders())
                 return Optional.of(pair.getLhsType());
 
         return Optional.empty();
@@ -619,11 +675,11 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     @Override
     public Optional<UnifyType> getRightHandedFunctionalInterfaceType(String typeName) {
-		if(!strInheritanceGraph.containsKey(typeName))
+        if (!strInheritanceGraph.containsKey(typeName))
             return Optional.empty();
 
-		for(UnifyPair pair : pairs)
-			if(pair.getRhsType().getName().equals(typeName))
+        for (UnifyPair pair : pairs)
+            if (pair.getRhsType().getName().equals(typeName))
                 return Optional.of(pair.getRhsType());
 
         return Optional.empty();
@@ -631,7 +687,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     @Override
     public Set<UnifyType> getAncestors(UnifyType t) {
-		if(!inheritanceGraph.containsKey(t))
+        if (!inheritanceGraph.containsKey(t))
             return new HashSet<>();
         Set<UnifyType> result = inheritanceGraph.get(t).getContentOfPredecessors();
         result.add(t);
@@ -640,7 +696,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     @Override
     public Set<UnifyType> getChildren(UnifyType t) {
-		if(!inheritanceGraph.containsKey(t))
+        if (!inheritanceGraph.containsKey(t))
             return new HashSet<>();
         Set<UnifyType> result = inheritanceGraph.get(t).getContentOfDescendants();
         result.add(t);
@@ -649,6 +705,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     /**
      * Takes a set of candidates for each position and computes all possible permutations.
+     *
      * @param candidates The length of the list determines the number of type params. Each set
      *                   contains the candidates for the corresponding position.
      */
@@ -660,6 +717,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 
     /**
      * Takes a set of candidates for each position and computes all possible permutations.
+     *
      * @param candidates The length of the list determines the number of type params. Each set
      *                   contains the candidates for the corresponding position.
      * @param idx        Idx for the current permutatiton.
@@ -667,21 +725,21 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
      * @param current    The permutation of type params that is currently explored
      */
     protected void permuteParams(ArrayList<Set<UnifyType>> candidates, int idx, Set<TypeParams> result, UnifyType[] current) {
-		if(candidates.size() == idx) {
+        if (candidates.size() == idx) {
             result.add(new TypeParams(Arrays.copyOf(current, current.length)));
             return;
         }
 
         Set<UnifyType> localCandidates = candidates.get(idx);
 
-		for(UnifyType t : localCandidates) {
+        for (UnifyType t : localCandidates) {
             current[idx] = t;
-			permuteParams(candidates, idx+1, result, current);
+            permuteParams(candidates, idx + 1, result, current);
         }
     }
 
     @Override
-	public String toString(){
+    public String toString() {
         return this.inheritanceGraph.toString();
     }
 	
@@ -692,9 +750,10 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
 	*/
 	
     public int compare (UnifyType left, UnifyType right, PairOperator pairop, UnifyContext context) {
-		try {logFile.write("left: "+ left + " right: " + right + " pairop: " + pairop +"\n");} catch (IOException ie) {}
-		// if (left.getName().equals("Matrix") || right.getName().equals("Matrix"))
-		// 	System.out.println("");
+        logger.debug(() -> "left: " + left + " right: " + right + " pairop: " + pairop +"\n");
+        //if (left.getName().equals("Matrix") || right.getName().equals("Matrix"))
+        //    context.logger().info("");
+
         /*
         pairop = PairOperator.SMALLERDOTWC;
         List<UnifyType> al = new ArrayList<>();
@@ -726,21 +785,19 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
         UnifyType ex;
         if (left instanceof PlaceholderType) {
             if ((right instanceof WildcardType)
-						&& ((ex = ((WildcardType)right).wildcardedType) instanceof PlaceholderType)
-						&& ((PlaceholderType)left).getName().equals(((PlaceholderType)ex).getName())) {// a <.? ? extends a oder a <.? ? super a
+                && ((ex = ((WildcardType) right).wildcardedType) instanceof PlaceholderType)
+                && ((PlaceholderType) left).getName().equals(((PlaceholderType) ex).getName())) {// a <.? ? extends a oder a <.? ? super a
                 return -1;
-				}
-				else {
+            } else {
                 return 0;
             }
         }
         if (right instanceof PlaceholderType) {//&& (left instanceof WildcardType)) {PL geloescht 2019-01-15 analog zu oben
           if ((left instanceof WildcardType) //PL eingefuegt 2019-01-15 analog zu oben
               && ((ex = ((WildcardType)left).wildcardedType) instanceof PlaceholderType)
-					&& ((PlaceholderType)right).getName().equals(((PlaceholderType)ex).getName())) {// ? extends a <. a oder ? super a <. a
+              && ((PlaceholderType)right).getName().equals(((PlaceholderType) ex).getName())) {// ? extends a <. a oder ? super a <. a
               return 1;
-			}
-			else {
+          } else {
               return 0;
           }
         }
@@ -751,26 +808,17 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
         Set<UnifyPair> smallerRes = unifyTask.applyTypeUnificationRules(hs, this);
 
         //if (left.getName().equals("Vector") || right.getName().equals("AbstractList"))
-		{try { 
-			logFile.write("\nsmallerRes: " + smallerRes);//"smallerHash: " + greaterHash.toString());
-			// logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no LogFile");}}
+        logger.debug(() -> "\nsmallerRes: " + smallerRes); //"smallerHash: " + greaterHash.toString());
 
         //Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok.
         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()))
+                               ((WildcardType) x.getLhsType()).getWildcardedType().equals(x.getRhsType()))
                            );
         long smallerLen = smallerRes.stream().filter(delFun).count();
-		try { 
-			logFile.write("\nsmallerLen: " + smallerLen +"\n");
-			// logFile.flush();
-		}
-		catch (IOException e) {
-			System.err.println("no LogFile");}
+        logger.debug(() -> "\nsmallerLen: " + smallerLen + "\n");
+
         if (smallerLen == 0) return -1;
         else {
             up = new UnifyPair(right, left, pairop);
@@ -780,12 +828,7 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
             Set<UnifyPair> greaterRes = unifyTask.applyTypeUnificationRules(hs, this);
 
             //if (left.getName().equals("Vector") || right.getName().equals("AbstractList"))
-			{try { 
-				logFile.write("\ngreaterRes: " + greaterRes);//"smallerHash: " + greaterHash.toString());
-				// logFile.flush();
-			}
-			catch (IOException e) {
-				System.err.println("no LogFile");}}
+            logger.debug(() -> "\ngreaterRes: " + greaterRes);//"smallerHash: " + greaterHash.toString());
 
             //Gleichungen der Form a <./=. Theta oder Theta <./=. a oder a <./=. b sind ok.
             long greaterLen = greaterRes.stream().filter(delFun).count();
@@ -807,7 +850,6 @@ public class FiniteClosure implements IFiniteClosure, ISerializableData {
       var pairList = data.getList("pairs").assertListOfUUIDs();
       Set<UnifyPair> pairs = pairList.stream()
         .map(pairData -> UnifyPair.fromSerial(pairData, context, keyStorage)).collect(Collectors.toSet());
-		return new FiniteClosure(pairs, context.logFile(), context.placeholderRegistry());
+      return new FiniteClosure(pairs, context.logger(), context.placeholderRegistry());
     }
-
 }

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

@@ -81,7 +81,7 @@ public class FunNType extends UnifyType implements ISerializableData {
 	}
 
 	@Override
-	public Boolean wrongWildcard() {
+	public boolean wrongWildcard() {
 		return (new ArrayList<UnifyType>(Arrays.asList(getTypeParams()
 				.get())).stream().filter(x -> (x instanceof WildcardType)).findFirst().isPresent());
 	}

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

@@ -48,12 +48,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOT, context);
 		}}
 		catch (ClassCastException e) {
-			try {
-			((FiniteClosure)fc).logFile.write("ClassCastException: " + left.toString() + " " + left.getGroundBasePair() + "\n\n");
-			 // ((FiniteClosure)fc).logFile.flush();
-			}
-			catch (IOException ie) {
-			}
+			((FiniteClosure)fc).logger.debug(() -> "ClassCastException: " + left.toString() + " " + left.getGroundBasePair() + "\n\n");
 			return -99;
 		}
 	}
@@ -61,7 +56,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 	/*
 	public int compareEq (UnifyPair left, UnifyPair right) {
 		if (left == null || right == null)
-			System.out.println("Fehler");
+			context.logger().info("Fehler");
 		if (left.getLhsType() instanceof PlaceholderType) {
 			return fc.compare(left.getRhsType(), right.getRhsType(), left.getPairOp());
 		}
@@ -82,12 +77,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
 						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
 				{
-					// System.out.println("");
+					// context.logger().info("");
 				}
 				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("");
+						// context.logger().info("");
 					}
 		}
 			else	 {
@@ -109,11 +104,11 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						&& (((ExtendsType)right).getExtendedType().getName().equals("java.util.Vector"))
 						&& (((ReferenceType)((ExtendsType)right).getExtendedType()).getTypeParams().iterator().next() instanceof ExtendsType)))
 				{
-					// System.out.println("");
+					// context.logger().info("");
 				}
 				if (right instanceof SuperType) 
 					{
-						// System.out.println("");
+						// context.logger().info("");
 					}
 			}
 				else	 {
@@ -176,83 +171,79 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		left.add(p4);
 		*/
 
+		Set<UnifyPair> lefteq = new HashSet<>();
+		Set<UnifyPair> leftle = new HashSet<>();
+		Set<UnifyPair> leftlewc = new HashSet<>();
+		Set<UnifyPair> lefteqOder = new HashSet<>();
+		Set<UnifyPair> lefteqRet = new HashSet<>();
+		Set<UnifyPair> leftleOder = new HashSet<>();
+		for (var x : left) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
 
-		Set<UnifyPair> lefteq = left.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> righteq = right.stream()
-				.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftle = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightle = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> leftlewc = left.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightlewc = right.stream()
-				.filter(x -> ((x.getLhsType() instanceof PlaceholderType || x.getRhsType() instanceof PlaceholderType) 
-						      && x.getPairOp() == PairOperator.SMALLERDOTWC))
-				.collect(Collectors.toCollection(HashSet::new));
-		//System.out.println(left.toString());
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) lefteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) leftle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) leftlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				lefteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				lefteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				leftleOder.add(x);
+			}
+		}
+
+
+		Set<UnifyPair> righteq = new HashSet<>();
+		Set<UnifyPair> rightle = new HashSet<>();
+		Set<UnifyPair> rightlewc = new HashSet<>();
+		Set<UnifyPair> righteqOder = new HashSet<>();
+		Set<UnifyPair> righteqRet = new HashSet<>();
+		Set<UnifyPair> rightleOder = new HashSet<>();
+		for (var x : right) {
+			boolean isLeftPlaceholder = x.getLhsType() instanceof PlaceholderType;
+			boolean isRightPlaceholder = x.getRhsType() instanceof PlaceholderType;
+			boolean hasPlaceholder = isLeftPlaceholder || isRightPlaceholder;
+
+			if (isLeftPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) righteq.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOT) 	rightle.add(x);
+			if (hasPlaceholder && x.getPairOp() == PairOperator.SMALLERDOTWC) rightlewc.add(x);
+
+			UnifyPair y = x.getGroundBasePair();
+			boolean isBasePairLeftPlaceholder = y.getLhsType() instanceof PlaceholderType;
+			boolean isBasePairRightPlaceholder = y.getRhsType() instanceof PlaceholderType;
+			if (isBasePairLeftPlaceholder && !isBasePairRightPlaceholder && x.getPairOp() == PairOperator.EQUALSDOT) {
+				righteqOder.add(x);
+			}
+			else if (isBasePairRightPlaceholder && ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1) {
+				righteqRet.add(x);
+			}
+			else if (x.getPairOp() == PairOperator.SMALLERDOT) {
+				rightleOder.add(x);
+			}
+		}
+
+		//context.logger().info(left.toString());
 		//Fall 2
 		//if (lefteq.iterator().next().getLhsType().getName().equals("AJO")) {
 		//	System.out.print("");
 		//}
 		
 		//ODER-CONSTRAINT
-		Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> leftBase = left.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
+		// Set<UnifyPair> rightBase = right.stream().map(x -> x.getGroundBasePair()).collect(Collectors.toCollection(HashSet::new));
 
-		Set<UnifyPair> lefteqOder = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair();
-				/*try {
-					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y: " + y.toString() +"\n");
-					((FiniteClosure)fc).logFile.write("y.getLhsType() : " + y.getLhsType() .toString() +"\n\n");
-					((FiniteClosure)fc).logFile.write("y.getRhsType(): " + y.getRhsType().toString() +"\n");
-					((FiniteClosure)fc).logFile.write("x.getPairOp(): " + x.getPairOp().toString() +"\n\n");
-					}
-					catch (IOException ie) {
-					}	*/
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqOder);
-		Set<UnifyPair> righteqOder = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getLhsType() instanceof PlaceholderType && 
-	            		   !(y.getRhsType() instanceof PlaceholderType) && 
-	            		   x.getPairOp() == PairOperator.EQUALSDOT);})
-				.collect(Collectors.toCollection(HashSet::new));
-		right.removeAll(righteqOder);
-		Set<UnifyPair> lefteqRet = left.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
 		left.removeAll(lefteqRet);
-		Set<UnifyPair> righteqRet = right.stream()
-				.filter(x -> { UnifyPair y = x.getGroundBasePair(); 
-	               return (y.getRhsType() instanceof PlaceholderType && 
-	            		   ((PlaceholderType)y.getRhsType()).getOrCons() == (byte)-1);})
-				.collect(Collectors.toCollection(HashSet::new));
+		right.removeAll(righteqOder);
 		right.removeAll(righteqRet);
-		Set<UnifyPair> leftleOder = left.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
-		Set<UnifyPair> rightleOder = right.stream()
-				.filter(x -> (x.getPairOp() == PairOperator.SMALLERDOT))
-				.collect(Collectors.toCollection(HashSet::new));
 
 		/*
 		synchronized(this) {
@@ -275,46 +266,34 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		*/
 		
 		
-		Integer compareEq;
+		int compareEq;
 		if (lefteqOder.size() == 1 && righteqOder.size() == 1 && lefteqRet.size() == 1 && righteqRet.size() == 1) {
 			Match m = new Match();
-			if ((compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair())) == -1) {
+			compareEq = compareEq(lefteqOder.iterator().next().getGroundBasePair(), righteqOder.iterator().next().getGroundBasePair());
+
+			if (compareEq == -1) {
 				ArrayList<UnifyPair> matchList =
 						rightleOder.stream().map(x -> {
 								UnifyPair leftElem = leftleOder.stream()
 														     .filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-														     .findAny().get(); 
-							return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);})
+														     .findAny().orElseThrow();
+								return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);}
+							)
 							.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result1: -1 \n\n"); } catch (IOException ie) {}
-					return -1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result1: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+
+				return (m.match(matchList).isPresent()) ? -1 : 0;
 			} else if (compareEq == 1) {
 				ArrayList<UnifyPair> matchList =
 						leftleOder.stream().map(x -> {
 							UnifyPair rightElem = rightleOder.stream()
-									                        .filter(y -> 
-									                        	y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
-									                        .findAny().get(); 
-														return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);})
+								.filter(y -> y.getGroundBasePair().getLhsType().equals(x.getGroundBasePair().getLhsType()))
+								.findAny().orElseThrow();
+							return new UnifyPair(x.getRhsType(), rightElem.getRhsType(), PairOperator.EQUALSDOT);}
+						)
 						.collect(Collectors.toCollection(ArrayList::new));
-				if (m.match(matchList).isPresent()) {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 1 \n\n"); } catch (IOException ie) {}
-					return 1;
-				}
-				else {
-					//try { ((FiniteClosure)fc).logFile.write("result2: 0 \n\n"); } catch (IOException ie) {}
-					return 0;
-				}
+				return (m.match(matchList).isPresent()) ? 1 : 0;
 			} else {
 				/*
-				synchronized(this) {
-					try {
 					((FiniteClosure)fc).logFile.write("leftBase: " + leftBase.toString() +"\n");
 					((FiniteClosure)fc).logFile.write("rightBase: " + rightBase.toString() +"\n\n");
 					((FiniteClosure)fc).logFile.write("left: " + left.toString() +"\n");
@@ -327,37 +306,33 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 					((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
 					((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
 					((FiniteClosure)fc).logFile.flush();
-					}
-					catch (IOException ie) {
-					}
-				}
 				*/
 				return 0;
 			}
 		}
 		
 		
-		if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof ExtendsType && leftle.size() == 1  && righteq.size() == 0 && rightle.size() == 1) {
+		if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof ExtendsType && leftle.size() == 1  && righteq.isEmpty() && rightle.size() == 1) {
 			return 1;
 		}
 		//Fall 2
-		if (lefteq.size() == 0 && leftle.size() == 1 && righteq.size() == 1 && righteq.iterator().next().getRhsType() instanceof ExtendsType && rightle.size() == 1) {
+		if (lefteq.isEmpty() && 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) {
+		if (lefteq.size() == 1 && lefteq.iterator().next().getRhsType() instanceof SuperType && leftle.size() == 1  && righteq.isEmpty() && 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) {
+		if (lefteq.isEmpty() && 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) {
+		if (lefteq.size() == 1 && leftle.isEmpty() && righteq.size() == 1 && rightle.size() == 1) {
 			return -1;
 		}
 		//Fall 5
-		if (lefteq.size() == 1 && leftle.size() == 1 && righteq.size() == 1 && rightle.size() == 0) {
+		if (lefteq.size() == 1 && leftle.size() == 1 && righteq.size() == 1 && rightle.isEmpty()) {
 			return 1;
 		}
 		//Fall 5
@@ -365,7 +340,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 			return 0;
 		}
 		// Nur Paare a =. Theta
-		if (leftle.size() == 0 && rightle.size() == 0 && leftlewc.size() == 0 && rightlewc.size() ==0) {
+		if (leftle.isEmpty() && rightle.isEmpty() && leftlewc.isEmpty() && rightlewc.isEmpty()) {
 			Stream<UnifyPair> lseq = lefteq.stream(); //left.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT));
 			Stream<UnifyPair> rseq = righteq.stream(); //right.filter(x -> (x.getLhsType() instanceof PlaceholderType && x.getPairOp() == PairOperator.EQUALSDOT));
 			BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
@@ -373,13 +348,10 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 			lseq = lseq.filter(x -> !(hm.get(x.getLhsType()) == null));//NOCHMALS UEBERPRUEFEN!!!!
 			lseq = lseq.filter(x -> !x.equals(hm.get(x.getLhsType()))); //Elemente die gleich sind muessen nicht verglichen werden
 			Optional<Integer> si = lseq.map(x -> compareEq(x, hm.get(x.getLhsType()))).reduce((x,y)-> { if (x == y) return x; else return 0; } );
-			if (!si.isPresent()) return 0;
-			else return si.get();
+			return si.orElse(0);
 		}
 		//Fall 1 und 4
-		if (lefteq.size() >= 1 && righteq.size() >= 1 && (leftlewc.size() > 0 || rightlewc.size() > 0)) {
-			if (lefteq.iterator().next().getLhsType().getName().equals("D")) 
-				System.out.print("");
+		if (!lefteq.isEmpty() && !righteq.isEmpty() && (!leftlewc.isEmpty() || !rightlewc.isEmpty())) {
 			//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
@@ -400,12 +372,12 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				//TODO: Hier wird bei Wildcards nicht das richtige compare aufgerufen PL 18-04-20
 				Pair<Integer, Set<UnifyPair>> int_Unifier = compare(lseq.getRhsType(), rseq.getRhsType());
 				Unifier uni = new Unifier();
-				int_Unifier.getValue().get().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				int_Unifier.getValue().orElseThrow().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
 				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName())
-					|| leftlewc.size() == 0 || rightlewc.size() == 0) return int_Unifier.getKey();
+					|| leftlewc.isEmpty() || rightlewc.isEmpty()) return int_Unifier.getKey();
 				else {
-					Set <UnifyPair> lsleuni = leftlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
-					Set <UnifyPair> rsleuni = rightlewc.stream().map(x -> uni.apply(x)).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> lsleuni = leftlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
+					Set <UnifyPair> rsleuni = rightlewc.stream().map(uni::apply).collect(Collectors.toCollection(HashSet::new));
 					BinaryOperator<HashMap<UnifyType,UnifyPair>> combiner = (x,y) -> { x.putAll(y); return x;};
 				
 					HashMap<UnifyType,UnifyPair> hm;
@@ -422,11 +394,11 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						Stream<UnifyPair> lslewcstr = lsleuni.stream().filter(x -> !(hm.get(x.getRhsType()) == null));
 						si = lslewcstr.map(x -> fc.compare(x.getLhsType(), hm.get(x.getRhsType()).getLhsType(), PairOperator.SMALLERDOTWC, context)).reduce((x,y)-> { if (x == y) return x; else return 0; } );
 					}
-					if (!si.isPresent()) return 0;
-					else return si.get();
+					return si.orElse(0);
 				}
 			} else {
-				if (leftlewc.size() > 0) {
+				if (!leftlewc.isEmpty()) {
+					/*
 					Set<UnifyPair> subst;
 					subst = leftlewc.stream().map(x -> { 
 						if (x.getLhsType() instanceof PlaceholderType) {
@@ -435,6 +407,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 						else {
 							return new UnifyPair(x.getRhsType(), x.getLhsType(), PairOperator.EQUALSDOT);
 						}}).collect(Collectors.toCollection(HashSet::new));
+					 */
 					Unifier uni = new Unifier();
 					lseq = uni.apply(lseq);
 				}

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

@@ -134,15 +134,15 @@ public final class PlaceholderType extends UnifyType{
 		wildcardable = true;
 	}
 
-	public void setWildcardtable(Boolean wildcardable) {
+	public void setWildcardtable(boolean wildcardable) {
 		this.wildcardable = wildcardable;
 	}
 
-	public Boolean isInnerType() {
+	public boolean isInnerType() {
 		return innerType;
 	}
 
-	public void setInnerType(Boolean innerType) {
+	public void setInnerType(boolean innerType) {
 		this.innerType = innerType;
 	}
 

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

@@ -32,7 +32,7 @@ public class ReferenceType extends UnifyType implements ISerializableData {
 		return visitor.visit(this, ht);
 	}
 
-	public ReferenceType(String name, Boolean genericTypeVar) {
+	public ReferenceType(String name, boolean genericTypeVar) {
 		super(name, new TypeParams());
 		hashCode = 31 + 17 * typeName.hashCode() + 17 * typeParams.hashCode();
 		this.genericTypeVar = genericTypeVar;

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

@@ -201,7 +201,7 @@ public class UnifyPair implements IConstraintElement, ISerializableData {
 			
 	}
 	
-	public Boolean wrongWildcard() {
+	public boolean wrongWildcard() {
 		return lhs.wrongWildcard() || rhs.wrongWildcard();
 	}
 	

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

@@ -103,7 +103,7 @@ public abstract class UnifyType implements ISerializableData {
     return new ArrayList<>(typeParams.getInvolvedPlaceholderTypes());
 	}
 	
-	public Boolean wrongWildcard() {//default
+	public boolean wrongWildcard() {//default
 		return false;
 	}
 

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

@@ -42,7 +42,7 @@ public abstract class WildcardType extends UnifyType implements ISerializableDat
 	}
 	
 	@Override
-	public Boolean wrongWildcard () {//This is an error
+	public boolean wrongWildcard () {//This is an error
 		return (wildcardedType instanceof WildcardType);
 	}
 	

src/main/java/de/dhbwstuttgart/util/Logger.java

@@ -1,9 +1,322 @@
 package de.dhbwstuttgart.util;
 
+import com.diogonunes.jcolor.Attribute;
+import de.dhbwstuttgart.core.ConsoleInterface;
+import de.dhbwstuttgart.server.SocketServer;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static com.diogonunes.jcolor.Ansi.colorize;
+
 public class Logger {
 
-  public static void print(String s) {
-    System.out.println(s);
+  public static final Logger NULL_LOGGER = new NullLogger();
+  private static final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+  protected final Writer writer;
+  protected final String prefix;
+
+  public Logger() {
+    this(null, "");
   }
 
+  public Logger(String prefix) {
+    this(null, prefix);
+  }
+
+  public Logger(Writer writer, String prefix) {
+    this.prefix = (Objects.equals(prefix, "")) ? "" : "["+prefix+"] ";
+    this.writer = writer;
+  }
+
+  /**
+   * Create a new logger object from the path provided
+   *
+   * @param filePath  The path to the output file. Recommended file extension ".log"
+   * @return          The Logger object for this output file
+   */
+  public static Logger forFile(String filePath, String prefix) {
+    File file = Path.of(filePath).toFile();
+    try {
+      Writer fileWriter = new FileWriter(file);
+      return new Logger(fileWriter, prefix);
+    }
+    catch (IOException exception) {
+      throw new RuntimeException("Failed to created Logger for file " + filePath, exception);
+    }
+  }
+
+  /**
+   * Create a new logger object that inherits the writer of the given logger object
+   *
+   * @param logger    The old logger object that will provide the writer
+   * @return          The new prefix for the new logger object
+   */
+  public static Logger inherit(Logger logger, String newPrefix) {
+    return new Logger(logger.writer, newPrefix);
+  }
+
+  /**
+   * Tint the prefix in the color of the logLevel
+   * @param logLevel  The logLevel to set the tint to
+   * @return          The tinted string (using ANSI sequences)
+   */
+  protected String getPrefix(LogLevel logLevel) {
+    String fullPrefix = prefix + "[" + logLevel + "] ";
+    return switch (logLevel) {
+      case DEBUG    -> colorize(fullPrefix, Attribute.BRIGHT_MAGENTA_TEXT());
+      case INFO     -> colorize(fullPrefix, Attribute.BLUE_TEXT());
+      case WARNING  -> colorize(fullPrefix, Attribute.YELLOW_TEXT());
+      case ERROR    -> colorize(fullPrefix, Attribute.RED_TEXT());
+      case SUCCESS  -> colorize(fullPrefix, Attribute.GREEN_TEXT());
+    };
+  }
+
+  /**
+   * Print text to the output or error stream, depending on the logLevel
+   * @param s         The string to print
+   * @param logLevel  If logLevel == error, then print to stderr or print to stdout otherwise
+   */
+  protected void print(String s, LogLevel logLevel) {
+    String coloredPrefix = this.getPrefix(logLevel);
+
+    // if we are running the server, prepend the timestamp
+    if(SocketServer.isServerRunning()) {
+      String timestamp = LocalDateTime.now().format(timeFormatter);
+      coloredPrefix = "[" + timestamp + "] " + coloredPrefix;
+    }
+
+    // output to the correct output-stream
+    if (logLevel.getValue() == LogLevel.ERROR.getValue()) {
+      System.out.println(coloredPrefix + s);
+    }
+    else {
+      System.err.println(coloredPrefix + s);
+    }
+  }
+
+  public boolean isLogLevelActive(LogLevel logLevel) {
+    return logLevel.isHigherOrEqualTo(ConsoleInterface.logLevel);
+  }
+
+  /**
+   * Write text to the attached writer if there is any
+   * @param s   The string to print
+   */
+  protected void write(String s) {
+    if (writer != null && ConsoleInterface.writeLogFiles) {
+      // writing to file should only be done when necessary
+      synchronized (writer) {
+        try {
+          writer.write(s);
+        }
+        catch (IOException exception) {
+          throw new RuntimeException("Failed writing to file", exception);
+        }
+      }
+    }
+  }
+
+  /**
+   * Base method for logging a string value. Should mostly be used by the Logger internal functions that
+   * abstract the logLevel away from the parameters
+   *
+   * @hidden Only relevant for the Logger and very special cases with dynamic logLevel
+   * @param s         The text to log
+   * @param logLevel  The logLevel on which the text should be logged
+   */
+  public void log(String s, LogLevel logLevel) {
+    if (isLogLevelActive(logLevel)) {
+      this.print(s, logLevel);
+      this.write(s);
+    }
+  }
+  public void log(Supplier<String> supp, LogLevel logLevel) {
+    if (isLogLevelActive(logLevel)) {
+      this.log(supp.get(), logLevel);
+    }
+  }
+  public void log(Object obj, LogLevel logLevel) {
+    if (isLogLevelActive(logLevel)) {
+      this.log(obj.toString(), logLevel);
+    }
+  }
+
+
+  /**
+   * Output a debug message
+   * @param s The string to log
+   */
+  public void debug(String s) {
+    this.log(s, LogLevel.DEBUG);
+  }
+  public void debug(Object o) {
+    this.log(o, LogLevel.DEBUG);
+  }
+  public void debug(Supplier<String> supp) {
+    this.log(supp, LogLevel.DEBUG);
+  }
+
+  /**
+   * Output an info message
+   * @param s The string to log
+   */
+  public void info(String s) {
+    this.log(s, LogLevel.INFO);
+  }
+  public void info(Object o) {
+    this.log(o, LogLevel.INFO);
+  }
+  public void info(Supplier<String> supp) {
+    this.log(supp, LogLevel.INFO);
+  }
+
+  /**
+   * Output a warning message
+   * @param s The string to log
+   */
+  public void warn(String s) {
+    this.log(s, LogLevel.WARNING);
+  }
+  public void warn(Object o) {
+    this.log(o, LogLevel.WARNING);
+  }
+  public void warn(Supplier<String> supp) {
+    this.log(supp, LogLevel.WARNING);
+  }
+
+  /**
+   * Output an error message
+   * @param s The string to log
+   */
+  public void error(String s) {
+    this.log(s, LogLevel.ERROR);
+  }
+  public void error(Object o) {
+    this.log(o, LogLevel.ERROR);
+  }
+  public void error(Supplier<String> supp) {
+    this.log(supp, LogLevel.ERROR);
+  }
+
+
+  /**
+   * Output a success message
+   * @param s The string to log
+   */
+  public void success(String s) {
+    this.log(s, LogLevel.SUCCESS);
+  }
+  public void success(Object o) {
+    this.log(o, LogLevel.SUCCESS);
+  }
+  public void success(Supplier<String> supp) {
+    this.log(supp, LogLevel.SUCCESS);
+  }
+
+  /**
+   * Special logging function that prints a throwable object and all of its recursive causes (including stacktrace)
+   * as an error
+   *
+   * @param throwable The Throwable object to output
+   */
+  public void exception(Throwable throwable) {
+    // Format the exception output
+    String s = "Exception: " + throwable.getMessage() + "\n" +
+      Arrays.stream(throwable.getStackTrace()).map(stackTraceElement ->
+        " | " + stackTraceElement.toString()
+      ).collect(Collectors.joining("\n"));
+
+    // if there is a cause printed afterward, announce it with the print of the exception
+    if (throwable.getCause() != null) {
+      s += "\n\nCaused by: ";
+    }
+
+    // print the exception
+    this.error(s);
+
+    // print the cause recursively
+    if (throwable.getCause() != null) {
+      this.exception(throwable.getCause());
+    }
+  }
+
+  public void close() {
+    if (this.writer != null) {
+      try {
+        this.writer.close();
+      }
+      catch (IOException exception) {
+        throw new RuntimeException("Failed to close a loggers writer. Was it maybe already closed? ", exception);
+      }
+    }
+  }
+
+
+  /**
+   * An enum representing the different log levels as integers:
+   * <ul>
+   *  <li>DEBUG: highly specific output only for debugging</li>
+   *  <li>INFO: informational output about the current state of the program</li>
+   *  <li>WARNING: warnings about potential issues or an unexpected state</li>
+   *  <li>ERROR: invalid states, errors and exceptions</li>
+   *  <li>SUCCESS: successfully executed key steps of the program</li>
+   * </ul>
+   */
+  public enum LogLevel {
+    /** Highly specific output only for debugging */
+    DEBUG(0),
+    /** Informational output about the current state of the program */
+    INFO(1),
+    /** Warnings about potential issues or an unexpected state **/
+    WARNING(2),
+    /** Invalid states, errors and exceptions */
+    ERROR(3),
+    /** Successfully executed key steps of the program */
+    SUCCESS(4);
+
+    private final int value;
+    LogLevel(final int newValue) {
+      value = newValue;
+    }
+
+    public boolean isHigherOrEqualTo(LogLevel other) {
+      return this.value >= other.value;
+    }
+
+    public int getValue() {
+      return value;
+    }
+
+    public static LogLevel fromValue(int value) {
+      return switch (value) {
+        case 0 -> LogLevel.DEBUG;
+        case 1 -> LogLevel.INFO;
+        case 2 -> LogLevel.WARNING;
+        case 3 -> LogLevel.ERROR;
+        case 4 -> LogLevel.SUCCESS;
+        default -> throw new RuntimeException("Invalid log level value: " + value);
+      };
+    }
+  }
+
+
+  /**
+   * A special case of logger that will never output anything
+   */
+  private static class NullLogger extends Logger {
+    @Override
+    public void log(String s, LogLevel logLevel) {
+      // Do nothing. Yay
+    }
+  }
 }

src/test/java/AllgemeinTest.java

@@ -1,6 +1,6 @@
 
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 import static targetast.TestCodegen.generateClassFiles;
 
 import java.io.File;
@@ -9,13 +9,12 @@ import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Arrays;
 
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.Lists;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 
 public class AllgemeinTest {
 

src/test/java/GenericsParserTest.java

@@ -6,12 +6,12 @@ import de.dhbwstuttgart.syntaxtree.GenericTypeVar;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.type.*;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class GenericsParserTest {
 

src/test/java/TestPackages.java

@@ -1,6 +1,6 @@
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.util.List;
@@ -24,7 +24,7 @@ public class TestPackages {
     }
 
     @Test
-    @Ignore("This doesn't work")
+    @Disabled("This doesn't work")
     public void testPackagesCircular() throws Exception {
         var cmp = new JavaTXCompiler(
             List.of(

src/test/java/TestTypeDeployment.java

@@ -4,7 +4,7 @@ import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.File;
 import java.nio.file.Path;
@@ -18,7 +18,7 @@ public class TestTypeDeployment {
     public void testTypeDeployment() throws Exception {
         var path = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Cycle.jav");
         var file = path.toFile();
-        var compiler = new JavaTXCompiler(file, false);
+        var compiler = new JavaTXCompiler(file);
         var parsedSource = compiler.sourceFiles.get(file);
         var tiResults = compiler.typeInference(file);
         Set<TypeInsert> tips = new HashSet<>();

src/test/java/astfactory/ASTFactoryTest.java

@@ -4,7 +4,7 @@ package astfactory;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.type.GenericRefType;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
@@ -12,7 +12,8 @@ import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.HashMap;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 
 public class ASTFactoryTest<A> extends HashMap<String, A>{
     @Test

src/test/java/finiteClosure/SuperInterfacesTest.java

@@ -4,12 +4,10 @@ import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.SyntaxTreeGenerator.FCGenerator;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
-import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 
 public class SuperInterfacesTest {
     @Test

src/test/java/server/PacketExampleData.java

@@ -18,6 +18,7 @@ import de.dhbwstuttgart.typeinference.unify.model.SuperType;
 import de.dhbwstuttgart.typeinference.unify.model.TypeParams;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.util.Logger;
 import java.io.Writer;
 import java.util.HashSet;
 import java.util.List;
@@ -84,13 +85,12 @@ class PacketExampleData {
 
   static UnifyContext createTestContext() {
     var placeholderRegistry = new PlaceholderRegistry();
-    var nullWriter = Writer.nullWriter();
-    return new UnifyContext(nullWriter, false, true,
+    return new UnifyContext(Logger.NULL_LOGGER, true,
       new UnifyResultModel(
         new ConstraintSet<>(),
         new FiniteClosure(
           new HashSet<>(),
-          nullWriter,
+          Logger.NULL_LOGGER,
           placeholderRegistry)),
       new UnifyTaskModel(),
       ForkJoinPool.commonPool(),

src/test/java/server/PacketTest.java

@@ -1,7 +1,7 @@
 package server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.parser.SourceLoc;
 import de.dhbwstuttgart.server.packet.DebugPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
@@ -16,18 +16,11 @@ import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialUUID;
 import de.dhbwstuttgart.server.packet.dataContainers.serialized.SerialValue;
 import de.dhbwstuttgart.typeinference.constraints.Constraint;
 import de.dhbwstuttgart.typeinference.constraints.ConstraintSet;
-import de.dhbwstuttgart.typeinference.unify.PlaceholderRegistry;
 import de.dhbwstuttgart.typeinference.unify.UnifyContext;
-import de.dhbwstuttgart.typeinference.unify.UnifyResultModel;
-import de.dhbwstuttgart.typeinference.unify.UnifyTaskModel;
-import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
-import java.io.Writer;
-import java.util.HashSet;
-import java.util.concurrent.ForkJoinPool;
 import java.util.function.BiFunction;
-import org.junit.Test;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class PacketTest {
 

src/test/java/server/ServerTest.java

@@ -1,9 +1,12 @@
 package server;
 
+import de.dhbwstuttgart.core.ConsoleInterface;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.core.JavaTXServer;
 import de.dhbwstuttgart.environment.CompilationEnvironment;
 import de.dhbwstuttgart.server.SocketClient;
+import de.dhbwstuttgart.server.packet.SetAutoclosePacket;
+import de.dhbwstuttgart.server.packet.UnifyRequestPacket;
 import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.factory.ASTFactory;
 import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
@@ -20,28 +23,33 @@ import de.dhbwstuttgart.typeinference.unify.model.FiniteClosure;
 import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyPair;
 import de.dhbwstuttgart.typeinference.unify.model.UnifyType;
+import de.dhbwstuttgart.util.Logger;
 import java.io.File;
 import java.io.IOException;
 import java.io.Writer;
 import java.nio.file.Path;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
-import org.junit.Test;
 import targetast.TestCodegen;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ServerTest {
 
-  @Test
+  public ServerTest() {
+    ConsoleInterface.unifyServerUrl = Optional.of("ws://localhost:5000");
+  }
+
+  //@Test
   public void checkServer_Scalar() throws IOException, ClassNotFoundException {
     compareLocalAndServerResult("Scalar.jav");
   }
 
-  @Test
+  //@Test
   public void checkServer_Matrix() throws IOException, ClassNotFoundException {
     compareLocalAndServerResult("Matrix.jav");
   }
@@ -49,11 +57,11 @@ public class ServerTest {
   protected void compareLocalAndServerResult(final String filename) throws IOException, ClassNotFoundException {
     File file = Path.of(TestCodegen.path.toString(), filename).toFile();
 
-    // get information from compiler
+    // get information from the compiler
     JavaTXCompiler compiler = new JavaTXCompiler(List.of(file));
 
     // NOW: simulate the call to method typeInference. Once via server and once locally
-    // if everything works, they should neither interfere with each other, nor differ in their result
+    // if everything works, they should neither interfere with each other nor differ in their result
 
     // get the values from the compiler
     PlaceholderRegistry placeholderRegistry = JavaTXCompiler.defaultClientPlaceholderRegistry; //new PlaceholderRegistry();
@@ -63,7 +71,7 @@ public class ServerTest {
 
     FiniteClosure finiteClosure = UnifyTypeFactory.generateFC(
       ServerTest.getAllClasses(compiler, file).stream().toList(),
-      Writer.nullWriter(),
+      Logger.NULL_LOGGER,
       compiler.classLoader,
       compiler,
       placeholderRegistry
@@ -82,9 +90,11 @@ public class ServerTest {
     // run the unification on the server
     PlaceholderRegistry prCopy = JavaTXCompiler.defaultClientPlaceholderRegistry.deepClone();
     UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-    UnifyContext context = new UnifyContext(Writer.nullWriter(), false, true, urm, usedTasks, prCopy);
-    SocketClient socketClient = new SocketClient("ws://localhost:5000");
-    List<ResultSet> serverResult = socketClient.execute(finiteClosure, cons, unifyCons, context);
+    UnifyContext context = new UnifyContext(Logger.NULL_LOGGER, true, urm, usedTasks, prCopy);
+    SocketClient.execute(SetAutoclosePacket.create());
+    List<ResultSet> serverResult = SocketClient.executeAndGet(
+      UnifyRequestPacket.create(finiteClosure, cons, unifyCons, context.placeholderRegistry())
+    ).getResultSet(context);
 
     // close the server
     server.forceStop();

src/test/java/syntaxtreegenerator/TestComplete.java

@@ -1,9 +1,5 @@
 package syntaxtreegenerator;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
@@ -12,21 +8,23 @@ import java.io.ObjectOutputStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.exceptions.NotImplementedException;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 
+import static org.junit.jupiter.api.Assertions.*;
+
 /**
  * Unit-Tests für den 'SyntaxTreeGenerator' aus dem Package 'parser' nach Vorbild der Klasse 'TestComplete' aus dem Test-Package 'targetast'
  */
 public class TestComplete {
     private static HashMap<String, File[]> javFiles = new HashMap<>();
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() {
         final String testFileDirectory = "resources/bytecode/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";
@@ -353,7 +351,7 @@ public class TestComplete {
             assertEquals("Comparing expected and resulting AST for mathStrucInteger.jav", expectedAST, resultingAST);
         } catch (Exception exc) {
             exc.printStackTrace();
-            assertTrue("An error occured while generating the AST for mathStrucInteger.jav", exc instanceof NotImplementedException);
+            assertInstanceOf(NotImplementedException.class, exc);
         }
     }
 

src/test/java/syntaxtreegenerator/TestNewFeatures.java

@@ -1,15 +1,15 @@
 package syntaxtreegenerator;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
 
 import java.io.File;
 import java.io.FileFilter;
 import java.io.FileInputStream;
 import java.util.HashMap;
 
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
@@ -17,7 +17,7 @@ import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 public class TestNewFeatures {
     private static HashMap<String, File[]> javFiles = new HashMap<>();
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() {
         final String testFileDirectory = "resources/syntaxtreegenerator/javFiles/";
         final String expectedASTDirectory = "resources/syntaxtreegenerator/";

src/test/java/targetast/ASTToTypedTargetAST.java

@@ -2,7 +2,6 @@ package targetast;
 
 import com.google.common.reflect.TypeToken;
 import de.dhbwstuttgart.core.JavaTXCompiler;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
 import de.dhbwstuttgart.parser.NullToken;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.*;
@@ -10,13 +9,13 @@ import de.dhbwstuttgart.syntaxtree.type.RefType;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
 import de.dhbwstuttgart.target.tree.TargetStructure;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
 import java.util.*;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ASTToTypedTargetAST {
 
@@ -24,7 +23,7 @@ public class ASTToTypedTargetAST {
     public void emptyClass() {
         ClassOrInterface emptyClass = new ClassOrInterface(0, new JavaClassName("EmptyClass"), new ArrayList<>(), Optional.empty(), Optional.empty(), new ArrayList<>(), new ArrayList<>(), new GenericDeclarationList(new ArrayList<>(), new NullToken()), new RefType(new JavaClassName("Object"), new NullToken()), false, false, new ArrayList<>(), new ArrayList<>(), new NullToken(), null);
         ResultSet emptyResultSet = new ResultSet(new HashSet<>());
-        TargetStructure emptyTargetClass = new ASTToTargetAST(List.of(emptyResultSet)).convert(emptyClass);
+        TargetStructure emptyTargetClass = new ASTToTargetAST(List.of(emptyResultSet), TestCodegen.createClassLoader()).convert(emptyClass);
         assert emptyTargetClass.getName().equals("EmptyClass");
         assert emptyTargetClass.methods().size() == 0;
         assert emptyTargetClass.fields().size() == 0;
@@ -32,13 +31,14 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void overloading() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Overloading.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var classLoader = new ByteArrayClassLoader();
         var overloading = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         var overloading2 = TestCodegen.generateClass(converter.convert(classes.get(1)), classLoader);
 
@@ -54,46 +54,54 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void tphsAndGenerics() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Tph2.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var tphAndGenerics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void cycles() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Cycle.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var cycle = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void infimum() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Infimum.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var infimum = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void gen() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Gen.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), TestCodegen.createClassLoader());
         var m = generics.getDeclaredMethod("m", Vector.class);
         var mReturnType = m.getGenericReturnType();
         assertEquals(mReturnType, m.getParameters()[0].getParameterizedType());
@@ -103,13 +111,15 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void definedGenerics() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         var B = generics.getTypeParameters()[0];
         var mt1 = generics.getDeclaredMethod("mt1", Object.class);
         var constructor = generics.getDeclaredConstructor(Object.class);
@@ -121,13 +131,15 @@ public class ASTToTypedTargetAST {
 
     @Test
     public void definedGenerics2() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics2.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics2 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
         assertEquals(generics2.getTypeParameters()[0].getBounds()[0], String.class);
         var m = generics2.getDeclaredMethod("m1", Object.class);
         assertEquals(m.getTypeParameters()[0].getBounds()[0], Integer.class);
@@ -135,26 +147,30 @@ public class ASTToTypedTargetAST {
     }
 
     @Test
-    @Ignore("Not implemented")
+    @Disabled("Not implemented")
     public void definedGenerics3() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics3.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics3 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
     }
 
     @Test
     public void definedGenerics4() throws Exception {
+        var classLoader = TestCodegen.createClassLoader();
+
         var file = Path.of(System.getProperty("user.dir"), "/resources/bytecode/javFiles/Generics4.jav").toFile();
         var compiler = new JavaTXCompiler(file);
         var resultSet = compiler.typeInference(file);
-        var converter = new ASTToTargetAST(compiler, resultSet);
+        var converter = new ASTToTargetAST(compiler, resultSet, classLoader);
         var classes = compiler.sourceFiles.get(file).getClasses();
 
-        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), new ByteArrayClassLoader());
+        var generics4 = TestCodegen.generateClass(converter.convert(classes.get(0)), classLoader);
 
         // var instance = generics4.getDeclaredConstructor().newInstance();
         // var method = generics4.getDeclaredMethod("m2", Object.class);

src/test/java/targetast/GreaterEqualTest.java

@@ -1,22 +1,21 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GreaterEqualTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "GreaterEqual.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "GreaterEqual.jav");
         classToTest = classFiles.get("GreaterEqual");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/GreaterThanTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class GreaterThanTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "GreaterThan.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "GreaterThan.jav");
         classToTest = classFiles.get("GreaterThan");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/InheritTest.java

@@ -1,22 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
-import java.nio.file.Path;
 import java.util.Vector;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class InheritTest {
     private static Class<?> classToTest, classToTestAA, classToTestBB, classToTestCC, classToTestDD;
     private static Object instanceOfClass, instanceOfClassAA, instanceOfClassBB, instanceOfClassCC, instanceOfClassDD;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUpBeforeClass() throws Exception {
-        var classLoader = new ByteArrayClassLoader();
+        var classLoader = TestCodegen.createClassLoader();
 
         var classes = TestCodegen.generateClassFiles(classLoader, "Inherit.jav");
         classToTest = classes.get("Inherit");
@@ -35,72 +33,72 @@ public class InheritTest {
     @Test
     public void testmainAA() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassAA, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassAA, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestAA, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassAA, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, instanceOfClassAA, 5));
     }
 
     @Test
     public void testmainBB() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassBB, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassBB, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestAA, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassBB, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, instanceOfClassBB, 5));
     }
 
     @Test
     public void testmainCC() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassCC, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassCC, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestCC, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassCC, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, instanceOfClassCC, 5));
     }
 
     @Test
     public void testmainDD() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassDD, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassDD, 5));
         Method main = classToTest.getDeclaredMethod("main", classToTestCC, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, instanceOfClassDD, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, instanceOfClassDD, 5));
     }
 
     @Test
     public void testmainVectorAA() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassAA, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassAA, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassAA);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorBB() throws Exception {
         Method m = classToTestAA.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassBB, 5), "AA");
+        assertEquals("AA", m.invoke(instanceOfClassBB, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassBB);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "AA");
+        assertEquals("AA", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorCC() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassCC, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassCC, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassCC);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, v, 5));
     }
 
     @Test
     public void testmainVectorDD() throws Exception {
         Method m = classToTestCC.getDeclaredMethod("m", Integer.class);
-        assertEquals(m.invoke(instanceOfClassDD, 5), "CC");
+        assertEquals("CC", m.invoke(instanceOfClassDD, 5));
         Vector v = new Vector<>();
         v.add(instanceOfClassDD);
         Method main = classToTest.getDeclaredMethod("main", Vector.class, Integer.class);
-        assertEquals(main.invoke(instanceOfClass, v, 5), "CC");
+        assertEquals("CC", main.invoke(instanceOfClass, v, 5));
     }
 }

src/test/java/targetast/InheritTest2.java

@@ -1,23 +1,22 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 import java.util.Vector;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@Ignore("FIXME")
+@Disabled("FIXME")
 public class InheritTest2 {
     private static Class<?> classToTest, classToTestAA, classToTestBB, classToTestCC, classToTestDD;
     private static Object instanceOfClass, instanceOfClassAA, instanceOfClassBB, instanceOfClassCC, instanceOfClassDD;
 
-    @BeforeClass
+    @BeforeAll
     public static void setUpBeforeClass() throws Exception {
-        var classLoader = new ByteArrayClassLoader();
+        var classLoader = TestCodegen.createClassLoader();
         classToTest   = TestCodegen.generateClassFiles(classLoader, "Inherit2.jav").get("Inherit2");
         classToTestAA = TestCodegen.generateClassFiles(classLoader, "AA.jav").get("AA");
         classToTestBB = TestCodegen.generateClassFiles(classLoader, "BB.jav").get("BB");

src/test/java/targetast/LessEqualTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class LessEqualTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "LessEqual.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "LessEqual.jav");
         classToTest = classFiles.get("LessEqual");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/LessThanTest.java

@@ -1,21 +1,20 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class LessThanTest {
     static Class<?> classToTest;
     static Object instance;
 
-    @BeforeClass
+    @BeforeAll
     public static void beforeClass() throws Exception {
-        var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "LessThan.jav");
+        var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "LessThan.jav");
         classToTest = classFiles.get("LessThan");
         instance = classToTest.getDeclaredConstructor().newInstance();
     }

src/test/java/targetast/OLTest.java

@@ -1,12 +1,12 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 
 public class OLTest {
 	private static Class<?> classToTest;
@@ -14,9 +14,9 @@ public class OLTest {
 	private static Object instanceOfClass;
 	private static Object instanceOfClass1;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "OL.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "OL.jav");
 		classToTest = classFiles.get("OL");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 		classToTest1 = classFiles.get("OLMain");

src/test/java/targetast/PostIncTest.java

@@ -1,20 +1,19 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PostIncTest {
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "PostIncDec.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "PostIncDec.jav");
 		classToTest = classFiles.get("PostIncDec");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/targetast/PreIncTest.java

@@ -1,20 +1,19 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PreIncTest {
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "PreInc.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "PreInc.jav");
 		classToTest = classFiles.get("PreInc");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/targetast/PutTest.java

@@ -1,22 +1,21 @@
 package targetast;
 
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
-import org.junit.BeforeClass;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
 import java.util.Stack;
 import java.util.Vector;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 public class PutTest {
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "Put.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "Put.jav");
 		classToTest = classFiles.get("Put");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/targetast/TestCodegen.java

@@ -2,7 +2,7 @@ package targetast;
 
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.bytecode.Codegen;
-import de.dhbwstuttgart.environment.ByteArrayClassLoader;
+import de.dhbwstuttgart.environment.DirectoryClassLoader;
 import de.dhbwstuttgart.environment.IByteArrayClassLoader;
 import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.target.generate.ASTToTargetAST;
@@ -14,10 +14,10 @@ import de.dhbwstuttgart.target.tree.expression.*;
 import de.dhbwstuttgart.target.tree.type.TargetFunNType;
 import de.dhbwstuttgart.target.tree.type.TargetRefType;
 import de.dhbwstuttgart.target.tree.type.TargetType;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 import org.objectweb.asm.Opcodes;
 
@@ -37,6 +37,10 @@ public class TestCodegen {
         Files.write(outputPath.resolve(name + ".class"), code);
     }
 
+    public static IByteArrayClassLoader createClassLoader() {
+        return new DirectoryClassLoader(List.of(outputPath.toFile()), ClassLoader.getSystemClassLoader());
+    }
+
     public static Path path = Path.of(System.getProperty("user.dir"), "resources/bytecode/javFiles/");
 
     public static Map<String, ? extends Class<?>> generateClassFiles(IByteArrayClassLoader classLoader, String... files) throws IOException, ClassNotFoundException {
@@ -119,7 +123,7 @@ public class TestCodegen {
     public void testEmptyClass() throws Exception {
         var clazz = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("Empty"));
         clazz.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "main", List.of(), null, new TargetBlock(List.of()));
-        generateClass(clazz, new ByteArrayClassLoader()).getDeclaredMethod("main").invoke(null);
+        generateClass(clazz, createClassLoader()).getDeclaredMethod("main").invoke(null);
     }
 
     @Test
@@ -132,7 +136,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "mul", List.of(new MethodParameter(TargetType.Integer, "a"), new MethodParameter(TargetType.Integer, "b")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Mul(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"), new TargetLocalVar(TargetType.Integer, "b"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "rem", List.of(new MethodParameter(TargetType.Integer, "a"), new MethodParameter(TargetType.Integer, "b")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Rem(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"), new TargetLocalVar(TargetType.Integer, "b"))))));
 
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         assertEquals(clazz.getDeclaredMethod("add", Integer.class, Integer.class).invoke(null, 10, 10), 20);
         assertEquals(clazz.getDeclaredMethod("sub", Integer.class, Integer.class).invoke(null, 20, 10), 10);
         assertEquals(clazz.getDeclaredMethod("div", Integer.class, Integer.class).invoke(null, 20, 10), 2);
@@ -148,7 +152,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "neg", List.of(new MethodParameter(TargetType.Integer, "a")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetUnaryOp.Negate(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "add", List.of(new MethodParameter(TargetType.Integer, "a")), TargetType.Integer, new TargetBlock(List.of(new TargetReturn(new TargetUnaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "a"))))));
 
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         assertEquals(clazz.getDeclaredMethod("not", Integer.class).invoke(null, 10), -11);
         assertEquals(clazz.getDeclaredMethod("neg", Integer.class).invoke(null, 10), -10);
         assertEquals(clazz.getDeclaredMethod("add", Integer.class).invoke(null, 10), 10);
@@ -162,7 +166,7 @@ public class TestCodegen {
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "and", List.of(new MethodParameter(TargetType.Boolean, "a"), new MethodParameter(TargetType.Boolean, "b")), TargetType.Boolean, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.And(TargetType.Boolean, new TargetLocalVar(TargetType.Boolean, "a"), new TargetLocalVar(TargetType.Boolean, "b"))))));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "or", List.of(new MethodParameter(TargetType.Boolean, "a"), new MethodParameter(TargetType.Boolean, "b")), TargetType.Boolean, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Or(TargetType.Boolean, new TargetLocalVar(TargetType.Boolean, "a"), new TargetLocalVar(TargetType.Boolean, "b"))))));
 
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         var and = clazz.getDeclaredMethod("and", Boolean.class, Boolean.class);
         var or = clazz.getDeclaredMethod("or", Boolean.class, Boolean.class);
         assertEquals(and.invoke(null, true, false), false);
@@ -176,7 +180,7 @@ public class TestCodegen {
     public void testArithmeticConvert() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("ArithmeticConvert"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "add", List.of(), TargetType.Long, new TargetBlock(List.of(new TargetReturn(new TargetBinaryOp.Add(TargetType.Long, new TargetLiteral.CharLiteral((char) 10), new TargetLiteral.LongLiteral((long) 20))))));
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         assertEquals(clazz.getDeclaredMethod("add").invoke(null), (long) 30);
     }
 
@@ -185,7 +189,7 @@ public class TestCodegen {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("HelloWorld"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "helloWorld", List.of(), null, new TargetBlock(List.of(new TargetMethodCall(null, new TargetFieldVar(new TargetRefType("java.io.PrintStream"), new TargetRefType("java.lang.System"), true, new TargetClassName(new TargetRefType("java.lang.System")), "out"), List.of(new TargetLiteral.StringLiteral("Hello World!")), new TargetRefType("java.io.PrintStream"), "println", false, false, false))));
 
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         clazz.getDeclaredMethod("helloWorld").invoke(null);
     }
 
@@ -193,7 +197,7 @@ public class TestCodegen {
     public void testIfStatement() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("IfStmt"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "ifStmt", List.of(new MethodParameter(TargetType.Integer, "val")), TargetType.Integer, new TargetBlock(List.of(new TargetIf(new TargetBinaryOp.Equal(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "val"), new TargetLiteral.IntLiteral(10)), new TargetReturn(new TargetLiteral.IntLiteral(1)), new TargetIf(new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "val"), new TargetLiteral.IntLiteral(5)), new TargetReturn(new TargetLiteral.IntLiteral(2)), new TargetReturn(new TargetLiteral.IntLiteral(3)))))));
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         var ifStmt = clazz.getDeclaredMethod("ifStmt", Integer.class);
         assertEquals(ifStmt.invoke(null, 10), 1);
         assertEquals(ifStmt.invoke(null, 3), 2);
@@ -204,7 +208,7 @@ public class TestCodegen {
     public void testFor() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("For"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "forLoop", List.of(), TargetType.Integer, new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "sum", new TargetLiteral.IntLiteral(0)), new TargetFor(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0))), new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(10)), List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))), new TargetBlock(List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "sum"), new TargetLocalVar(TargetType.Integer, "i")))))), new TargetReturn(new TargetLocalVar(TargetType.Integer, "sum")))));
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         assertEquals(clazz.getDeclaredMethod("forLoop").invoke(null), 45);
     }
 
@@ -212,7 +216,7 @@ public class TestCodegen {
     public void testWhile() throws Exception {
         var targetClass = new TargetClass(Opcodes.ACC_PUBLIC, new JavaClassName("While"));
         targetClass.addMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "whileLoop", List.of(), TargetType.Integer, new TargetBlock(List.of(new TargetVarDecl(TargetType.Integer, "i", new TargetLiteral.IntLiteral(0)), new TargetWhile(new TargetBinaryOp.Less(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(10)), new TargetBlock(List.of(new TargetAssign(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetBinaryOp.Add(TargetType.Integer, new TargetLocalVar(TargetType.Integer, "i"), new TargetLiteral.IntLiteral(1)))))), new TargetReturn(new TargetLocalVar(TargetType.Integer, "i")))));
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         assertEquals(clazz.getDeclaredMethod("whileLoop").invoke(null), 10);
     }
 
@@ -235,7 +239,7 @@ public class TestCodegen {
                 new TargetReturn(new TargetLocalVar(TargetType.Integer, "res"))
         )));
 
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         var m = clazz.getDeclaredMethod("switchClassic", Integer.class);
         assertEquals(m.invoke(null, 10), 0);
         assertEquals(m.invoke(null, 15), 1);
@@ -264,7 +268,7 @@ public class TestCodegen {
                         List.of(new TargetLiteral.IntLiteral(2))
                 ), true), TargetType.Integer)
                 ))));
-        var clazz = generateClass(targetClass, new ByteArrayClassLoader());
+        var clazz = generateClass(targetClass, createClassLoader());
         var m = clazz.getDeclaredMethod("switchType", Object.class);
         assertEquals(m.invoke(null, "String"), 0);
         assertEquals(m.invoke(null,  10), 1);
@@ -273,9 +277,9 @@ public class TestCodegen {
     }
 
     @Test
-    @Ignore("The lambda class is not generated because we don't call ASTToTargetAST")
+    @Disabled("The lambda class is not generated because we don't call ASTToTargetAST")
     public void testLambda() throws Exception {
-        var classLoader = new ByteArrayClassLoader();
+        var classLoader = createClassLoader();
         // var fun = classLoader.loadClass(Path.of(System.getProperty("user.dir"), "src/test/java/targetast/Fun1$$.class"));
         var interfaceType = TargetFunNType.fromParams(List.of(TargetType.Integer), 1);