JavaPatternMatching/test/unify/RuleSetTest.java

package unify;


import java.util.Optional;
import java.util.Set;

import junit.framework.Assert;

import org.junit.Test;

import de.dhbwstuttgart.typeinference.unify.interfaces.IRuleSet;
import de.dhbwstuttgart.typeinference.unifynew.RuleSet;
import de.dhbwstuttgart.typinference.unify.model.ExtendsType;
import de.dhbwstuttgart.typinference.unify.model.MPair;
import de.dhbwstuttgart.typinference.unify.model.MPair.PairOperator;
import de.dhbwstuttgart.typinference.unify.model.SimpleType;
import de.dhbwstuttgart.typinference.unify.model.SuperType;


public class RuleSetTest {
	
	@Test
	public void testReduceUp() {
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getFiniteClosure());
		TypeFactory tf = new TypeFactory();
	
		/*
		 * Positive Tests
		 */
		
		MPair reduce1 = new MPair(tf.getSimpleType("type"), tf.getSuperType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair reduce2 = new MPair(tf.getPlaceholderType("T"), tf.getSuperType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);

		MPair expected1 = new MPair(tf.getSimpleType("type"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair expected2 = new MPair(tf.getPlaceholderType("T"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		
		Optional<MPair> opt1 = rules.reduceUp(reduce1);
		Optional<MPair> opt2 = rules.reduceUp(reduce2);
		
		Assert.assertTrue(opt1.isPresent());
		Assert.assertTrue(opt2.isPresent());
		Assert.assertEquals(opt1.get(), expected1);
		Assert.assertEquals(opt2.get(), expected2);

		/*
		 * Negative Tests
		 */
		
		MPair noreduce1 = new MPair(tf.getSuperType(tf.getSimpleType("type")), tf.getSuperType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair noreduce2 = new MPair(tf.getPlaceholderType("T"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair noreduce3 = new MPair(tf.getPlaceholderType("T"), tf.getExtendsType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair noreduce4 = new MPair(tf.getPlaceholderType("T"), tf.getSuperType(tf.getSimpleType("type")), PairOperator.EQUALSDOT);
		
		Assert.assertFalse(rules.reduceUp(noreduce1).isPresent());
		Assert.assertFalse(rules.reduceUp(noreduce2).isPresent());
		Assert.assertFalse(rules.reduceUp(noreduce3).isPresent());
		Assert.assertFalse(rules.reduceUp(noreduce4).isPresent());
	}
	
	@Test
	public void testReduceLow() {
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getFiniteClosure());
		TypeFactory tf = new TypeFactory();
	
		/*
		 * Positive Tests
		 */
		MPair reduce1 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair reduce2 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getPlaceholderType("T"), PairOperator.SMALLERDOT);

		MPair expected1 = new MPair(tf.getSimpleType("type"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair expected2 = new MPair(tf.getSimpleType("type"), tf.getPlaceholderType("T"), PairOperator.SMALLERDOT);
		
		Optional<MPair> opt1 = rules.reduceLow(reduce1);
		Optional<MPair> opt2 = rules.reduceLow(reduce2);
		
		Assert.assertTrue(opt1.isPresent());
		Assert.assertTrue(opt2.isPresent());
		Assert.assertEquals(opt1.get(), expected1);
		Assert.assertEquals(opt2.get(), expected2);

		/*
		 * Negative Tests
		 */
		MPair noreduce1 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getExtendsType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair noreduce2 = new MPair(tf.getPlaceholderType("T"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair noreduce3 = new MPair(tf.getSuperType(tf.getPlaceholderType("T")), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair noreduce4 = new MPair(tf.getExtendsType(tf.getPlaceholderType("T")), tf.getSimpleType("type"), PairOperator.EQUALSDOT);
		
		Assert.assertFalse(rules.reduceLow(noreduce1).isPresent());
		Assert.assertFalse(rules.reduceLow(noreduce2).isPresent());
		Assert.assertFalse(rules.reduceLow(noreduce3).isPresent());
		Assert.assertFalse(rules.reduceLow(noreduce4).isPresent());
	}
	
	@Test
	public void testReduceUpLow() {
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getFiniteClosure());
		TypeFactory tf = new TypeFactory();
	
		/*
		 * Positive Tests
		 */
		MPair reduce1 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getSuperType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair reduce2 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getSuperType(tf.getPlaceholderType("T")), PairOperator.SMALLERDOT);

		MPair expected1 = new MPair(tf.getSimpleType("type"), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair expected2 = new MPair(tf.getSimpleType("type"), tf.getPlaceholderType("T"), PairOperator.SMALLERDOT);
		
		Optional<MPair> opt1 = rules.reduceUpLow(reduce1);
		Optional<MPair> opt2 = rules.reduceUpLow(reduce2);
		
		Assert.assertTrue(opt1.isPresent());
		Assert.assertTrue(opt2.isPresent());
		Assert.assertEquals(opt1.get(), expected1);
		Assert.assertEquals(opt2.get(), expected2);

		/*
		 * Negative Tests
		 */
		MPair noreduce1 = new MPair(tf.getExtendsType(tf.getSimpleType("type")), tf.getExtendsType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair noreduce2 = new MPair(tf.getSuperType(tf.getPlaceholderType("T")), tf.getExtendsType(tf.getSimpleType("type")), PairOperator.SMALLERDOT);
		MPair noreduce3 = new MPair(tf.getSuperType(tf.getPlaceholderType("T")), tf.getSimpleType("type"), PairOperator.SMALLERDOT);
		MPair noreduce4 = new MPair(tf.getExtendsType(tf.getPlaceholderType("T")), tf.getSimpleType("type"), PairOperator.EQUALSDOT);
		
		Assert.assertFalse(rules.reduceUpLow(noreduce1).isPresent());
		Assert.assertFalse(rules.reduceUpLow(noreduce2).isPresent());
		Assert.assertFalse(rules.reduceUpLow(noreduce3).isPresent());
		Assert.assertFalse(rules.reduceUpLow(noreduce4).isPresent());
	}
	
	@Test
	public void testReduce1() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		
		/*
		 * Positive Tests
		 */
		
		// C<T1, T2, T3, T4>
		SimpleType c1 = tf.getSimpleType("C", "T1", "T2", "T3", "T4");
		// D<T4, T1, T2, T3>
		SimpleType d1 = tf.getSimpleType("D", "T4", "T1", "T2", "T3");
		SimpleType buffer = tf.getSimpleType("Buffer");
		
		//C<Int, ? extends Double, M, N>
		SimpleType c2 = tf.getSimpleType("C", tf.getSimpleType("Int"), tf.getExtendsType(tf.getSimpleType("Double")), tf.getPlaceholderType("M"), tf.getPlaceholderType("N"));
		//D<? super HashSet<Int>, Number, Double, N>
		SimpleType d2 = tf.getSimpleType("D", tf.getSuperType(tf.getSimpleType("HashSet", "Int")), tf.getSimpleType("Number"), tf.getSimpleType("Double"), tf.getPlaceholderType("N"));

		// C<...> < buffer < D<...>
		fcb.add(c1, buffer);
		fcb.add(buffer, d1);
		
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		MPair pair = new MPair(c2, d2, PairOperator.SMALLERDOT);
		
		System.out.println("------ Reduce1 ------");
		Optional<Set<MPair>> res = rules.reduce1(pair);
		System.out.println(res);
		
		pair = new MPair(c2, c2, PairOperator.SMALLERDOT);
		res = rules.reduce1(pair);
		System.out.println(res);
		
		/*
		 * Negative Tests
		 */
		
		// Case 1: D <. C and C <* D
		pair = new MPair(d2, c2, PairOperator.SMALLERDOT);
		Assert.assertFalse(rules.reduce1(pair).isPresent());
		
		// Case 2: D =. C
		pair = new MPair(c2, d2, PairOperator.EQUALSDOT);
		Assert.assertFalse(rules.reduce1(pair).isPresent());
		
		// Case 3: C <. D and !(C <* D)
		fcb.clear();
		rules = new RuleSet(fcb.getFiniteClosure());
		pair = new MPair(c1, d1, PairOperator.SMALLERDOT);
		Assert.assertFalse(rules.reduce1(pair).isPresent());
	}
	
	@Test
	public void testReduce2() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		
		/*
		 * Positive Tests
		 */
		System.out.println("----- Reduce2 ------");
		
		// C<T1, SType1, ? extends SType1>
		SimpleType c1 = tf.getSimpleType("C", tf.getPlaceholderType("T1"), tf.getSimpleType("SType1"), tf.getExtendsType(tf.getSimpleType("SType1")));
		// C<T2, SType2, ? extends SType2>
		SimpleType c2 = tf.getSimpleType("C", tf.getPlaceholderType("T2"), tf.getSimpleType("SType2"), tf.getExtendsType(tf.getSimpleType("SType2")));

		MPair pair1 = new MPair(c1, c2, PairOperator.EQUALSDOT);
		MPair pair2 = new MPair(tf.getExtendsType(c1), tf.getExtendsType(c2), PairOperator.EQUALSDOT);
		MPair pair3 = new MPair(tf.getSuperType(c1), tf.getSuperType(c2), PairOperator.EQUALSDOT);
		
		Optional<Set<MPair>> opt1 = rules.reduce2(pair1);
		System.out.println(opt1);

		Optional<Set<MPair>> opt2 = rules.reduce2(pair2);
		System.out.println(opt2);
		
		Optional<Set<MPair>> opt3 = rules.reduce2(pair3);
		System.out.println(opt3);
		

		/*
		 * Negative Tests
		 */
		
		SimpleType d1 = tf.getSimpleType("D", tf.getPlaceholderType("T2"), tf.getSimpleType("SType2"), tf.getExtendsType(tf.getSimpleType("SType2")));
		pair1 = new MPair(d1, c1, PairOperator.EQUALSDOT); // Case 1: D =. C
		pair2 = new MPair(tf.getExtendsType(c1), c2, PairOperator.EQUALSDOT); // Case 2: ? extends C =. C
		pair3 = new MPair(tf.getExtendsType(c1), tf.getSuperType(c2), PairOperator.EQUALSDOT); // Case 3: ? extends C =. ? super C
		MPair pair4 = new MPair(c1, c2, PairOperator.SMALLERDOT); // Case 4: C <. C

		Assert.assertFalse(rules.reduceEq(pair1).isPresent());
		Assert.assertFalse(rules.reduceEq(pair2).isPresent());
		Assert.assertFalse(rules.reduceEq(pair3).isPresent());
		Assert.assertFalse(rules.reduceEq(pair4).isPresent());
	}
	
	@Test
	public void testReduceExt() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		
		/*
		 * Positive Tests
		 */
		
		// X<T1, T2, T3, T4>
		SimpleType x1 = tf.getSimpleType("X", "T1", "T2", "T3", "T4");
		// Y<T4, T1, T2, T3>
		SimpleType y1 = tf.getSimpleType("Y", "T4", "T1", "T2", "T3");
		SimpleType buffer = tf.getSimpleType("Buffer");
		
		//X<Int, ? extends Double, M, N>
		SimpleType x2 = tf.getSimpleType("X", tf.getSimpleType("Int"), tf.getExtendsType(tf.getSimpleType("Double")), tf.getPlaceholderType("M"), tf.getPlaceholderType("N"));
		//? extends Y<? super HashSet<Int>, Number, Double, N>
		ExtendsType extY1 = tf.getExtendsType(tf.getSimpleType("Y", tf.getSuperType(tf.getSimpleType("HashSet", "Int")), tf.getSimpleType("Number"), tf.getSimpleType("Double"), tf.getPlaceholderType("N")));

		// Y<...> < buffer < X<...>
		fcb.add(x1, buffer);
		fcb.add(buffer, y1);
		
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		MPair pair1 = new MPair(x2, extY1, PairOperator.SMALLERDOTWC);
		MPair pair2 = new MPair(tf.getExtendsType(x2), extY1, PairOperator.SMALLERDOTWC);
		MPair pair3 = new MPair(extY1, extY1, PairOperator.SMALLERDOTWC);
		
		System.out.println("------ ReduceExt ------");
		Optional<Set<MPair>> opt1 = rules.reduceExt(pair1);
		System.out.println(opt1);
		
		Optional<Set<MPair>> opt2 = rules.reduceExt(pair2);
		System.out.println(opt2);
		
		Optional<Set<MPair>> opt3 = rules.reduceExt(pair3);
		System.out.println(opt3);
		
		/*
		 * Negative Tests
		 */
		
		// Case 1: X <.? Y
		pair1 = new MPair(x2, extY1.getExtendedType(), PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceExt(pair1).isPresent());
		
		// Case 2: X =. ? super Y
		pair2 = new MPair(x2, extY1, PairOperator.EQUALSDOT);
		Assert.assertFalse(rules.reduceExt(pair2).isPresent());

		// Case 3: ? extends Y <.? ? extends X
		pair3 = new MPair(extY1, tf.getExtendsType(x2), PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceExt(pair3).isPresent());
		
		// Case 4: X <. ? extends Y and ? extends Y not in grArg(X)
		fcb.clear();
		rules = new RuleSet(fcb.getFiniteClosure());
		pair1 = new MPair(x2, extY1, PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceExt(pair1).isPresent());
	}
	
	@Test
	public void testReduceSup() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		
		/*
		 * Positive Tests
		 */
		
		// X<T1, T2, T3, T4>
		SimpleType x1 = tf.getSimpleType("X", "T1", "T2", "T3", "T4");
		// Y<T4, T1, T2, T3>
		SimpleType y1 = tf.getSimpleType("Y", "T4", "T1", "T2", "T3");
		SimpleType buffer = tf.getSimpleType("Buffer");
		
		//X<Int, ? extends Double, M, N>
		SimpleType x2 = tf.getSimpleType("X", tf.getSimpleType("Int"), tf.getExtendsType(tf.getSimpleType("Double")), tf.getPlaceholderType("M"), tf.getPlaceholderType("N"));
		//? super Y<? super HashSet<Int>, Number, Double, N>
		SuperType supY1 = tf.getSuperType(tf.getSimpleType("Y", tf.getSuperType(tf.getSimpleType("HashSet", "Int")), tf.getSimpleType("Number"), tf.getSimpleType("Double"), tf.getPlaceholderType("N")));

		// Y<...> < buffer < X<...>
		fcb.add(y1, buffer);
		fcb.add(buffer, x1);
		
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		MPair pair1 = new MPair(x2, supY1, PairOperator.SMALLERDOTWC);
		MPair pair2 = new MPair(tf.getSuperType(x2), supY1, PairOperator.SMALLERDOTWC);
		MPair pair3 = new MPair(supY1, supY1, PairOperator.SMALLERDOTWC);
		
		System.out.println("------ ReduceSup ------");
		Optional<Set<MPair>> opt1 = rules.reduceSup(pair1);
		System.out.println(opt1);
		
		Optional<Set<MPair>> opt2 = rules.reduceSup(pair2);
		System.out.println(opt2);
		
		Optional<Set<MPair>> opt3 = rules.reduceSup(pair3);
		System.out.println(opt3);
		
		/*
		 * Negative Tests
		 */
		
		// Case 1: X <.? Y
		pair1 = new MPair(x2, supY1.getSuperedType(), PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceSup(pair1).isPresent());
		
		// Case 2: X =. ? super Y
		pair2 = new MPair(x2, supY1, PairOperator.EQUALSDOT);
		Assert.assertFalse(rules.reduceSup(pair2).isPresent());

		// Case 3: ? super Y <.? ? super X
		pair3 = new MPair(supY1, tf.getSuperType(x2), PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceSup(pair3).isPresent());
		
		// Case 4: X <. ? super Y and ? super Y not in grArg(X)
		fcb.clear();
		rules = new RuleSet(fcb.getFiniteClosure());
		pair1 = new MPair(x2, supY1, PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceSup(pair1).isPresent());
	}
	
	@Test
	public void testReduceEq() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		
		/*
		 * Positive Tests
		 */
		System.out.println("----- ReduceEq ------");
		
		// C<T1, SType1, ? extends SType1>
		SimpleType c1 = tf.getSimpleType("C", tf.getPlaceholderType("T1"), tf.getSimpleType("SType1"), tf.getExtendsType(tf.getSimpleType("SType1")));
		// C<T2, SType2, ? extends SType2>
		SimpleType c2 = tf.getSimpleType("C", tf.getPlaceholderType("T2"), tf.getSimpleType("SType2"), tf.getExtendsType(tf.getSimpleType("SType2")));

		MPair pair = new MPair(c1, c2, PairOperator.SMALLERDOTWC);
		Optional<Set<MPair>> res = rules.reduceEq(pair);
		System.out.println(res);

		/*
		 * Negative Tests
		 */
		
		// Case 1: D <.? C
		SimpleType d1 = tf.getSimpleType("D", tf.getPlaceholderType("T2"), tf.getSimpleType("SType2"), tf.getExtendsType(tf.getSimpleType("SType2")));
		pair = new MPair(d1, c1, PairOperator.SMALLERDOTWC);
		Assert.assertFalse(rules.reduceEq(pair).isPresent());
		
		// Case 2: C <. C
		pair = new MPair(c1, c2, PairOperator.SMALLERDOT);
		Assert.assertFalse(rules.reduceEq(pair).isPresent());
	}
	
	@Test
	public void testErase1() {
		TypeFactory tf = new TypeFactory();
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getCollectionExample());
		
		/*
		 * Positive Tests
		 */
		MPair erase1 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("Collection"), PairOperator.SMALLERDOT);
		MPair erase2 = new MPair(tf.getSimpleType("HashSet", "W"), tf.getSimpleType("Collection"), PairOperator.SMALLERDOT);
		MPair erase3 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOT);
		
		Assert.assertTrue(rules.erase1(erase1));
		Assert.assertTrue(rules.erase1(erase2));
		Assert.assertTrue(rules.erase1(erase3));
		
		/*
		 * Negative Tests
		 */
		MPair noerase1 = new MPair(tf.getSimpleType("Collection"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOT);
		MPair noerase2 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("Collection"), PairOperator.EQUALSDOT);
		MPair noerase3 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("Collection"), PairOperator.SMALLERDOTWC);
		
		Assert.assertFalse(rules.erase1(noerase1));
		Assert.assertFalse(rules.erase1(noerase2));
		Assert.assertFalse(rules.erase1(noerase3));
	}
	
	@Test
	public void testErase2() {
		TypeFactory tf = new TypeFactory();
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getCollectionExample());
		
		/*
		 * Positive Tests
		 */
		MPair erase1 = new MPair(tf.getSimpleType("List", "T"), tf.getExtendsType(tf.getSimpleType("Collection")), PairOperator.SMALLERDOTWC);
		MPair erase2 = new MPair(tf.getSimpleType("Collection"), tf.getSuperType(tf.getSimpleType("HashSet", "T")), PairOperator.SMALLERDOTWC);
		MPair erase3 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOTWC);
		MPair erase4 = new MPair(tf.getExtendsType(tf.getSimpleType("LinkedList", "T")), tf.getExtendsType(tf.getSimpleType("List", "T")), PairOperator.SMALLERDOTWC);
		MPair erase5 = new MPair(tf.getSuperType(tf.getSimpleType("List", "T")), tf.getSuperType(tf.getSimpleType("Stack", "T")), PairOperator.SMALLERDOTWC);

		
		Assert.assertTrue(rules.erase2(erase1));
		Assert.assertTrue(rules.erase2(erase2));
		Assert.assertTrue(rules.erase2(erase3));
		Assert.assertTrue(rules.erase2(erase4));
		Assert.assertTrue(rules.erase2(erase5));
		
		/*
		 * Negative Tests
		 */
		MPair noerase1 = new MPair(tf.getSimpleType("Collection"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOTWC);
		MPair noerase2 = new MPair(tf.getSuperType(tf.getSimpleType("List", "T")), tf.getSimpleType("ArrayList", "T"), PairOperator.SMALLERDOTWC);
		MPair noerase3 = new MPair(tf.getExtendsType(tf.getSimpleType("List", "T")), tf.getSuperType(tf.getSimpleType("List", "T")), PairOperator.SMALLERDOTWC);
		MPair noerase4 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOT);
		
		Assert.assertFalse(rules.erase2(noerase1));
		Assert.assertFalse(rules.erase2(noerase2));
		Assert.assertFalse(rules.erase2(noerase3));
		Assert.assertFalse(rules.erase2(noerase4));
	}
	
	@Test
	public void testErase3() {
		TypeFactory tf = new TypeFactory();
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getFiniteClosure());
		
		/*
		 * Positive Tests
		 */
		MPair erase1 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("List", "T"), PairOperator.EQUALSDOT);
		MPair erase2 = new MPair(tf.getPlaceholderType("W"), tf.getPlaceholderType("W"), PairOperator.EQUALSDOT);
		
		Assert.assertTrue(rules.erase3(erase1));
		Assert.assertTrue(rules.erase3(erase2));
		
		/*
		 * Negative Tests
		 */
		MPair noerase1 = new MPair(tf.getSimpleType("Collection"), tf.getSimpleType("List", "T"), PairOperator.EQUALSDOT);
		MPair noerase2 = new MPair(tf.getSimpleType("List", "T"), tf.getSimpleType("List", "T"), PairOperator.SMALLERDOT);
		
		Assert.assertFalse(rules.erase3(noerase1));
		Assert.assertFalse(rules.erase3(noerase2));
	}
	
	@Test
	public void testSwap() {
		TypeFactory tf = new TypeFactory();
		IRuleSet rules = new RuleSet(new FiniteClosureBuilder().getFiniteClosure());
		
		/*
		 * Positive Tests
		 */
		MPair swap1 = new MPair(tf.getExtendsType(tf.getSimpleType("MyClass")), tf.getPlaceholderType("P"), PairOperator.EQUALSDOT);
		MPair swap2 = new MPair(tf.getSimpleType("MyClass"), tf.getPlaceholderType("X"), PairOperator.EQUALSDOT);
		
		MPair expected1 = new MPair(tf.getPlaceholderType("P"), tf.getExtendsType(tf.getSimpleType("MyClass")), PairOperator.EQUALSDOT);
		MPair expected2 = new MPair(tf.getPlaceholderType("X"), tf.getSimpleType("MyClass"), PairOperator.EQUALSDOT);
		
		Optional<MPair> opt1 = rules.swap(swap1);
		Optional<MPair> opt2 = rules.swap(swap2);
		
		// swap((? extends MyClass =. P)) = (P =. MyClass)
		Assert.assertEquals(opt1.get(), expected1);
		
		// swap((MyClass =. X)) = (X =. MyClass)
		Assert.assertEquals(opt2.get(), expected2);
		
		/*
		 * Negative Tests
		 */
		MPair noswap1 = new MPair(tf.getPlaceholderType("Z"), tf.getPlaceholderType("X"), PairOperator.EQUALSDOT);
		MPair noswap2 = new MPair(tf.getSimpleType("MyClass"), tf.getExtendsType(tf.getPlaceholderType("X")), PairOperator.EQUALSDOT);
		MPair noswap3 = new MPair( tf.getPlaceholderType("X"), tf.getSimpleType("MyClass"), PairOperator.EQUALSDOT);
		MPair noswap4 = new MPair(tf.getSimpleType("MyClass"), tf.getPlaceholderType("X"), PairOperator.SMALLERDOT);
		
		opt1 = rules.swap(noswap1);
		opt2 = rules.swap(noswap2);
		Optional<MPair> opt3 = rules.swap(noswap3);
		Optional<MPair> opt4 = rules.swap(noswap4);
		
		Assert.assertFalse(opt1.isPresent());
		Assert.assertFalse(opt2.isPresent());
		Assert.assertFalse(opt3.isPresent());
		Assert.assertFalse(opt4.isPresent());
	}
	
	@Test
	public void testAdapt() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		
		SimpleType t1 = tf.getSimpleType("Type1", "T", "U");
		SimpleType t2 = tf.getSimpleType("Type2", "T");
		SimpleType t3 = tf.getSimpleType("Type3", tf.getPlaceholderType("T"), tf.getSimpleType("Integer"));
		
		fcb.add(t1, t2);
		fcb.add(t2, t3);
		
		IRuleSet rules = new RuleSet(fcb.getFiniteClosure());
		
		SimpleType c1 = tf.getSimpleType("Type1", "String", "Double");
		SimpleType c2 = tf.getSimpleType("Type2", "Object");
		SimpleType c3 = tf.getSimpleType("Type3", "Object", "Number");
		
		MPair pair1 = new MPair(c1, c2, PairOperator.SMALLERDOT);
		MPair pair2 = new MPair(c1, c3, PairOperator.SMALLERDOT);
		System.out.println("------ Adapt ------");
		System.out.println(rules.adapt(pair1));
		System.out.println(rules.adapt(pair2)); // Not working yet
		
	}
	
	@Test
	public void testAdaptExt() {
		
	}
	
	@Test
	public void testAdaptSup() {
		
	}
}