JavaCompilerCore/test/unify/FiniteClosureTest.java

package unify;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;

import org.junit.Assert;
import org.junit.Test;

import de.dhbwstuttgart.typeinference.unify.interfaces.IFiniteClosure;
import de.dhbwstuttgart.typeinference.unify.model.Type;
import de.dhbwstuttgart.typeinference.unifynew.TypeFactory;

public class FiniteClosureTest {
	
	@Test
	public void testSmaller() {
		TypeFactory tf = new TypeFactory();
		
		Type integer = tf.getSimpleType("Integer");
		Type number = tf.getSimpleType("Number");
		
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		fcb.add(integer, number);
		fcb.add(tf.getSimpleType("MyMap", "T"), tf.getSimpleType("HashMap", tf.getSimpleType("Integer")));
		fcb.add(tf.getSimpleType("HashMap", "T"), tf.getSimpleType("Collection"));
		IFiniteClosure fc = fcb.getCollectionExample();

		/*
		 * Test Case 1:
		 * 
		 * smaller(Set<Integer>) = { HashSet<Integer>, Set<Integer, TreeSet<Integer>, LinkedHashSet<Integer> }
		 */
		
		Type setInt = tf.getSimpleType("Set", integer);
		Type hashSetInt = tf.getSimpleType("HashSet", integer);
		Type treeSetInt = tf.getSimpleType("TreeSet", integer);
		Type linkedHashSetInt = tf.getSimpleType("LinkedHashSet", integer);
		
		Set<Type> expectedResult = new HashSet<>(Arrays.stream(new Type[] {
				setInt, hashSetInt, linkedHashSetInt, treeSetInt,
		}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setInt));
		
		/*
		 * Test Case 2:
		 * 
		 * smaller(Set<? ext Integer>) = 
		 * { HashSet<Integer>, Set<Integer>, TreeSet<Integer>, LinkedHashSet<Integer>,
		 *   HashSet<? ext Integer>, Set<? ext Integer>, TreeSet<? ext Integer>, LinkedHashSet<? ext Integer> }
		 */
		
		Type extInt = tf.getExtendsType(integer);
		Type hashSetExtInt = tf.getSimpleType("HashSet", extInt);
		Type treeSetExtInt = tf.getSimpleType("TreeSet", extInt);
		Type linkedHashSetExtInt = tf.getSimpleType("LinkedHashSet", extInt);
		Type setExtInt = tf.getSimpleType("Set", extInt);
		
		expectedResult = new HashSet<>(Arrays.stream(new Type[] {
					setInt, hashSetInt, linkedHashSetInt, treeSetInt,
					hashSetExtInt, treeSetExtInt, linkedHashSetExtInt, setExtInt,
			}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setExtInt));
		
		/*
		 * Test Case 3:
		 * 
		 * smaller(Set<? ext Number>) = 
	 	 * { HashSet<Integer>, Set<Integer>, TreeSet<Integer>, LinkedHashSet<Integer>,
	 	 *   HashSet<Number>, Set<Number>, TreeSet<Number>, LinkedHashSet<Number>,
		 *   HashSet<? ext Integer>, Set<? ext Integer>, TreeSet<? ext Integer>, LinkedHashSet<? ext Integer> 
		 *   HashSet<? ext Number, Set<? ext Number, TreeSet<? ext Number, LinkedHashSet<? ext Number> }
		 */
		
		Type hashSetNum = tf.getSimpleType("HashSet", number);
		Type treeSetNum = tf.getSimpleType("TreeSet", number);
		Type linkedHashSetNum = tf.getSimpleType("LinkedHashSet", number);
		Type setNum = tf.getSimpleType("Set", number);
		
		Type extNum = tf.getExtendsType(number);
		Type hashSetExtNum = tf.getSimpleType("HashSet", extNum);
		Type treeSetExtNum = tf.getSimpleType("TreeSet", extNum);
		Type linkedHashSetExtNum = tf.getSimpleType("LinkedHashSet", extNum);
		Type setExtNum = tf.getSimpleType("Set", extNum);
		
		expectedResult =  new HashSet<>(Arrays.stream(new Type[] {
				setInt, hashSetInt, linkedHashSetInt, treeSetInt,
				setNum, hashSetNum, linkedHashSetNum, treeSetNum,
				setExtInt, hashSetExtInt, linkedHashSetExtInt, treeSetExtInt,
				setExtNum, hashSetExtNum, linkedHashSetExtNum, treeSetExtNum
		}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setExtNum));
		
		/*
		 * Test Case 4:
		 * TODO ist das ergebnis korrekt oder müssen die ? ext Ts raus weil der allgemeienste Typ T ausreicht?
		 * smaller(Set<T>) = 		 
		 * { HashSet<T>, Set<T>, TreeSet<T>, LinkedHashSet<T>,
		 *   HashSet<? ext T>, Set<? ext T>, TreeSet<? ext T>, LinkedHashSet<? ext T> }
		 */
		
		Type t = tf.getPlaceholderType("T");
		Type setT = tf.getSimpleType("Set", t);
		Type hashSetT = tf.getSimpleType("HashSet", t);
		Type treeSetT = tf.getSimpleType("TreeSet", t);
		Type linkedHashSetT = tf.getSimpleType("LinkedHashSet", t);
		Type hashSetExtT = tf.getSimpleType("HashSet", t);
		Type treeSetExtT = tf.getSimpleType("TreeSet", t);
		Type linkedHashSetExtT = tf.getSimpleType("LinkedHashSet", t);
		Type setExtT = tf.getSimpleType("Set", t);
		
		expectedResult = new HashSet<>(Arrays.stream(new Type[] {
					setT, hashSetT, treeSetT, linkedHashSetT,
					setExtT, hashSetExtT, treeSetExtT, linkedHashSetExtT
			}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setT));
		
		/*
		 * Test Case 5 
		 * 
		 * smaller(Set<? super Integer> = 
		 * { Set<Integer>, HashSet<Integer>, TreeSet<Integer>, LinkedHashSet<Integer>,
		 *   Set<? super Integer>, HashSet<? super Integer>, TreeSet<? super Integer>, LinkedHashSet<? super Integer>,
		 *   Set<? super Number>, HashSet<? super Number>, TreeSet<? super Number>, LinkedHashSet<? super Number> }
		 */

		Type superNum = tf.getSuperType(number);
		Type superInt = tf.getSuperType(integer);
		
		Type setSupInt = tf.getSimpleType("Set", superInt);
		Type hashSetSupInt = tf.getSimpleType("HashSet", superInt);
		Type linkedHashSetSupInt = tf.getSimpleType("LinkedHashSet", superInt);
		Type treeSetSupInt = tf.getSimpleType("TreeSet", superInt);
		Type setSupNum = tf.getSimpleType("Set", superNum);
		Type hashSetSupNum = tf.getSimpleType("HashSet", superNum);
		Type linkedHashSetSupNum = tf.getSimpleType("LinkedHashSet", superNum);
		Type treeSetSupNum = tf.getSimpleType("TreeSet", superNum);
		
		expectedResult = new HashSet<>(Arrays.stream(new Type[] {
				setSupInt, hashSetSupInt, linkedHashSetSupInt, treeSetSupInt,
				setSupNum, hashSetSupNum, linkedHashSetSupNum, treeSetSupNum,
				setInt, hashSetInt, linkedHashSetInt, treeSetInt,
				setNum, hashSetNum, linkedHashSetNum, treeSetNum
		}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setSupInt));
		
		/*
		 * Test Case 6:
		 * 
		 * smaller(Set<? ext T) = 
		 * { HashSet<T>, Set<T>, TreeSet<T>, LinkedHashSet<T>,
		 *   HashSet<? ext T>, Set<? ext T>, TreeSet<? ext T>, LinkedHashSet<? ext T> }
		 * 
		 */
		
		expectedResult = new HashSet<>(Arrays.stream(new Type[] {
				setT, hashSetT, treeSetT, linkedHashSetT,
				setExtT, hashSetExtT, treeSetExtT, linkedHashSetExtT
		}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setExtT));
		
		/*
		 * Test Case 7:
		 * smaller(Set<NotInFc>) = 		 
		 * { HashSet<NotInFc>, Set<NotInFc>, TreeSet<NotInFc>, LinkedHashSet<NotInFc>,
		 *   HashSet<? ext NotInFc>, Set<? ext NotInFc>, TreeSet<? ext NotInFc>, LinkedHashSet<? ext NotInFc> }
		 */
		
		Type notInFc = tf.getSimpleType("notInFC");
		Type setNotInFc = tf.getSimpleType("Set", notInFc);
		Type hashSetNotInFc = tf.getSimpleType("HashSet", notInFc);
		Type treeSetNotInFc = tf.getSimpleType("TreeSet", notInFc);
		Type linkedHashSetNotInFc = tf.getSimpleType("LinkedHashSet", notInFc);
		Type hashSetExtNotInFc = tf.getSimpleType("HashSet", notInFc);
		Type treeSetExtNotInFc = tf.getSimpleType("TreeSet", notInFc);
		Type linkedHashSetExtNotInFc = tf.getSimpleType("LinkedHashSet", notInFc);
		Type setExtNotInFc = tf.getSimpleType("Set", notInFc);
		
		expectedResult = new HashSet<>(Arrays.stream(new Type[] {
				setNotInFc, hashSetNotInFc, treeSetNotInFc, linkedHashSetNotInFc,
				setExtNotInFc, hashSetExtNotInFc, treeSetExtNotInFc, linkedHashSetExtNotInFc
		}).collect(Collectors.toSet()));
		
		Assert.assertEquals(expectedResult, fc.smaller(setNotInFc));
		
		/*
		 * Test Case 8:
		 * 
		 */
	}
	
	@Test
	public void testGreater() {
		TypeFactory tf = new TypeFactory();
		FiniteClosureBuilder fcb = new FiniteClosureBuilder();
		fcb.add(tf.getSimpleType("Integer"), tf.getSimpleType("Number"));
		fcb.add(tf.getSimpleType("MyMap", "T"), tf.getSimpleType("HashMap", tf.getSimpleType("Integer")));
		fcb.add(tf.getSimpleType("HashMap", "T"), tf.getSimpleType("Collection"));
		IFiniteClosure fc = fcb.getCollectionExample();
		
		System.out.println("\n\n----- Greater Test -----");
		System.out.println("Greater(LinkedList<T>) = " + fc.greater(tf.getSimpleType("LinkedList", "T")));
		System.out.println("Greater(TreeSet<T>) = " + fc.greater(tf.getSimpleType("TreeSet", "T")));
		System.out.println("Greater(Collection) = " + fc.greater(tf.getSimpleType("Collection")));
		System.out.println(fc.greater(tf.getSimpleType("Deque", tf.getSimpleType("Integer"))));
		System.out.println(fc.greater(tf.getSimpleType("Deque", tf.getSimpleType("Number"))));
		System.out.println(fc.greater(tf.getSimpleType("Deque", tf.getExtendsType(tf.getSimpleType("Integer")))));
		System.out.println(fc.greater(tf.getSimpleType("Deque", tf.getSuperType(tf.getSimpleType("Integer")))));
	}
	
	@Test
	public void testGrArg() {
		IFiniteClosure fc = new FiniteClosureBuilder().getCollectionExample();
		TypeFactory tf = new TypeFactory();
		
		System.out.println("\n\n----- GrArg Test -----");
		System.out.println("GrArg(List<T>) = " + fc.grArg(tf.getSimpleType("List", "T")));
		System.out.println("GrArg(? extends List<T>) = " + fc.grArg(tf.getExtendsType(tf.getSimpleType("List", "T"))));
		System.out.println("GrArg(? super List<T>) = " + fc.grArg(tf.getSuperType(tf.getSimpleType("List", "T"))));
	}
	
	
	@Test
	public void testSmArg() {
		IFiniteClosure fc = new FiniteClosureBuilder().getCollectionExample();
		TypeFactory tf = new TypeFactory();
		
		System.out.println("\n\n----- SmArg Test -----");
		System.out.println("SmArg(List<T>) = " + fc.smArg(tf.getSimpleType("List", "T")));
		System.out.println("SmArg(? extends List<T>) = " + fc.smArg(tf.getExtendsType(tf.getSimpleType("List", "T"))));
		System.out.println("SmArg(? super List<T>) = " + fc.smArg(tf.getSuperType(tf.getSimpleType("List", "T"))));
	}
	
	@Test
	public void testGetGenericType() {
		
		// TODO
	}
}