From 7c0a91e62494ff3a6474695cf91c5a42e6cdec85 Mon Sep 17 00:00:00 2001 From: Florian Steurer Date: Thu, 28 Apr 2016 21:24:52 +0200 Subject: [PATCH] unitTest for lambda6, alternative sequential execution, minor bugs --- .../syntaxtree/factory/UnifyTypeFactory.java | 2 +- .../typeinference/unify/TypeUnify.java | 12 +- .../typeinference/unify/TypeUnifyTask.java | 44 ++-- .../unify/model/FiniteClosure.java | 2 +- .../typeinference/unify/model/Unifier.java | 25 +- test/unify/UnifyTest.java | 225 +++++++++++++++--- 6 files changed, 258 insertions(+), 52 deletions(-) diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java index 4ba6fee4..ba397a58 100644 --- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java +++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java @@ -106,7 +106,7 @@ public class UnifyTypeFactory { } public static UnifyType convert(GenericTypeVar t){ - return new ReferenceType(t.get_Name()); + return new PlaceholderType(t.get_Name()); } public static UnifyConstraintsSet convert(ConstraintsSet constraints) { diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java index ec013f9d..f457fbb8 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java +++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnify.java @@ -8,9 +8,17 @@ import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; public class TypeUnify { public Set> unify(Set eq, IFiniteClosure fc) { - TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc); + TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, true); ForkJoinPool pool = new ForkJoinPool(); pool.invoke(unifyTask); - return unifyTask.join(); + Set> res = unifyTask.join(); + return res; } + + public Set> unifySequential(Set eq, IFiniteClosure fc) { + TypeUnifyTask unifyTask = new TypeUnifyTask(eq, fc, false); + Set> res = unifyTask.compute(); + return res; + } + } diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java index 7c51d31c..ed6702be 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java +++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java @@ -54,14 +54,17 @@ public class TypeUnifyTask extends RecursiveTask>> { protected IFiniteClosure fc; - public TypeUnifyTask(Set eq, IFiniteClosure fc) { + protected boolean parallel; + + public TypeUnifyTask(Set eq, IFiniteClosure fc, boolean parallel) { this.eq = eq; this.fc = fc; + this.parallel = parallel; } @Override protected Set> compute() { - return unify(eq, fc); + return unify(eq, fc, parallel); } /** @@ -70,7 +73,7 @@ public class TypeUnifyTask extends RecursiveTask>> { * @param fc The finite closure * @return The set of all principal type unifiers */ - public Set> unify(Set eq, IFiniteClosure fc) { + protected Set> unify(Set eq, IFiniteClosure fc, boolean parallel) { /* * Step 1: Repeated application of reduce, adapt, erase, swap */ @@ -165,17 +168,27 @@ public class TypeUnifyTask extends RecursiveTask>> { /* * Step 6 a) Restart (fork) for pairs where subst was applied */ - if (eqPrime.equals(eq)) - eqPrimePrimeSet.add(eqPrime); - else if(eqPrimePrime.isPresent()) { - TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc); - forks.add(fork); - fork.fork(); + if(parallel) { + if (eqPrime.equals(eq)) + eqPrimePrimeSet.add(eqPrime); + else if(eqPrimePrime.isPresent()) { + TypeUnifyTask fork = new TypeUnifyTask(eqPrimePrime.get(), fc, true); + forks.add(fork); + fork.fork(); + } + else { + TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc, true); + forks.add(fork); + fork.fork(); + } } - else { - TypeUnifyTask fork = new TypeUnifyTask(eqPrime, fc); - forks.add(fork); - fork.fork(); + else { // sequentiell (Step 6b is included) + if (eqPrime.equals(eq)) + eqPrimePrimeSet.add(eqPrime); + else if(eqPrimePrime.isPresent()) + eqPrimePrimeSet.addAll(unify(eqPrimePrime.get(), fc, false)); + else + eqPrimePrimeSet.addAll(unify(eqPrime, fc, false)); } } @@ -183,8 +196,9 @@ public class TypeUnifyTask extends RecursiveTask>> { * Step 6 b) Build the union over everything. */ - for(TypeUnifyTask fork : forks) - eqPrimePrimeSet.addAll(fork.join()); + if(parallel) + for(TypeUnifyTask fork : forks) + eqPrimePrimeSet.addAll(fork.join()); /* * Step 7: Filter empty sets; diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java b/src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java index a08f79cb..d9de2a3b 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java +++ b/src/de/dhbwstuttgart/typeinference/unify/model/FiniteClosure.java @@ -233,7 +233,7 @@ public class FiniteClosure implements IFiniteClosure { Unifier sigma2 = sigma2Opt.get(); if(sigma2.size() == 0) // type.equals(theta2) continue; - sigma2.swapPlaceholderSubstitutions(type.getTypeParams()); + sigma2.swapPlaceholderSubstitutionsReverse(type.getTypeParams()); Set theta1s = greater(theta2); for (UnifyType theta1 : theta1s) { // Because only the most general type is calculated, sigma1 diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java b/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java index dbcc9b39..2dd7c83f 100644 --- a/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java +++ b/src/de/dhbwstuttgart/typeinference/unify/model/Unifier.java @@ -98,10 +98,27 @@ public class Unifier implements Function, Iterable b) if a is an element of the target params. - if(substitutions.containsKey(tph) && substitutions.get(tph) instanceof PlaceholderType) { - PlaceholderType newLhs = (PlaceholderType) substitutions.get(tph); - substitutions.remove(tph); - substitutions.put(newLhs, tph); + if(substitutions.containsKey(tph)) { + if((substitutions.get(tph) instanceof PlaceholderType)) { + PlaceholderType newLhs = (PlaceholderType) substitutions.get(tph); + substitutions.remove(tph); + substitutions.put(newLhs, tph); + } + } + } + } + + public void swapPlaceholderSubstitutionsReverse(Iterable sourceParams) { + for(UnifyType tph : sourceParams) { + if(!(tph instanceof PlaceholderType)) + continue; + if(substitutions.containsValue(tph)) { + UnifyType key = substitutions.values().stream().filter(x -> x.equals(tph)).findAny().get(); + if(key instanceof PlaceholderType) { + PlaceholderType newLhs = (PlaceholderType) tph; + substitutions.remove(key); + substitutions.put(newLhs, key); + } } } } diff --git a/test/unify/UnifyTest.java b/test/unify/UnifyTest.java index 45551710..d4f36b39 100644 --- a/test/unify/UnifyTest.java +++ b/test/unify/UnifyTest.java @@ -11,13 +11,14 @@ import org.junit.Test; import de.dhbwstuttgart.typeinference.unify.TypeUnify; import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure; import de.dhbwstuttgart.typeinference.unify.model.UnifyPair; +import de.dhbwstuttgart.typeinference.unify.model.FunNType; import de.dhbwstuttgart.typeinference.unify.model.PairOperator; import de.dhbwstuttgart.typeinference.unify.model.PlaceholderType; import de.dhbwstuttgart.typeinference.unify.model.UnifyType; import de.dhbwstuttgart.typeinference.unify.model.TypeParams; import junit.framework.Assert; -public class UnifyTest extends TypeUnify{ +public class UnifyTest { /** * Testing the unification for cases with (n)one pair and without generics. @@ -51,7 +52,7 @@ public class UnifyTest extends TypeUnify{ Set eq = new HashSet(); Set> expected = new HashSet<>(); expected.add(new HashSet<>()); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); /* @@ -69,7 +70,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, integer, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, doubl, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -87,7 +88,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, object, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -104,7 +105,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -128,7 +129,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, supNumber, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, supObject, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println("? super Integer"); System.out.println(actual); actual = filterGeneratedTPHsMultiple(actual); @@ -156,7 +157,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, supDouble, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, supNumber, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); actual = filterGeneratedTPHsMultiple(actual); Assert.assertEquals(expected, actual); @@ -174,7 +175,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, extNumber, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, extObject, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); actual = filterGeneratedTPHsMultiple(actual); Assert.assertEquals(expected, actual); @@ -199,7 +200,7 @@ public class UnifyTest extends TypeUnify{ addAsSet(expected, new UnifyPair(tphA, integer, PairOperator.EQUALSDOT)); addAsSet(expected, new UnifyPair(tphA, number, PairOperator.EQUALSDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); actual = filterGeneratedTPHsMultiple(actual); Assert.assertEquals(expected, actual); @@ -216,7 +217,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); expected.add(new HashSet<>()); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -231,7 +232,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -248,7 +249,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); addAsSet(expected, new UnifyPair(tphA, tphB, PairOperator.SMALLERDOT)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -264,7 +265,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); addAsSet(expected, new UnifyPair(tphA, tphB, PairOperator.SMALLERDOTWC)); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); @@ -286,7 +287,7 @@ public class UnifyTest extends TypeUnify{ IFiniteClosure voidFC = fcb.getFiniteClosure(); - actual = unify(eq, voidFC); + actual = new TypeUnify().unifySequential(eq, fc); Assert.assertEquals(expected, actual); } @@ -331,7 +332,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(tf.getSimpleType("List", tphB), tf.getSimpleType("List", extNum), PairOperator.SMALLERDOT)); Set> expected = new HashSet<>(); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); //System.out.println(actual); //Assert.assertEquals(actual, expected); @@ -350,7 +351,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(tf.getSimpleType("Vector", extA), tf.getSimpleType("Vector", extNum), PairOperator.SMALLERDOT)); expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); //System.out.println(actual); //Assert.assertEquals(actual, expected); @@ -366,7 +367,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(tf.getSimpleType("Vector", extNum), tf.getSimpleType("Vector", extA), PairOperator.SMALLERDOT)); expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println(actual); //Assert.assertEquals(actual, expected); @@ -387,7 +388,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(extNum, tphB, PairOperator.SMALLERDOTWC)); expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); //System.out.println(actual); //Assert.assertEquals(actual, expected); @@ -449,7 +450,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(tf.getSimpleType("List", integer), tf.getSimpleType("List", tphB), PairOperator.SMALLERDOT)); Set> expected = new HashSet<>(); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); System.out.println(actual); //Assert.assertEquals(actual, expected); @@ -469,7 +470,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Case 2"); System.out.println(actual); @@ -489,7 +490,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Case 3"); @@ -514,7 +515,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println(actual); //Assert.assertEquals(expected, actual); @@ -533,7 +534,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println(actual); //Assert.assertEquals(expected, actual); @@ -552,7 +553,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Case 7"); System.out.println(actual); @@ -573,7 +574,7 @@ public class UnifyTest extends TypeUnify{ expected = new HashSet<>(); - actual = unify(eq, fc); + actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Case 8:"); System.out.println(actual); @@ -608,7 +609,7 @@ public class UnifyTest extends TypeUnify{ eq.add(new UnifyPair(tf.getSimpleType("Matrix"), tf.getSimpleType("Vector", tf.getPlaceholderType("a")), PairOperator.SMALLERDOT)); Set> expected = new HashSet<>(); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Test Matrix:"); System.out.println(actual); @@ -675,7 +676,7 @@ public class UnifyTest extends TypeUnify{ expected.add(solution); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Test Void:"); System.out.println(actual); @@ -683,6 +684,172 @@ public class UnifyTest extends TypeUnify{ Assert.assertEquals(expected, actual); } +// @Test +// public void unifyTestMatrixSimple() { +//// [(C <. C), +//// (D <. D), +//// (java.lang.Boolean <. PC), +//// (java.lang.Integer <. E1), +//// (java.util.Vector <. java.util.Vector), +//// (java.lang.Integer <. PD), +//// (java.util.Vector <. java.util.Vector), +//// (PE <. java.lang.Boolean), +//// (C <. java.lang.Integer), +//// (PD <. java.lang.Integer), +//// (PE <. java.lang.Boolean), +//// (E2 <. PF), +//// (C <. java.lang.Integer), +//// (java.util.Vector <. java.util.Vector), +//// (PG <. java.lang.Double), +//// (java.lang.Integer <. java.lang.Double), +//// (PF <. java.lang.Double), +//// (PG <. D), +//// (D <. PH), +//// (void <. B), +//// (void <. PI), +//// (Matrix <. java.util.Vector), +//// (void <. void)] +// +// TypeFactory tf = new TypeFactory(); +// FiniteClosureBuilder fcb = new FiniteClosureBuilder(); +// +// UnifyType tphC = tf.getPlaceholderType("C"); +// UnifyType tphD = tf.getPlaceholderType("D"); +// UnifyType tphPC = tf.getPlaceholderType("PC"); +// UnifyType tphE1 = tf.getPlaceholderType("E1"); +// UnifyType tphPD = tf.getPlaceholderType("PD"); +// UnifyType tphE3 = tf.getPlaceholderType("E3"); +// UnifyType tphPE = tf.getPlaceholderType("PE"); +// UnifyType tphE2 = tf.getPlaceholderType("E2"); +// UnifyType tphPG = tf.getPlaceholderType("PG"); +// UnifyType tphPF = tf.getPlaceholderType("PF"); +// UnifyType tphPH = tf.getPlaceholderType("PH"); +// UnifyType tphPI = tf.getPlaceholderType("PI"); +// UnifyType tphE4 = tf.getPlaceholderType("E4"); +// UnifyType tphB = tf.getPlaceholderType("B"); +// +// UnifyType integer = tf.getSimpleType("java.lang.Integer"); +// UnifyType voidType = tf.getSimpleType("void"); +// UnifyType bool = tf.getSimpleType("java.lang.Boolean"); +// UnifyType object = tf.getSimpleType("java.lang.Object"); +// UnifyType doubl = tf.getSimpleType("java.lang.Double"); +// UnifyType number = tf.getSimpleType("java.lang.Number"); +// +// fcb.add(integer, number); +// fcb.add(bool, object); +// fcb.add(doubl, number); +// fcb.add(number, object); +// fcb.add(voidType, voidType); +// +// IFiniteClosure fc = fcb.getFiniteClosure(); +// +// Set eq = new HashSet(); +// eq.add(new UnifyPair(tphC, tphC, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphD, tphD, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(bool, tphPC, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(integer, tphE1, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE1), PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(integer, tphPD, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE3), PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphPE, bool, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphC, integer, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphPD, integer, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphPE, bool, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphE2, tphPF, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphC, integer, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tf.getSimpleType("Vector", integer), tf.getSimpleType("Vector", tphE2), PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphPG, doubl, PairOperator.SMALLERDOT)); +// //eq.add(new UnifyPair(integer, doubl, PairOperator.SMALLERDOT)); KEIN WUNDER INFERIERT DAS NICHT +// eq.add(new UnifyPair(tphPF, doubl, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphPG, tphD, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tphD, tphPH, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(voidType, tphB, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(voidType, tphPI, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(tf.getSimpleType("Matrix"), tphPI, PairOperator.SMALLERDOT)); +// eq.add(new UnifyPair(voidType, tphPI, PairOperator.SMALLERDOT)); +// +// Set> expected = new HashSet<>(); +// +// Set> actual = unify(eq, fc); +// +// System.out.println("Test Void:"); +// System.out.println(actual); +// +// //Assert.assertEquals(expected, actual); +// } + + @Test + public void unifyTestLambda6() { +// [(D <. D), +// (R455538610 <. ND), +// (Matrix <. T1455538610), +// (C <. T2455538610), +// (B <. Fun2), +// (ND <. NE), +// (Fun1 <. NC), +// (NC <. NF), +// (Fun1 <. NB), +// (NB <. D), +// (void <. NG), +// (Matrix <. java.lang.Object), +// (void <. void)] + + TypeFactory tf = new TypeFactory(); + FiniteClosureBuilder fcb = new FiniteClosureBuilder(); + + UnifyType tphD = tf.getPlaceholderType("D"); + UnifyType tphND = tf.getPlaceholderType("ND"); + UnifyType tphR4 = tf.getPlaceholderType("R4"); + UnifyType tphT1 = tf.getPlaceholderType("T1"); + UnifyType tphT2 = tf.getPlaceholderType("T2"); + UnifyType tphC = tf.getPlaceholderType("C"); + UnifyType tphNE = tf.getPlaceholderType("NE"); + UnifyType tphNC = tf.getPlaceholderType("NC"); + UnifyType tphB = tf.getPlaceholderType("B"); + UnifyType tphNF = tf.getPlaceholderType("NF"); + UnifyType tphNB = tf.getPlaceholderType("NB"); + UnifyType tphNG = tf.getPlaceholderType("NG"); + + UnifyType voidType = tf.getSimpleType("void"); + UnifyType object = tf.getSimpleType("java.lang.Object"); + UnifyType matrix = tf.getSimpleType("java.lang.Matrix"); + + UnifyType r = tf.getPlaceholderType("R"); + UnifyType t1 = tf.getPlaceholderType("T1"); + UnifyType t2 = tf.getPlaceholderType("T2"); + UnifyType fun1 = FunNType.getFunNType(new TypeParams(r, t1)); + UnifyType fun2 = FunNType.getFunNType(new TypeParams(r, t1, t2)); + + fcb.add(matrix, object); + fcb.add(voidType, voidType); + + IFiniteClosure fc = fcb.getFiniteClosure(); + + Set eq = new HashSet(); + eq.add(new UnifyPair(tphD, tphD, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphR4, tphND, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(matrix, tphT1, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphC, tphT2, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphB, FunNType.getFunNType(new TypeParams(tphR4, tphT1, tphT2)), PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphND, tphNE, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(FunNType.getFunNType(new TypeParams(tphNE, tphB)), tphNC, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphNC, tphNF, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(FunNType.getFunNType(new TypeParams(tphNF, tphC)), tphNB, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(tphNB, tphD, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(voidType, tphNG, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(matrix, object, PairOperator.SMALLERDOT)); + eq.add(new UnifyPair(voidType, voidType, PairOperator.SMALLERDOT)); + + Set> expected = new HashSet<>(); + + Set> actual = new TypeUnify().unifySequential(eq, fc); + + System.out.println("Test Lambda6:"); + System.out.println(actual); + + //Assert.assertEquals(expected, actual); + } + @Test public void unifyTestOverloading(){ /* @@ -723,7 +890,7 @@ public class UnifyTest extends TypeUnify{ expectedSolution.add(new UnifyPair(tphT1, ol, PairOperator.EQUALSDOT)); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Test Overloading:"); System.out.println(actual); @@ -774,7 +941,7 @@ public class UnifyTest extends TypeUnify{ solution.add(new UnifyPair(tphT2, integer, PairOperator.EQUALSDOT)); expected.add(solution); - Set> actual = unify(eq, fc); + Set> actual = new TypeUnify().unifySequential(eq, fc); System.out.println("Test Subclass:"); System.out.println(actual);