Moved unification tests

src/test/java/fr/insarennes/nperier/minichamo/language/typing/TypeTests.java

@@ -179,49 +179,4 @@ public class TypeTests {
         Assertions.assertEquals(t2, aliasType.specify(sp2));
     }
 
-    @Test
-    public void sameTypeUnificationTest() {
-        Map<String, Type> exp = new HashMap<>();
-        Type t1 = BuiltinType.unit();
-        Type t2 = new FunctionType(new Type[] {
-                new NupleType(new Type[] {
-                        BuiltinType.integer(),
-                        BuiltinType.bool()
-                }),
-                BuiltinType.list(BuiltinType.str())
-        });
-        Assertions.assertEquals(exp, Type.unify(t1, t1));
-        Assertions.assertEquals(exp, Type.unify(t2, t2));
-    }
-
-    @Test
-    public void simpleUnificationTest() {
-        TokenPeekIterator it = new Lexer("'a;; int list;;").wrap();
-        Type t1 = TypeParser.parse(it, ctx);
-        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
-        Type t2 = TypeParser.parse(it, ctx);
-        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
-        Assertions.assertFalse(it.hasNext());
-        Map<String, Type> exp = new HashMap<>();
-        exp.put("a", BuiltinType.list(BuiltinType.integer()));
-        Assertions.assertEquals(exp, Type.unify(t1, t2));
-        Assertions.assertEquals(exp, Type.unify(t2, t1));
-
-    }
-
-    @Test
-    public void aliasUnificationTest() {
-        TokenPeekIterator it = new Lexer("(int, 'a) lol;; ('b * string) list;;").wrap();
-        Type t1 = TypeParser.parse(it, ctx);
-        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
-        Type t2 = TypeParser.parse(it, ctx);
-        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
-        Assertions.assertFalse(it.hasNext());
-        Map<String, Type> exp = new HashMap<>();
-        exp.put("a", BuiltinType.str());
-        exp.put("b", BuiltinType.integer());
-        Assertions.assertEquals(exp, Type.unify(t1, t2));
-        Assertions.assertEquals(exp, Type.unify(t2, t1));
-    }
-
 }

src/test/java/fr/insarennes/nperier/minichamo/language/typing/unification/UnificationTest.java

+package fr.insarennes.nperier.minichamo.language.typing.unification;
+
+import fr.insarennes.nperier.minichamo.language.typing.BuiltinType;
+import fr.insarennes.nperier.minichamo.language.typing.FunctionType;
+import fr.insarennes.nperier.minichamo.language.typing.NupleType;
+import fr.insarennes.nperier.minichamo.language.typing.Type;
+import fr.insarennes.nperier.minichamo.lexing.Lexer;
+import fr.insarennes.nperier.minichamo.lexing.tokens.TokenType;
+import fr.insarennes.nperier.minichamo.parsing.Context;
+import fr.insarennes.nperier.minichamo.parsing.TypeParser;
+import fr.insarennes.nperier.minichamo.parsing.TypedefParser;
+import fr.insarennes.nperier.minichamo.utils.TokenPeekIterator;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class UnificationTest {
+
+    private static Context baseCtx;
+    private Context ctx;
+
+    @BeforeAll
+    public static void init() {
+        baseCtx = new Context();
+        TokenPeekIterator it = new Lexer("type ('a, 'b) lol = ('a * 'b) list;;").wrap();
+        it.junkIf(TokenType.TYPEDEF);
+        TypedefParser.parse(it, baseCtx);
+    }
+
+    @BeforeEach
+    public void before() {
+        ctx = baseCtx.duplicate();
+    }
+
+    @Test
+    public void sameTypeUnificationTest() {
+        Map<String, Type> exp = new HashMap<>();
+        Type t1 = BuiltinType.unit();
+        Type t2 = new FunctionType(new Type[] {
+                new NupleType(new Type[] {
+                        BuiltinType.integer(),
+                        BuiltinType.bool()
+                }),
+                BuiltinType.list(BuiltinType.str())
+        });
+        Assertions.assertEquals(exp, Type.unify(t1, t1).getMappings());
+        Assertions.assertEquals(exp, Type.unify(t2, t2).getMappings());
+    }
+
+    @Test
+    public void simpleUnificationTest() {
+        TokenPeekIterator it = new Lexer("'a;; int list;;").wrap();
+        Type t1 = TypeParser.parse(it, ctx);
+        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
+        Type t2 = TypeParser.parse(it, ctx);
+        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
+        Assertions.assertFalse(it.hasNext());
+        Map<String, Type> exp = new HashMap<>();
+        exp.put("a", BuiltinType.list(BuiltinType.integer()));
+        Assertions.assertEquals(exp, Type.unify(t1, t2).getMappings());
+        Assertions.assertEquals(exp, Type.unify(t2, t1).getMappings());
+
+    }
+
+    @Test
+    public void aliasUnificationTest() {
+        TokenPeekIterator it = new Lexer("(int, 'a) lol;; ('b * string) list;;").wrap();
+        Type t1 = TypeParser.parse(it, ctx);
+        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
+        Type t2 = TypeParser.parse(it, ctx);
+        Assertions.assertTrue(it.junkIf(TokenType.TERMINATION));
+        Assertions.assertFalse(it.hasNext());
+        Map<String, Type> exp = new HashMap<>();
+        exp.put("a", BuiltinType.str());
+        exp.put("b", BuiltinType.integer());
+        Assertions.assertEquals(exp, Type.unify(t1, t2).getMappings());
+        Assertions.assertEquals(exp, Type.unify(t2, t1).getMappings());
+    }
+
+}