package unify;

import junit.framework.Assert;

import org.junit.Test;

import de.dhbwstuttgart.syntaxtree.factory.UnifyPairMengenBuilder;
import de.dhbwstuttgart.syntaxtree.factory.UnifyTypeFactory;
import de.dhbwstuttgart.syntaxtree.factory.Unify_FC_TTO_Builder;
import de.dhbwstuttgart.syntaxtree.type.ExtendsWildcardType;
import de.dhbwstuttgart.syntaxtree.type.ObjectType;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.Type;
import de.dhbwstuttgart.syntaxtree.type.RefType;
import de.dhbwstuttgart.syntaxtree.type.SuperWildcardType;
import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
import de.dhbwstuttgart.syntaxtree.type.WildcardType;
import de.dhbwstuttgart.typeinference.Menge;
import de.dhbwstuttgart.typeinference.Pair;
import de.dhbwstuttgart.typeinference.unify.Unify;

public class UnifyOldTest {

	@Test
	public void unifyTest1() {
		// Init Factories and Builders
		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();

<<<<<<< HEAD
		/*
		 * Test a <. Boolean
		 */

		// Init Types
		RefType boolT = this.GetSimpleType("java.lang.Boolean");
		TypePlaceholder aTph = this.GetTypePlaceholder("a");

		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(aTph, boolT, PairOperator.Equal);
		resultBuilder.addPair(aTph, this.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 = this.GetSimpleType("java.lang.Boolean");
		aTph = this.GetTypePlaceholder("a");
		TypePlaceholder bTph = this.GetTypePlaceholder("b");

		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(aTph, boolT, PairOperator.Equal);
		resultBuilder.addPair(aTph, this.GetExtendsType(boolT),
				PairOperator.Equal);
		resultBuilder.addPair(bTph, boolT, PairOperator.Equal);
		resultBuilder.addPair(bTph, this.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 = this.GetTypePlaceholder("a");
		bTph = this.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 = this.GetSimpleType("java.lang.Integer");
		boolT = this.GetSimpleType("java.lang.Boolean");
		aTph = this.GetTypePlaceholder("a");
		bTph = this.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() {

		// Init Factories and Builders
		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();

		/*
		 * Test a <. MyClass<T, F>
		 */

		TypePlaceholder aTph = this.GetTypePlaceholder("a");
		RefType myType = this.GetSimpleType("MyClass",
				this.GetTypePlaceholder("T"),
				this.GetTypePlaceholder("F"));

		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(aTph, myType, PairOperator.Equal);
		resultBuilder.addPair(aTph, this.GetExtendsType(myType));
		Menge<Menge<Pair>> expectedResult = resultBuilder.getNestedPairMenge();

		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(aTph, myType);
		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 List<List<T>> <. List<T>
		 */

		TypePlaceholder tTph = this.GetTypePlaceholder("T");
		RefType list = this.GetSimpleType("List", tTph);
		RefType listlist = this.GetSimpleType("List", list);

		// Expected Result
		resultBuilder.clear();
		resultBuilder.addPair(this.GetExtendsType(list), tTph,
				PairOperator.Equal);
		expectedResult = resultBuilder.getNestedPairMenge();

		// Actual Result
		assumptionBuilder.clear();
		assumptionBuilder.addPair(listlist, list);
		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
				fcBuilder.Get_FC_TTO());

		System.out.println(expectedResult);
		System.out.println(actualResult);

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

		/*
		 * Test List<T> <. List<List<T>>
		 */
	}

	@Test
	public void unifyTestInheritance() {

		// Init Factories and Builders
		Unify_FC_TTO_Builder fcBuilder = new Unify_FC_TTO_Builder();
		UnifyPairMengenBuilder assumptionBuilder = new UnifyPairMengenBuilder();
		UnifyPairMengenBuilder resultBuilder = new UnifyPairMengenBuilder();

		// Init Types
		RefType tBool = this.GetSimpleType("java.lang.Boolean");
		RefType tString = this.GetSimpleType("java.lang.String");
		RefType tInt = this.GetSimpleType("java.lang.Integer");
		TypePlaceholder tphA = this.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, this.GetExtendsType(tBool),
				PairOperator.Equal);
		resultBuilder.addPair(tphA, tString, PairOperator.Equal);
		resultBuilder.addPair(tphA, this.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 containsAll(m1, m2) && containsAll(m2, m1);
	}

	private static boolean containsAll(Menge<Menge<Pair>> m1,
			Menge<Menge<Pair>> m2) {
		for (Menge<Pair> elem : m2)
			if (!contains(m1, elem))
				return false;
		return true;
	}

	private static boolean contains(Menge<Menge<Pair>> m1, Menge<Pair> m2) {
		for (Menge<Pair> elem : m1)
			if (mengePairEquals(elem, m2))
				return true;
		return false;
	}

	private static boolean mengePairEquals(Menge<Pair> m1, Menge<Pair> m2) {
		if (m1.size() != m2.size())
			return false;

		return containsAllPair(m1, m2) && containsAllPair(m2, m1);
	}

	private static boolean containsAllPair(Menge<Pair> m1, Menge<Pair> m2) {
		for (Pair elem : m1)
			if (contains(m2, elem))
				return true;
		return false;
	}

	private static boolean contains(Menge<Pair> m, Pair p) {
		for (Pair elem : m)
			if (pairEquals(elem, p))
				return true;
		return false;

	}

	private static boolean pairEquals(Pair p1, Pair p2) {
		return (p1.TA1.equals(p2.TA1) && p1.TA2.equals(p2.TA2))
				|| (p1.TA1.equals(p2.TA2) && p1.TA2.equals(p2.TA1));
	}
	
	
	private RefType GetSimpleType(String name, Type... parameters) {
		if(parameters.length == 0)	
			return new RefType(name, null, 0);
		
		Menge<Type> typeParams = new Menge<Type>();
		
		for(Type t : parameters)
			typeParams.add(t);
		
		return new RefType(name, typeParams, null, 0);
	}
	
	private ExtendsWildcardType GetExtendsType(ObjectType extendedType) {
		return new ExtendsWildcardType(extendedType);
	}
	
	private SuperWildcardType GetSuperType(ObjectType superedType) {
		return new SuperWildcardType(superedType);
	}
	
	private WildcardType GetWildcardType() {
		return new WildcardType(null, null, 0);
	}
	
	private TypePlaceholder GetTypePlaceholder(String name) {
		return TypePlaceholder.backdoorCreate(name);
	}
=======
		TypePlaceholder a = typeFactory.GetTypePlaceholder("a");
		ExtendsWildcardType extA = typeFactory.GetExtendsType(a);
		TypePlaceholder b = typeFactory.GetTypePlaceholder("b");
		ExtendsWildcardType extB = typeFactory.GetExtendsType(b);
		RefType integer = typeFactory.GetSimpleType("Integer");
		SuperWildcardType supInt = typeFactory.GetSuperType(integer);
		RefType listsupint = typeFactory.GetSimpleType("List", supInt);
		RefType number = typeFactory.GetSimpleType("Number");
		RefType object = typeFactory.GetSimpleType("XObjectX");
		ExtendsWildcardType extNum = typeFactory.GetExtendsType(number);
		RefType intlist = typeFactory.GetSimpleType("List", integer);
		RefType alist = typeFactory.GetSimpleType("List", a);
		RefType extBlist = typeFactory.GetSimpleType("List", extB);
		RefType blist = typeFactory.GetSimpleType("List", b);
		RefType extNumlist = typeFactory.GetSimpleType("List", extNum);

		fcBuilder.AddInheritance(number, object);
		fcBuilder.AddInheritance(integer, number);
		
		
		assumptionBuilder.addPair(alist, extBlist, PairOperator.Smaller);
		assumptionBuilder.addPair(blist, extNumlist, PairOperator.Smaller);
		
		System.out.println(Unify.unify(assumptionBuilder.getPairMenge(),
				fcBuilder.Get_FC_TTO()));
	}
//	
//	@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() {
//
//		// 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 <. MyClass<T, F>
//		 */
//
//		TypePlaceholder aTph = typeFactory.GetTypePlaceholder("a");
//		RefType myType = typeFactory.GetSimpleType("MyClass",
//				typeFactory.GetTypePlaceholder("T"),
//				typeFactory.GetTypePlaceholder("F"));
//
//		// Expected Result
//		resultBuilder.clear();
//		resultBuilder.addPair(aTph, myType, PairOperator.Equal);
//		resultBuilder.addPair(aTph, typeFactory.GetExtendsType(myType));
//		Menge<Menge<Pair>> expectedResult = resultBuilder.getNestedPairMenge();
//
//		// Actual Result
//		assumptionBuilder.clear();
//		assumptionBuilder.addPair(aTph, myType);
//		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 List<List<T>> <. List<T>
//		 */
//
//		TypePlaceholder tTph = typeFactory.GetTypePlaceholder("T");
//		RefType list = typeFactory.GetSimpleType("List", tTph);
//		RefType listlist = typeFactory.GetSimpleType("List", list);
//
//		// Expected Result
//		resultBuilder.clear();
//		resultBuilder.addPair(typeFactory.GetExtendsType(list), tTph,
//				PairOperator.Equal);
//		expectedResult = resultBuilder.getNestedPairMenge();
//
//		// Actual Result
//		assumptionBuilder.clear();
//		assumptionBuilder.addPair(listlist, list);
//		actualResult = Unify.unify(assumptionBuilder.getPairMenge(),
//				fcBuilder.Get_FC_TTO());
//
//		System.out.println(expectedResult);
//		System.out.println(actualResult);
//
//		Assert.assertTrue(mengeEquals(expectedResult, actualResult));
//
//		/*
//		 * Test List<T> <. List<List<T>>
//		 */
//	}
//
//	@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 containsAll(m1, m2) && containsAll(m2, m1);
//	}
//
//	private static boolean containsAll(Menge<Menge<Pair>> m1,
//			Menge<Menge<Pair>> m2) {
//		for (Menge<Pair> elem : m2)
//			if (!contains(m1, elem))
//				return false;
//		return true;
//	}
//
//	private static boolean contains(Menge<Menge<Pair>> m1, Menge<Pair> m2) {
//		for (Menge<Pair> elem : m1)
//			if (mengePairEquals(elem, m2))
//				return true;
//		return false;
//	}
//
//	private static boolean mengePairEquals(Menge<Pair> m1, Menge<Pair> m2) {
//		if (m1.size() != m2.size())
//			return false;
//
//		return containsAllPair(m1, m2) && containsAllPair(m2, m1);
//	}
//
//	private static boolean containsAllPair(Menge<Pair> m1, Menge<Pair> m2) {
//		for (Pair elem : m1)
//			if (contains(m2, elem))
//				return true;
//		return false;
//	}
//
//	private static boolean contains(Menge<Pair> m, Pair p) {
//		for (Pair elem : m)
//			if (pairEquals(elem, p))
//				return true;
//		return false;
//
//	}
//
//	private static boolean pairEquals(Pair p1, Pair p2) {
//		return (p1.TA1.equals(p2.TA1) && p1.TA2.equals(p2.TA2))
//				|| (p1.TA1.equals(p2.TA2) && p1.TA2.equals(p2.TA1));
//	}
>>>>>>> d89d06797e17a7a95f007fe24e9b6133b3b13179

}