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>
@@ -71,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>
@@ -97,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>
@@ -110,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>
@@ -158,4 +158,4 @@ http://maven.apache.org/maven-v4_0_0.xsd">
 			<url>file:///${project.basedir}/maven-repository/</url>
 		</repository>
 	</distributionManagement>
-</project>
+</project>

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

@@ -14,6 +14,7 @@ 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.*;
@@ -87,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() {
@@ -232,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);
@@ -277,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);
@@ -760,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;
 
@@ -771,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)) {
@@ -779,21 +795,22 @@ 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());
 
-        mv.visitVarInsn(ALOAD, 0);
+        if (!state.isStatic)
+            mv.visitVarInsn(ALOAD, 0);
         for (var index = 0; index < lambda.captures().size(); index++) {
             var capture = lambda.captures().get(index);
             var pattern = (TargetTypePattern) capture.pattern();
@@ -1521,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);
@@ -1535,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)
@@ -1581,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)
@@ -1597,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());
@@ -1607,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);
@@ -1713,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());
@@ -1745,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);

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

@@ -1,5 +1,6 @@
 package de.dhbwstuttgart.core;
 
+import de.dhbwstuttgart.server.SocketClient;
 import de.dhbwstuttgart.util.Logger;
 import java.io.File;
 import java.io.IOException;
@@ -7,8 +8,12 @@ import java.util.*;
 
 public class ConsoleInterface {
 
+  /**
+   * 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<>();
@@ -16,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");
@@ -45,7 +49,7 @@ 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")) {
@@ -61,15 +65,15 @@ public class ConsoleInterface {
     }
 
     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;
@@ -81,29 +85,22 @@ public class JavaTXCompiler {
 	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());
+		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
@@ -398,81 +395,89 @@ public class JavaTXCompiler {
 
 		};
 
-		logger.debug("Unify:" + unifyCons.toString());
-		logger.info("Unify:" + unifyCons.toString());
-		unifyCons = unifyCons.map(distributeInnerVars);
-		logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
-		// Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
-		logger.debug("FC:\\" + finiteClosure.toString() + "\n");
-		logger.debug(ASTTypePrinter.print(sf));
-		logger.info(ASTTypePrinter.print(sf));
-		// logFile.flush();
-		logger.info("Unify nach Oder-Constraints-Anpassung:" + unifyCons.toString());
-		Set<PlaceholderType> varianceTPHold;
-		Set<PlaceholderType> varianceTPH = new HashSet<>();
-		varianceTPH = varianceInheritanceConstraintSet(unifyCons);
+    logger.debug("Unify:" + unifyCons.toString());
+    logger.info("Unify:" + unifyCons.toString());
+    unifyCons = unifyCons.map(distributeInnerVars);
+    logger.debug("\nUnify_distributeInnerVars: " + unifyCons.toString());
+    // Set<Set<UnifyPair>> results = new HashSet<>(); Nach vorne gezogen
+    logger.debug("FC:\\" + finiteClosure.toString() + "\n");
+    logger.info(ASTTypePrinter.print(sf));
+    // logFile.flush();
+    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);
 
 		/*
 		 * PL 2018-11-07 wird in varianceInheritanceConstraintSet erledigt do { //PL 2018-11-05 Huellenbildung Variance auf alle TPHs der Terme auf der jeweiligen //anderen Seite übertragen varianceTPHold = new HashSet<>(varianceTPH); varianceTPH = varianceInheritanceConstraintSet(unifyCons); unifyCons.map( y -> { if ((y.getLhsType() instanceof PlaceholderType) && (y.getRhsType() instanceof PlaceholderType)) { if (((PlaceholderType)y.getLhsType()).getVariance() != 0 &&
 		 * ((PlaceholderType)y.getRhsType()).getVariance() == 0) { ((PlaceholderType)y.getRhsType()).setVariance(((PlaceholderType)y.getLhsType( )).getVariance()); } if (((PlaceholderType)y.getLhsType()).getVariance() == 0 && ((PlaceholderType)y.getRhsType()).getVariance() != 0) { ((PlaceholderType)y.getLhsType()).setVariance(((PlaceholderType)y.getRhsType( )).getVariance()); } } return y; } ); } while (!varianceTPHold.equals(varianceTPH));
 		 */
 
-		// Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
-		// logFile, log);
-		// Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
-		List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .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))
-		 */;
+    // Set<Set<UnifyPair>> result = unify.unifySequential(xConsSet, finiteClosure,
+    // logFile, log);
+    // Set<Set<UnifyPair>> result = unify.unify(xConsSet, finiteClosure);
+    List<Set<Constraint<UnifyPair>>> oderConstraints = unifyCons.getOderConstraints()// .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))
+     */;
+    if (ConsoleInterface.unifyServerUrl.isPresent()) {
+        UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
+        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(logger, true, urm, usedTasks, placeholderRegistry);
+				TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+        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 */
+    else {
+        // Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
+        // oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
+        // finiteClosure));
+        UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
+        Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
+        logger.info("RESULT: " + result);
+        results.addAll(result);
 
-		if (unifyServer.isPresent()) {
-			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
-			SocketClient socketClient = new SocketClient(unifyServer.get());
-			return socketClient.execute(finiteClosure, cons, unifyCons, context);
-		}
-		else if (resultmodel) {
-			/* UnifyResultModel Anfang */
-			UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
-			UnifyResultListenerImpl li = new UnifyResultListenerImpl();
-			urm.addUnifyResultListener(li);
-			UnifyContext context = new UnifyContext(logger, true, urm, usedTasks, placeholderRegistry);
-			TypeUnify.unifyParallel(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-			logger.info("RESULT Final: " + li.getResults());
-			logger.info("Constraints for Generated Generics: " + " ???");
-			logFile.write("RES_FINAL: " + li.getResults().toString() + "\n");
-			// logFile.flush();
-			return li.getResults();
-		}
-		/* UnifyResultModel End */
-		else {
-			// Set<Set<UnifyPair>> result = unify.unify(unifyCons.getUndConstraints(),
-			// oderConstraints, finiteClosure, logFile, log, new UnifyResultModel(cons,
-			// finiteClosure));
-			UnifyContext context = new UnifyContext(logger, false, new UnifyResultModel(cons, finiteClosure), usedTasks, placeholderRegistry);
-			Set<Set<UnifyPair>> result = TypeUnify.unifyOderConstraints(unifyCons.getUndConstraints(), oderConstraints, finiteClosure, context);
-			logger.info("RESULT: " + result);
-			logFile.write("RES: " + result.toString() + "\n");
-			// logFile.flush();
-			results.addAll(result);
-
-			results = results.stream().map(x -> {
-				Optional<Set<UnifyPair>> res = new RuleSet(placeholderRegistry).subst(x.stream().map(y -> {
-					if (y.getPairOp() == PairOperator.SMALLERDOTWC)
-						y.setPairOp(PairOperator.EQUALSDOT);
-					return y; // alle Paare a <.? b erden durch a =. b ersetzt
-				}).collect(Collectors.toCollection(HashSet::new)));
-				if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
-					return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
-				} else
-					return x; // wenn nichts veraendert wurde wird x zurueckgegeben
-			}).collect(Collectors.toCollection(HashSet::new));
-			logger.info("RESULT Final: " + results);
-			logger.info("Constraints for Generated Generics: " + " ???");
-			logger.debug("RES_FINAL: " + results.toString() + "\n");
-			// logFile.flush();
-			logger.debug("PLACEHOLDERS: " + placeholderRegistry);
-			// logFile.flush();
+        results = results.stream().map(x -> {
+          Optional<Set<UnifyPair>> res = new RuleSet(placeholderRegistry).subst(x.stream().map(y -> {
+            if (y.getPairOp() == PairOperator.SMALLERDOTWC)
+              y.setPairOp(PairOperator.EQUALSDOT);
+            return y; // alle Paare a <.? b erden durch a =. b ersetzt
+          }).collect(Collectors.toCollection(HashSet::new)));
+          if (res.isPresent()) {// wenn subst ein Erg liefert wurde was veraendert
+            return new TypeUnifyTask(context).applyTypeUnificationRules(res.get(), finiteClosure);
+          } else
+            return x; // wenn nichts veraendert wurde wird x zurueckgegeben
+        }).collect(Collectors.toCollection(HashSet::new));
+        logger.info("RESULT Final: " + results);
+        logger.info("Constraints for Generated Generics: " + " ???");
+        logger.debug("RES_FINAL: " + results.toString() + "\n");
+        // logFile.flush();
+        logger.debug("PLACEHOLDERS: " + placeholderRegistry);
+        // logFile.flush();
 		}
 
 		return results.stream().map((unifyPairs -> new ResultSet(UnifyTypeFactory.convert(unifyPairs, Pair.generateTPHMap(cons), placeholderRegistry)))).collect(Collectors.toList());
@@ -648,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;
 	}
 
@@ -669,7 +674,7 @@ public class JavaTXCompiler {
 			output = new FileOutputStream(outputFile);
 			output.write(bytecode);
 			output.close();
-			defaultLogger.info(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/SyntaxTreeGenerator/StatementGenerator.java

@@ -1100,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/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;
@@ -17,6 +19,7 @@ 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;
@@ -32,39 +35,31 @@ public class SocketClient extends WebSocketClient {
 
   public static Logger logger = new Logger("SocketClient");
 
-  // 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;
+  /**
+   * The singleton object
+   */
+  private static SocketClient socketClient = null;
 
-  public SocketClient(String url) {
-    super(URI.create(url), Map.of(
-      "packetProtocolVersion", SocketServer.packetProtocolVersion
-    ));
-    // make sure, the url is in a valid format
+  /**
+   * 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
     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
@@ -73,62 +68,108 @@ 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);
-    }
-    catch (Exception exception) {
-      throw new RuntimeException("Exception occurred in server connection: ", exception);
+      throw new RuntimeException(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");
-    }
+    // 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));
+  }
 
-    return unifyResultPacket.getResultSet(context);
+  private SocketClient(String host, int port, boolean secure) throws InterruptedException {
+    this(String.format("%s://%s:%d/", secure ? "wss" : "ws", host, port));
   }
 
   /**
-   *  Specific client-side implementations to handle incoming packets
+   * 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);
+    }
+
+    return future;
+  }
+
+  /**
+   * 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();
-        this.close();
-        throw exception;
-      }
-
+    if (!(packet instanceof IServerToClientPacket serverToClientPacket)) {
+      System.err.println("Received package of invalid type + " + packet.getClass().getName());
+      this.close();
       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) {
-    logger.info("Connected to server with status " + handshakedata.getHttpStatus());
+    logger.success("Connected to server with status " + handshakedata.getHttpStatus());
   }
 
   @Override
@@ -146,16 +187,16 @@ public class SocketClient extends WebSocketClient {
         (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) {
-    logger.error("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

@@ -1,7 +1,6 @@
 package de.dhbwstuttgart.server;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.server.packet.ErrorPacket;
 import de.dhbwstuttgart.server.packet.IClientToServerPacket;
 import de.dhbwstuttgart.server.packet.IPacket;
@@ -9,69 +8,98 @@ 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;
 
 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";
 
+  // 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,
-          true
-        );
-        webSocket.send(PacketContainer.serialize(errorPacket));
-      }
-      catch (JsonProcessingException exception) {
-        System.err.println("Failed to serialize json: " + exception);
-      }
+      this.sendError(webSocket,
+        "Mismatch in packet protocol version! Client (you): \"" + ppv + "\" and Server (me): \"" + packetProtocolVersion + "\"",
+        true
+      );
       webSocket.close(1);
       return;
     }
 
-
-    SocketData socketData = new SocketData(UUID.randomUUID().toString());
-    webSocket.setAttachment(socketData);
+    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) {
@@ -101,20 +129,22 @@ public class SocketServer extends WebSocketServer {
       this.onPacketReceived(webSocket, reconstructedPacket);
     } catch (JsonProcessingException e) {
       logger.exception(e);
-      this.log("Error on processing incoming package: " + e.getMessage(), webSocket);
+      this.log(webSocket, "Error on processing incoming package: " + e.getMessage());
     }
   }
 
   @Override
   public void onError(WebSocket webSocket, Exception e) {
+    if (webSocket != null) {
+      log(webSocket, e.getMessage());
+      webSocket.close();
+    }
     logger.exception(e);
-    log(e.getMessage(), webSocket);
-    webSocket.close();
   }
 
   @Override
   public void onStart() {
-    logger.info("Websocket server started on port " + this.getPort());
+    logger.success("Websocket server started on port " + this.getPort());
   }
 
   /**
@@ -122,8 +152,7 @@ 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);
@@ -134,33 +163,31 @@ public class SocketServer extends WebSocketServer {
   /**
    * 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) {
       logger.exception(e);
-      log("Failed to send error: " + text, webSocket);
+      log(webSocket, "Failed to send error: " + text);
     }
   }
 
   /**
-   *  The server-side implementation on how to handle certain packets when received
+   * The server-side implementation on how to handle certain packets when received
    */
   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;
     }
@@ -169,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 (remainingUnhandledTasks <= 0) {
-        sendMessage(webSocket, "All requested tasks finished! Closing connection...");
-        webSocket.close();
+
+      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();
-    logger.info("["+socketData.id+"] " + msg);
+  public void log(WebSocket webSocket, String msg) {
+    String socketId = (webSocket == null) ? "???" : webSocket.<SocketData>getAttachment().id;
+    logger.info("[" + socketId + "] " + msg);
   }
 
   /**
@@ -196,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

@@ -25,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);
@@ -47,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);
   }
@@ -76,6 +81,8 @@ 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");

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;
@@ -20,18 +23,16 @@ 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.FileWriter;
-import java.io.IOException;
-import java.io.Writer;
 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;
@@ -39,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;
   }
 
 
@@ -95,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...");
-    SocketServer.logger.info("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(Logger.NULL_LOGGER, true,
-        new UnifyResultModel(new ConstraintSet<>(), new FiniteClosure(new HashSet<>(), Logger.NULL_LOGGER, 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
       );
 
@@ -130,17 +141,24 @@ public class UnifyRequestPacket implements IClientToServerPacket {
 
       var resultSets = resultListener.getResults();
 
-      SocketServer.logger.info("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) {
       SocketServer.logger.exception(e);
-      socketServer.log(e.getMessage(), webSocket);
+      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) {
-    SocketClient.logger.info("[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/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,8 @@ 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.*;
@@ -67,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) {
@@ -782,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;
@@ -819,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);
         }
     }
@@ -857,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/StatementToTargetExpression.java

@@ -15,6 +15,7 @@ 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;
@@ -33,54 +34,71 @@ public class StatementToTargetExpression implements ASTVisitor {
         throw new NotImplementedException();
     }
 
+    private class LambdaCaptureFinder extends 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) {
+            for (var localVariables : this.localVariables) {
+                if (localVariables.contains(name))
+                    return true;
+            }
+            return false;
+        }
+
+        @Override
+        public void visit(Block block) {
+            localVariables.push(new HashSet<>());
+            super.visit(block);
+            localVariables.pop();
+        }
+
+        @Override
+        public void visit(LocalVar localVar) {
+            super.visit(localVar);
+            var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType()), localVar.name));
+            if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
+                captures.add(capture);
+        }
+
+        @Override
+        public void visit(LocalVarDecl varDecl) {
+            var localVariables = this.localVariables.peek();
+            localVariables.add(varDecl.getName());
+        }
+
+        @Override
+        public void visit(LambdaExpression lambda) {
+            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 = StreamSupport.stream(lambdaExpression.params.spliterator(), false)
-                .map(p -> (FormalParameter) p)
-                .map(p -> new MethodParameter(new TargetTypePattern(converter.convert(p.getType()), p.getName())))
-                .toList();
-
+        var parameters = createParameters(lambdaExpression);
         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<>();
-            {
-                localVariables.push(new HashSet<>());
-            }
-
-            boolean hasLocalVar(String name) {
-                for (var localVariables : this.localVariables) {
-                    if (localVariables.contains(name))
-                        return true;
-                }
-                return false;
-            }
-
-            @Override
-            public void visit(Block block) {
-                localVariables.push(new HashSet<>());
-                super.visit(block);
-                localVariables.pop();
-            }
-
-            @Override
-            public void visit(LocalVar localVar) {
-                super.visit(localVar);
-                var capture = new MethodParameter(new TargetTypePattern(converter.convert(localVar.getType()), localVar.name));
-                if (!hasLocalVar(localVar.name) && !parameters.contains(capture) && !captures.contains(capture))
-                    captures.add(capture);
-            }
-
-            @Override
-            public void visit(LocalVarDecl varDecl) {
-                var localVariables = this.localVariables.peek();
-                localVariables.add(varDecl.getName());
-            }
-
-            @Override
-            public void visit(LambdaExpression lambda) {
-            } // Don't look at lambda expressions
-        });
+        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());
@@ -121,7 +139,10 @@ public class StatementToTargetExpression implements ASTVisitor {
 
     @Override
     public void visit(BoolExpression bool) {
-        Target.logger.info("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

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,84 +9,97 @@ 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 {
-  private static final long serialVersionUID = 1L;
-  private Boolean isInherited = false;//wird beides nur für die Method-Constraints benoetigt
-  private Boolean isImplemented = false;
+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;
+	
+	/*
+	 * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
+	 * auszuwaehlen 
+	 */
+	/*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
+	
+	private Constraint<A> extendConstraint = null;
+	
+	public Constraint() {
+		super();
+	}
 
-  /*
-   * wird verwendet um bei der Codegenerierung die richtige Methoden - Signatur
-   * auszuwaehlen
-   */
-  /*private*/ Set<A> methodSignatureConstraint = new HashSet<>();
-
-  private Constraint<A> extendConstraint = null;
-
-  public Constraint() {
-    super();
+  public Constraint(int initialCapacity) {
+    super(initialCapacity);
   }
 
-  public Constraint(Boolean isInherited, Boolean isImplemented) {
-    this.isInherited = isInherited;
-    this.isImplemented = isImplemented;
+	public Constraint(boolean isInherited, boolean isImplemented) {
+		this.isInherited = isInherited;
+		this.isImplemented = isImplemented;
+	}
+	
+	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) {
+		this.isInherited = isInherited;
+	}
+	
+	public boolean isInherited() {
+		return isInherited;
+	}
+	
+	public boolean isImplemented() {
+		return isImplemented;
+	}
+	
+	public Constraint<A> getExtendConstraint() {
+		return extendConstraint;
+	}
+	
+	public void setExtendConstraint(Constraint<A> c) {
+		extendConstraint = c;
+	}
+	
+	public Set<A> getmethodSignatureConstraint() {
+		return methodSignatureConstraint;
+	}
+	
+	public void setmethodSignatureConstraint(Set<A> c) {
+		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 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) {
-    this.isInherited = isInherited;
-  }
-
-  public Boolean isInherited() {
-    return isInherited;
-  }
-
-  public Boolean isImplemented() {
-    return isImplemented;
-  }
-
-  public Constraint<A> getExtendConstraint() {
-    return extendConstraint;
-  }
-
-  public void setExtendConstraint(Constraint<A> c) {
-    extendConstraint = c;
-  }
-
-  public Set<A> getmethodSignatureConstraint() {
-    return methodSignatureConstraint;
-  }
-
-  public void setmethodSignatureConstraint(Set<A> c) {
-    methodSignatureConstraint = c;
-  }
-
-  public String toString() {
+	public String toString() {
     return super.toString() + "\nisInherited = " + isInherited
       + " isOveridden = " + isImplemented
       + " msc[" + methodSignatureConstraint.size() + "] = " + methodSignatureConstraint
       //" + extendsContraint: "  + (extendConstraint != null ? extendConstraint.toStringBase() : "null" )
       + "\n";
-  }
+	}
+	
+	public String toStringBase() {
+		return super.toString();
+	}
 
-  public String toStringBase() {
-    return super.toString();
+
+  @Override
+  public int compareTo(Constraint<A> o) {
+    return this.toString().compareTo(o.toString());
   }
 
   private String serialUUID = null;
@@ -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,11 +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;
@@ -22,28 +24,32 @@ 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) {
-    this.results = set;
-    this.genIns = new HashSet<>();
-    results.forEach(x -> {
-      if (x instanceof PairTPHsmallerTPH) {
-        this.genIns.add(x);
-      }
-    });
-  }
+    public ResultSet(Set<ResultPair> set){
+        this.results = set;
+        this.genIns = TypeUnifyTaskHelper.getPresizedHashSet(results.size());
+        results.forEach(x -> {
+          if (x instanceof PairTPHsmallerTPH) {
+            this.genIns.add(x);
+          }
+        });
+    }
 
-  public boolean contains(ResultPair toCheck) {
-    return this.results.contains(toCheck);
-  }
+    public List<ResultPair> getSortedResults() {
+      return results.stream().sorted().toList();
+    }
 
-  public void remove(ResultPair toCheck) {
-    results.remove(toCheck);
-  }
+    public boolean contains(ResultPair toCheck) {
+    	return this.results.contains(toCheck);
+    }
+    
+    public void remove(ResultPair toCheck) {
+    	results.remove(toCheck);
+    }
 
   public ResolvedType resolveType(RefTypeOrTPHOrWildcardOrGeneric type) {
     if (type instanceof TypePlaceholder)
@@ -86,9 +92,24 @@ public class ResultSet implements ISerializableData {
     }
   }
 
+	@Override
+	public int hashCode() {
+		return results.hashCode();
+	}
+
   @Override
-  public int hashCode() {
-    return results.hashCode();
+  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

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)));
@@ -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 {
@@ -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();
@@ -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();
-                        recursivelyAddRecordConstraints(pattern);
-                    }
-
+                  if (el.getPattern() instanceof RecordPattern pattern) {
+                    recursivelyAddRecordConstraints(pattern);
+                  }
                 }
             });
 
@@ -905,7 +909,7 @@ 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;
 

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

@@ -94,8 +94,8 @@ public class MartelliMontanariUnify implements IUnify {
 			// SUBST - Rule
 			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));
+				//PL 2018-04-01 nach checken, ob es richtig ist, dass keine Substitutionen uebergeben werden muessen.
+				termsList.replaceAll(mgu::apply);
 				idx = idx+1 == termsList.size() ? 0 : idx+1;
 				continue;
 			}

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

@@ -6,6 +6,7 @@ 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;
@@ -648,15 +649,17 @@ 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());
 			occuringTypes.push(pair.getRhsType());
 		}
-		
+
 		while(!occuringTypes.isEmpty()) {
 			UnifyType t1 = occuringTypes.pop();
 			if(!typeMap.containsKey(t1))
@@ -668,12 +671,12 @@ 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;
-		
+
 		while(!result1.isEmpty()) {
 			UnifyPair pair = result1.poll();
 			PlaceholderType lhsType = null;
@@ -691,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
@@ -858,8 +872,8 @@ public class RuleSet implements IRuleSet{
         								   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 								     } );
 
-		logger.debug("FUNgreater: " + pair);
-		logger.debug("FUNred: " + result);
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNred: " + result);
 
 
 		return Optional.of(result);
@@ -927,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++) {
@@ -946,13 +960,13 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(rhsType, funNLhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+									   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
 									   UnifyType r = x.getRhsType();
 									   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
 
-		logger.debug("FUNgreater: " + pair);
-		logger.debug("FUNgreater: " + result);
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNgreater: " + result);
 
 		return Optional.of(result);
 	}
@@ -972,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++) {
@@ -992,14 +1006,14 @@ public class RuleSet implements IRuleSet{
 		result.add(new UnifyPair(lhsType, funNRhsType.setTypeParams(new TypeParams(freshPlaceholders)), PairOperator.EQUALSDOT, pair.getSubstitution(), pair.getBasePair()));
 		
 		result.stream().forEach(x -> { UnifyType l = x.getLhsType();
-		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); } 
+		   							   if (l instanceof PlaceholderType) { ((PlaceholderType)l).disableWildcardtable(); }
 		   							   UnifyType r = x.getRhsType();
 		   							   if (r instanceof PlaceholderType) { ((PlaceholderType)r).disableWildcardtable(); }
 									 } );
 
 
-		logger.debug("FUNgreater: " + pair);
-		logger.debug("FUNsmaller: " + result);
+		logger.debug(() -> "FUNgreater: " + pair);
+		logger.debug(() -> "FUNsmaller: " + result);
 
 		return Optional.of(result);
 	}

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

@@ -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;

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;
@@ -49,7 +46,6 @@ import java.util.concurrent.RecursiveTask;
 import java.util.function.BiFunction;
 import java.util.function.BinaryOperator;
 import java.util.stream.Collectors;
-import org.apache.commons.io.output.NullOutputStream;
 
 
 /**
@@ -57,7 +53,7 @@ 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;
@@ -106,19 +102,17 @@ 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.newWithLogger(Logger.NULL_LOGGER);
     rules = new RuleSet(context.placeholderRegistry());
@@ -155,7 +149,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     this.fc = fc;
     this.oup = new OrderingUnifyPair(fc, context);
 
-    this.context = context.newWithLogger(
+    this.context = (context.logger() instanceof ServerTaskLogger) ? context : context.newWithLogger(
       Logger.forFile(
         System.getProperty("user.dir") + "/logFiles/" + "Thread",
         "Unify"
@@ -213,13 +207,6 @@ 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) {
@@ -249,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<>();
       }
 
@@ -286,14 +273,14 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     //.collect(Collectors.toCollection(HashSet::new)));
 
-    if (this.myIsCancelled()) {
+    if (this.isExecutionCancelled()) {
       return CompletableFuture.completedFuture(new HashSet<>());
     }
 
     rekTiefe++;
     nOfUnify++;
-    context.logger().debug(nOfUnify.toString() + " Unifikation: " + eq.toString());
-    context.logger().debug(nOfUnify.toString() + " Oderconstraints: " + oderConstraints.toString());
+    context.logger().debug(() -> nOfUnify + " Unifikation: " + eq.toString());
+    context.logger().debug(() -> nOfUnify + " Oderconstraints: " + oderConstraints.toString());
 
     /*
      * Variancen auf alle Gleichungen vererben
@@ -315,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));
-    context.logger().debug("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);
@@ -344,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));
-      context.logger().debug("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);
@@ -364,8 +340,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     eq0.forEach(UnifyPair::disableCondWildcards);
 
-    context.logger().debug(nOfUnify.toString() + " Unifikation nach applyTypeUnificationRules: " + eq.toString());
-    context.logger().debug(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
@@ -417,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.
-    context.logger().debug(nOfUnify.toString() + " Oderconstraints2: " + oderConstraintsOutput.toString());
+    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) {
-        context.logger().debug(noUndefPair.toString() + " UndefinedPairs; " + up);
-        context.logger().debug("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 -> context.logger().debug("AllSubst: " + x.getAllSubstitutions().toString()));
+      undefinedPairs.forEach(x -> context.logger().debug(() -> "AllSubst: " + x.getAllSubstitutions().toString()));
       return CompletableFuture.completedFuture(error);
     }
 
@@ -487,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<>());
     }
 
@@ -506,14 +482,14 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
      * Step 5: Substitution
      */
     //writeLog("vor Subst: " + eqPrime);
-    context.logger().debug("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()))
-      context.logger().debug("nach Subst: " + newOderConstraints);
+      context.logger().debug(() -> "nach Subst: " + newOderConstraints);
 
 
     {// sequentiell (Step 6b is included)
@@ -536,7 +512,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
           return eqPrimePrimeSet;
         });
         if (finalresult && isSolvedForm(eqPrime)) {
-          context.logger().debug("eqPrime:" + eqPrime.toString() + "\n");
+          context.logger().debug(() -> "eqPrime:" + eqPrime.toString() + "\n");
 
           /* methodconstraintsets werden zum Ergebnis hinzugefuegt
            * Anfang
@@ -592,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)) {
-        context.logger().debug("Result1 " + eqPrimePrimeSet);
+        Set<Set<UnifyPair>> finalEqPrimePrimeSet = eqPrimePrimeSet;
+        context.logger().debug(() -> "Result1 " + finalEqPrimePrimeSet);
       }
       return eqPrimePrimeSet;
     });
@@ -680,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);
-      context.logger().debug("optOrigPair: " + optOrigPair);
+      context.logger().debug(() -> "optOrigPair: " + optOrigPair);
 
       if (optOrigPair.isPresent()) {
         sameEqSet = TypeUnifyTaskHelper.findConstraintsWithSameTVAssociation(optOrigPair.get(), singleElementSets);
       }
+    } else {
+      optOrigPair = Optional.empty();
     }
 
 
@@ -697,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
-      context.logger().debug("Return computeCR: " + result.toString());
+      context.logger().debug(() ->"Return computeCR: " + result.toString());
       return result;
     });
   }
@@ -724,14 +703,14 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     VarianceCase varianceCase = VarianceCase.createFromVariance(variance, oderConstraint, this, context);
 
-    context.logger().debug("nextSet: " + nextSet.toString());
-    context.logger().debug("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());
-      context.logger().debug("ERSTELLUNG methodSignatureConstraint: " + methodSignatureConstraint);
+      context.logger().debug(() -> "ERSTELLUNG methodSignatureConstraint: " + methodSignatureConstraint);
       //context.logger().info("ERSTELLUNG methodSignatureConstraint: " +noOfThread+" "+methodSignatureConstraint);
       //context.logger().info("a: " +a);
       //context.logger().info("eq: " +eq);
@@ -740,7 +719,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
     i++;
     Set<Set<UnifyPair>> elems = new HashSet<>(singleElementSets);
-    context.logger().debug("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<>();
 
@@ -761,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(
@@ -772,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;
@@ -814,7 +797,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             //context.logger().info(a_last);
 
             try {//PL eingefuegt 2019-03-06 da bei map mmer wieder Nullpointer kamen
-              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.
+              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
@@ -823,11 +806,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
 
               varianceCase.applyComputedResults(result, currentThreadResult, compResult, compRes);
             } catch (NullPointerException e) {
-              context.logger().debug("NullPointerException: " + a_last.toString());
+              context.logger().debug(() -> "NullPointerException: " + a_last.toString());
             }
           } else {
             //alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
-            context.logger().debug("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);
           }
         }
@@ -852,7 +836,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
               || (!isUndefinedPairSetSet(par_res) && !isUndefinedPairSetSet(result))
               || result.isEmpty()) {
               //alle Fehlerfaelle und alle korrekten Ergebnis jeweils adden
-              context.logger().debug("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);
             }
           }
@@ -873,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);
         }
 
-        context.logger().debug("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)
@@ -913,7 +898,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         if (currentThreadResult.size() > 1) {
           // context.logger().info();
         }
-        context.logger().debug("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;
@@ -924,23 +910,28 @@ 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));
         }
-        context.logger().debug("nextSetasList nach filter-Aufruf: " + nextSetAsList);
-        nofstred = nextSetAsList.size();
-        //NOCH NICHT korrekt PL 2018-10-12
-        //nextSetasList = nextSetasList.stream().filter(y -> couldBecorrect(reducedUndefResSubstGroundedBasePair, y))
-        //			.collect(Collectors.toCollection(ArrayList::new));
-        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());
-        context.logger().debug("Number of all erased Elements (undef): " + noAllErasedElements.toString());
-        context.logger().debug("Number of Backtracking: " + noBacktracking++);
+
+        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));
+          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());
+          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) {
@@ -950,7 +941,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       //	result.removeIf(y -> isUndefinedPairSet(y));
       //}
       //else result.stream().filter(y -> !isUndefinedPairSet(y));
-      context.logger().debug("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);
@@ -967,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
@@ -987,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());
 
-      context.logger().debug("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<>();
@@ -1008,7 +999,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             if (result.isEmpty() || isUndefinedPairSetSet(result)) {
               result.addAll(localRes);
             }
-            context.logger().debug("FALSE: " + aPair + "sameEqSet: " + sameEqSet);
+            context.logger().debug(() ->"FALSE: " + aPair + "sameEqSet: " + sameEqSet);
             return false;
           }
         } else {
@@ -1030,12 +1021,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
             if (result.isEmpty() || isUndefinedPairSetSet(result)) {
               result.addAll(localRes);
             }
-            context.logger().debug("FALSE: " + aPair + "sameEqSet: " + sameEqSet);
+            context.logger().debug(() ->"FALSE: " + aPair + "sameEqSet: " + sameEqSet);
             return false;
           }
         }
       }
-      context.logger().debug("TRUE: " + aPair + "sameEqSet: " + sameEqSet);
+      context.logger().debug(() ->"TRUE: " + aPair + "sameEqSet: " + sameEqSet);
       return true;
     }
     return true;
@@ -1121,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 {
-              context.logger().debug("Second erase:" + checkPair);
+              context.logger().debug(() ->"Second erase:" + checkPair);
               return false;
             }
             //*/
@@ -1320,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) {
-    context.logger().debug("eq2s: " + eq2s.toString());
+    context.logger().debug(() ->"eq2s: " + eq2s.toString());
     oderConstraintsOutput.addAll(oderConstraintsInput);
     List<Set<Set<? extends Set<UnifyPair>>>> result = new ArrayList<>(9);
 
@@ -1407,10 +1398,12 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       }
     }
 
-    context.logger().debug("eq2s: " + eq2s);
-    context.logger().debug("eq2sAsListFst: " + eq2sAsListFst);
-    context.logger().debug("eq2sAsListSnd: " + eq2sAsListSnd);
-    context.logger().debug("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);
@@ -1707,7 +1700,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
     //}
     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>???]
 
-    context.logger().debug("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
@@ -1718,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;
@@ -1739,7 +1733,8 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
       if ((match.match(ml)).isEmpty()) {
         thetaQs.remove(c);
       }
-      context.logger().debug("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,
@@ -1763,7 +1758,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         for (TypeParams tp : permuteParams(candidateParams))
           thetaQPrimes.add(c.setTypeParams(tp));
       }
-      context.logger().debug("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);
@@ -1836,7 +1831,7 @@ public class TypeUnifyTask extends RecursiveTask<CompletableFuture<Set<Set<Unify
         }
       }
     }
-    context.logger().debug("result von " + pair + ": " + result);
+    context.logger().debug(() ->"result von " + pair + ": " + result);
     return result;
   }
 

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

@@ -9,7 +9,7 @@ public record UnifyContext(
   // 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
@@ -22,7 +22,7 @@ public record UnifyContext(
 
   public UnifyContext(
     Logger logger,
-    Boolean parallel,
+    boolean parallel,
     UnifyResultModel resultModel,
     UnifyTaskModel usedTasks,
     ExecutorService executor,
@@ -33,7 +33,7 @@ public record UnifyContext(
 
   public UnifyContext(
     Logger logger,
-    Boolean parallel,
+    boolean parallel,
     UnifyResultModel resultModel,
     UnifyTaskModel usedTasks,
     PlaceholderRegistry placeholderRegistry
@@ -52,6 +52,7 @@ public record UnifyContext(
   }
 
   public UnifyContext newWithParallel(boolean parallel) {
+    if (this.parallel == parallel) return this;
     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);
   }
 
@@ -37,7 +36,7 @@ public class Variance1Case extends VarianceCase {
     if (this.isOderConstraint) {
       nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
     }
-    context.logger().debug("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,18 +67,19 @@ 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) -> {
+    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 */
 
@@ -108,16 +104,17 @@ 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();
           }
           context.logger().debug("fork_res: " + fork_res.toString());
           context.logger().debug(Boolean.valueOf((typeUnifyTask.isUndefinedPairSetSet(fork_res))).toString());
-          prevResults.getSecond().add(fork_res);
+          prevResults.addForkResult(fork_res);
           if (!typeUnifyTask.isUndefinedPairSetSet(fork_res)) {
             aParDef.add(fork.getNextSetElement());
           }
@@ -127,8 +124,8 @@ public class Variance1Case extends VarianceCase {
         }
       );
 
-      if (typeUnifyTask.myIsCancelled()) {
-        throw new UnifyCancelException();
+      if (typeUnifyTask.isExecutionCancelled()) {
+        return CompletableFuture.completedFuture(new ComputationResults());
       }
     }
 

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());
-    context.logger().debug("Min: a in " + variance + " " + a);
+    context.logger().debug(() -> "Min: a in " + variance + " " + a);
     if (this.isOderConstraint) {
       nextSetasListOderConstraints.add(((Constraint<UnifyPair>) a).getExtendConstraint());
     }
-    context.logger().debug("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) -> {
+    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 */
 
-    context.logger().debug("a in " + variance + " " + a);
-    context.logger().debug("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);
-      context.logger().debug("-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,16 +105,17 @@ 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;
           }
-          context.logger().debug("fork_res: " + fork_res.toString());
-          context.logger().debug(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());
           }
@@ -128,8 +125,8 @@ public class VarianceM1Case extends VarianceCase {
         }
       );
 
-      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) {
-      context.logger().debug("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) {
-      context.logger().debug("Geloescht currentThreadResult: " + currentThreadResult);
+      context.logger().debug(() -> "Geloescht currentThreadResult: " + currentThreadResult);
       //result = result;
     }
   }
@@ -165,13 +162,13 @@ public class VarianceM1Case extends VarianceCase {
   ) {
 
     // context.logger().info("");
-    context.logger().debug("a: " + rekTiefe + " variance: " + variance + a.toString());
-    context.logger().debug("aParDef: " + aParDef.toString());
+    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);
-      context.logger().debug("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);
 
-        context.logger().debug("Removed: " + erased);
+        context.logger().debug(() -> "Removed: " + erased);
 
-        context.logger().debug("Not Removed: " + nextSetAsList);
+        context.logger().debug(() -> "Not Removed: " + nextSetAsList);
 
       }
     } else {
@@ -217,9 +214,9 @@ public class VarianceM1Case extends VarianceCase {
 
         nextSetAsList.removeAll(erased);
 
-        context.logger().debug("Removed: " + erased);
+        context.logger().debug(() -> "Removed: " + erased);
 
-        context.logger().debug("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,8 +49,6 @@ public class Variance2Case extends VarianceCase {
     Set<Set<UnifyPair>> result,
     Set<Set<UnifyPair>> aParDef
   ) {
-    CompletableFuture<Tuple<Set<Set<UnifyPair>>, Set<Set<Set<UnifyPair>>>>> resultValuesFuture;
-
     context.logger().debug("var2einstieg");
     Set<TypeUnify2Task> forks = new HashSet<>();
     Set<UnifyPair> newEqOrig = new HashSet<>(eq);
@@ -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) -> {
+    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 */
 
-    context.logger().debug("a in " + variance + " " + a);
-    context.logger().debug("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);
+        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
   ) {
-    context.logger().debug("RES var=1 ADD:" + result.toString() + " " + currentThreadResult.toString());
+    context.logger().debug("RES var=0 ADD:" + result.toString() + " " + currentThreadResult.toString());
     result.addAll(currentThreadResult);
   }
 

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,11 +17,11 @@ 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);
-      default -> throw new RuntimeException("Invalid variance: " + variance);
+      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,
@@ -104,4 +104,29 @@ public abstract class VarianceCase {
     Set<Set<UnifyPair>> aParDef,
     List<Set<UnifyPair>> nextSetAsList
   );
+
+  /**
+   * 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

@@ -12,15 +12,12 @@ 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;
+	public static int inverseVariance(int variance) {
+		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/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/Node.java

@@ -53,7 +53,7 @@ class Node<T> {
 			addDescendant(descendant);
 		}
 	}
-	
+
 	/**
 	 * Adds a directed edge from the predecessor to this node (predecessor -> this)
 	 */
@@ -73,7 +73,7 @@ class Node<T> {
 			addPredecessor(predecessor);
 		}
 	}
-	
+
 	/**
 	 * The content of this node.
 	 */

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

@@ -48,7 +48,7 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 				return fc.compare(left.getRhsType(), right.getRhsType(), PairOperator.SMALLERDOT, context);
 		}}
 		catch (ClassCastException e) {
-			((FiniteClosure)fc).logger.debug("ClassCastException: " + left.toString() + " " + left.getGroundBasePair() + "\n\n");
+			((FiniteClosure)fc).logger.debug(() -> "ClassCastException: " + left.toString() + " " + left.getGroundBasePair() + "\n\n");
 			return -99;
 		}
 	}
@@ -170,30 +170,66 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		left.add(p2);
 		left.add(p4);
 		*/
-		
 
-		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));
+		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;
+
+			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")) {
@@ -201,54 +237,14 @@ public class OrderingUnifyPair extends OrderingExtend<Set<UnifyPair>> {
 		//}
 		
 		//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) {
 					try {
@@ -270,89 +266,73 @@ 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) {
-				ArrayList<UnifyPair> matchList = 
-						rightleOder.stream().map(x -> { 
-							UnifyPair leftElem = leftleOder.stream()
+			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);})
-											.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;
-				}
+														     .findAny().orElseThrow();
+								return new UnifyPair(x.getRhsType(), leftElem.getRhsType(), PairOperator.EQUALSDOT);}
+							)
+							.collect(Collectors.toCollection(ArrayList::new));
+
+				return (m.match(matchList).isPresent()) ? -1 : 0;
 			} else if (compareEq == 1) {
-				ArrayList<UnifyPair> matchList = 
-						leftleOder.stream().map(x -> { 
+				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);})
-											.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;
-				}
+								.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));
+				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");
-						((FiniteClosure)fc).logFile.write("right: " + right.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqOder: " + lefteqOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
-						((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
-						((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
-						((FiniteClosure)fc).logFile.flush();
-					}
-					catch (IOException ie) {
-					}
-				}
+					((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("lefteqOder: " + lefteqOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqOder: " + righteqOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("lefteqRet: " + lefteqRet.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("righteqRet: " + righteqRet.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("leftleOder: " + leftleOder.toString() +"\n");
+					((FiniteClosure)fc).logFile.write("rightleOder: " + rightleOder.toString() +"\n\n");
+					((FiniteClosure)fc).logFile.write("result3: 0 \n\n");
+					((FiniteClosure)fc).logFile.flush();
 				*/
 				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
@@ -360,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;};
@@ -368,11 +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.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
@@ -393,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()));
-				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName()) 
-					|| leftlewc.size() == 0 || rightlewc.size() == 0) return int_Unifier.getKey();
+				int_Unifier.getValue().orElseThrow().forEach(x -> uni.add((PlaceholderType) x.getLhsType(), x.getRhsType()));
+				if (!lseq.getRhsType().getName().equals(rseq.getRhsType().getName())
+					|| 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;
@@ -415,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) {
@@ -428,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

@@ -2,24 +2,29 @@ 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 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 static Logger NULL_LOGGER = new NullLogger();
-
   public Logger() {
     this(null, "");
   }
@@ -53,7 +58,7 @@ public class Logger {
   /**
    * 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
+   * @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) {
@@ -68,10 +73,11 @@ public class Logger {
   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 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());
     };
   }
 
@@ -82,7 +88,15 @@ public class Logger {
    */
   protected void print(String s, LogLevel logLevel) {
     String coloredPrefix = this.getPrefix(logLevel);
-    if (logLevel.value > LogLevel.WARNING.value) {
+
+    // 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 {
@@ -90,8 +104,12 @@ public class Logger {
     }
   }
 
+  public boolean isLogLevelActive(LogLevel logLevel) {
+    return logLevel.isHigherOrEqualTo(ConsoleInterface.logLevel);
+  }
+
   /**
-   * Write text to the attached writer, if there is any
+   * Write text to the attached writer if there is any
    * @param s   The string to print
    */
   protected void write(String s) {
@@ -117,32 +135,49 @@ public class Logger {
    * @param logLevel  The logLevel on which the text should be logged
    */
   public void log(String s, LogLevel logLevel) {
-    if (logLevel.value >= ConsoleInterface.logLevel.value) {
+    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);
+    }
+  }
+
 
   /**
-   * Replaces the old FileWriter.write() call
+   * 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.debug(o.toString());
+    this.log(o, LogLevel.DEBUG);
+  }
+  public void debug(Supplier<String> supp) {
+    this.log(supp, LogLevel.DEBUG);
   }
 
   /**
-   * Replaces the old System.out.println() call
+   * 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.info(o.toString());
+    this.log(o, LogLevel.INFO);
+  }
+  public void info(Supplier<String> supp) {
+    this.log(supp, LogLevel.INFO);
   }
 
   /**
@@ -153,7 +188,10 @@ public class Logger {
     this.log(s, LogLevel.WARNING);
   }
   public void warn(Object o) {
-    this.warn(o.toString());
+    this.log(o, LogLevel.WARNING);
+  }
+  public void warn(Supplier<String> supp) {
+    this.log(supp, LogLevel.WARNING);
   }
 
   /**
@@ -164,7 +202,25 @@ public class Logger {
     this.log(s, LogLevel.ERROR);
   }
   public void error(Object o) {
-    this.error(o.toString());
+    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);
   }
 
   /**
@@ -180,7 +236,7 @@ public class Logger {
         " | " + stackTraceElement.toString()
       ).collect(Collectors.joining("\n"));
 
-    // if there will be a cause printed afterward, announce it with the print of the exception
+    // if there is a cause printed afterward, announce it with the print of the exception
     if (throwable.getCause() != null) {
       s += "\n\nCaused by: ";
     }
@@ -207,22 +263,50 @@ public class Logger {
 
 
   /**
-   * An enum representing the different log levels as integers
+   * 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 {
-    // all the output
+    /** Highly specific output only for debugging */
     DEBUG(0),
-    // a lot of info about the process
+    /** Informational output about the current state of the program */
     INFO(1),
-    // warnings and up
+    /** Warnings about potential issues or an unexpected state **/
     WARNING(2),
-    // only errors and exceptions
-    ERROR(3);
+    /** 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);
+      };
+    }
   }
 
 
@@ -232,7 +316,7 @@ public class Logger {
   private static class NullLogger extends Logger {
     @Override
     public void log(String s, LogLevel logLevel) {
-      // do nothing. Yay
+      // 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;

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/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;
@@ -27,24 +30,26 @@ 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.Ignore;
-import org.junit.Test;
 import targetast.TestCodegen;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.*;
 
-@Ignore("Server tests create huge overhead, so they are ignored until required")
 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");
   }
@@ -52,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();
@@ -86,8 +91,10 @@ public class ServerTest {
     PlaceholderRegistry prCopy = JavaTXCompiler.defaultClientPlaceholderRegistry.deepClone();
     UnifyResultModel urm = new UnifyResultModel(cons, finiteClosure);
     UnifyContext context = new UnifyContext(Logger.NULL_LOGGER, true, urm, usedTasks, prCopy);
-    SocketClient socketClient = new SocketClient("ws://localhost:5000");
-    List<ResultSet> serverResult = socketClient.execute(finiteClosure, cons, unifyCons, context);
+    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);
 

src/test/java/targetast/TestGenerics.java

@@ -12,9 +12,9 @@ import de.dhbwstuttgart.target.generate.Bound;
 import static de.dhbwstuttgart.target.generate.Bound.*;
 import de.dhbwstuttgart.target.generate.BoundsList;
 import de.dhbwstuttgart.target.generate.GenericsResult;
-import org.junit.Ignore;
-import org.junit.Test;
-import static org.junit.Assert.*;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
 
 import java.io.File;
 import java.io.IOException;
@@ -22,7 +22,7 @@ import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 
-@Ignore("TODO: Rewrite with the new algorithm")
+@Disabled("TODO: Rewrite with the new algorithm")
 public class TestGenerics {
     private static final String rootDirectory = System.getProperty("user.dir") + "/resources/insertGenerics/javFiles/";
     private static final String bytecodeDirectory = System.getProperty("user.dir") + "targetTest";

src/test/java/targetast/TphTest.java

@@ -1,21 +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 static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 
 public class TphTest {
 
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "Tph.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "Tph.jav");
 		classToTest = classFiles.get("Tph");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/targetast/WhileTest.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 WhileTest {
 	private static Class<?> classToTest;
 	private static Object instanceOfClass;
 	
-	@BeforeClass
+	@BeforeAll
 	public static void setUpBeforeClass() throws Exception {
-		var classFiles = TestCodegen.generateClassFiles(new ByteArrayClassLoader(), "While.jav");
+		var classFiles = TestCodegen.generateClassFiles(TestCodegen.createClassLoader(), "While.jav");
 		classToTest = classFiles.get("While");
 		instanceOfClass = classToTest.getDeclaredConstructor().newInstance();
 	}

src/test/java/typeinference/JavaTXCompilerTest.java

@@ -8,8 +8,8 @@ import de.dhbwstuttgart.typedeployment.TypeInsert;
 import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Disabled;
 
 import java.io.File;
 import java.io.IOException;
@@ -22,7 +22,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-@Ignore("To be renewed")
+@Disabled("To be renewed")
 public class JavaTXCompilerTest {
 
     public static final String rootDirectory = System.getProperty("user.dir") + "/src/test/resources/javFiles/";