Snap for 4632767 from 1afe9e0652b9b53edade5aa276162abe27b32a67 to pi-releaseandroid-wear-9.0.0_r9android-wear-9.0.0_r8android-wear-9.0.0_r7android-wear-9.0.0_r6android-wear-9.0.0_r5android-wear-9.0.0_r4android-wear-9.0.0_r3android-wear-9.0.0_r23android-wear-9.0.0_r22android-wear-9.0.0_r21android-wear-9.0.0_r20android-wear-9.0.0_r2android-wear-9.0.0_r19android-wear-9.0.0_r18android-wear-9.0.0_r17android-wear-9.0.0_r16android-wear-9.0.0_r15android-wear-9.0.0_r14android-wear-9.0.0_r13android-wear-9.0.0_r12android-wear-9.0.0_r11android-wear-9.0.0_r10android-wear-9.0.0_r1android-vts-9.0_r9android-vts-9.0_r8android-vts-9.0_r7android-vts-9.0_r6android-vts-9.0_r5android-vts-9.0_r4android-vts-9.0_r14android-vts-9.0_r13android-vts-9.0_r12android-vts-9.0_r11android-vts-9.0_r10android-cts-9.0_r9android-cts-9.0_r8android-cts-9.0_r7android-cts-9.0_r6android-cts-9.0_r5android-cts-9.0_r4android-cts-9.0_r3android-cts-9.0_r2android-cts-9.0_r13android-cts-9.0_r12android-cts-9.0_r11android-cts-9.0_r10android-cts-9.0_r1android-9.0.0_r9android-9.0.0_r8android-9.0.0_r7android-9.0.0_r60android-9.0.0_r6android-9.0.0_r59android-9.0.0_r58android-9.0.0_r57android-9.0.0_r56android-9.0.0_r55android-9.0.0_r54android-9.0.0_r53android-9.0.0_r52android-9.0.0_r51android-9.0.0_r50android-9.0.0_r5android-9.0.0_r49android-9.0.0_r48android-9.0.0_r3android-9.0.0_r2android-9.0.0_r18android-9.0.0_r17android-9.0.0_r10android-9.0.0_r1security-pi-releasepie-vts-releasepie-security-releasepie-s2-releasepie-release-2pie-releasepie-r2-s2-releasepie-r2-s1-releasepie-r2-releasepie-platform-releasepie-gsipie-cuttlefish-testingpie-cts-release

Change-Id: Ibe65883e94ed5a7272dff3f100393987a1cf3da2

7 files changed, 1877 insertions, 0 deletions

diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ArrayTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ArrayTypeTest.java
new file mode 100644
index 000000000..1d8e4dd02
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ArrayTypeTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.resolution.types.ResolvedVoidType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class ArrayTypeTest {
+
+    private ResolvedArrayType arrayOfBooleans;
+    private ResolvedArrayType arrayOfStrings;
+    private ResolvedArrayType arrayOfListOfA;
+    private ResolvedArrayType arrayOfListOfStrings;
+    private ReferenceTypeImpl OBJECT;
+    private ReferenceTypeImpl STRING;
+    private TypeSolver typeSolver;
+    private ResolvedTypeParameterDeclaration tpA;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        OBJECT = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        STRING = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        arrayOfBooleans = new ResolvedArrayType(ResolvedPrimitiveType.BOOLEAN);
+        arrayOfStrings = new ResolvedArrayType(STRING);
+        tpA = ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList());
+        arrayOfListOfA = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ResolvedTypeVariable(tpA)), typeSolver));
+        arrayOfListOfStrings = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)), typeSolver));
+    }
+
+    @Test
+    public void testIsArray() {
+        assertEquals(true, arrayOfBooleans.isArray());
+        assertEquals(true, arrayOfStrings.isArray());
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        assertEquals(false, arrayOfBooleans.isPrimitive());
+        assertEquals(false, arrayOfStrings.isPrimitive());
+    }
+
+    @Test
+    public void testIsNull() {
+        assertEquals(false, arrayOfBooleans.isNull());
+        assertEquals(false, arrayOfStrings.isNull());
+    }
+
+    @Test
+    public void testIsReference() {
+        assertEquals(true, arrayOfBooleans.isReference());
+        assertEquals(true, arrayOfStrings.isReference());
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        assertEquals(false, arrayOfBooleans.isReferenceType());
+        assertEquals(false, arrayOfStrings.isReferenceType());
+    }
+
+    @Test
+    public void testIsVoid() {
+        assertEquals(false, arrayOfBooleans.isVoid());
+        assertEquals(false, arrayOfStrings.isVoid());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        assertEquals(false, arrayOfBooleans.isTypeVariable());
+        assertEquals(false, arrayOfStrings.isTypeVariable());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsReferenceTypeUsage() {
+        arrayOfBooleans.asReferenceType();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsTypeParameter() {
+        arrayOfBooleans.asTypeParameter();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsPrimitive() {
+        arrayOfBooleans.asPrimitive();
+    }
+
+    @Test
+    public void testAsArrayTypeUsage() {
+        assertTrue(arrayOfBooleans == arrayOfBooleans.asArrayType());
+        assertTrue(arrayOfStrings == arrayOfStrings.asArrayType());
+        assertTrue(arrayOfListOfA == arrayOfListOfA.asArrayType());
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("boolean[]", arrayOfBooleans.describe());
+        assertEquals("java.lang.String[]", arrayOfStrings.describe());
+    }
+
+    @Test
+    public void testReplaceParam() {
+        assertTrue(arrayOfBooleans == arrayOfBooleans.replaceTypeVariables(tpA, OBJECT));
+        assertTrue(arrayOfStrings == arrayOfStrings.replaceTypeVariables(tpA, OBJECT));
+        assertEquals(arrayOfListOfStrings, arrayOfListOfStrings.replaceTypeVariables(tpA, OBJECT));
+        ResolvedArrayType arrayOfListOfObjects = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(OBJECT), typeSolver));
+        assertEquals(true, arrayOfListOfA.replaceTypeVariables(tpA, OBJECT).isArray());
+        assertEquals(ImmutableList.of(OBJECT),
+                arrayOfListOfA.replaceTypeVariables(tpA, OBJECT).asArrayType().getComponentType()
+                        .asReferenceType().typeParametersValues());
+        assertEquals(new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                arrayOfListOfA.replaceTypeVariables(tpA, OBJECT).asArrayType().getComponentType()
+                        .asReferenceType().getTypeDeclaration());
+        assertEquals(new ReferenceTypeImpl(
+                        new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                        ImmutableList.of(OBJECT), typeSolver),
+                arrayOfListOfA.replaceTypeVariables(tpA, OBJECT).asArrayType().getComponentType());
+        assertEquals(arrayOfListOfObjects, arrayOfListOfA.replaceTypeVariables(tpA, OBJECT));
+        assertEquals(arrayOfListOfStrings, arrayOfListOfA.replaceTypeVariables(tpA, STRING));
+        assertTrue(arrayOfListOfA != arrayOfListOfA.replaceTypeVariables(tpA, OBJECT));
+    }
+
+    @Test
+    public void testIsAssignableBy() {
+        assertEquals(false, arrayOfBooleans.isAssignableBy(OBJECT));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(STRING));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(ResolvedVoidType.INSTANCE));
+
+        assertEquals(true, arrayOfBooleans.isAssignableBy(arrayOfBooleans));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(arrayOfStrings));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(arrayOfListOfA));
+        assertEquals(false, arrayOfBooleans.isAssignableBy(arrayOfListOfStrings));
+        assertEquals(false, arrayOfStrings.isAssignableBy(arrayOfBooleans));
+        assertEquals(true, arrayOfStrings.isAssignableBy(arrayOfStrings));
+        assertEquals(false, arrayOfStrings.isAssignableBy(arrayOfListOfA));
+        assertEquals(false, arrayOfStrings.isAssignableBy(arrayOfListOfStrings));
+        assertEquals(false, arrayOfListOfA.isAssignableBy(arrayOfBooleans));
+        assertEquals(false, arrayOfListOfA.isAssignableBy(arrayOfStrings));
+        assertEquals(true, arrayOfListOfA.isAssignableBy(arrayOfListOfA));
+        assertEquals(false, arrayOfListOfA.isAssignableBy(arrayOfListOfStrings));
+        assertEquals(false, arrayOfListOfStrings.isAssignableBy(arrayOfBooleans));
+        assertEquals(false, arrayOfListOfStrings.isAssignableBy(arrayOfStrings));
+        assertEquals(false, arrayOfListOfStrings.isAssignableBy(arrayOfListOfA));
+        assertEquals(true, arrayOfListOfStrings.isAssignableBy(arrayOfListOfStrings));
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/NullTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/NullTypeTest.java
new file mode 100644
index 000000000..4df2460c6
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/NullTypeTest.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.resolution.types.ResolvedVoidType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class NullTypeTest {
+
+    private ResolvedArrayType arrayOfBooleans;
+    private ResolvedArrayType arrayOfListOfA;
+    private ReferenceTypeImpl OBJECT;
+    private ReferenceTypeImpl STRING;
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        OBJECT = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        STRING = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        arrayOfBooleans = new ResolvedArrayType(ResolvedPrimitiveType.BOOLEAN);
+        arrayOfListOfA = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()))), typeSolver));
+    }
+
+    @Test
+    public void testIsArray() {
+        assertEquals(false, NullType.INSTANCE.isArray());
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        assertEquals(false, NullType.INSTANCE.isPrimitive());
+    }
+
+    @Test
+    public void testIsNull() {
+        assertEquals(true, NullType.INSTANCE.isNull());
+    }
+
+    @Test
+    public void testIsReference() {
+        assertEquals(true, NullType.INSTANCE.isReference());
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        assertEquals(false, NullType.INSTANCE.isReferenceType());
+    }
+
+    @Test
+    public void testIsVoid() {
+        assertEquals(false, NullType.INSTANCE.isVoid());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        assertEquals(false, NullType.INSTANCE.isTypeVariable());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsReferenceTypeUsage() {
+        NullType.INSTANCE.asReferenceType();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsTypeParameter() {
+        NullType.INSTANCE.asTypeParameter();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsArrayTypeUsage() {
+        NullType.INSTANCE.asArrayType();
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("null", NullType.INSTANCE.describe());
+    }
+
+    @Test
+    public void testIsAssignableBy() {
+        try {
+            assertEquals(false, NullType.INSTANCE.isAssignableBy(NullType.INSTANCE));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, NullType.INSTANCE.isAssignableBy(OBJECT));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, NullType.INSTANCE.isAssignableBy(STRING));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, NullType.INSTANCE.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, NullType.INSTANCE.isAssignableBy(ResolvedVoidType.INSTANCE));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java
new file mode 100644
index 000000000..3679dbd41
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/PrimitiveTypeTest.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.resolution.types.ResolvedVoidType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class PrimitiveTypeTest {
+
+    private ResolvedArrayType arrayOfBooleans;
+    private ResolvedArrayType arrayOfListOfA;
+    private ReferenceTypeImpl OBJECT;
+    private ReferenceTypeImpl STRING;
+    private TypeSolver typeSolver;
+
+    private ReferenceTypeImpl booleanBox;
+    private ReferenceTypeImpl characterBox;
+    private ReferenceTypeImpl byteBox;
+    private ReferenceTypeImpl shortBox;
+    private ReferenceTypeImpl integerBox;
+    private ReferenceTypeImpl longBox;
+    private ReferenceTypeImpl floatBox;
+    private ReferenceTypeImpl doubleBox;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        OBJECT = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        STRING = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        arrayOfBooleans = new ResolvedArrayType(ResolvedPrimitiveType.BOOLEAN);
+        arrayOfListOfA = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()))), typeSolver));
+
+        booleanBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Boolean.class, typeSolver), typeSolver);
+        characterBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Character.class, typeSolver), typeSolver);
+        byteBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Byte.class, typeSolver), typeSolver);
+        shortBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Short.class, typeSolver), typeSolver);
+        integerBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Integer.class, typeSolver), typeSolver);
+        longBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Long.class, typeSolver), typeSolver);
+        floatBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Float.class, typeSolver), typeSolver);
+        doubleBox = new ReferenceTypeImpl(new ReflectionClassDeclaration(Double.class, typeSolver), typeSolver);
+
+    }
+
+    @Test
+    public void testIsArray() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isArray());
+        }
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(true, ptu.isPrimitive());
+        }
+    }
+
+    @Test
+    public void testIsNull() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isNull());
+        }
+    }
+
+    @Test
+    public void testIsReference() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isReference());
+        }
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isReferenceType());
+        }
+    }
+
+    @Test
+    public void testIsVoid() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isVoid());
+        }
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isTypeVariable());
+        }
+    }
+
+    @Test
+    public void testAsReferenceTypeUsage() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            try {
+                ptu.asReferenceType();
+                fail();
+            } catch (UnsupportedOperationException e) {
+            }
+        }
+    }
+
+    @Test
+    public void testAsTypeParameter() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            try {
+                ptu.asTypeParameter();
+                fail();
+            } catch (UnsupportedOperationException e) {
+            }
+        }
+    }
+
+    @Test
+    public void testAsArrayTypeUsage() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            try {
+                ptu.asArrayType();
+                fail();
+            } catch (UnsupportedOperationException e) {
+            }
+        }
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("boolean", ResolvedPrimitiveType.BOOLEAN.describe());
+        assertEquals("char", ResolvedPrimitiveType.CHAR.describe());
+        assertEquals("byte", ResolvedPrimitiveType.BYTE.describe());
+        assertEquals("short", ResolvedPrimitiveType.SHORT.describe());
+        assertEquals("int", ResolvedPrimitiveType.INT.describe());
+        assertEquals("long", ResolvedPrimitiveType.LONG.describe());
+        assertEquals("float", ResolvedPrimitiveType.FLOAT.describe());
+        assertEquals("double", ResolvedPrimitiveType.DOUBLE.describe());
+    }
+
+    @Test
+    public void testIsAssignableByOtherPrimitiveTypes() {
+        assertEquals(true, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(true, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, ResolvedPrimitiveType.FLOAT.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+
+        assertEquals(false, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.CHAR));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.BYTE));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+    }
+
+    @Test
+    public void testIsAssignableByBoxedTypes() {
+        assertEquals(true, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(booleanBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(characterBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(byteBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(shortBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(integerBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.BOOLEAN.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(booleanBox));
+        assertEquals(true, ResolvedPrimitiveType.CHAR.isAssignableBy(characterBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(byteBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(shortBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(integerBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.CHAR.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(booleanBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.BYTE.isAssignableBy(byteBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(shortBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(integerBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.BYTE.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(booleanBox));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.SHORT.isAssignableBy(byteBox));
+        assertEquals(true, ResolvedPrimitiveType.SHORT.isAssignableBy(shortBox));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(integerBox));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.SHORT.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(booleanBox));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(byteBox));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(shortBox));
+        assertEquals(true, ResolvedPrimitiveType.INT.isAssignableBy(integerBox));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.INT.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(booleanBox));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(byteBox));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(shortBox));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(integerBox));
+        assertEquals(true, ResolvedPrimitiveType.LONG.isAssignableBy(longBox));
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.LONG.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.FLOAT.isAssignableBy(booleanBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(byteBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(shortBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(integerBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(longBox));
+        assertEquals(true, ResolvedPrimitiveType.FLOAT.isAssignableBy(floatBox));
+        assertEquals(false, ResolvedPrimitiveType.FLOAT.isAssignableBy(doubleBox));
+
+        assertEquals(false, ResolvedPrimitiveType.DOUBLE.isAssignableBy(booleanBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(characterBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(byteBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(shortBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(integerBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(longBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(floatBox));
+        assertEquals(true, ResolvedPrimitiveType.DOUBLE.isAssignableBy(doubleBox));
+    }
+
+    @Test
+    public void testIsAssignableByAnythingElse() {
+        for (ResolvedPrimitiveType ptu : ResolvedPrimitiveType.values()) {
+            assertEquals(false, ptu.isAssignableBy(OBJECT));
+            assertEquals(false, ptu.isAssignableBy(STRING));
+            assertEquals(false, ptu.isAssignableBy(NullType.INSTANCE));
+            assertEquals(false, ptu.isAssignableBy(ResolvedVoidType.INSTANCE));
+            assertEquals(false, ptu.isAssignableBy(arrayOfBooleans));
+            assertEquals(false, ptu.isAssignableBy(arrayOfListOfA));
+        }
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ReferenceTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ReferenceTypeTest.java
new file mode 100644
index 000000000..3f4b318a7
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/ReferenceTypeTest.java
@@ -0,0 +1,600 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedClassDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedInterfaceDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.*;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.Serializable;
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.*;
+
+public class ReferenceTypeTest {
+
+    private ReferenceTypeImpl listOfA;
+    private ReferenceTypeImpl listOfStrings;
+    private ReferenceTypeImpl linkedListOfString;
+    private ReferenceTypeImpl collectionOfString;
+    private ReferenceTypeImpl listOfWildcardExtendsString;
+    private ReferenceTypeImpl listOfWildcardSuperString;
+    private ReferenceTypeImpl object;
+    private ReferenceTypeImpl string;
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        object = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        listOfA = new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()))), typeSolver);
+        listOfStrings = new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)), typeSolver);
+        linkedListOfString = new ReferenceTypeImpl(
+                new ReflectionClassDeclaration(LinkedList.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)), typeSolver);
+        collectionOfString = new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(Collection.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)), typeSolver);
+        listOfWildcardExtendsString = new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(ResolvedWildcard.extendsBound(string)), typeSolver);
+        listOfWildcardSuperString = new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(ResolvedWildcard.superBound(string)), typeSolver);
+    }
+
+    @Test
+    public void testDerivationOfTypeParameters() {
+        ReflectionTypeSolver typeSolver = new ReflectionTypeSolver();
+        ReferenceTypeImpl ref1 = new ReferenceTypeImpl(typeSolver.solveType(LinkedList.class.getCanonicalName()), typeSolver);
+        assertEquals(1, ref1.typeParametersValues().size());
+        assertEquals(true, ref1.typeParametersValues().get(0).isTypeVariable());
+        assertEquals("E", ref1.typeParametersValues().get(0).asTypeParameter().getName());
+    }
+
+    @Test
+    public void testIsArray() {
+        assertEquals(false, object.isArray());
+        assertEquals(false, string.isArray());
+        assertEquals(false, listOfA.isArray());
+        assertEquals(false, listOfStrings.isArray());
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        assertEquals(false, object.isPrimitive());
+        assertEquals(false, string.isPrimitive());
+        assertEquals(false, listOfA.isPrimitive());
+        assertEquals(false, listOfStrings.isPrimitive());
+    }
+
+    @Test
+    public void testIsNull() {
+        assertEquals(false, object.isNull());
+        assertEquals(false, string.isNull());
+        assertEquals(false, listOfA.isNull());
+        assertEquals(false, listOfStrings.isNull());
+    }
+
+    @Test
+    public void testIsReference() {
+        assertEquals(true, object.isReference());
+        assertEquals(true, string.isReference());
+        assertEquals(true, listOfA.isReference());
+        assertEquals(true, listOfStrings.isReference());
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        assertEquals(true, object.isReferenceType());
+        assertEquals(true, string.isReferenceType());
+        assertEquals(true, listOfA.isReferenceType());
+        assertEquals(true, listOfStrings.isReferenceType());
+    }
+
+    @Test
+    public void testIsVoid() {
+        assertEquals(false, object.isVoid());
+        assertEquals(false, string.isVoid());
+        assertEquals(false, listOfA.isVoid());
+        assertEquals(false, listOfStrings.isVoid());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        assertEquals(false, object.isTypeVariable());
+        assertEquals(false, string.isTypeVariable());
+        assertEquals(false, listOfA.isTypeVariable());
+        assertEquals(false, listOfStrings.isTypeVariable());
+    }
+
+    @Test
+    public void testAsReferenceTypeUsage() {
+        assertTrue(object == object.asReferenceType());
+        assertTrue(string == string.asReferenceType());
+        assertTrue(listOfA == listOfA.asReferenceType());
+        assertTrue(listOfStrings == listOfStrings.asReferenceType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsTypeParameter() {
+        object.asTypeParameter();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsArrayTypeUsage() {
+        object.asArrayType();
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("java.lang.Object", object.describe());
+        assertEquals("java.lang.String", string.describe());
+        assertEquals("java.util.List<A>", listOfA.describe());
+        assertEquals("java.util.List<java.lang.String>", listOfStrings.describe());
+    }
+
+    @Test
+    public void testReplaceParam() {
+        ResolvedTypeParameterDeclaration tpA = ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList());
+        assertTrue(object == object.replaceTypeVariables(tpA, object));
+        assertTrue(string == string.replaceTypeVariables(tpA, object));
+        assertEquals(listOfStrings, listOfStrings.replaceTypeVariables(tpA, object));
+        assertEquals(listOfStrings, listOfA.replaceTypeVariables(tpA, string));
+    }
+
+    @Test
+    public void testIsAssignableBySimple() {
+        assertEquals(true, object.isAssignableBy(string));
+        assertEquals(false, string.isAssignableBy(object));
+        assertEquals(false, listOfStrings.isAssignableBy(listOfA));
+        assertEquals(false, listOfA.isAssignableBy(listOfStrings));
+
+        assertEquals(false, object.isAssignableBy(ResolvedVoidType.INSTANCE));
+        assertEquals(false, string.isAssignableBy(ResolvedVoidType.INSTANCE));
+        assertEquals(false, listOfStrings.isAssignableBy(ResolvedVoidType.INSTANCE));
+        assertEquals(false, listOfA.isAssignableBy(ResolvedVoidType.INSTANCE));
+
+        assertEquals(true, object.isAssignableBy(NullType.INSTANCE));
+        assertEquals(true, string.isAssignableBy(NullType.INSTANCE));
+        assertEquals(true, listOfStrings.isAssignableBy(NullType.INSTANCE));
+        assertEquals(true, listOfA.isAssignableBy(NullType.INSTANCE));
+    }
+
+    @Test
+    public void testIsAssignableByBoxedPrimitive(){
+        ResolvedReferenceType numberType = new ReferenceTypeImpl(new ReflectionClassDeclaration(Number.class, typeSolver),typeSolver);
+        ResolvedReferenceType intType = new ReferenceTypeImpl(new ReflectionClassDeclaration(Integer.class, typeSolver),typeSolver);
+        ResolvedReferenceType doubleType = new ReferenceTypeImpl(new ReflectionClassDeclaration(Double.class, typeSolver),typeSolver);
+
+        assertEquals(true,  numberType.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(true,  numberType.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+        assertEquals(true,  numberType.isAssignableBy(ResolvedPrimitiveType.SHORT));
+        assertEquals(true,  numberType.isAssignableBy(ResolvedPrimitiveType.LONG));
+        assertEquals(true,  numberType.isAssignableBy(ResolvedPrimitiveType.FLOAT));
+        assertEquals(false, numberType.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(true,  intType.isAssignableBy(ResolvedPrimitiveType.INT));
+        assertEquals(true,  doubleType.isAssignableBy(ResolvedPrimitiveType.DOUBLE));
+    }
+
+    @Test
+    public void testIsAssignableByGenerics() {
+        assertEquals(false, listOfStrings.isAssignableBy(listOfWildcardExtendsString));
+        assertEquals(false, listOfStrings.isAssignableBy(listOfWildcardExtendsString));
+        assertEquals(true, listOfWildcardExtendsString.isAssignableBy(listOfStrings));
+        assertEquals(false, listOfWildcardExtendsString.isAssignableBy(listOfWildcardSuperString));
+        assertEquals(true, listOfWildcardSuperString.isAssignableBy(listOfStrings));
+        assertEquals(false, listOfWildcardSuperString.isAssignableBy(listOfWildcardExtendsString));
+    }
+
+    @Test
+    public void testIsAssignableByGenericsInheritance() {
+        assertEquals(true, collectionOfString.isAssignableBy(collectionOfString));
+        assertEquals(true, collectionOfString.isAssignableBy(listOfStrings));
+        assertEquals(true, collectionOfString.isAssignableBy(linkedListOfString));
+
+        assertEquals(false, listOfStrings.isAssignableBy(collectionOfString));
+        assertEquals(true, listOfStrings.isAssignableBy(listOfStrings));
+        assertEquals(true, listOfStrings.isAssignableBy(linkedListOfString));
+
+        assertEquals(false, linkedListOfString.isAssignableBy(collectionOfString));
+        assertEquals(false, linkedListOfString.isAssignableBy(listOfStrings));
+        assertEquals(true, linkedListOfString.isAssignableBy(linkedListOfString));
+    }
+
+    @Test
+    public void testGetAllAncestorsConsideringTypeParameters() {
+        assertTrue(linkedListOfString.getAllAncestors().contains(object));
+        assertTrue(linkedListOfString.getAllAncestors().contains(listOfStrings));
+        assertTrue(linkedListOfString.getAllAncestors().contains(collectionOfString));
+        assertFalse(linkedListOfString.getAllAncestors().contains(listOfA));
+    }
+
+    class Foo {
+
+    }
+
+    class Bar extends Foo {
+
+    }
+
+    class Bazzer<A, B, C> {
+
+    }
+
+    class MoreBazzing<A, B> extends Bazzer<B, String, A> {
+
+    }
+
+    @Test
+    public void testGetAllAncestorsConsideringGenericsCases() {
+        ReferenceTypeImpl foo = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+        ReferenceTypeImpl bar = new ReferenceTypeImpl(new ReflectionClassDeclaration(Bar.class, typeSolver), typeSolver);
+        ReferenceTypeImpl left, right;
+
+        //YES MoreBazzing<Foo, Bar> e1 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(foo, bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, Bar> e2 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(ResolvedWildcard.extendsBound(foo), bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<Foo, ? extends Bar> e3 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(foo, ResolvedWildcard.extendsBound(bar)), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, ? extends Foo> e4 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(ResolvedWildcard.extendsBound(foo), ResolvedWildcard.extendsBound(foo)), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, ? extends Foo> e5 = new MoreBazzing<Bar, Bar>();
+        left = new ReferenceTypeImpl(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(ResolvedWildcard.extendsBound(foo), ResolvedWildcard.extendsBound(foo)), typeSolver);
+        right = new ReferenceTypeImpl(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(bar, bar), typeSolver);
+        assertEquals(true, left.isAssignableBy(right));
+
+        //YES Bazzer<Object, String, String> e6 = new MoreBazzing<String, Object>();
+        left = new ReferenceTypeImpl(
+                new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                ImmutableList.of(object, string, string), typeSolver);
+        right = new ReferenceTypeImpl(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(string, object), typeSolver);
+
+        // To debug the following
+        List<ResolvedReferenceType> ancestors = right.getAllAncestors();
+        ResolvedReferenceType moreBazzingAncestor = ancestors.stream().filter(a -> a.getQualifiedName().endsWith("Bazzer")).findFirst().get();
+
+        assertEquals(true, left.isAssignableBy(right));
+
+        //YES Bazzer<String,String,String> e7 = new MoreBazzing<String, String>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(string, string, string), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(string, string), typeSolver))
+        );
+
+        //YES Bazzer<Bar,String,Foo> e8 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar, string, foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES Bazzer<Foo,String,Bar> e9 = new MoreBazzing<Bar, Foo>();
+        assertEquals(true,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(foo, string, bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Bar,String,Foo> n1 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar, string, foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Bar,String,Bar> n2 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar, string, foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Foo,Object,Bar> n3 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeImpl(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(foo, object, bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeImpl(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+    }
+
+    @Test
+    public void charSequenceIsAssignableToObject() {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ReferenceTypeImpl charSequence = new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(CharSequence.class, typeSolver), typeSolver);
+        ReferenceTypeImpl object = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        assertEquals(false, charSequence.isAssignableBy(object));
+        assertEquals(true, object.isAssignableBy(charSequence));
+    }
+
+    @Test
+    public void testGetFieldTypeExisting() {
+        class Foo<A> {
+            List<A> elements;
+        }
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ReferenceTypeImpl ref = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+
+        assertEquals(true, ref.getFieldType("elements").isPresent());
+        assertEquals(true, ref.getFieldType("elements").get().isReferenceType());
+        assertEquals(List.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().getQualifiedName());
+        assertEquals(1, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().size());
+        assertEquals(true, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).isTypeVariable());
+        assertEquals("A", ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).asTypeParameter().getName());
+
+        ref = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)),
+                typeSolver);
+
+        assertEquals(true, ref.getFieldType("elements").isPresent());
+        assertEquals(true, ref.getFieldType("elements").get().isReferenceType());
+        assertEquals(List.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().getQualifiedName());
+        assertEquals(1, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().size());
+        assertEquals(true, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).isReferenceType());
+        assertEquals(String.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetFieldTypeUnexisting() {
+        class Foo<A> {
+            List<A> elements;
+        }
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ReferenceTypeImpl ref = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+
+        assertEquals(false, ref.getFieldType("bar").isPresent());
+
+        ref = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)),
+                typeSolver);
+
+        assertEquals(false, ref.getFieldType("bar").isPresent());
+    }
+
+    @Test
+    public void testTypeParamValue() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        ResolvedClassDeclaration abstractList = new ReflectionClassDeclaration(AbstractList.class, typeResolver);
+        ResolvedClassDeclaration abstractCollection = new ReflectionClassDeclaration(AbstractCollection.class, typeResolver);
+        ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver);
+        ResolvedInterfaceDeclaration collection = new ReflectionInterfaceDeclaration(Collection.class, typeResolver);
+        ResolvedInterfaceDeclaration iterable = new ReflectionInterfaceDeclaration(Iterable.class, typeResolver);
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+        ResolvedReferenceType arrayListOfString = new ReferenceTypeImpl(arraylist, ImmutableList.of(string), typeResolver);
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(arraylist.getTypeParameters().get(0)));
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(abstractList.getTypeParameters().get(0)));
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(abstractCollection.getTypeParameters().get(0)));
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(list.getTypeParameters().get(0)));
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(collection.getTypeParameters().get(0)));
+        assertEquals(Optional.of(string), arrayListOfString.typeParamValue(iterable.getTypeParameters().get(0)));
+    }
+
+    @Test
+    public void testGetAllAncestorsOnRawType() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        ResolvedReferenceType rawArrayList = new ReferenceTypeImpl(arraylist, typeResolver);
+
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        rawArrayList.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(9, ancestors.size());
+
+        ResolvedTypeVariable tv = new ResolvedTypeVariable(arraylist.getTypeParameters().get(0));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(RandomAccess.class, typeResolver), typeResolver), ancestors.get("java.util.RandomAccess"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractCollection.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.AbstractCollection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.List"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Cloneable.class, typeResolver), typeResolver), ancestors.get("java.lang.Cloneable"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractList.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.util.AbstractList"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(tv), typeResolver), ancestors.get("java.lang.Iterable"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Serializable.class, typeResolver), typeResolver), ancestors.get("java.io.Serializable"));
+    }
+
+    @Test
+    public void testGetAllAncestorsOnTypeWithSpecifiedTypeParametersForInterface() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver);
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+        ResolvedReferenceType listOfString = new ReferenceTypeImpl(list, ImmutableList.of(string), typeResolver);
+
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        listOfString.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(3, ancestors.size());
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.lang.Iterable"));
+    }
+
+    @Test
+    public void testGetAllAncestorsOnTypeWithSpecifiedTypeParametersForClassAbstractCollection() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration abstractCollection = new ReflectionClassDeclaration(AbstractCollection.class, typeResolver);
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+        ResolvedReferenceType abstractCollectionOfString = new ReferenceTypeImpl(abstractCollection, ImmutableList.of(string), typeResolver);
+
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        abstractCollectionOfString.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(3, ancestors.size());
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.lang.Iterable"));
+    }
+
+    @Test
+    public void testGetAllAncestorsOnTypeWithSpecifiedTypeParametersForClassAbstractList() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration abstractList = new ReflectionClassDeclaration(AbstractList.class, typeResolver);
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+        ResolvedReferenceType abstractListOfString = new ReferenceTypeImpl(abstractList, ImmutableList.of(string), typeResolver);
+
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        abstractListOfString.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(5, ancestors.size());
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractCollection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.AbstractCollection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.List"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.lang.Iterable"));
+    }
+
+    @Test
+    public void testGetAllAncestorsOnTypeWithSpecifiedTypeParametersForClassArrayList() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+        ResolvedReferenceType arrayListOfString = new ReferenceTypeImpl(arraylist, ImmutableList.of(string), typeResolver);
+
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        arrayListOfString.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(9, ancestors.size());
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(RandomAccess.class, typeResolver), typeResolver), ancestors.get("java.util.RandomAccess"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractCollection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.AbstractCollection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.List"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Cloneable.class, typeResolver), typeResolver), ancestors.get("java.lang.Cloneable"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractList.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.util.AbstractList"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(string), typeResolver), ancestors.get("java.lang.Iterable"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Serializable.class, typeResolver), typeResolver), ancestors.get("java.io.Serializable"));
+    }
+
+    @Test
+    public void testTypeParametersValues() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedReferenceType stream = new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Stream.class, typeResolver), typeResolver);
+        assertEquals(1, stream.typeParametersValues().size());
+        assertEquals(new ResolvedTypeVariable(new ReflectionInterfaceDeclaration(Stream.class, typeResolver).getTypeParameters().get(0)), stream.typeParametersValues().get(0));
+    }
+
+    @Test
+    public void testReplaceTypeVariables() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedInterfaceDeclaration streamInterface = new ReflectionInterfaceDeclaration(Stream.class, typeResolver);
+        ResolvedReferenceType stream = new ReferenceTypeImpl(streamInterface, typeResolver);
+
+        ResolvedMethodDeclaration streamMap = streamInterface.getDeclaredMethods().stream().filter(m -> m.getName().equals("map")).findFirst().get();
+        ResolvedTypeParameterDeclaration streamMapR = streamMap.findTypeParameter("T").get();
+        ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(streamMapR);
+        stream = stream.deriveTypeParameters(stream.typeParametersMap().toBuilder().setValue(stream.getTypeDeclaration().getTypeParameters().get(0), typeVariable).build());
+
+        ResolvedTypeParameterDeclaration tpToReplace = streamInterface.getTypeParameters().get(0);
+        ResolvedType replaced = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+
+        ResolvedType streamReplaced = stream.replaceTypeVariables(tpToReplace, replaced);
+        assertEquals("java.util.stream.Stream<java.lang.String>", streamReplaced.describe());
+    }
+
+    @Test
+    public void testReplaceTypeVariablesWithLambdaInBetween() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedInterfaceDeclaration streamInterface = new ReflectionInterfaceDeclaration(Stream.class, typeResolver);
+        ResolvedReferenceType stream = new ReferenceTypeImpl(streamInterface, typeResolver);
+
+        ResolvedMethodDeclaration streamMap = streamInterface.getDeclaredMethods().stream().filter(m -> m.getName().equals("map")).findFirst().get();
+        ResolvedTypeParameterDeclaration streamMapR = streamMap.findTypeParameter("T").get();
+        ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(streamMapR);
+        stream = stream.deriveTypeParameters(stream.typeParametersMap().toBuilder().setValue(stream.getTypeDeclaration().getTypeParameters().get(0), typeVariable).build());
+
+        ResolvedTypeParameterDeclaration tpToReplace = streamInterface.getTypeParameters().get(0);
+        ResolvedType replaced = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeResolver), typeResolver);
+
+        ResolvedType streamReplaced = stream.replaceTypeVariables(tpToReplace, replaced);
+        assertEquals("java.util.stream.Stream<java.lang.String>", streamReplaced.describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/TypeVariableUsageTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/TypeVariableUsageTest.java
new file mode 100644
index 000000000..1808b9c13
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/TypeVariableUsageTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+
+import static org.junit.Assert.*;
+
+public class TypeVariableUsageTest {
+
+    private ResolvedTypeVariable tpA;
+    private ReferenceTypeImpl tpString;
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        tpA = new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()));
+        
+        typeSolver = new ReflectionTypeSolver();
+        tpString = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+    }
+
+    @Test
+    public void testIsAssignableBySimple() {
+        assertEquals(false, tpString.isAssignableBy(tpA));
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/VoidTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/VoidTypeTest.java
new file mode 100644
index 000000000..2c88ebbb8
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/VoidTypeTest.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedArrayType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.resolution.types.ResolvedVoidType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class VoidTypeTest {
+
+    private ResolvedArrayType arrayOfBooleans;
+    private ResolvedArrayType arrayOfListOfA;
+    private ReferenceTypeImpl OBJECT;
+    private ReferenceTypeImpl STRING;
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        OBJECT = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        STRING = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        arrayOfBooleans = new ResolvedArrayType(ResolvedPrimitiveType.BOOLEAN);
+        arrayOfListOfA = new ResolvedArrayType(new ReferenceTypeImpl(
+                new ReflectionInterfaceDeclaration(List.class, typeSolver),
+                ImmutableList.of(new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()))), typeSolver));
+    }
+
+    @Test
+    public void testIsArray() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isArray());
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isPrimitive());
+    }
+
+    @Test
+    public void testIsNull() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isNull());
+    }
+
+    @Test
+    public void testIsReference() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isReference());
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isReferenceType());
+    }
+
+    @Test
+    public void testIsVoid() {
+        assertEquals(true, ResolvedVoidType.INSTANCE.isVoid());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        assertEquals(false, ResolvedVoidType.INSTANCE.isTypeVariable());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsReferenceTypeUsage() {
+        ResolvedVoidType.INSTANCE.asReferenceType();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsTypeParameter() {
+        ResolvedVoidType.INSTANCE.asTypeParameter();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsArrayTypeUsage() {
+        ResolvedVoidType.INSTANCE.asArrayType();
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("void", ResolvedVoidType.INSTANCE.describe());
+    }
+
+    @Test
+    public void testIsAssignableBy() {
+        try {
+            assertEquals(false, ResolvedVoidType.INSTANCE.isAssignableBy(NullType.INSTANCE));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, ResolvedVoidType.INSTANCE.isAssignableBy(OBJECT));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, ResolvedVoidType.INSTANCE.isAssignableBy(STRING));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, ResolvedVoidType.INSTANCE.isAssignableBy(ResolvedPrimitiveType.BOOLEAN));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+        try {
+            assertEquals(false, ResolvedVoidType.INSTANCE.isAssignableBy(ResolvedVoidType.INSTANCE));
+            fail();
+        } catch (UnsupportedOperationException e) {
+
+        }
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/WildcardUsageTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/WildcardUsageTest.java
new file mode 100644
index 000000000..705805dd9
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/model/typesystem/WildcardUsageTest.java
@@ -0,0 +1,422 @@
+/*
+ * Copyright 2016 Federico Tomassetti
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.github.javaparser.symbolsolver.model.typesystem;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.resolution.types.ResolvedWildcard;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class WildcardUsageTest {
+
+    class Foo {
+    }
+
+    class Bar extends Foo {
+    }
+
+    private TypeSolver typeSolver;
+    private ReferenceTypeImpl foo;
+    private ReferenceTypeImpl bar;
+    private ReferenceTypeImpl object;
+    private ReferenceTypeImpl string;
+    private ResolvedWildcard unbounded = ResolvedWildcard.UNBOUNDED;
+    private ResolvedWildcard superFoo;
+    private ResolvedWildcard superBar;
+    private ResolvedWildcard extendsFoo;
+    private ResolvedWildcard extendsBar;
+    private ResolvedWildcard superA;
+    private ResolvedWildcard extendsA;
+    private ResolvedWildcard superString;
+    private ResolvedWildcard extendsString;
+    private ResolvedTypeVariable a;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        foo = new ReferenceTypeImpl(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+        bar = new ReferenceTypeImpl(new ReflectionClassDeclaration(Bar.class, typeSolver), typeSolver);
+        object = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        superFoo = ResolvedWildcard.superBound(foo);
+        superBar = ResolvedWildcard.superBound(bar);
+        extendsFoo = ResolvedWildcard.extendsBound(foo);
+        extendsBar = ResolvedWildcard.extendsBound(bar);
+        a = new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()));
+        superA = ResolvedWildcard.superBound(a);
+        extendsA = ResolvedWildcard.extendsBound(a);
+        superString = ResolvedWildcard.superBound(string);
+        extendsString = ResolvedWildcard.extendsBound(string);
+    }
+
+    @Test
+    public void testIsArray() {
+        assertEquals(false, unbounded.isArray());
+        assertEquals(false, superFoo.isArray());
+        assertEquals(false, superBar.isArray());
+        assertEquals(false, extendsFoo.isArray());
+        assertEquals(false, extendsBar.isArray());
+    }
+
+    @Test
+    public void testIsPrimitive() {
+        assertEquals(false, unbounded.isPrimitive());
+        assertEquals(false, superFoo.isPrimitive());
+        assertEquals(false, superBar.isPrimitive());
+        assertEquals(false, extendsFoo.isPrimitive());
+        assertEquals(false, extendsBar.isPrimitive());
+    }
+
+    @Test
+    public void testIsNull() {
+        assertEquals(false, unbounded.isNull());
+        assertEquals(false, superFoo.isNull());
+        assertEquals(false, superBar.isNull());
+        assertEquals(false, extendsFoo.isNull());
+        assertEquals(false, extendsBar.isNull());
+    }
+
+    @Test
+    public void testIsReference() {
+        assertEquals(true, unbounded.isReference());
+        assertEquals(true, superFoo.isReference());
+        assertEquals(true, superBar.isReference());
+        assertEquals(true, extendsFoo.isReference());
+        assertEquals(true, extendsBar.isReference());
+    }
+
+    @Test
+    public void testIsReferenceType() {
+        assertEquals(false, unbounded.isReferenceType());
+        assertEquals(false, superFoo.isReferenceType());
+        assertEquals(false, superBar.isReferenceType());
+        assertEquals(false, extendsFoo.isReferenceType());
+        assertEquals(false, extendsBar.isReferenceType());
+    }
+
+    @Test
+    public void testIsVoid() {
+        assertEquals(false, unbounded.isVoid());
+        assertEquals(false, superFoo.isVoid());
+        assertEquals(false, superBar.isVoid());
+        assertEquals(false, extendsFoo.isVoid());
+        assertEquals(false, extendsBar.isVoid());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        assertEquals(false, unbounded.isTypeVariable());
+        assertEquals(false, superFoo.isTypeVariable());
+        assertEquals(false, superBar.isTypeVariable());
+        assertEquals(false, extendsFoo.isTypeVariable());
+        assertEquals(false, extendsBar.isTypeVariable());
+    }
+
+    @Test
+    public void testIsWildcard() {
+        assertEquals(true, unbounded.isWildcard());
+        assertEquals(true, superFoo.isWildcard());
+        assertEquals(true, superBar.isWildcard());
+        assertEquals(true, extendsFoo.isWildcard());
+        assertEquals(true, extendsBar.isWildcard());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsArrayTypeUsage() {
+        unbounded.asArrayType();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsReferenceTypeUsage() {
+        unbounded.asReferenceType();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsTypeParameter() {
+        unbounded.asTypeParameter();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsPrimitive() {
+        unbounded.asPrimitive();
+    }
+
+    @Test
+    public void testAsWildcard() {
+        assertTrue(unbounded == unbounded.asWildcard());
+        assertTrue(superFoo == superFoo.asWildcard());
+        assertTrue(superBar == superBar.asWildcard());
+        assertTrue(extendsFoo == extendsFoo.asWildcard());
+        assertTrue(extendsBar == extendsBar.asWildcard());
+    }
+
+    @Test
+    public void testAsDescribe() {
+        assertEquals("?", unbounded.describe());
+        assertEquals("? super com.github.javaparser.symbolsolver.model.typesystem.WildcardUsageTest.Foo", superFoo.describe());
+        assertEquals("? super com.github.javaparser.symbolsolver.model.typesystem.WildcardUsageTest.Bar", superBar.describe());
+        assertEquals("? extends com.github.javaparser.symbolsolver.model.typesystem.WildcardUsageTest.Foo", extendsFoo.describe());
+        assertEquals("? extends com.github.javaparser.symbolsolver.model.typesystem.WildcardUsageTest.Bar", extendsBar.describe());
+    }
+
+    @Test
+    public void testReplaceParam() {
+        ResolvedTypeParameterDeclaration tpA = ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList());
+        ResolvedTypeParameterDeclaration tpB = ResolvedTypeParameterDeclaration.onType("B", "foo.Bar", Collections.emptyList());
+        assertTrue(unbounded == unbounded.replaceTypeVariables(tpA, string));
+        assertTrue(superFoo == superFoo.replaceTypeVariables(tpA, string));
+        assertTrue(extendsFoo == extendsFoo.replaceTypeVariables(tpA, string));
+        assertEquals(superString, superA.replaceTypeVariables(tpA, string));
+        assertEquals(extendsString, extendsA.replaceTypeVariables(tpA, string));
+        assertTrue(superA == superA.replaceTypeVariables(tpB, string));
+        assertTrue(extendsA == extendsA.replaceTypeVariables(tpB, string));
+    }
+
+    @Test
+    public void testIsAssignableBySimple() {
+        assertEquals(false, unbounded.isAssignableBy(object));
+        assertEquals(true, object.isAssignableBy(unbounded));
+        assertEquals(false, string.isAssignableBy(unbounded));
+        assertEquals(true, superFoo.isAssignableBy(foo));
+        assertEquals(false, foo.isAssignableBy(superFoo));
+        assertEquals(false, extendsFoo.isAssignableBy(foo));
+        assertEquals(true, foo.isAssignableBy(extendsFoo));
+    }
+
+    /*@Test
+    public void testIsAssignableByGenerics() {
+        assertEquals(false, listOfStrings.isAssignableBy(listOfWildcardExtendsString));
+        assertEquals(false, listOfStrings.isAssignableBy(listOfWildcardExtendsString));
+        assertEquals(true,  listOfWildcardExtendsString.isAssignableBy(listOfStrings));
+        assertEquals(false, listOfWildcardExtendsString.isAssignableBy(listOfWildcardSuperString));
+        assertEquals(true,  listOfWildcardSuperString.isAssignableBy(listOfStrings));
+        assertEquals(false, listOfWildcardSuperString.isAssignableBy(listOfWildcardExtendsString));
+    }
+
+    @Test
+    public void testIsAssignableByGenericsInheritance() {
+        assertEquals(true, collectionOfString.isAssignableBy(collectionOfString));
+        assertEquals(true, collectionOfString.isAssignableBy(listOfStrings));
+        assertEquals(true, collectionOfString.isAssignableBy(linkedListOfString));
+
+        assertEquals(false, listOfStrings.isAssignableBy(collectionOfString));
+        assertEquals(true, listOfStrings.isAssignableBy(listOfStrings));
+        assertEquals(true, listOfStrings.isAssignableBy(linkedListOfString));
+
+        assertEquals(false, linkedListOfString.isAssignableBy(collectionOfString));
+        assertEquals(false, linkedListOfString.isAssignableBy(listOfStrings));
+        assertEquals(true, linkedListOfString.isAssignableBy(linkedListOfString));
+    }
+
+    @Test
+    public void testGetAllAncestorsConsideringTypeParameters() {
+        assertTrue(linkedListOfString.getAllAncestors().contains(object));
+        assertTrue(linkedListOfString.getAllAncestors().contains(listOfStrings));
+        assertTrue(linkedListOfString.getAllAncestors().contains(collectionOfString));
+        assertFalse(linkedListOfString.getAllAncestors().contains(listOfA));
+    }
+
+    @Test
+    public void testGetAllAncestorsConsideringGenericsCases() {
+        ReferenceTypeUsage foo = new ReferenceTypeUsage(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+        ReferenceTypeUsage bar = new ReferenceTypeUsage(new ReflectionClassDeclaration(Bar.class, typeSolver), typeSolver);
+        ReferenceTypeUsage left, right;
+
+        //YES MoreBazzing<Foo, Bar> e1 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                    new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                    ImmutableList.of(foo, bar), typeSolver)
+                .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, Bar> e2 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(WildcardUsage.extendsBound(foo), bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<Foo, ? extends Bar> e3 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(foo, WildcardUsage.extendsBound(bar)), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, ? extends Foo> e4 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                        ImmutableList.of(WildcardUsage.extendsBound(foo), WildcardUsage.extendsBound(foo)), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES MoreBazzing<? extends Foo, ? extends Foo> e5 = new MoreBazzing<Bar, Bar>();
+        left = new ReferenceTypeUsage(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(WildcardUsage.extendsBound(foo), WildcardUsage.extendsBound(foo)), typeSolver);
+        right = new ReferenceTypeUsage(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(bar, bar), typeSolver);
+        assertEquals(true, left.isAssignableBy(right));
+
+        //YES Bazzer<Object, String, String> e6 = new MoreBazzing<String, Object>();
+        left = new ReferenceTypeUsage(
+                new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                ImmutableList.of(object, string, string), typeSolver);
+        right = new ReferenceTypeUsage(
+                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                ImmutableList.of(string, object), typeSolver);
+        assertEquals(true, left.isAssignableBy(right));
+
+        //YES Bazzer<String,String,String> e7 = new MoreBazzing<String, String>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(string, string, string), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(string, string), typeSolver))
+        );
+
+        //YES Bazzer<Bar,String,Foo> e8 = new MoreBazzing<Foo, Bar>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar, string, foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(foo, bar), typeSolver))
+        );
+
+        //YES Bazzer<Foo,String,Bar> e9 = new MoreBazzing<Bar, Foo>();
+        assertEquals(true,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(foo, string, bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Bar,String,Foo> n1 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar,string,foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Bar,String,Bar> n2 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(bar, string, foo), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+
+        //NO Bazzer<Foo,Object,Bar> n3 = new MoreBazzing<Bar, Foo>();
+        assertEquals(false,
+                new ReferenceTypeUsage(
+                        new ReflectionClassDeclaration(Bazzer.class, typeSolver),
+                        ImmutableList.of(foo, object, bar), typeSolver)
+                        .isAssignableBy(new ReferenceTypeUsage(
+                                new ReflectionClassDeclaration(MoreBazzing.class, typeSolver),
+                                ImmutableList.of(bar, foo), typeSolver))
+        );
+    }
+
+    @Test
+    public void charSequenceIsAssignableToObject() {
+        TypeSolver typeSolver = new JreTypeSolver();
+        ReferenceTypeUsage charSequence = new ReferenceTypeUsage(new ReflectionInterfaceDeclaration(CharSequence.class, typeSolver), typeSolver);
+        ReferenceTypeUsage object = new ReferenceTypeUsage(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        assertEquals(false, charSequence.isAssignableBy(object));
+        assertEquals(true, object.isAssignableBy(charSequence));
+    }
+
+    @Test
+    public void testGetFieldTypeExisting() {
+        class Foo<A> {
+            List<A> elements;
+        }
+
+        TypeSolver typeSolver = new JreTypeSolver();
+        ReferenceTypeUsage ref = new ReferenceTypeUsage(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+
+        assertEquals(true, ref.getFieldType("elements").isPresent());
+        assertEquals(true, ref.getFieldType("elements").get().isReferenceType());
+        assertEquals(List.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().getQualifiedName());
+        assertEquals(1, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().size());
+        assertEquals(true, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).isTypeParameter());
+        assertEquals("A", ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).asTypeParameter().getName());
+
+        ref = new ReferenceTypeUsage(new ReflectionClassDeclaration(Foo.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeUsage(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)),
+                typeSolver);
+
+        assertEquals(true, ref.getFieldType("elements").isPresent());
+        assertEquals(true, ref.getFieldType("elements").get().isReferenceType());
+        assertEquals(List.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().getQualifiedName());
+        assertEquals(1, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().size());
+        assertEquals(true, ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).isReferenceType());
+        assertEquals(String.class.getCanonicalName(), ref.getFieldType("elements").get().asReferenceType().typeParametersValues().get(0).asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetFieldTypeUnexisting() {
+        class Foo<A> {
+            List<A> elements;
+        }
+
+        TypeSolver typeSolver = new JreTypeSolver();
+        ReferenceTypeUsage ref = new ReferenceTypeUsage(new ReflectionClassDeclaration(Foo.class, typeSolver), typeSolver);
+
+        assertEquals(false, ref.getFieldType("bar").isPresent());
+
+        ref = new ReferenceTypeUsage(new ReflectionClassDeclaration(Foo.class, typeSolver),
+                ImmutableList.of(new ReferenceTypeUsage(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver)),
+                typeSolver);
+
+        assertEquals(false, ref.getFieldType("bar").isPresent());
+    }*/
+
+}