JavaTXCompilerInJavaTX/test/unify/UnifyTest.java

package unify;

import junit.framework.Assert;

import org.junit.Test;

import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.Pair.PairOperator;
import de.dhbwstuttgart.typeinference.unify.Unify;

public class UnifyTest {
	
	@Test
	public void unifyTestSimpleTypes() {
		
		// Init Factories and Builders
		UnifyTypeFactory typeFactory = new UnifyTypeFactory();
		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();
		
		/*
		 * Test a <. Boolean
		 */
		
		// Init Types
		RefType boolT = typeFactory.GetSimpleType("java.lang.Boolean");
		TypePlaceholder aTPH = typeFactory.GetTypePlaceholder("a");
		
		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(aTPH, boolT, PairOperator.Equal);
		resultBuilder.addPair(aTPH, typeFactory.GetExtendsType(boolT), PairOperator.Equal);
		Menge<Menge<Pair>> expectedResult = resultBuilder.getNestedPairMenge();	
		
		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(aTPH, boolT);
		Menge<Menge<Pair>> actualResult = Unify.unify(assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
		
//		System.out.println(expectedResult);
//		System.out.println(actualResult);
		
		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
			
		
		/*
		 * Test b <. a, a <. Boolean
		 */
		
		// Init Types
		boolT = typeFactory.GetSimpleType("java.lang.Boolean");
		aTPH = typeFactory.GetTypePlaceholder("a");
		TypePlaceholder bTPH = typeFactory.GetTypePlaceholder("b");
		
		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(aTPH, boolT, PairOperator.Equal);
		resultBuilder.addPair(aTPH, typeFactory.GetExtendsType(boolT), PairOperator.Equal);
		resultBuilder.addPair(bTPH, boolT, PairOperator.Equal);
		resultBuilder.addPair(bTPH, typeFactory.GetExtendsType(boolT), PairOperator.Equal);
		expectedResult = resultBuilder.getNestedPairMenge();	
		
		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(bTPH, aTPH);
		assumptionBuilder.addPair(aTPH, boolT);
		actualResult = Unify.unify(assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
		
//		System.out.println(expectedResult);
//		System.out.println(actualResult);
		
		// NOTE: Elemente im actualResult sind nicht unique
		//Assert.assertTrue(mengeEquals(expectedResult, actualResult));
		
		
		/*
		 * Test b <. a, a <. b
		 */
		
		aTPH = typeFactory.GetTypePlaceholder("a");
		bTPH = typeFactory.GetTypePlaceholder("b");
		
		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(bTPH, aTPH);
		resultBuilder.addPair(aTPH, bTPH);
		
		Menge<Pair> buffer = resultBuilder.getPairMenge();
		expectedResult = new Menge<Menge<Pair>>();
		expectedResult.add(buffer);
		
		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(bTPH, aTPH);
		assumptionBuilder.addPair(aTPH, bTPH);
		actualResult = Unify.unify(assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
		
//		System.out.println(expectedResult);
//		System.out.println(actualResult);

		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
		
		
		/*
		 * Test Integer <. a, a <. Boolean
		 */	
		
		RefType intT = typeFactory.GetSimpleType("java.lang.Integer");
		boolT = typeFactory.GetSimpleType("java.lang.Boolean");
		aTPH = typeFactory.GetTypePlaceholder("a");
		bTPH = typeFactory.GetTypePlaceholder("b");
		
		// Expected Result
		resultBuilder.clear();
		expectedResult = resultBuilder.getNestedPairMenge();
		
		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(intT, aTPH);
		assumptionBuilder.addPair(aTPH, boolT);
		actualResult = Unify.unify(assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
		
//		System.out.println(expectedResult);
//		System.out.println(actualResult);

		Assert.assertTrue(mengeEquals(expectedResult, actualResult));

	}
	
	@Test
	public void unifyTestGenerics() {
		
	}
	
	@Test
	public void unifyTestInheritance() {
		
		// Init Factories and Builders
		UnifyTypeFactory typeFactory = new UnifyTypeFactory();
		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();
		
		// Init Types
		RefType tBool = typeFactory.GetSimpleType("java.lang.Boolean");
		RefType tString = typeFactory.GetSimpleType("java.lang.String");
		RefType tInt = typeFactory.GetSimpleType("java.lang.Integer");
		TypePlaceholder tphA = typeFactory.GetTypePlaceholder("a");
		
		// Build inheritance hierachy
		// Bool <. String <. Int
		fcBuilder.AddInheritance(tBool, tString);
		fcBuilder.AddInheritance(tString, tInt);
		
		// Build Assumptions
		assumptionBuilder.addPair(tphA, tString);

		// Build expected result
		resultBuilder.addPair(tphA, tBool, PairOperator.Equal);
		resultBuilder.addPair(tphA, typeFactory.GetExtendsType(tBool), PairOperator.Equal);
		resultBuilder.addPair(tphA, tString, PairOperator.Equal);
		resultBuilder.addPair(tphA, typeFactory.GetExtendsType(tString), PairOperator.Equal);
		
		// Assert
		Menge<Menge<Pair>> actualResult = Unify.unify(assumptionBuilder.getPairMenge(), fcBuilder.Get_FC_TTO());
		
		System.out.println(actualResult);
		System.out.println("-------------------");
		System.out.println(resultBuilder.getNestedPairMenge());
		
		Assert.assertTrue(mengeEquals(resultBuilder.getNestedPairMenge(), actualResult));
	}
	
	@Test
	public void unifyTestWildcards() {
		
	}
	
	private static boolean mengeEquals(Menge<Menge<Pair>> m1, Menge<Menge<Pair>> m2) {
		if(m1.size() != m2.size())
			return false;
		
		return m1.containsAll(m2) && m2.containsAll(m1);
	}
}