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

86 files changed, 13486 insertions, 0 deletions

diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/AbstractTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/AbstractTest.java
new file mode 100644
index 000000000..911211b3c
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/AbstractTest.java
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+import java.io.File;
+
+public abstract class AbstractTest {
+
+    protected static File adaptPath(File path) {
+        if (path.exists()) {
+            return path;
+        } else {
+            File underJavaParserCore = new File("javaparser-symbol-solver-testing/" + path.getPath());
+            if (underJavaParserCore.exists()) {
+                return underJavaParserCore;
+            } else {
+                throw new IllegalArgumentException("I cannot adapt the path " + path.getAbsolutePath());
+            }
+        }
+    }
+
+    protected static String adaptPath(String path) {
+        return adaptPath(new File(path)).getPath();
+    }
+
+    protected boolean isJava9() {
+        return System.getProperty("java.version").startsWith("9.");
+    }
+
+    protected boolean isJava8() {
+        return System.getProperty("java.version").startsWith("1.8.");
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/FindingAllFields.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/FindingAllFields.java
new file mode 100644
index 000000000..c0b70e992
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/FindingAllFields.java
@@ -0,0 +1,57 @@
+/*
+ * 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;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class FindingAllFields extends AbstractResolutionTest {
+
+    @Test
+    public void findAllInheritedFields() {
+        CompilationUnit cu = parseSample("AClassWithFields");
+        ClassOrInterfaceDeclaration classC = Navigator.demandClass(cu, "C");
+        ResolvedReferenceTypeDeclaration typeDeclaration = JavaParserFacade.get(new ReflectionTypeSolver()).getTypeDeclaration(classC);
+        assertEquals(3, typeDeclaration.getAllFields().size());
+        assertEquals(ImmutableSet.of("a", "b", "c"),
+                typeDeclaration.getAllFields().stream().map(ResolvedDeclaration::getName).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void findAllInheritedFieldsAndGenerics() {
+        CompilationUnit cu = parseSample("AClassWithFieldsAndGenerics");
+        ClassOrInterfaceDeclaration classC = Navigator.demandClass(cu, "C");
+        ResolvedReferenceTypeDeclaration typeDeclaration = JavaParserFacade.get(new ReflectionTypeSolver()).getTypeDeclaration(classC);
+        assertEquals(3, typeDeclaration.getAllFields().size());
+        assertEquals(ImmutableSet.of("a", "b", "c"),
+                typeDeclaration.getAllFields().stream().map(ResolvedDeclaration::getName).collect(Collectors.toSet()));
+        assertEquals("java.util.List<java.lang.String>", typeDeclaration.getField("b").getType().describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue113.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue113.java
new file mode 100644
index 000000000..e57a2e1be
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue113.java
@@ -0,0 +1,53 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue113 extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(adaptPath(new File("src/test/resources/issue113"))));
+    }
+
+    @Test
+    public void issue113providedCodeDoesNotCrash() throws FileNotFoundException {
+        String pathToSourceFile = adaptPath("src/test/resources/issue113/com/foo/Widget.java");
+        CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile));
+
+        JavaParserFacade parserFacade = JavaParserFacade.get(typeSolver);
+        MethodDeclaration methodDeclaration = cu.findAll(MethodDeclaration.class).stream()
+                .filter(node -> node.getName().getIdentifier().equals("doSomething")).findAny().orElse(null);
+        methodDeclaration.findAll(MethodCallExpr.class).forEach(parserFacade::solve);
+    }
+
+    @Test
+    public void issue113superClassIsResolvedCorrectly() throws FileNotFoundException {
+        String pathToSourceFile = adaptPath("src/test/resources/issue113/com/foo/Widget.java");
+        CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile));
+
+        JavaParserClassDeclaration jssExtendedWidget = new JavaParserClassDeclaration(cu.getClassByName("Widget").get(), typeSolver);
+        ResolvedReferenceType superClass = jssExtendedWidget.getSuperClass();
+        assertEquals("com.foo.base.Widget", superClass.getQualifiedName());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue116.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue116.java
new file mode 100644
index 000000000..d8d346d1f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue116.java
@@ -0,0 +1,52 @@
+/*
+ * 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;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue116 extends AbstractResolutionTest {
+
+    @Test
+    public void arrayTypeIsNotPartOfTheTree() {
+        CompilationUnit cu = parseSample("Issue116");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest");
+        MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "foo");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        com.github.javaparser.ast.type.Type typeNode = methodDeclaration.getParameters().get(0).getType();
+        ResolvedType type = javaParserFacade.convert(typeNode, typeNode);
+        assertEquals("java.lang.String[]", type.describe());
+
+        ExpressionStmt expressionStmt = (ExpressionStmt) methodDeclaration.getBody().get().getStatements().get(0);
+        Expression argRef = expressionStmt.getExpression();
+        assertEquals("java.lang.String[]", javaParserFacade.getType(argRef).describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue128.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue128.java
new file mode 100644
index 000000000..38f8b7ce3
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue128.java
@@ -0,0 +1,50 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue128 extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        File srcDir = adaptPath(new File("src/test/resources/issue128"));
+        typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(srcDir));
+    }
+
+    @Test
+    public void verifyJavaTestClassIsSolved() {
+        typeSolver.solveType("foo.JavaTest");
+    }
+
+    @Test
+    public void loopOnStaticallyImportedType() {
+        CompilationUnit cu = parseSampleWithStandardExtension("issue128/foo/Issue128");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest");
+        ExpressionStmt expressionStmt = (ExpressionStmt)clazz.getMethodsByName("test").get(0).getBody().get().getStatement(0);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) expressionStmt.getExpression();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        assertEquals(false, javaParserFacade.solve(methodCallExpr).isSolved());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue1364.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue1364.java
new file mode 100644
index 000000000..67086b0fd
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue1364.java
@@ -0,0 +1,91 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseResult;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.Providers;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.SimpleName;
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * @author Dominik Hardtke
+ * @since 02.02.2018
+ */
+public class Issue1364 extends AbstractResolutionTest {
+    private JavaParser javaParser;
+
+    @Before
+    public void setup() {
+        ClassOrInterfaceDeclaration fakeObject = new ClassOrInterfaceDeclaration();
+        fakeObject.setName(new SimpleName("java.lang.Object"));
+
+        TypeSolver typeSolver = new TypeSolver() {
+            @Override
+            public TypeSolver getParent() {
+                return null;
+            }
+
+            @Override
+            public void setParent(TypeSolver parent) {
+            }
+
+            @Override
+            public SymbolReference<ResolvedReferenceTypeDeclaration> tryToSolveType(String name) {
+                if ("java.lang.Object".equals(name)) {
+                    // custom handling
+                    return SymbolReference.solved(new JavaParserClassDeclaration(fakeObject, this));
+                }
+
+                return SymbolReference.unsolved(ResolvedReferenceTypeDeclaration.class);
+            }
+        };
+
+        ParserConfiguration config = new ParserConfiguration();
+        config.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        javaParser = new JavaParser(config);
+    }
+
+    @Test(timeout = 1000)
+    public void resolveSubClassOfObject() {
+        String code = String.join(System.lineSeparator(),
+                "package graph;",
+                "public class Vertex {",
+                "    public static void main(String[] args) {",
+                "        System.out.println();",
+                "    }",
+                "}"
+        );
+
+        ParseResult<CompilationUnit> parseResult = javaParser.parse(ParseStart.COMPILATION_UNIT, Providers.provider(code));
+        assertTrue(parseResult.isSuccessful());
+        assertTrue(parseResult.getResult().isPresent());
+
+        List<MethodCallExpr> methodCallExprs = parseResult.getResult().get().findAll(MethodCallExpr.class);
+        assertEquals(1, methodCallExprs.size());
+
+        try {
+            methodCallExprs.get(0).calculateResolvedType();
+            fail("An UnsolvedSymbolException should be thrown");
+        } catch (UnsolvedSymbolException ignored) {
+            // all is fine if an UnsolvedSymbolException is thrown
+        }
+    }
+}
+
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue144.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue144.java
new file mode 100644
index 000000000..74c8ff7d1
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue144.java
@@ -0,0 +1,70 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue144 extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        File srcDir = adaptPath(new File("src/test/resources/issue144"));
+        typeSolver = new JavaParserTypeSolver(srcDir);
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void issue144() {
+        CompilationUnit cu = parseSampleWithStandardExtension("issue144/HelloWorld");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "HelloWorld");
+        ExpressionStmt expressionStmt = (ExpressionStmt)clazz.getMethodsByName("main").get(0).getBody().get().getStatement(0);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) expressionStmt.getExpression();
+        Expression firstParameter = methodCallExpr.getArgument(0);
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        javaParserFacade.solve(firstParameter).isSolved();
+    }
+
+    @Test
+    public void issue144WithReflectionTypeSolver() {
+        CompilationUnit cu = parseSampleWithStandardExtension("issue144/HelloWorld");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "HelloWorld");
+        ExpressionStmt expressionStmt = (ExpressionStmt)clazz.getMethodsByName("main").get(0).getBody().get().getStatement(0);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) expressionStmt.getExpression();
+        Expression firstParameter = methodCallExpr.getArgument(0);
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver(true));
+
+        assertEquals(true, javaParserFacade.solve(firstParameter).isSolved());
+    }
+
+    @Test
+    public void issue144WithCombinedTypeSolver() {
+        CompilationUnit cu = parseSampleWithStandardExtension("issue144/HelloWorld");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "HelloWorld");
+        ExpressionStmt expressionStmt = (ExpressionStmt)clazz.getMethodsByName("main").get(0).getBody().get().getStatement(0);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) expressionStmt.getExpression();
+        Expression firstParameter = methodCallExpr.getArgument(0);
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new CombinedTypeSolver(typeSolver, new ReflectionTypeSolver(true)));
+
+        assertEquals(true, javaParserFacade.solve(firstParameter).isSolved());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue156.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue156.java
new file mode 100644
index 000000000..b500af7c2
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue156.java
@@ -0,0 +1,37 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue156 extends AbstractResolutionTest {
+
+    @Test
+    public void testFieldAccessThroughClassAndThis() {
+
+        CompilationUnit cu = parseSample("Issue156");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Issue156");
+        List<MethodCallExpr> methods = clazz.getChildNodes().get(2).getChildNodes().get(1).findAll(MethodCallExpr.class);
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        assertEquals("char", javaParserFacade.getType(methods.get(0)).describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue18.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue18.java
new file mode 100644
index 000000000..af0dd18ac
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue18.java
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue18 extends AbstractResolutionTest {
+
+    @Test
+    public void typeDeclarationSuperClassImplicitlyIncludeObject() {
+        CompilationUnit cu = parseSample("Issue18");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "bar");
+        ExpressionStmt expr = (ExpressionStmt) methodDeclaration.getBody().get().getStatements().get(1);
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        ResolvedType type = javaParserFacade.getType(expr.getExpression());
+        assertEquals("java.lang.Object", type.describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue185.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue185.java
new file mode 100644
index 000000000..c0ad0b11b
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue185.java
@@ -0,0 +1,35 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+
+
+public class Issue185 extends AbstractResolutionTest {
+
+    @Test
+    public void testIssue() throws FileNotFoundException {
+        File src = adaptPath(new File("src/test/resources/recursion-issue"));
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        CompilationUnit agendaCu = JavaParser.parse(adaptPath(new File("src/test/resources/recursion-issue/Usage.java")));
+        MethodCallExpr foo = Navigator.findMethodCall(agendaCu, "foo").get();
+        assertNotNull(foo);
+        JavaParserFacade.get(combinedTypeSolver).getType(foo);
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue186.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue186.java
new file mode 100644
index 000000000..2590e9ec5
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue186.java
@@ -0,0 +1,50 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue186 extends AbstractResolutionTest {
+
+    @Test
+    public void lambdaFlatMapIssue() {
+        CompilationUnit cu = parseSample("Issue186");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest");
+        MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "foo");
+        MethodCallExpr methodCallExpr = Navigator.findMethodCall(methodDeclaration, "flatMap").get();
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        assertEquals("java.util.stream.Stream<java.lang.String>", javaParserFacade.getType(methodCallExpr).describe());
+
+    }
+
+    @Test
+    public void lambdaPrimitivesIssue() {
+        CompilationUnit cu = parseSample("Issue186");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest");
+        MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "bar");
+        List<LambdaExpr> lambdas = methodDeclaration.findAll(LambdaExpr.class);
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        assertEquals("java.util.function.Predicate<? super java.lang.String>", javaParserFacade.getType(lambdas.get(0)).describe());
+        assertEquals("java.util.function.Function<? super java.lang.String, ? extends java.lang.Integer>", javaParserFacade.getType(lambdas.get(1)).describe());
+        assertEquals("java.util.function.Predicate<? super java.lang.Integer>", javaParserFacade.getType(lambdas.get(2)).describe());
+
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue200.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue200.java
new file mode 100644
index 000000000..ff3598717
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue200.java
@@ -0,0 +1,33 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue200 extends AbstractResolutionTest {
+
+    @Test
+    public void issue200() {
+        CompilationUnit cu = parseSample("Issue200");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "JavaTest");
+        MethodDeclaration methodDeclaration = Navigator.demandMethod(clazz, "foo");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        List<ReturnStmt> nodesByType = methodDeclaration.findAll(ReturnStmt.class);
+        assertEquals("java.util.stream.Stream<JavaTest.Solved>", javaParserFacade.getType((nodesByType.get(0)).getExpression().get()).describe());
+    }
+}
\ No newline at end of file
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue228.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue228.java
new file mode 100644
index 000000000..7ed5bdbbb
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue228.java
@@ -0,0 +1,31 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class Issue228 extends AbstractResolutionTest{
+
+    @Test
+    public void testSolvingMethodWitPrimitiveParameterTypeAsUsage() {
+        String code = 
+                  "class Test { "
+                + "  long l = call(1); "
+                + "  long call(final long i) { "
+                + "    return i; "
+                + "  }"
+                + "}";
+        CompilationUnit cu = JavaParser.parse(code);
+        MethodCallExpr methodCall = cu.findAll(MethodCallExpr.class).get(0);
+        JavaParserFacade parserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        MethodUsage solvedCall = parserFacade.solveMethodAsUsage(methodCall);
+        assertEquals("long", solvedCall.getParamType(0).describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue232.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue232.java
new file mode 100644
index 000000000..cb4550d7e
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue232.java
@@ -0,0 +1,27 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+public class Issue232 extends AbstractResolutionTest {
+    @Test
+    public void issue232() {
+        CompilationUnit cu = parseSample("Issue232");
+        ClassOrInterfaceDeclaration cls = Navigator.demandClassOrInterface(cu, "OfDouble");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        Context context = JavaParserFactory.getContext(cls, typeSolver);
+        SymbolReference<ResolvedTypeDeclaration> reference = context.solveType("OfPrimitive<Double, DoubleConsumer, OfDouble>", typeSolver);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue235.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue235.java
new file mode 100644
index 000000000..0e4d1aa9f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue235.java
@@ -0,0 +1,51 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.ObjectCreationExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+@RunWith(Parameterized.class)
+public class Issue235 extends AbstractResolutionTest{
+    private final String method;
+
+    public Issue235(String method) {
+        this.method = method;
+    }
+
+    @Parameterized.Parameters(name = "{0}")
+    public static Collection<String> data() throws Exception {
+        return Arrays.asList(
+                "new_Bar_Baz_direct",
+                "new_Bar_Baz",
+                "new_Bar",
+                "new_Foo_Bar"
+        );
+    }
+
+    @Test
+    public void issue235() {
+        CompilationUnit cu = parseSample("Issue235");
+        ClassOrInterfaceDeclaration cls = Navigator.demandClassOrInterface(cu, "Foo");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodDeclaration m = Navigator.demandMethod(cls, this.method);
+        ExpressionStmt stmt = (ExpressionStmt) m.getBody().get().getStatements().get(0);
+        ObjectCreationExpr expression = (ObjectCreationExpr) stmt.getExpression();
+        Assert.assertNotNull(javaParserFacade.convertToUsage(expression.getType()));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue241.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue241.java
new file mode 100644
index 000000000..9b42314a6
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue241.java
@@ -0,0 +1,40 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.type.Type;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue241 extends AbstractResolutionTest{
+
+    @Test
+    public void testSolveStaticallyImportedMemberType() {
+        File src = adaptPath(new File("src/test/resources"));
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(src));
+        		
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        
+        CompilationUnit cu = parseSample("Issue241");
+        ClassOrInterfaceDeclaration cls = Navigator.demandClassOrInterface(cu, "Main");
+        VariableDeclarator v = Navigator.demandVariableDeclaration(cls, "foo").get();
+        
+        Type t = v.getType();
+        ResolvedType t2 = javaParserFacade.convert(t, t);
+        String typeName = t2.asReferenceType().getQualifiedName();
+       
+        assertEquals("issue241.TypeWithMemberType.MemberInterface", typeName);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue251.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue251.java
new file mode 100644
index 000000000..d8dc0a7c4
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue251.java
@@ -0,0 +1,31 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class Issue251 extends AbstractResolutionTest{
+
+    @Test
+    public void testSolveStaticallyImportedMemberType() {
+        CompilationUnit cu = parseSample("Issue251");
+        ClassOrInterfaceDeclaration cls = Navigator.demandClassOrInterface(cu, "Main");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodDeclaration m = Navigator.demandMethod(cls, "bar");
+        ExpressionStmt stmt = (ExpressionStmt) m.getBody().get().getStatements().get(1);
+        MethodCallExpr expression = (MethodCallExpr) stmt.getExpression();
+        Assert.assertNotNull(javaParserFacade.solve(expression));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue276.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue276.java
new file mode 100644
index 000000000..6baaab018
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue276.java
@@ -0,0 +1,41 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.MethodContext;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class Issue276 extends AbstractResolutionTest{
+
+    @Test
+    public void testSolveStaticallyImportedMemberType() throws FileNotFoundException {
+        CompilationUnit cu = JavaParser.parse(new File(adaptPath("src/test/resources/issue276/foo/C.java")));
+        ClassOrInterfaceDeclaration cls = Navigator.demandClassOrInterface(cu, "C");
+        TypeSolver typeSolver = new CombinedTypeSolver(
+        		new ReflectionTypeSolver(), 
+        		new JavaParserTypeSolver(adaptPath(new File("src/test/resources/issue276"))));
+        List<MethodDeclaration> methods = cls.findAll(MethodDeclaration.class);
+        boolean isSolved = false;
+        for (MethodDeclaration method: methods) {
+        	if (method.getNameAsString().equals("overrideMe")) {
+        		MethodContext context = new MethodContext(method, typeSolver);
+        		isSolved = context.solveType("FindMeIfYouCan", typeSolver).isSolved();
+        	}
+        }
+        Assert.assertTrue(isSolved);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue300.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue300.java
new file mode 100644
index 000000000..da19b8d5a
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue300.java
@@ -0,0 +1,63 @@
+/*
+ * 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;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.FieldAccessExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+import java.io.File;
+import java.io.FileNotFoundException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class Issue300 extends AbstractResolutionTest {
+
+    @Test
+    public void fieldAccessIssue() throws ParseException, FileNotFoundException {
+        String pathToSourceFile = adaptPath("src/test/resources/issue300/Issue300.java");
+        CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile));
+
+        final FieldAccessExpr fieldAccess = Navigator.findNodeOfGivenClass(cu, FieldAccessExpr.class);
+        assertNotNull(fieldAccess);
+
+        TypeSolver typeSolver = new CombinedTypeSolver(
+                new ReflectionTypeSolver(),
+                new JavaParserTypeSolver(adaptPath(new File("src/test/resources/issue300"))));
+        final JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        final SymbolReference<? extends ResolvedValueDeclaration> ref = javaParserFacade.solve(fieldAccess);
+        assertEquals(ResolvedPrimitiveType.INT, ref.getCorrespondingDeclaration().getType().asPrimitive());
+    }
+}
+
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue314.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue314.java
new file mode 100644
index 000000000..b20ff7914
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue314.java
@@ -0,0 +1,58 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.FileNotFoundException;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue314 extends AbstractResolutionTest{
+
+    private TypeSolver typeResolver;
+    private JavaParserFacade javaParserFacade;
+
+    private ResolvedType getExpressionType(TypeSolver typeSolver, Expression expression) {
+        return JavaParserFacade.get(typeSolver).getType(expression);
+    }
+
+    @Before
+    public void setup() {
+        typeResolver = new ReflectionTypeSolver();
+        javaParserFacade = JavaParserFacade.get(typeResolver);
+    }
+
+    @Test
+    public void resolveReferenceToFieldInheritedByInterface() {
+        String code = "package foo.bar;\n"+
+                "interface  A {\n" +
+                "        int a = 0;\n" +
+                "    }\n" +
+                "    \n" +
+                "    class B implements A {\n" +
+                "        int getA() {\n" +
+                "            return a;\n" +
+                "        }\n" +
+                "    }";
+        CompilationUnit cu = JavaParser.parse(code);
+        NameExpr refToA = Navigator.findNameExpression(Navigator.demandClass(cu, "B"), "a").get();
+        SymbolReference<? extends ResolvedValueDeclaration> symbolReference = javaParserFacade.solve(refToA);
+        assertEquals(true, symbolReference.isSolved());
+        assertEquals(true, symbolReference.getCorrespondingDeclaration().isField());
+        assertEquals("a", symbolReference.getCorrespondingDeclaration().getName());
+    }
+
+
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue343.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue343.java
new file mode 100644
index 000000000..3c34c6a59
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue343.java
@@ -0,0 +1,60 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue343 extends AbstractResolutionTest{
+
+    private TypeSolver typeResolver;
+    private JavaParserFacade javaParserFacade;
+
+    private ResolvedType getExpressionType(TypeSolver typeSolver, Expression expression) {
+        return JavaParserFacade.get(typeSolver).getType(expression);
+    }
+
+    @Before
+    public void setup() {
+        typeResolver = new ReflectionTypeSolver();
+        javaParserFacade = JavaParserFacade.get(typeResolver);
+    }
+
+    @Test
+    public void resolveStringLiteralOutsideAST() {
+        assertEquals(javaParserFacade.classToResolvedType(String.class), getExpressionType(typeResolver, new StringLiteralExpr("")));
+    }
+
+    @Test
+    public void resolveIntegerLiteralOutsideAST() {
+        assertEquals(javaParserFacade.classToResolvedType(int.class), getExpressionType(typeResolver, new IntegerLiteralExpr(2)));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void toResolveDoubleWeNeedTheAST() {
+        getExpressionType(typeResolver, JavaParser.parseExpression("new Double[]{2.0d, 3.0d}[1]"));
+    }
+
+
+    @Test(expected = IllegalStateException.class)
+    public void toResolveFloatWeNeedTheAST() {
+        getExpressionType(typeResolver, JavaParser.parseExpression("new Float[]{2.0d, 3.0d}"));
+    }
+
+    @Test
+    public void resolveMethodCallOnStringLiteralOutsideAST() {
+        assertEquals(javaParserFacade.classToResolvedType(int.class), getExpressionType(typeResolver, new MethodCallExpr(new StringLiteralExpr("hello"), "length")));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void resolveLocaleOutsideAST() {
+        getExpressionType(typeResolver, new FieldAccessExpr(new NameExpr("Locale"), "US"));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue347.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue347.java
new file mode 100644
index 000000000..88755be23
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue347.java
@@ -0,0 +1,55 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.MethodContext;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue347 extends AbstractResolutionTest{
+
+    private TypeSolver typeSolver;
+    private JavaParserFacade javaParserFacade;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        javaParserFacade = JavaParserFacade.get(typeSolver);
+    }
+
+    @Test
+    public void resolvingReferenceToEnumDeclarationInSameFile() {
+        String code = "package foo.bar;\nenum Foo {\n" +
+                "    FOO_A, FOO_B\n" +
+                "}\n" +
+                "\n" +
+                "class UsingFoo {\n" +
+                "    Foo myFooField;\n" +
+                "}";
+        CompilationUnit cu = JavaParser.parse(code);
+        FieldDeclaration fieldDeclaration = Navigator.findNodeOfGivenClass(cu, FieldDeclaration.class);
+        ResolvedType fieldType = javaParserFacade.getType(fieldDeclaration);
+        assertEquals(true, fieldType.isReferenceType());
+        assertEquals(true, fieldType.asReferenceType().getTypeDeclaration().isEnum());
+        assertEquals("foo.bar.Foo", fieldType.asReferenceType().getQualifiedName());
+    }
+}
+
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue84.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue84.java
new file mode 100644
index 000000000..ddb920b3f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/Issue84.java
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class Issue84 extends AbstractResolutionTest {
+
+    @Test
+    public void variadicIssue() {
+        CompilationUnit cu = parseSample("Issue84");
+        final MethodCallExpr methodCall = Navigator.findMethodCall(cu, "variadicMethod").get();
+
+        final JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        final ResolvedType type = javaParserFacade.getType(methodCall);
+        assertEquals(String.class.getCanonicalName(), type.asReferenceType().getQualifiedName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaParserAPIIntegrationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaParserAPIIntegrationTest.java
new file mode 100644
index 000000000..eb3072265
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaParserAPIIntegrationTest.java
@@ -0,0 +1,158 @@
+package com.github.javaparser.symbolsolver;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.StreamProvider;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.*;
+import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+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.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaParserAPIIntegrationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+    private ResolvedReferenceType string;
+    private ResolvedReferenceType listOfBoolean;
+
+    @Before
+    public void setup() {
+        File src = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(src));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolver = combinedTypeSolverNewCode;
+
+        TypeSolver ts = new ReflectionTypeSolver();
+        string = new ReferenceTypeImpl(ts.solveType(String.class.getCanonicalName()), ts);
+        ResolvedReferenceType booleanC = new ReferenceTypeImpl(ts.solveType(Boolean.class.getCanonicalName()), ts);
+        listOfBoolean = new ReferenceTypeImpl(ts.solveType(List.class.getCanonicalName()), ImmutableList.of(booleanC), ts);
+    }
+
+    @Test
+    public void annotationDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/Annotations.java.txt"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        AnnotationDeclaration declaration = (AnnotationDeclaration)cu.getType(0);
+        assertEquals("MyAnnotation", declaration.getNameAsString());
+        ResolvedAnnotationDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+    @Test
+    public void annotationMemberDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/Annotations.java.txt"));
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        CompilationUnit cu = new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+        AnnotationDeclaration declaration = (AnnotationDeclaration)cu.getType(2);
+        assertEquals("MyAnnotationWithFields", declaration.getNameAsString());
+        AnnotationMemberDeclaration memberDeclaration = (AnnotationMemberDeclaration)declaration.getMember(0);
+        ResolvedAnnotationMemberDeclaration resolvedDeclaration = memberDeclaration.resolve();
+    }
+
+    @Test
+    public void classDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration declaration = (ClassOrInterfaceDeclaration)cu.getType(0);
+        declaration.resolve();
+    }
+
+    @Test
+    public void interfaceDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/resources/MethodTypeParams.java.txt"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration declaration = (ClassOrInterfaceDeclaration)cu.getType(1);
+        assertEquals("VoidVisitor", declaration.getNameAsString());
+        assertEquals(true, declaration.isInterface());
+        declaration.resolve();
+    }
+
+    private CompilationUnit parseWithSymbolResolution(File f) throws IOException {
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        return new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+    }
+
+    @Test
+    public void constructorDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration)cu.getType(0);
+        ConstructorDeclaration constructorDeclaration = classOrInterfaceDeclaration.getDefaultConstructor().get();
+        ResolvedConstructorDeclaration resolvedConstructorDeclaration = constructorDeclaration.resolve();
+    }
+    @Test
+    public void enumDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/AccessSpecifier.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        EnumDeclaration declaration = (EnumDeclaration) cu.getType(0);
+        assertEquals("AccessSpecifier", declaration.getNameAsString());
+        ResolvedEnumDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+    @Test
+    public void enumConstantDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/AccessSpecifier.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        EnumDeclaration enumDeclaration = (EnumDeclaration) cu.getType(0);
+        assertEquals("AccessSpecifier", enumDeclaration.getNameAsString());
+        EnumConstantDeclaration declaration = enumDeclaration.getEntry(0);
+        assertEquals("PUBLIC", declaration.getNameAsString());
+        ResolvedEnumConstantDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+    @Test
+    public void fieldDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        FieldDeclaration declaration = classDeclaration.getFields().get(0);
+        ResolvedFieldDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+    // TODO make VariableDeclarator resolvable
+
+    @Test
+    public void methodDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        CompilationUnit cu = parseWithSymbolResolution(f);
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        MethodDeclaration declaration = classDeclaration.getMethodsByName("getComments").get(0);
+        ResolvedMethodDeclaration resolvedDeclaration = declaration.resolve();
+        assertEquals("getComments", resolvedDeclaration.getName());
+        assertEquals(0, resolvedDeclaration.getNumberOfParams());
+    }
+
+    @Test
+    public void parameterDeclarationResolve() throws IOException {
+        File f = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core/com/github/javaparser/ast/CompilationUnit.java"));
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        CompilationUnit cu = new JavaParser(parserConfiguration).parse(ParseStart.COMPILATION_UNIT, new StreamProvider(new FileInputStream(f))).getResult().get();
+        ClassOrInterfaceDeclaration classDeclaration = (ClassOrInterfaceDeclaration) cu.getType(0);
+        assertEquals("CompilationUnit", classDeclaration.getNameAsString());
+        MethodDeclaration methodDeclaration = classDeclaration.getMethodsByName("setComments").get(0);
+        Parameter declaration = methodDeclaration.getParameter(0);
+        ResolvedParameterDeclaration resolvedDeclaration = declaration.resolve();
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaSymbolSolverTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaSymbolSolverTest.java
new file mode 100644
index 000000000..998a90451
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/JavaSymbolSolverTest.java
@@ -0,0 +1,67 @@
+/*
+ * 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;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaSymbolSolverTest extends AbstractResolutionTest {
+
+    @Test
+    public void resolveMethodDeclaration() {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        CompilationUnit cu = parseSample("SymbolResolverExample");
+        new JavaSymbolSolver(typeSolver).inject(cu);
+
+        MethodDeclaration methodDeclaration = cu.getClassByName("A").get().getMethods().get(0);
+        ResolvedMethodDeclaration resolvedMethodDeclaration = methodDeclaration.resolve();
+        assertEquals("foo", resolvedMethodDeclaration.getName());
+        assertEquals("A[]", resolvedMethodDeclaration.getReturnType().describe());
+        assertEquals("java.lang.String[]", resolvedMethodDeclaration.getParam(0).getType().describe());
+        assertEquals("int[]", resolvedMethodDeclaration.getParam(1).getType().describe());
+    }
+
+    @Test
+    public void resolveArrayType() {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        CompilationUnit cu = parseSample("SymbolResolverExample");
+        new JavaSymbolSolver(typeSolver).inject(cu);
+
+        MethodDeclaration methodDeclaration = cu.getClassByName("A").get().getMethods().get(0);
+        ResolvedType resolvedType = methodDeclaration.getType().resolve();
+        assertEquals("A[]", resolvedType.describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/ConvertToUsageTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/ConvertToUsageTest.java
new file mode 100644
index 000000000..44eda270e
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/ConvertToUsageTest.java
@@ -0,0 +1,40 @@
+package com.github.javaparser.symbolsolver.javaparsermodel;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class ConvertToUsageTest extends AbstractResolutionTest {
+
+    private final TypeSolver typeSolver = new ReflectionTypeSolver();
+
+    @Test
+    public void testConvertTypeToUsage() {
+        CompilationUnit cu = parseSample("LocalTypeDeclarations");
+        List<NameExpr> n = cu.findAll(NameExpr.class);
+
+        assertEquals("int", usageDescribe(n, "a"));
+        assertEquals("java.lang.Integer", usageDescribe(n, "b"));
+        assertEquals("java.lang.Class<java.lang.Integer>", usageDescribe(n, "c"));
+        assertEquals("java.lang.Class<? super java.lang.Integer>", usageDescribe(n, "d"));
+        assertEquals("java.lang.Class<? extends java.lang.Integer>", usageDescribe(n, "e"));
+        assertEquals("java.lang.Class<? extends java.lang.Class<? super java.lang.Class<? extends java.lang.Integer>>>", usageDescribe(n, "f"));
+        assertEquals("java.lang.Class<? super java.lang.Class<? extends java.lang.Class<? super java.lang.Integer>>>", usageDescribe(n, "g"));
+    }
+
+    private String usageDescribe(List<NameExpr> n, String name){
+        return n.stream().filter(x -> x.getNameAsString().equals(name))
+                .map(JavaParserFacade.get(typeSolver)::getType)
+                .map(ResolvedType::describe)
+                .findFirst().orElse(null);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/DifferentiateDotExpressionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/DifferentiateDotExpressionTest.java
new file mode 100644
index 000000000..cf5a87bf7
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/DifferentiateDotExpressionTest.java
@@ -0,0 +1,100 @@
+package com.github.javaparser.symbolsolver.javaparsermodel;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class DifferentiateDotExpressionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(new File("src/test/resources/differentiate_dot_expressions"))));
+        typeSolver = combinedTypeSolver;
+    }
+
+    @Test
+    public void methodCallsFromFieldObjects() {
+        ClassOrInterfaceDeclaration clazz = ((JavaParserClassDeclaration) typeSolver.solveType("FieldDotExpressions")).getWrappedNode();
+        MethodDeclaration mainMethod = Navigator.demandMethod(clazz, "main");
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        MethodCallExpr firstFieldMethodCall = Navigator.findMethodCall(mainMethod, "firstContainerMethod").get();
+        MethodCallExpr secondFieldMethodCall = Navigator.findMethodCall(mainMethod, "secondContainerMethod").get();
+        MethodCallExpr thirdFieldMethodCall = Navigator.findMethodCall(mainMethod, "thirdContainerMethod").get();
+
+        assertEquals(true, javaParserFacade.solve(firstFieldMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(secondFieldMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(thirdFieldMethodCall).isSolved());
+    }
+
+    @Test
+    public void staticMethodCallsFromInnerClasses() {
+        ClassOrInterfaceDeclaration clazz = ((JavaParserClassDeclaration) typeSolver.solveType("InnerClassDotExpressions")).getWrappedNode();
+        MethodDeclaration mainMethod = Navigator.demandMethod(clazz, "main");
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        MethodCallExpr methodCall = Navigator.findMethodCall(mainMethod, "methodCall").get();
+        MethodCallExpr innerMethodCall = Navigator.findMethodCall(mainMethod, "innerMethodCall").get();
+        MethodCallExpr innerInnerMethodCall = Navigator.findMethodCall(mainMethod, "innerInnerMethodCall").get();
+
+        assertEquals(true, javaParserFacade.solve(methodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(innerMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(innerInnerMethodCall).isSolved());
+    }
+
+    @Test
+    public void staticFieldCallsFromInnerClasses() {
+        ClassOrInterfaceDeclaration clazz = ((JavaParserClassDeclaration) typeSolver.solveType("InnerStaticClassFieldDotExpressions")).getWrappedNode();
+        MethodDeclaration mainMethod = Navigator.demandMethod(clazz, "main");
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        MethodCallExpr methodCallWithNestedStaticFieldParam = Navigator.findMethodCall(mainMethod, "parseInt").get();
+
+        assertEquals(true, javaParserFacade.solve(methodCallWithNestedStaticFieldParam).isSolved());
+    }
+
+    @Test
+    public void packageStaticMethodCalls() {
+        ClassOrInterfaceDeclaration clazz = ((JavaParserClassDeclaration) typeSolver.solveType("PackageDotExpressions")).getWrappedNode();
+        MethodDeclaration mainMethod = Navigator.demandMethod(clazz, "main");
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        MethodCallExpr staticMethodCall = Navigator.findMethodCall(mainMethod, "staticMethod").get();
+
+        MethodCallExpr methodCall = Navigator.findMethodCall(mainMethod, "methodCall").get();
+        MethodCallExpr innerMethodCall = Navigator.findMethodCall(mainMethod, "innerMethodCall").get();
+        MethodCallExpr innerInnerMethodCall = Navigator.findMethodCall(mainMethod, "innerInnerMethodCall").get();
+
+        MethodCallExpr firstFieldMethodCall = Navigator.findMethodCall(mainMethod, "firstContainerMethod").get();
+        MethodCallExpr secondFieldMethodCall = Navigator.findMethodCall(mainMethod, "secondContainerMethod").get();
+        MethodCallExpr thirdFieldMethodCall = Navigator.findMethodCall(mainMethod, "thirdContainerMethod").get();
+
+        assertEquals(true, javaParserFacade.solve(staticMethodCall).isSolved());
+
+        assertEquals(true, javaParserFacade.solve(methodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(innerMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(innerInnerMethodCall).isSolved());
+
+        assertEquals(true, javaParserFacade.solve(firstFieldMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(secondFieldMethodCall).isSolved());
+        assertEquals(true, javaParserFacade.solve(thirdFieldMethodCall).isSolved());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclarationTest.java
new file mode 100644
index 000000000..1029456ba
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclarationTest.java
@@ -0,0 +1,98 @@
+package com.github.javaparser.symbolsolver.javaparsermodel.declarations;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+public class JavaParserAnonymousClassDeclarationTest extends AbstractResolutionTest {
+
+  @Test
+  public void anonymousClassAsMethodArgument() {
+    CompilationUnit cu = parseSample("AnonymousClassDeclarations");
+    ClassOrInterfaceDeclaration aClass = Navigator.demandClass(cu, "AnonymousClassDeclarations");
+    MethodDeclaration method = Navigator.demandMethod(aClass, "fooBar1");
+    MethodCallExpr methodCall = Navigator.findMethodCall(method, "of").get();
+
+    CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+    combinedTypeSolver.add(new ReflectionTypeSolver());
+    MethodUsage methodUsage =
+        JavaParserFacade.get(combinedTypeSolver).solveMethodAsUsage(methodCall);
+
+    assertThat(methodUsage.getQualifiedSignature(),
+               is("AnonymousClassDeclarations.ParDo.of(AnonymousClassDeclarations.DoFn<I, O>)"));
+  }
+
+  @Test
+  public void callingSuperClassInnerClassMethod() {
+    CompilationUnit cu = parseSample("AnonymousClassDeclarations");
+    ClassOrInterfaceDeclaration aClass = Navigator.demandClass(cu, "AnonymousClassDeclarations");
+    MethodDeclaration method = Navigator.demandMethod(aClass, "fooBar2");
+    MethodCallExpr methodCall = Navigator.findMethodCall(method, "innerClassMethod").get();
+
+    CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+    combinedTypeSolver.add(new ReflectionTypeSolver());
+    MethodUsage methodUsage =
+        JavaParserFacade.get(combinedTypeSolver).solveMethodAsUsage(methodCall);
+
+    assertThat(methodUsage.getQualifiedSignature(),
+               is("AnonymousClassDeclarations.DoFn.ProcessContext.innerClassMethod()"));
+  }
+
+  @Test
+  public void callingAnonymousClassInnerMethod() {
+    CompilationUnit cu = parseSample("AnonymousClassDeclarations");
+    ClassOrInterfaceDeclaration aClass = Navigator.demandClass(cu, "AnonymousClassDeclarations");
+    MethodDeclaration method = Navigator.demandMethod(aClass, "fooBar3");
+    MethodCallExpr methodCall = Navigator.findMethodCall(method, "callAnnonClassInnerMethod").get();
+
+    CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+    combinedTypeSolver.add(new ReflectionTypeSolver());
+    MethodUsage methodUsage =
+        JavaParserFacade.get(combinedTypeSolver).solveMethodAsUsage(methodCall);
+
+    assertTrue(methodUsage.getQualifiedSignature().startsWith("AnonymousClassDeclarations"));
+    assertTrue(methodUsage.getQualifiedSignature().contains("Anonymous-"));
+    assertTrue(methodUsage.getQualifiedSignature().endsWith("callAnnonClassInnerMethod()"));
+  }
+
+  @Test
+  public void usingAnonymousSuperClassInnerType() {
+    CompilationUnit cu = parseSample("AnonymousClassDeclarations");
+    ClassOrInterfaceDeclaration aClass = Navigator.demandClass(cu, "AnonymousClassDeclarations");
+    MethodDeclaration method = Navigator.demandMethod(aClass, "fooBar4");
+    MethodCallExpr methodCall = Navigator.findMethodCall(method, "toString").get();
+
+    CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+    combinedTypeSolver.add(new ReflectionTypeSolver());
+    MethodUsage methodUsage =
+        JavaParserFacade.get(combinedTypeSolver).solveMethodAsUsage(methodCall);
+
+    assertThat(methodUsage.getQualifiedSignature(), is("java.lang.Enum.toString()"));
+  }
+
+  @Test
+  public void usingAnonymousClassInnerType() {
+    CompilationUnit cu = parseSample("AnonymousClassDeclarations");
+    ClassOrInterfaceDeclaration aClass = Navigator.demandClass(cu, "AnonymousClassDeclarations");
+    MethodDeclaration method = Navigator.demandMethod(aClass, "fooBar5");
+    MethodCallExpr methodCall = Navigator.findMethodCall(method, "toString").get();
+
+    CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+    combinedTypeSolver.add(new ReflectionTypeSolver());
+    MethodUsage methodUsage =
+        JavaParserFacade.get(combinedTypeSolver).solveMethodAsUsage(methodCall);
+
+    assertThat(methodUsage.getQualifiedSignature(), is("java.lang.Enum.toString()"));
+  }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclarationTest.java
new file mode 100644
index 000000000..0e70b1807
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclarationTest.java
@@ -0,0 +1,894 @@
+/*
+ * 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.javaparsermodel.declarations;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.AccessSpecifier;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionFactory;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaParserClassDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+    private TypeSolver typeSolverNewCode;
+    private ResolvedReferenceType string;
+    private ResolvedReferenceType listOfBoolean;
+
+    @Before
+    public void setup() {
+        File src = adaptPath(new File("src/test/test_sourcecode/javaparser_src/proper_source"));
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_src/generated"))));
+        typeSolver = combinedTypeSolver;
+
+        File srcNewCode = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(srcNewCode));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolverNewCode = combinedTypeSolverNewCode;
+
+        TypeSolver ts = new ReflectionTypeSolver();
+        string = new ReferenceTypeImpl(ts.solveType(String.class.getCanonicalName()), ts);
+        ResolvedReferenceType booleanC = new ReferenceTypeImpl(ts.solveType(Boolean.class.getCanonicalName()), ts);
+        listOfBoolean = new ReferenceTypeImpl(ts.solveType(List.class.getCanonicalName()), ImmutableList.of(booleanC), ts);
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(true, compilationUnit.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(true, compilationUnit.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(compilationUnit, compilationUnit.asType());
+    }
+
+    @Test
+    public void testAsClass() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(compilationUnit, compilationUnit.asClass());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsInterface() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        compilationUnit.asInterface();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsEnum() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        compilationUnit.asEnum();
+    }
+
+    @Test
+    public void testGetPackageName() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast", compilationUnit.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("CompilationUnit", compilationUnit.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.CompilationUnit", compilationUnit.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+    @Test
+    public void testGetSuperclassWithoutTypeParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithTypeParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", compilationUnit.getSuperClass().getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(3, constructorDeclaration.getAllSuperClasses().size());
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.body.BodyDeclaration")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.Node")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("java.lang.Object")));
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(2);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetInterfacesWithoutParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.DocumentableNode"), coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(7, constructorDeclaration.getInterfaces().size());
+
+        ResolvedReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllInterfacesWithoutParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable"), compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.NamedNode", "com.github.javaparser.ast.body.AnnotableNode", "com.github.javaparser.ast.DocumentableNode"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(9, constructorDeclaration.getAllInterfaces().size());
+
+        ResolvedReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(7);
+        assertEquals("java.lang.Cloneable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(8, constructorDeclaration.getAncestors().size());
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllAncestorsWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(12, constructorDeclaration.getAllAncestors().size());
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(2);
+        assertEquals("java.lang.Cloneable", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(4);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(9);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(10);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(11);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    ///
+    /// Test fields
+    ///
+
+    @Test
+    public void testGetFieldForExistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        ResolvedFieldDeclaration fieldDeclaration = null;
+
+        // declared field
+        fieldDeclaration = constructorDeclaration.getField("modifiers");
+        assertEquals("modifiers", fieldDeclaration.getName());
+        assertEquals("java.util.EnumSet", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessSpecifier.PRIVATE, fieldDeclaration.accessSpecifier());
+        assertEquals(false, fieldDeclaration.isStatic());
+
+        // inherited field
+        fieldDeclaration = constructorDeclaration.getField("annotations");
+        assertEquals("annotations", fieldDeclaration.getName());
+        assertEquals("java.util.List", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessSpecifier.PRIVATE, fieldDeclaration.accessSpecifier());
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void testGetFieldForUnexistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        constructorDeclaration.getField("unexisting");
+    }
+
+    @Test
+    public void testGetAllFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ResolvedFieldDeclaration> allFields = constructorDeclaration.getAllFields();
+        assertEquals(16, allFields.size());
+
+        ResolvedFieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(13);
+        assertEquals("comment", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(14);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(15);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllGenericFields() throws IOException, ParseException {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        CompilationUnit cu = JavaParser.parse(adaptPath(new File("src/test/resources/GenericFields.java.txt")));
+        JavaParserClassDeclaration classDeclaration = new JavaParserClassDeclaration(Navigator.demandClass(cu, "CB"), typeSolver);
+
+        assertEquals(3, classDeclaration.getAllFields().size());
+
+        ReferenceTypeImpl rtClassDeclaration = new ReferenceTypeImpl(classDeclaration, typeSolver);
+
+        assertEquals("s", classDeclaration.getAllFields().get(0).getName());
+        assertEquals(string, classDeclaration.getAllFields().get(0).getType());
+        assertEquals(string, rtClassDeclaration.getFieldType("s").get());
+
+        assertEquals("t", classDeclaration.getAllFields().get(1).getName());
+        assertEquals("java.util.List<java.lang.Boolean>", classDeclaration.getAllFields().get(1).getType().describe());
+        assertEquals(listOfBoolean, rtClassDeclaration.getFieldType("t").get());
+
+        assertEquals("i", classDeclaration.getAllFields().get(2).getName());
+        assertEquals(ResolvedPrimitiveType.INT, classDeclaration.getAllFields().get(2).getType());
+        assertEquals(ResolvedPrimitiveType.INT, rtClassDeclaration.getFieldType("i").get());
+    }
+
+    @Test
+    public void testGetAllStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ResolvedFieldDeclaration> allFields = constructorDeclaration.getAllStaticFields();
+        assertEquals(3, allFields.size());
+
+        ResolvedFieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllNonStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ResolvedFieldDeclaration> allFields = constructorDeclaration.getAllNonStaticFields();
+        assertEquals(13, allFields.size());
+
+        ResolvedFieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("comment", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetDeclaredFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ResolvedFieldDeclaration> allFields = constructorDeclaration.getDeclaredFields();
+        assertEquals(6, allFields.size());
+
+        ResolvedFieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+    }
+
+    ///
+    /// Test methods
+    ///
+
+    @Test
+    public void testGetDeclaredMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<ResolvedMethodDeclaration> allMethods = constructorDeclaration.getDeclaredMethods();
+        assertEquals(20, allMethods.size());
+
+        List<ResolvedMethodDeclaration> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)", sortedMethods.get(0).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)", sortedMethods.get(1).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getBody()", sortedMethods.get(2).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()", sortedMethods.get(3).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)", sortedMethods.get(4).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)", sortedMethods.get(5).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()", sortedMethods.get(6).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()", sortedMethods.get(7).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getName()", sortedMethods.get(8).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()", sortedMethods.get(9).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()", sortedMethods.get(10).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()", sortedMethods.get(11).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()", sortedMethods.get(12).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)", sortedMethods.get(13).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)", sortedMethods.get(14).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)", sortedMethods.get(15).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)", sortedMethods.get(16).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)", sortedMethods.get(17).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)", sortedMethods.get(18).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)", sortedMethods.get(19).getQualifiedSignature());
+    }
+
+    @Test
+    public void testGetAllMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<MethodUsage> allMethods = constructorDeclaration.getAllMethods();
+
+        List<MethodUsage> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        List<String> signatures = sortedMethods.stream().map(m -> m.getQualifiedSignature()).collect(Collectors.toList());
+
+        assertEquals(ImmutableList.of("com.github.javaparser.ast.Node.addOrphanComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.clone()",
+                "com.github.javaparser.ast.Node.contains(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.equals(java.lang.Object)",
+                "com.github.javaparser.ast.Node.getAllContainedComments()",
+                "com.github.javaparser.ast.Node.getBegin()",
+                "com.github.javaparser.ast.Node.getChildrenNodes()",
+                "com.github.javaparser.ast.Node.getComment()",
+                "com.github.javaparser.ast.Node.getEnd()",
+                "com.github.javaparser.ast.Node.getNodesByType(java.lang.Class<N>)",
+                "com.github.javaparser.ast.Node.getOrphanComments()",
+                "com.github.javaparser.ast.Node.getParentNode()",
+                "com.github.javaparser.ast.Node.getParentNodeOfType(java.lang.Class<T>)",
+                "com.github.javaparser.ast.Node.getRange()",
+                "com.github.javaparser.ast.Node.getUserData(com.github.javaparser.ast.UserDataKey<M>)",
+                "com.github.javaparser.ast.Node.hasComment()",
+                "com.github.javaparser.ast.Node.hashCode()",
+                "com.github.javaparser.ast.Node.isPositionedAfter(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.isPositionedBefore(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(java.util.List<? extends com.github.javaparser.ast.Node>)",
+                "com.github.javaparser.ast.Node.setBegin(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setBlockComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.setEnd(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setLineComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setParentNode(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setRange(com.github.javaparser.Range)",
+                "com.github.javaparser.ast.Node.setUserData(com.github.javaparser.ast.UserDataKey<M>, M)",
+                "com.github.javaparser.ast.Node.toString()",
+                "com.github.javaparser.ast.Node.toStringWithoutComments()",
+                "com.github.javaparser.ast.Node.tryAddImportToParentCompilationUnit(java.lang.Class<?>)",
+                "com.github.javaparser.ast.body.BodyDeclaration.getAnnotations()",
+                "com.github.javaparser.ast.body.BodyDeclaration.setAnnotations(java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getBody()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getName()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByClass(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.createBody()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.setJavaDocComment(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.addModifier(com.github.javaparser.ast.Modifier...)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isAbstract()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isFinal()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isNative()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPrivate()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isProtected()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPublic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStrictfp()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isSynchronized()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isTransient()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isVolatile()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.Class<?>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(com.github.javaparser.ast.type.ReferenceType)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)",
+                "java.lang.Object.finalize()",
+                "java.lang.Object.getClass()",
+                "java.lang.Object.notify()",
+                "java.lang.Object.notifyAll()",
+                "java.lang.Object.registerNatives()",
+                "java.lang.Object.wait()",
+                "java.lang.Object.wait(long)",
+                "java.lang.Object.wait(long, int)"), signatures);
+    }
+
+    ///
+    /// Test constructors
+    ///
+
+    @Test
+    public void testGetConstructors() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ResolvedConstructorDeclaration> constructors = constructorDeclaration.getConstructors();
+        assertEquals(4, constructors.size());
+
+        assertEquals("ConstructorDeclaration()", constructors.get(0).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.lang.String)", constructors.get(1).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(2).getSignature());
+        assertEquals("ConstructorDeclaration(com.github.javaparser.Range, java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(3).getSignature());
+    }
+
+    ///
+    /// Resolution
+    ///
+
+    //SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes);
+    @Test
+    public void testSolveMethodExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<ResolvedMethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of());
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(RuntimeException.class.getClass(), typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        // This is solved because it is raw
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+    }
+
+    @Test
+    public void testSolveMethodNotExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<ResolvedMethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("unexistingMethod", ImmutableList.of());
+        assertEquals(false, res.isSolved());
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of(ResolvedPrimitiveType.BOOLEAN));
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveMethodNotExistingBecauseOfTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<ResolvedMethodDeclaration> res = null;
+
+        ResolvedReferenceType stringType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode);
+        ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode);
+        ResolvedReferenceType classOfStringType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), stringType);
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(classOfStringType));
+        assertEquals(false, res.isSolved());
+    }
+
+
+    ///
+    /// Assignability
+    ///
+
+    // boolean isAssignableBy(Type type);
+
+    // boolean canBeAssignedTo(TypeDeclaration other)
+
+    // boolean isAssignableBy(TypeDeclaration other);
+
+    ///
+    /// Annotations
+    ///
+
+    // hasDirectlyAnnotation
+
+    @Test
+    public void testHasDirectlyAnnotation() throws IOException, ParseException {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        CompilationUnit cu = JavaParser.parse(adaptPath(new File("src/test/resources/Annotations.java.txt")));
+
+        JavaParserClassDeclaration ca = new JavaParserClassDeclaration(Navigator.demandClass(cu, "CA"), typeSolver);
+        assertEquals(true, ca.hasDirectlyAnnotation("foo.bar.MyAnnotation"));
+        assertEquals(false, ca.hasDirectlyAnnotation("foo.bar.MyAnnotation2"));
+        assertEquals(false, ca.hasDirectlyAnnotation("MyAnnotation"));
+        assertEquals(false, ca.hasDirectlyAnnotation("foo.bar.MyUnexistingAnnotation"));
+
+        JavaParserClassDeclaration cb = new JavaParserClassDeclaration(Navigator.demandClass(cu, "CB"), typeSolver);
+        assertEquals(false, cb.hasDirectlyAnnotation("foo.bar.MyAnnotation"));
+        assertEquals(true, cb.hasDirectlyAnnotation("foo.bar.MyAnnotation2"));
+        assertEquals(false, cb.hasDirectlyAnnotation("MyAnnotation"));
+        assertEquals(false, cb.hasDirectlyAnnotation("foo.bar.MyUnexistingAnnotation"));
+    }
+
+    // hasAnnotation
+
+    @Test
+    public void testHasAnnotation() throws IOException, ParseException {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        CompilationUnit cu = JavaParser.parse(adaptPath(new File("src/test/resources/Annotations.java.txt")));
+
+        JavaParserClassDeclaration ca = new JavaParserClassDeclaration(Navigator.demandClass(cu, "CA"), typeSolver);
+        assertEquals(true, ca.hasAnnotation("foo.bar.MyAnnotation"));
+        assertEquals(false, ca.hasAnnotation("foo.bar.MyAnnotation2"));
+        assertEquals(false, ca.hasAnnotation("MyAnnotation"));
+        assertEquals(false, ca.hasAnnotation("foo.bar.MyUnexistingAnnotation"));
+
+        JavaParserClassDeclaration cb = new JavaParserClassDeclaration(Navigator.demandClass(cu, "CB"), typeSolver);
+        assertEquals(true, cb.hasAnnotation("foo.bar.MyAnnotation"));
+        assertEquals(true, cb.hasAnnotation("foo.bar.MyAnnotation2"));
+        assertEquals(false, cb.hasAnnotation("MyAnnotation"));
+        assertEquals(false, cb.hasAnnotation("foo.bar.MyUnexistingAnnotation"));
+    }
+
+    ///
+    ///
+    ///
+
+    // List<TypeParameterDeclaration> getTypeParameters();
+
+    // AccessLevel accessLevel();
+
+    ///
+    /// Containment
+    ///
+
+    // Set<TypeDeclaration> internalTypes()
+
+    // Optional<TypeDeclaration> containerType()
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclarationTest.java
new file mode 100644
index 000000000..c171f4b94
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclarationTest.java
@@ -0,0 +1,826 @@
+/*
+ * 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.javaparsermodel.declarations;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaParserEnumDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        File srcNewCode = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(srcNewCode));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolver = combinedTypeSolverNewCode;
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsClass() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asClass();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsInterface() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asInterface();
+    }
+
+    @Test
+    public void testAsEnum() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asEnum());
+    }
+
+    @Test
+    public void testGetPackageName() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast", modifier.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("Modifier", modifier.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast.Modifier", modifier.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+    /*@Test
+    public void testGetSuperclassWithoutTypeParameters() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithTypeParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", compilationUnit.getSuperClass().getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(3, constructorDeclaration.getAllSuperClasses().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(2);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetInterfacesWithoutParameters() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.DocumentableNode"), coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(7, constructorDeclaration.getInterfaces().size());
+
+        ReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllInterfacesWithoutParameters() {
+        JavaParserEnumDeclaration modifier = (JavaParserEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable"), compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.NamedNode", "com.github.javaparser.ast.body.AnnotableNode", "com.github.javaparser.ast.DocumentableNode"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(9, constructorDeclaration.getAllInterfaces().size());
+
+        ReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(7);
+        assertEquals("java.lang.Cloneable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(8, constructorDeclaration.getAncestors().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllAncestorsWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(12, constructorDeclaration.getAllAncestors().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(2);
+        assertEquals("java.lang.Cloneable", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(4);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(9);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(10);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(11);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    ///
+    /// Test fields
+    ///
+
+    @Test
+    public void testGetFieldForExistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        FieldDeclaration fieldDeclaration = null;
+
+        // declared field
+        fieldDeclaration = constructorDeclaration.getField("modifiers");
+        assertEquals("modifiers", fieldDeclaration.getName());
+        assertEquals("java.util.EnumSet", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessLevel.PRIVATE, fieldDeclaration.accessLevel());
+        assertEquals(false, fieldDeclaration.isStatic());
+
+        // inherited field
+        fieldDeclaration = constructorDeclaration.getField("annotations");
+        assertEquals("annotations", fieldDeclaration.getName());
+        assertEquals("java.util.List", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessLevel.PRIVATE, fieldDeclaration.accessLevel());
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void testGetFieldForUnexistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        constructorDeclaration.getField("unexisting");
+    }
+
+    @Test
+    public void testGetAllFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllFields();
+        assertEquals(16, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(13);
+        assertEquals("comment", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(14);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(15);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllStaticFields();
+        assertEquals(3, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllNonStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllNonStaticFields();
+        assertEquals(13, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("comment", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetDeclaredFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getDeclaredFields();
+        assertEquals(6, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+    }
+
+    ///
+    /// Test methods
+    ///
+
+    @Test
+    public void testGetDeclaredMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<MethodDeclaration> allMethods = constructorDeclaration.getDeclaredMethods();
+        assertEquals(20, allMethods.size());
+
+        List<MethodDeclaration> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)", sortedMethods.get(0).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)", sortedMethods.get(1).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getBody()", sortedMethods.get(2).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()", sortedMethods.get(3).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)", sortedMethods.get(4).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)", sortedMethods.get(5).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()", sortedMethods.get(6).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()", sortedMethods.get(7).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getName()", sortedMethods.get(8).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()", sortedMethods.get(9).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()", sortedMethods.get(10).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()", sortedMethods.get(11).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()", sortedMethods.get(12).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)", sortedMethods.get(13).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)", sortedMethods.get(14).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)", sortedMethods.get(15).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)", sortedMethods.get(16).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)", sortedMethods.get(17).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)", sortedMethods.get(18).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)", sortedMethods.get(19).getQualifiedSignature());
+    }
+
+    @Test
+    public void testGetAllMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<MethodUsage> allMethods = constructorDeclaration.getAllMethods();
+
+        List<MethodUsage> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        List<String> signatures = sortedMethods.stream().map(m -> m.getQualifiedSignature()).collect(Collectors.toList());
+
+        assertEquals(ImmutableList.of("com.github.javaparser.ast.Node.addOrphanComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.clone()",
+                "com.github.javaparser.ast.Node.contains(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.equals(java.lang.Object)",
+                "com.github.javaparser.ast.Node.getAllContainedComments()",
+                "com.github.javaparser.ast.Node.getBegin()",
+                "com.github.javaparser.ast.Node.getChildrenNodes()",
+                "com.github.javaparser.ast.Node.getComment()",
+                "com.github.javaparser.ast.Node.getEnd()",
+                "com.github.javaparser.ast.Node.getNodesByType(java.lang.Class<N>)",
+                "com.github.javaparser.ast.Node.getOrphanComments()",
+                "com.github.javaparser.ast.Node.getParentNode()",
+                "com.github.javaparser.ast.Node.getParentNodeOfType(java.lang.Class<T>)",
+                "com.github.javaparser.ast.Node.getRange()",
+                "com.github.javaparser.ast.Node.getUserData(com.github.javaparser.ast.UserDataKey<M>)",
+                "com.github.javaparser.ast.Node.hasComment()",
+                "com.github.javaparser.ast.Node.hashCode()",
+                "com.github.javaparser.ast.Node.isPositionedAfter(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.isPositionedBefore(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(java.util.List<? extends com.github.javaparser.ast.Node>)",
+                "com.github.javaparser.ast.Node.setBegin(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setBlockComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.setEnd(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setLineComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setParentNode(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setRange(com.github.javaparser.Range)",
+                "com.github.javaparser.ast.Node.setUserData(com.github.javaparser.ast.UserDataKey<M>, M)",
+                "com.github.javaparser.ast.Node.toString()",
+                "com.github.javaparser.ast.Node.toStringWithoutComments()",
+                "com.github.javaparser.ast.Node.tryAddImportToParentCompilationUnit(java.lang.Class<?>)",
+                "com.github.javaparser.ast.body.BodyDeclaration.getAnnotations()",
+                "com.github.javaparser.ast.body.BodyDeclaration.setAnnotations(java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getBody()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getName()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByClass(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.createBody()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.setJavaDocComment(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.addModifier(com.github.javaparser.ast.Modifier...)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isAbstract()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isFinal()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isNative()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPrivate()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isProtected()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPublic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStrictfp()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isSynchronized()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isTransient()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isVolatile()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.Class<?>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(com.github.javaparser.ast.type.ReferenceType)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)",
+                "java.lang.Object.finalize()",
+                "java.lang.Object.getClass()",
+                "java.lang.Object.notify()",
+                "java.lang.Object.notifyAll()",
+                "java.lang.Object.registerNatives()",
+                "java.lang.Object.wait()",
+                "java.lang.Object.wait(long)",
+                "java.lang.Object.wait(long, int)"), signatures);
+    }
+
+    ///
+    /// Test constructors
+    ///
+
+    @Test
+    public void testGetConstructors() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ConstructorDeclaration> constructors = constructorDeclaration.getConstructors();
+        assertEquals(4, constructors.size());
+
+        assertEquals("ConstructorDeclaration()", constructors.get(0).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.lang.String)", constructors.get(1).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(2).getSignature());
+        assertEquals("ConstructorDeclaration(com.github.javaparser.Range, java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(3).getSignature());
+    }
+
+    ///
+    /// Resolution
+    ///
+
+    //SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes);
+    @Test
+    public void testSolveMethodExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of());
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(RuntimeException.class.getClass(), typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        // This is solved because it is raw
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+    }
+
+    @Test
+    public void testSolveMethodNotExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("unexistingMethod", ImmutableList.of());
+        assertEquals(false, res.isSolved());
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of(PrimitiveType.BOOLEAN));
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveMethodNotExistingBecauseOfTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        ReferenceType stringType = (ReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode);
+        ReferenceType rawClassType = (ReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode);
+        ReferenceType classOfStringType = (ReferenceType) rawClassType.replaceTypeVariables("T", stringType);
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(classOfStringType));
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveSymbolUnexisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("unexisting", typeSolver);
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveSymbolToDeclaredField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("name", typeSolver);
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPublicField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("NODE_BY_BEGIN_POSITION", typeSolver);
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPrivateField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("parentNode", typeSolver);
+        assertEquals(false, res.isSolved());
+    }
+
+    ///
+    /// Assignability
+    ///
+
+    // boolean isAssignableBy(Type type);
+
+    // boolean canBeAssignedTo(TypeDeclaration other)
+
+    // boolean isAssignableBy(TypeDeclaration other);
+
+    ///
+    /// Annotations
+    ///
+
+    // hasDirectlyAnnotation
+
+    // hasAnnotation
+
+    ///
+    ///
+    ///
+
+    // List<TypeParameterDeclaration> getTypeParameters();
+
+    // AccessLevel accessLevel();
+
+    ///
+    /// Containment
+    ///
+
+    // Set<TypeDeclaration> internalTypes()
+
+    // Optional<TypeDeclaration> containerType()*/
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclarationTest.java
new file mode 100644
index 000000000..cf5e5802b
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclarationTest.java
@@ -0,0 +1,826 @@
+/*
+ * 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.javaparsermodel.declarations;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaParserInterfaceDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        File srcNewCode = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(srcNewCode));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolver = combinedTypeSolverNewCode;
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(true, nodeWithAnnotations.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(true, nodeWithAnnotations.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(nodeWithAnnotations, nodeWithAnnotations.asType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsClass() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(nodeWithAnnotations, nodeWithAnnotations.asClass());
+    }
+
+    @Test
+    public void testAsInterface() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(nodeWithAnnotations, nodeWithAnnotations.asInterface());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsEnum() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        nodeWithAnnotations.asEnum();
+    }
+
+    @Test
+    public void testGetPackageName() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("com.github.javaparser.ast.nodeTypes", nodeWithAnnotations.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("NodeWithAnnotations", nodeWithAnnotations.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", nodeWithAnnotations.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+    /*@Test
+    public void testGetSuperclassWithoutTypeParameters() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithTypeParameters() {
+        JavaParserClassDeclaration compilationUnit = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", compilationUnit.getSuperClass().getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(3, constructorDeclaration.getAllSuperClasses().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(2);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetInterfacesWithoutParameters() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.DocumentableNode"), coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(7, constructorDeclaration.getInterfaces().size());
+
+        ReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllInterfacesWithoutParameters() {
+        JavaParserInterfaceDeclaration nodeWithAnnotations = (JavaParserInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable"), compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavaParserClassDeclaration coid = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.NamedNode", "com.github.javaparser.ast.body.AnnotableNode", "com.github.javaparser.ast.DocumentableNode"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfacesWithParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(9, constructorDeclaration.getAllInterfaces().size());
+
+        ReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(7);
+        assertEquals("java.lang.Cloneable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(8, constructorDeclaration.getAncestors().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllAncestorsWithoutTypeParameters() {
+        JavaParserClassDeclaration cu = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestorsWithTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(12, constructorDeclaration.getAllAncestors().size());
+
+        ReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(2);
+        assertEquals("java.lang.Cloneable", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(4);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(9);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(10);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(11);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    ///
+    /// Test fields
+    ///
+
+    @Test
+    public void testGetFieldForExistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        FieldDeclaration fieldDeclaration = null;
+
+        // declared field
+        fieldDeclaration = constructorDeclaration.getField("modifiers");
+        assertEquals("modifiers", fieldDeclaration.getName());
+        assertEquals("java.util.EnumSet", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessLevel.PRIVATE, fieldDeclaration.accessLevel());
+        assertEquals(false, fieldDeclaration.isStatic());
+
+        // inherited field
+        fieldDeclaration = constructorDeclaration.getField("annotations");
+        assertEquals("annotations", fieldDeclaration.getName());
+        assertEquals("java.util.List", fieldDeclaration.getType().asReferenceType().getQualifiedName());
+        assertEquals(AccessLevel.PRIVATE, fieldDeclaration.accessLevel());
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void testGetFieldForUnexistingField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        constructorDeclaration.getField("unexisting");
+    }
+
+    @Test
+    public void testGetAllFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllFields();
+        assertEquals(16, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(13);
+        assertEquals("comment", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(14);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(15);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllStaticFields();
+        assertEquals(3, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("NODE_BY_BEGIN_POSITION", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("ABSOLUTE_BEGIN_LINE", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("ABSOLUTE_END_LINE", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetAllNonStaticFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getAllNonStaticFields();
+        assertEquals(13, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(6);
+        assertEquals("annotations", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(7);
+        assertEquals("range", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(8);
+        assertEquals("parentNode", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(9);
+        assertEquals("childrenNodes", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(10);
+        assertEquals("orphanComments", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(11);
+        assertEquals("userData", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(12);
+        assertEquals("comment", fieldDeclaration.getName());
+    }
+
+    @Test
+    public void testGetDeclaredFields() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<FieldDeclaration> allFields = constructorDeclaration.getDeclaredFields();
+        assertEquals(6, allFields.size());
+
+        FieldDeclaration fieldDeclaration = null;
+
+        fieldDeclaration = allFields.get(0);
+        assertEquals("modifiers", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(1);
+        assertEquals("typeParameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(2);
+        assertEquals("name", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(3);
+        assertEquals("parameters", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(4);
+        assertEquals("throws_", fieldDeclaration.getName());
+
+        fieldDeclaration = allFields.get(5);
+        assertEquals("body", fieldDeclaration.getName());
+    }
+
+    ///
+    /// Test methods
+    ///
+
+    @Test
+    public void testGetDeclaredMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<MethodDeclaration> allMethods = constructorDeclaration.getDeclaredMethods();
+        assertEquals(20, allMethods.size());
+
+        List<MethodDeclaration> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)", sortedMethods.get(0).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)", sortedMethods.get(1).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getBody()", sortedMethods.get(2).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()", sortedMethods.get(3).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)", sortedMethods.get(4).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)", sortedMethods.get(5).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()", sortedMethods.get(6).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()", sortedMethods.get(7).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getName()", sortedMethods.get(8).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()", sortedMethods.get(9).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()", sortedMethods.get(10).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()", sortedMethods.get(11).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()", sortedMethods.get(12).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)", sortedMethods.get(13).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)", sortedMethods.get(14).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)", sortedMethods.get(15).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)", sortedMethods.get(16).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)", sortedMethods.get(17).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)", sortedMethods.get(18).getQualifiedSignature());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)", sortedMethods.get(19).getQualifiedSignature());
+    }
+
+    @Test
+    public void testGetAllMethods() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        Set<MethodUsage> allMethods = constructorDeclaration.getAllMethods();
+
+        List<MethodUsage> sortedMethods = allMethods.stream()
+                .sorted((o1, o2) -> o1.getQualifiedSignature().compareTo(o2.getQualifiedSignature()))
+                .collect(Collectors.toList());
+
+        List<String> signatures = sortedMethods.stream().map(m -> m.getQualifiedSignature()).collect(Collectors.toList());
+
+        assertEquals(ImmutableList.of("com.github.javaparser.ast.Node.addOrphanComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.clone()",
+                "com.github.javaparser.ast.Node.contains(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.equals(java.lang.Object)",
+                "com.github.javaparser.ast.Node.getAllContainedComments()",
+                "com.github.javaparser.ast.Node.getBegin()",
+                "com.github.javaparser.ast.Node.getChildrenNodes()",
+                "com.github.javaparser.ast.Node.getComment()",
+                "com.github.javaparser.ast.Node.getEnd()",
+                "com.github.javaparser.ast.Node.getNodesByType(java.lang.Class<N>)",
+                "com.github.javaparser.ast.Node.getOrphanComments()",
+                "com.github.javaparser.ast.Node.getParentNode()",
+                "com.github.javaparser.ast.Node.getParentNodeOfType(java.lang.Class<T>)",
+                "com.github.javaparser.ast.Node.getRange()",
+                "com.github.javaparser.ast.Node.getUserData(com.github.javaparser.ast.UserDataKey<M>)",
+                "com.github.javaparser.ast.Node.hasComment()",
+                "com.github.javaparser.ast.Node.hashCode()",
+                "com.github.javaparser.ast.Node.isPositionedAfter(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.isPositionedBefore(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setAsParentNodeOf(java.util.List<? extends com.github.javaparser.ast.Node>)",
+                "com.github.javaparser.ast.Node.setBegin(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setBlockComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setComment(com.github.javaparser.ast.comments.Comment)",
+                "com.github.javaparser.ast.Node.setEnd(com.github.javaparser.Position)",
+                "com.github.javaparser.ast.Node.setLineComment(java.lang.String)",
+                "com.github.javaparser.ast.Node.setParentNode(com.github.javaparser.ast.Node)",
+                "com.github.javaparser.ast.Node.setRange(com.github.javaparser.Range)",
+                "com.github.javaparser.ast.Node.setUserData(com.github.javaparser.ast.UserDataKey<M>, M)",
+                "com.github.javaparser.ast.Node.toString()",
+                "com.github.javaparser.ast.Node.toStringWithoutComments()",
+                "com.github.javaparser.ast.Node.tryAddImportToParentCompilationUnit(java.lang.Class<?>)",
+                "com.github.javaparser.ast.body.BodyDeclaration.getAnnotations()",
+                "com.github.javaparser.ast.body.BodyDeclaration.setAnnotations(java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.GenericVisitor<R, A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.accept(com.github.javaparser.ast.visitor.VoidVisitor<A>, A)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getBody()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getDeclarationAsString(boolean, boolean, boolean)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getJavaDoc()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getModifiers()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getName()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getNameExpr()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getThrows()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.getTypeParameters()",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setBody(com.github.javaparser.ast.stmt.BlockStmt)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setModifiers(java.util.EnumSet<com.github.javaparser.ast.Modifier>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setName(java.lang.String)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setNameExpr(com.github.javaparser.ast.expr.NameExpr)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setParameters(java.util.List<com.github.javaparser.ast.body.Parameter>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setThrows(java.util.List<com.github.javaparser.ast.type.ReferenceType>)",
+                "com.github.javaparser.ast.body.ConstructorDeclaration.setTypeParameters(java.util.List<com.github.javaparser.ast.type.TypeParameter>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addMarkerAnnotation(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.Class<? extends java.lang.annotation.Annotation>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.addSingleMemberAnnotation(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByClass(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.getAnnotationByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.Class<? extends java.lang.annotation.Annotation>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.isAnnotationPresent(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.createBody()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.setJavaDocComment(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.addModifier(com.github.javaparser.ast.Modifier...)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isAbstract()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isFinal()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isNative()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPrivate()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isProtected()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isPublic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStrictfp()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isSynchronized()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isTransient()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isVolatile()",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addAndGetParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.body.Parameter)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(com.github.javaparser.ast.type.Type, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.Class<?>, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.addParameter(java.lang.String, java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByName(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.Class<?>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithParameters.getParamByType(java.lang.String)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(com.github.javaparser.ast.type.ReferenceType)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.addThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)",
+                "com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)",
+                "java.lang.Object.finalize()",
+                "java.lang.Object.getClass()",
+                "java.lang.Object.notify()",
+                "java.lang.Object.notifyAll()",
+                "java.lang.Object.registerNatives()",
+                "java.lang.Object.wait()",
+                "java.lang.Object.wait(long)",
+                "java.lang.Object.wait(long, int)"), signatures);
+    }
+
+    ///
+    /// Test constructors
+    ///
+
+    @Test
+    public void testGetConstructors() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        List<ConstructorDeclaration> constructors = constructorDeclaration.getConstructors();
+        assertEquals(4, constructors.size());
+
+        assertEquals("ConstructorDeclaration()", constructors.get(0).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.lang.String)", constructors.get(1).getSignature());
+        assertEquals("ConstructorDeclaration(java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(2).getSignature());
+        assertEquals("ConstructorDeclaration(com.github.javaparser.Range, java.util.EnumSet<com.github.javaparser.ast.Modifier>, java.util.List<com.github.javaparser.ast.expr.AnnotationExpr>, java.util.List<com.github.javaparser.ast.type.TypeParameter>, java.lang.String, java.util.List<com.github.javaparser.ast.body.Parameter>, java.util.List<com.github.javaparser.ast.type.ReferenceType>, com.github.javaparser.ast.stmt.BlockStmt)", constructors.get(3).getSignature());
+    }
+
+    ///
+    /// Resolution
+    ///
+
+    //SymbolReference<MethodDeclaration> solveMethod(String name, List<Type> parameterTypes);
+    @Test
+    public void testSolveMethodExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of());
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.isStatic()", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(RuntimeException.class.getClass(), typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.String)", res.getCorrespondingDeclaration().getQualifiedSignature());
+
+        // This is solved because it is raw
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode)));
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.isThrows(java.lang.Class<? extends java.lang.Throwable>)", res.getCorrespondingDeclaration().getQualifiedSignature());
+    }
+
+    @Test
+    public void testSolveMethodNotExisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        res = constructorDeclaration.solveMethod("unexistingMethod", ImmutableList.of());
+        assertEquals(false, res.isSolved());
+
+        res = constructorDeclaration.solveMethod("isStatic", ImmutableList.of(PrimitiveType.BOOLEAN));
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveMethodNotExistingBecauseOfTypeParameters() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<MethodDeclaration> res = null;
+
+        ReferenceType stringType = (ReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolverNewCode);
+        ReferenceType rawClassType = (ReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolverNewCode);
+        ReferenceType classOfStringType = (ReferenceType) rawClassType.replaceTypeVariables("T", stringType);
+        res = constructorDeclaration.solveMethod("isThrows", ImmutableList.of(classOfStringType));
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveSymbolUnexisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("unexisting", typeSolver);
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveSymbolToDeclaredField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("name", typeSolver);
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPublicField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("NODE_BY_BEGIN_POSITION", typeSolver);
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPrivateField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ValueDeclaration> res = constructorDeclaration.solveSymbol("parentNode", typeSolver);
+        assertEquals(false, res.isSolved());
+    }
+
+    ///
+    /// Assignability
+    ///
+
+    // boolean isAssignableBy(Type type);
+
+    // boolean canBeAssignedTo(TypeDeclaration other)
+
+    // boolean isAssignableBy(TypeDeclaration other);
+
+    ///
+    /// Annotations
+    ///
+
+    // hasDirectlyAnnotation
+
+    // hasAnnotation
+
+    ///
+    ///
+    ///
+
+    // List<TypeParameterDeclaration> getTypeParameters();
+
+    // AccessLevel accessLevel();
+
+    ///
+    /// Containment
+    ///
+
+    // Set<TypeDeclaration> internalTypes()
+
+    // Optional<TypeDeclaration> containerType()*/
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/Issue257.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/Issue257.java
new file mode 100644
index 000000000..460b51667
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/Issue257.java
@@ -0,0 +1,47 @@
+package com.github.javaparser.symbolsolver.javassistmodel;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.Statement;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class Issue257 extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/issue257/issue257.jar");
+        File jar = new File(pathToJar);
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(jar.getAbsolutePath()), new ReflectionTypeSolver());
+    }
+
+    @Test
+    public void verifyBCanBeSolved() throws FileNotFoundException {
+        typeSolver.solveType("net.testbug.B");
+    }
+
+    @Test
+    public void issue257() throws FileNotFoundException {
+        String pathToSourceFile = adaptPath("src/test/resources/issue257/A.java.txt");
+        CompilationUnit cu = JavaParser.parse(new File(pathToSourceFile));
+        Statement statement = cu.getClassByName("A").get().getMethodsByName("run").get(0).getBody().get().getStatement(0);
+        ExpressionStmt expressionStmt = (ExpressionStmt)statement;
+        Expression expression = expressionStmt.getExpression();
+        JavaParserFacade.get(typeSolver).getType(expression);
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclarationTest.java
new file mode 100644
index 000000000..9f55977c5
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclarationTest.java
@@ -0,0 +1,404 @@
+/*
+ * 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.javassistmodel;
+
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavassistClassDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    private TypeSolver newTypeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToJar), new ReflectionTypeSolver());
+
+        String newPathToJar = adaptPath("src/test/resources/javaparser-core-3.0.0-alpha.2.jar");
+        newTypeSolver = new CombinedTypeSolver(new JarTypeSolver(newPathToJar), new ReflectionTypeSolver());
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(true, compilationUnit.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(false, compilationUnit.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(true, compilationUnit.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(compilationUnit, compilationUnit.asType());
+    }
+
+    @Test
+    public void testAsClass() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(compilationUnit, compilationUnit.asClass());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsInterface() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        compilationUnit.asInterface();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsEnum() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        compilationUnit.asEnum();
+    }
+
+    @Test
+    public void testGetPackageName() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast", compilationUnit.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("CompilationUnit", compilationUnit.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.CompilationUnit", compilationUnit.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+    @Test
+    public void testGetSuperclass() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithoutTypeParameters() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithTypeParameters() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", compilationUnit.getSuperClass().getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllSuperclasses() {
+        JavassistClassDeclaration cu = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestors() {
+        JavassistClassDeclaration cu = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfaces() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavassistClassDeclaration coid = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.DocumentableNode"), coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfaces() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of(), compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavassistClassDeclaration coid = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.NamedNode", "com.github.javaparser.ast.body.AnnotableNode", "com.github.javaparser.ast.DocumentableNode"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithoutTypeParameters() {
+        JavassistClassDeclaration cu = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithTypeParameters() {
+        JavassistClassDeclaration constructorDeclaration = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(3, constructorDeclaration.getAllSuperClasses().size());
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.body.BodyDeclaration")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.Node")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("java.lang.Object")));
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(2);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetInterfacesWithoutParameters() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavassistClassDeclaration coid = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.nodeTypes.NodeWithExtends", "com.github.javaparser.ast.nodeTypes.NodeWithImplements"), coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfacesWithParameters() {
+        JavassistClassDeclaration constructorDeclaration = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(7, constructorDeclaration.getInterfaces().size());
+
+        ResolvedReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllInterfacesWithoutParameters() {
+        JavassistClassDeclaration compilationUnit = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable"), compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        JavassistClassDeclaration coid = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.nodeTypes.NodeWithExtends",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations",
+                "java.lang.Cloneable",
+                "com.github.javaparser.ast.nodeTypes.NodeWithImplements",
+                "com.github.javaparser.ast.nodeTypes.NodeWithName",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers",
+                "com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc",
+                "com.github.javaparser.ast.nodeTypes.NodeWithMembers"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfacesWithParameters() {
+        JavassistClassDeclaration constructorDeclaration = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(9, constructorDeclaration.getAllInterfaces().size());
+
+        ResolvedReferenceType interfaze = null;
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(7);
+        assertEquals("java.lang.Cloneable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAncestorsWithTypeParameters() {
+        JavassistClassDeclaration constructorDeclaration = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(8, constructorDeclaration.getAncestors().size());
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllAncestorsWithoutTypeParameters() {
+        JavassistClassDeclaration cu = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestorsWithTypeParameters() {
+        JavassistClassDeclaration constructorDeclaration = (JavassistClassDeclaration) newTypeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(12, constructorDeclaration.getAllAncestors().size());
+
+        ResolvedReferenceType ancestor = null;
+
+        ancestor = constructorDeclaration.getAllAncestors().get(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(1);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(2);
+        assertEquals("java.lang.Cloneable", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(4);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavaDoc.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithName.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(8);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(9);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(10);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrowable", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrowable.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllAncestors().get(11);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.T").get().asReferenceType().getQualifiedName());
+    }
+    
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclarationTest.java
new file mode 100644
index 000000000..8e6d66fe8
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclarationTest.java
@@ -0,0 +1,122 @@
+/*
+ * 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.javassistmodel;
+
+import com.github.javaparser.resolution.declarations.ResolvedEnumDeclaration;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavassistEnumDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-3.0.0-alpha.2.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToJar), new ReflectionTypeSolver());
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsClass() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asClass();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsInterface() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asInterface();
+    }
+
+    @Test
+    public void testAsEnum() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asEnum());
+    }
+
+    @Test
+    public void testGetPackageName() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast", modifier.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("Modifier", modifier.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        ResolvedEnumDeclaration modifier = (ResolvedEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast.Modifier", modifier.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclarationTest.java
new file mode 100644
index 000000000..a593ec406
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclarationTest.java
@@ -0,0 +1,121 @@
+/*
+ * 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.javassistmodel;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavassistInterfaceDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-3.0.0-alpha.2.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToJar), new ReflectionTypeSolver());
+    }
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(true, nodeWithAnnotations.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(false, nodeWithAnnotations.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(true, nodeWithAnnotations.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(nodeWithAnnotations, nodeWithAnnotations.asType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsClass() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        nodeWithAnnotations.asClass();
+    }
+
+    @Test
+    public void testAsInterface() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals(nodeWithAnnotations, nodeWithAnnotations.asInterface());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsEnum() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        nodeWithAnnotations.asEnum();
+    }
+
+    @Test
+    public void testGetPackageName() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("com.github.javaparser.ast.nodeTypes", nodeWithAnnotations.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("NodeWithAnnotations", nodeWithAnnotations.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        JavassistInterfaceDeclaration nodeWithAnnotations = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations");
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", nodeWithAnnotations.getQualifiedName());
+    }
+
+    ///
+    /// Test ancestors
+    ///
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/FunctionInterfaceLogicTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/FunctionInterfaceLogicTest.java
new file mode 100644
index 000000000..bda2cc900
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/FunctionInterfaceLogicTest.java
@@ -0,0 +1,51 @@
+/*
+ * 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.logic;
+
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import static org.junit.Assert.assertEquals;
+
+public class FunctionInterfaceLogicTest {
+
+    @Test
+    public void testGetFunctionalMethodNegativeCaseOnClass() {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        assertEquals(false, FunctionalInterfaceLogic.getFunctionalMethod(string).isPresent());
+    }
+
+    @Test
+    public void testGetFunctionalMethodPositiveCasesOnInterfaces() {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType function = new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Function.class, typeSolver), typeSolver);
+        assertEquals(true, FunctionalInterfaceLogic.getFunctionalMethod(function).isPresent());
+        assertEquals("apply", FunctionalInterfaceLogic.getFunctionalMethod(function).get().getName());
+        ResolvedType consumer = new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Consumer.class, typeSolver), typeSolver);
+        assertEquals(true, FunctionalInterfaceLogic.getFunctionalMethod(consumer).isPresent());
+        assertEquals("accept", FunctionalInterfaceLogic.getFunctionalMethod(consumer).get().getName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/InferenceContextTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/InferenceContextTest.java
new file mode 100644
index 000000000..3af207f9f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/logic/InferenceContextTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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.logic;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.MyObjectProvider;
+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.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Federico Tomassetti
+ */
+public class InferenceContextTest {
+
+    private TypeSolver typeSolver;
+    private ResolvedReferenceType string;
+    private ResolvedReferenceType object;
+    private ResolvedReferenceType listOfString;
+    private ResolvedReferenceType listOfE;
+    private ResolvedTypeParameterDeclaration tpE;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+        string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+        object = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver);
+        listOfString = listOf(string);
+        tpE = mock(ResolvedTypeParameterDeclaration.class);
+        when(tpE.getName()).thenReturn("T");
+
+        listOfE = listOf(new ResolvedTypeVariable(tpE));
+    }
+
+    private ResolvedReferenceType listOf(ResolvedType elementType) {
+        return new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeSolver), ImmutableList.of(elementType), typeSolver);
+    }
+
+    @Test
+    public void noVariablesArePlacedWhenNotNeeded() {
+        ResolvedType result = new InferenceContext(MyObjectProvider.INSTANCE).addPair(object, string);
+        assertEquals(object, result);
+    }
+
+    @Test
+    public void placingASingleVariableTopLevel() {
+        ResolvedType result = new InferenceContext(MyObjectProvider.INSTANCE).addPair(new ResolvedTypeVariable(tpE), listOfString);
+        assertEquals(new InferenceVariableType(0, MyObjectProvider.INSTANCE), result);
+    }
+
+    @Test
+    public void placingASingleVariableInside() {
+        ResolvedType result = new InferenceContext(MyObjectProvider.INSTANCE).addPair(listOfE, listOfString);
+        assertEquals(listOf(new InferenceVariableType(0, MyObjectProvider.INSTANCE)), result);
+    }
+
+}
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());
+    }*/
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionClassDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionClassDeclarationTest.java
new file mode 100644
index 000000000..8de0e2391
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionClassDeclarationTest.java
@@ -0,0 +1,776 @@
+/*
+ * 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.reflectionmodel;
+
+import com.github.javaparser.ast.AccessSpecifier;
+import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.io.Serializable;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class ReflectionClassDeclarationTest extends AbstractTest {
+    
+    private TypeSolver typeResolver = new ReflectionTypeSolver(false);
+
+    @Test
+    public void testIsClass() {
+        class Foo<E> {
+            E field;
+        }
+        class Bar extends Foo<String> {
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+        ResolvedClassDeclaration bar = new ReflectionClassDeclaration(Bar.class, typeResolver);
+
+        assertEquals(true, foo.isClass());
+        assertEquals(true, bar.isClass());
+    }
+
+    @Test
+    public void testGetSuperclassSimpleImplicit() {
+        class Foo<E> {
+            E field;
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+
+        assertEquals(Object.class.getCanonicalName(), foo.getSuperClass().getQualifiedName());
+        assertEquals(Collections.emptyList(), foo.getSuperClass().typeParametersValues());
+    }
+
+    @Test
+    public void testGetSuperclassSimple() {
+        class Bar {
+        }
+        class Foo<E> extends Bar {
+            E field;
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+
+        assertEquals("Bar", foo.getSuperClass().getTypeDeclaration().getName());
+        assertEquals(Collections.emptyList(), foo.getSuperClass().typeParametersValues());
+    }
+
+    @Test
+    public void testGetSuperclassWithGenericSimple() {
+        class Foo<E> {
+            E field;
+        }
+        class Bar extends Foo<String> {
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+        ResolvedClassDeclaration bar = new ReflectionClassDeclaration(Bar.class, typeResolver);
+
+        assertEquals("Foo", bar.getSuperClass().getTypeDeclaration().getName());
+        assertEquals(1, bar.getSuperClass().typeParametersValues().size());
+        assertEquals(String.class.getCanonicalName(), bar.getSuperClass().typeParametersValues().get(0).asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithGenericInheritanceSameName() {
+        class Foo<E> {
+            E field;
+        }
+        class Bar<E> extends Foo<E> {
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+        ResolvedClassDeclaration bar = new ReflectionClassDeclaration(Bar.class, typeResolver);
+
+        assertEquals("Foo", bar.getSuperClass().getTypeDeclaration().getName());
+        assertEquals(1, bar.getSuperClass().typeParametersValues().size());
+        assertEquals(true, bar.getSuperClass().typeParametersValues().get(0).isTypeVariable());
+        assertEquals("E", bar.getSuperClass().typeParametersValues().get(0).asTypeParameter().getName());
+        assertEquals(true, bar.getSuperClass().typeParametersValues().get(0).asTypeParameter().declaredOnType());
+        assertEquals(false, bar.getSuperClass().typeParametersValues().get(0).asTypeParameter().declaredOnMethod());
+        assertTrue(bar.getSuperClass().typeParametersValues().get(0).asTypeParameter().getQualifiedName().endsWith("Bar.E"));
+    }
+
+    @Test
+    public void testGetSuperclassWithGenericInheritanceDifferentName() {
+        class Foo<E> {
+            E field;
+        }
+        class Bar extends Foo<String> {
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+        ResolvedClassDeclaration bar = new ReflectionClassDeclaration(Bar.class, typeResolver);
+
+        assertEquals(true, foo.isClass());
+        assertEquals(true, bar.isClass());
+    }
+
+    @Test
+    public void testGetFieldDeclarationTypeVariableInheritance() {
+        class Foo<E> {
+            E field;
+        }
+        class Bar extends Foo<String> {
+        }
+
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedReferenceTypeDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver);
+        ResolvedReferenceTypeDeclaration bar = new ReflectionClassDeclaration(Bar.class, typeResolver);
+
+        ResolvedFieldDeclaration fooField = foo.getField("field");
+        assertEquals(true, fooField.getType().isTypeVariable());
+        assertEquals("E", fooField.getType().asTypeParameter().getName());
+
+        ResolvedFieldDeclaration barField = bar.getField("field");
+        assertEquals(true, barField.getType().isReferenceType());
+        assertEquals(String.class.getCanonicalName(), barField.getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetDeclaredMethods() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedReferenceTypeDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver);
+        List<ResolvedMethodDeclaration> methods = string.getDeclaredMethods().stream()
+                .filter(m -> m.accessSpecifier() != AccessSpecifier.PRIVATE && m.accessSpecifier() != AccessSpecifier.DEFAULT)
+                .sorted((a, b) -> a.getName().compareTo(b.getName()))
+                .collect(Collectors.toList());
+        if (isJava9()) {
+            assertEquals(69, methods.size());
+        } else {
+            assertEquals(67, methods.size());
+        }
+        assertEquals("charAt", methods.get(0).getName());
+        assertEquals(false, methods.get(0).isAbstract());
+        assertEquals(1, methods.get(0).getNumberOfParams());
+        assertEquals("int", methods.get(0).getParam(0).getType().describe());
+        if (isJava9()) {
+            assertEquals("compareTo", methods.get(6).getName());
+            assertEquals(false, methods.get(6).isAbstract());
+            assertEquals(1, methods.get(6).getNumberOfParams());
+            assertEquals("java.lang.String", methods.get(6).getParam(0).getType().describe());
+        } else {
+            assertEquals("concat", methods.get(6).getName());
+            assertEquals(false, methods.get(6).isAbstract());
+            assertEquals(1, methods.get(6).getNumberOfParams());
+            assertEquals("java.lang.String", methods.get(6).getParam(0).getType().describe());
+        }
+    }
+
+    @Test
+    public void testGetInterfaces() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        // Serializable, Cloneable, List<E>, RandomAccess
+        assertEquals(ImmutableSet.of(Serializable.class.getCanonicalName(),
+                Cloneable.class.getCanonicalName(),
+                List.class.getCanonicalName(),
+                RandomAccess.class.getCanonicalName()),
+                arraylist.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfaces() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        // Serializable, Cloneable, Iterable<E>, Collection<E>, List<E>, RandomAccess
+        assertEquals(ImmutableSet.of(Serializable.class.getCanonicalName(),
+                Cloneable.class.getCanonicalName(),
+                List.class.getCanonicalName(),
+                RandomAccess.class.getCanonicalName(),
+                Collection.class.getCanonicalName(),
+                Iterable.class.getCanonicalName()),
+                arraylist.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclasses() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        assertEquals(ImmutableSet.of(Object.class.getCanonicalName(),
+                AbstractCollection.class.getCanonicalName(),
+                AbstractList.class.getCanonicalName()),
+                arraylist.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+        ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver);
+        assertEquals(ImmutableSet.of(Object.class.getCanonicalName()),
+                string.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetPackageName() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        assertEquals("java.util", arraylist.getPackageName());
+        ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver);
+        assertEquals("java.lang", string.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        assertEquals("ArrayList", arraylist.getClassName());
+        ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver);
+        assertEquals("String", string.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        assertEquals("java.util.ArrayList", arraylist.getQualifiedName());
+        ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver);
+        assertEquals("java.lang.String", string.getQualifiedName());
+    }
+
+    // solveMethod
+    // isAssignableBy
+    // canBeAssignedTo
+    // hasField
+    // solveSymbol
+    // solveType
+    // getDeclaredMethods
+    // getAllMethods
+
+    @Test
+    public void testGetAllFields() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        assertEquals(ImmutableSet.of("modCount", "serialVersionUID", "MAX_ARRAY_SIZE", "size", "elementData", "EMPTY_ELEMENTDATA", "DEFAULTCAPACITY_EMPTY_ELEMENTDATA", "DEFAULT_CAPACITY"),
+                arraylist.getAllFields().stream().map(ResolvedDeclaration::getName).collect(Collectors.toSet()));
+    }
+
+    ///
+    /// Test ancestors
+    ///    
+
+    @Test
+    public void testAllAncestors() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver);
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        arraylist.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(9, ancestors.size());
+
+        ResolvedTypeVariable typeVariable = 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(typeVariable), typeResolver), ancestors.get("java.util.AbstractCollection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(List.class, typeResolver), ImmutableList.of(typeVariable), 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(typeVariable), typeResolver), ancestors.get("java.util.Collection"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(AbstractList.class, typeResolver), ImmutableList.of(typeVariable), 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(typeVariable), typeResolver), ancestors.get("java.lang.Iterable"));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Serializable.class, typeResolver), typeResolver), ancestors.get("java.io.Serializable"));
+    }
+
+    @Test
+    public void testGetSuperclassWithoutTypeParameters() {
+        ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals("com.github.javaparser.ast.Node", compilationUnit.getSuperClass().getQualifiedName());
+    }
+
+    @Test
+    public void testGetSuperclassWithTypeParameters() {
+        ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals("com.github.javaparser.ast.body.CallableDeclaration", compilationUnit.getSuperClass().getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", compilationUnit.getSuperClass().typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.CallableDeclaration.T").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithoutTypeParameters() {
+        ReflectionClassDeclaration cu = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.Node", "java.lang.Object"), cu.getAllSuperClasses().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllSuperclassesWithTypeParameters() {
+        ReflectionClassDeclaration constructorDeclaration = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(4, constructorDeclaration.getAllSuperClasses().size());
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.body.CallableDeclaration")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.body.BodyDeclaration")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("com.github.javaparser.ast.Node")));
+        assertEquals(true, constructorDeclaration.getAllSuperClasses().stream().anyMatch(s -> s.getQualifiedName().equals("java.lang.Object")));
+
+        ResolvedReferenceType ancestor;
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(0);
+        assertEquals("com.github.javaparser.ast.body.CallableDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.CallableDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(1);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(2);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = constructorDeclaration.getAllSuperClasses().get(3);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetInterfacesWithoutParameters() {
+        ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of(), compilationUnit.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+
+        ReflectionClassDeclaration coid = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.nodeTypes.NodeWithExtends",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier",
+                "com.github.javaparser.ast.nodeTypes.NodeWithConstructors",
+                "com.github.javaparser.ast.nodeTypes.NodeWithImplements",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier",
+                "com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters",
+                "com.github.javaparser.resolution.Resolvable"),
+                coid.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetInterfacesWithParameters() {
+        ReflectionClassDeclaration constructorDeclaration = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        System.out.println(constructorDeclaration.getInterfaces().stream().map(t -> t.getQualifiedName()).collect(Collectors.toList()));
+        assertEquals(8, constructorDeclaration.getInterfaces().size());
+
+        ResolvedReferenceType interfaze;
+
+        interfaze = constructorDeclaration.getInterfaces().get(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getInterfaces().get(7);
+        assertEquals("com.github.javaparser.resolution.Resolvable", interfaze.getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllInterfacesWithoutParameters() {
+        ReflectionClassDeclaration compilationUnit = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.visitor.Visitable", "com.github.javaparser.ast.observer.Observable",
+                "com.github.javaparser.HasParentNode", "com.github.javaparser.ast.nodeTypes.NodeWithRange",
+                "com.github.javaparser.ast.nodeTypes.NodeWithTokenRange").stream().sorted().collect(Collectors.toList()),
+                compilationUnit.getAllInterfaces().stream().map(i -> i.getQualifiedName()).sorted().collect(Collectors.toList()));
+
+        ReflectionClassDeclaration coid = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ClassOrInterfaceDeclaration");
+        assertEquals(ImmutableSet.of("com.github.javaparser.ast.nodeTypes.NodeWithExtends",
+                "com.github.javaparser.ast.nodeTypes.NodeWithAnnotations",
+                "java.lang.Cloneable",
+                "com.github.javaparser.HasParentNode",
+                "com.github.javaparser.ast.visitor.Visitable",
+                "com.github.javaparser.ast.nodeTypes.NodeWithImplements",
+                "com.github.javaparser.ast.nodeTypes.NodeWithSimpleName",
+                "com.github.javaparser.ast.nodeTypes.NodeWithModifiers",
+                "com.github.javaparser.ast.nodeTypes.NodeWithJavadoc",
+                "com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters",
+                "com.github.javaparser.ast.nodeTypes.NodeWithMembers",
+                "com.github.javaparser.ast.observer.Observable",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStaticModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers",
+                "com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier",
+                "com.github.javaparser.ast.nodeTypes.NodeWithRange",
+                "com.github.javaparser.ast.nodeTypes.NodeWithTokenRange",
+                "com.github.javaparser.ast.nodeTypes.NodeWithConstructors",
+                "com.github.javaparser.resolution.Resolvable"), coid.getAllInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllInterfacesWithParameters() {
+        ReflectionClassDeclaration constructorDeclaration = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        List<ResolvedReferenceType> interfaces = constructorDeclaration.getAllInterfaces();
+        assertEquals(34, interfaces.size());
+
+        ResolvedReferenceType interfaze;
+        int i = 0;
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.resolution.Resolvable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("java.lang.Cloneable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.HasParentNode", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.HasParentNode.T").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.observer.Observable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.visitor.Visitable", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithRange", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithRange.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTokenRange", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTokenRange.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", interfaze.getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStaticModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStaticModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier.N").get().asReferenceType().getQualifiedName());
+
+        interfaze = constructorDeclaration.getAllInterfaces().get(i++);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier", interfaze.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", interfaze.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier.N").get().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void testGetAncestorsWithTypeParameters() {
+        ReflectionClassDeclaration constructorDeclaration = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+        assertEquals(9, constructorDeclaration.getAncestors().size());
+
+        ResolvedReferenceType ancestor;
+        List<ResolvedReferenceType> ancestors = constructorDeclaration.getAncestors();
+        ancestors.sort(Comparator.comparing(ResolvedReferenceType::getQualifiedName));
+
+        ancestor = ancestors.get(0);
+        assertEquals("com.github.javaparser.ast.body.CallableDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.CallableDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(1);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(2);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(3);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(4);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(5);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(6);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(7);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.get(8);
+        assertEquals("com.github.javaparser.resolution.Resolvable", ancestor.getQualifiedName());
+    }
+
+    @Test
+    public void testGetAllAncestorsWithoutTypeParameters() {
+        ReflectionClassDeclaration cu = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.CompilationUnit");
+        assertEquals(ImmutableSet.of("java.lang.Cloneable", "com.github.javaparser.ast.visitor.Visitable",
+                "com.github.javaparser.ast.observer.Observable", "com.github.javaparser.ast.Node",
+                "com.github.javaparser.ast.nodeTypes.NodeWithTokenRange", "java.lang.Object", "com.github.javaparser.HasParentNode",
+                "com.github.javaparser.ast.nodeTypes.NodeWithRange"), cu.getAllAncestors().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet()));
+    }
+
+    @Test
+    public void testGetAllAncestorsWithTypeParameters() {
+        ReflectionClassDeclaration constructorDeclaration = (ReflectionClassDeclaration) typeResolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        ResolvedReferenceType ancestor;
+        List<ResolvedReferenceType> ancestors = constructorDeclaration.getAllAncestors();
+        ancestors.sort(Comparator.comparing(ResolvedReferenceType::getQualifiedName));
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.HasParentNode", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.HasParentNode.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.Node", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.body.BodyDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.BodyDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.body.CallableDeclaration", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.body.CallableDeclaration.T").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithAnnotations.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithBlockStmt.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithDeclaration", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithJavadoc.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithModifiers.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithRange", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithRange.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithSimpleName.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithThrownExceptions.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTokenRange", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.Node", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTokenRange.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.NodeWithTypeParameters.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAbstractModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithFinalModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPrivateModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithProtectedModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithPublicModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStaticModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStaticModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier", ancestor.getQualifiedName());
+        assertEquals("com.github.javaparser.ast.body.ConstructorDeclaration", ancestor.typeParametersMap().getValueBySignature("com.github.javaparser.ast.nodeTypes.modifiers.NodeWithStrictfpModifier.N").get().asReferenceType().getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.observer.Observable", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.ast.visitor.Visitable", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("com.github.javaparser.resolution.Resolvable", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("java.lang.Cloneable", ancestor.getQualifiedName());
+
+        ancestor = ancestors.remove(0);
+        assertEquals("java.lang.Object", ancestor.getQualifiedName());
+
+        assertTrue(ancestors.isEmpty());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionEnumDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionEnumDeclarationTest.java
new file mode 100644
index 000000000..00379b0ba
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionEnumDeclarationTest.java
@@ -0,0 +1,106 @@
+/*
+ * 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.reflectionmodel;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ReflectionEnumDeclarationTest extends AbstractTest {
+
+    private TypeSolver typeSolver = new ReflectionTypeSolver(false);
+
+    ///
+    /// Test misc
+    ///
+
+    @Test
+    public void testIsClass() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isClass());
+    }
+
+    @Test
+    public void testIsInterface() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isInterface());
+    }
+
+    @Test
+    public void testIsEnum() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isEnum());
+    }
+
+    @Test
+    public void testIsTypeVariable() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(false, modifier.isTypeParameter());
+    }
+
+    @Test
+    public void testIsType() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(true, modifier.isType());
+    }
+
+    @Test
+    public void testAsType() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asType());
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsClass() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asClass();
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testAsInterface() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        modifier.asInterface();
+    }
+
+    @Test
+    public void testAsEnum() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals(modifier, modifier.asEnum());
+    }
+
+    @Test
+    public void testGetPackageName() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast", modifier.getPackageName());
+    }
+
+    @Test
+    public void testGetClassName() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("Modifier", modifier.getClassName());
+    }
+
+    @Test
+    public void testGetQualifiedName() {
+        ReflectionEnumDeclaration modifier = (ReflectionEnumDeclaration) typeSolver.solveType("com.github.javaparser.ast.Modifier");
+        assertEquals("com.github.javaparser.ast.Modifier", modifier.getQualifiedName());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclarationTest.java
new file mode 100644
index 000000000..a52661078
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclarationTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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.reflectionmodel;
+
+import com.github.javaparser.resolution.declarations.ResolvedInterfaceDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedTypeVariable;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+
+public class ReflectionInterfaceDeclarationTest extends AbstractTest {
+
+    @Test
+    public void testGetDeclaredMethods() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedReferenceTypeDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver);
+        List<ResolvedMethodDeclaration> methods = list.getDeclaredMethods().stream()
+                .sorted((a, b) -> a.getName().compareTo(b.getName()))
+                .collect(Collectors.toList());
+        if (isJava9()) {
+            assertEquals(40, methods.size());
+            assertEquals("clear", methods.get(4).getName());
+            assertEquals(true, methods.get(4).isAbstract());
+            assertEquals(0, methods.get(4).getNumberOfParams());
+            assertEquals("contains", methods.get(5).getName());
+            assertEquals(true, methods.get(5).isAbstract());
+            assertEquals(1, methods.get(5).getNumberOfParams());
+            assertEquals(true, methods.get(5).getParam(0).getType().isReferenceType());
+            assertEquals(Object.class.getCanonicalName(), methods.get(5).getParam(0).getType().asReferenceType().getQualifiedName());
+        } else {
+            assertEquals(28, methods.size());
+            assertEquals("clear", methods.get(4).getName());
+            assertEquals(true, methods.get(4).isAbstract());
+            assertEquals(0, methods.get(4).getNumberOfParams());
+            assertEquals("contains", methods.get(5).getName());
+            assertEquals(true, methods.get(5).isAbstract());
+            assertEquals(1, methods.get(5).getNumberOfParams());
+            assertEquals(true, methods.get(5).getParam(0).getType().isReferenceType());
+            assertEquals(Object.class.getCanonicalName(), methods.get(5).getParam(0).getType().asReferenceType().getQualifiedName());
+        }
+    }
+
+    @Test
+    public void testAllAncestors() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+        ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver);
+        Map<String, ResolvedReferenceType> ancestors = new HashMap<>();
+        list.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a));
+        assertEquals(3, ancestors.size());
+
+        ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(list.getTypeParameters().get(0));
+        assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(typeVariable), 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(typeVariable), typeResolver), ancestors.get("java.lang.Iterable"));
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionMethodDeclarationTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionMethodDeclarationTest.java
new file mode 100644
index 000000000..8a5be170f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/reflectionmodel/ReflectionMethodDeclarationTest.java
@@ -0,0 +1,78 @@
+/*
+ * 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.reflectionmodel;
+
+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.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class ReflectionMethodDeclarationTest {
+
+    @Test
+    public void testGetSignature() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedClassDeclaration object = new ReflectionClassDeclaration(Object.class, typeResolver);
+        ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver);
+
+        ResolvedMethodDeclaration hashCode = object.getAllMethods().stream().filter(m -> m.getName().equals("hashCode")).findFirst().get().getDeclaration();
+        ResolvedMethodDeclaration equals = object.getAllMethods().stream().filter(m -> m.getName().equals("equals")).findFirst().get().getDeclaration();
+        ResolvedMethodDeclaration containsAll = list.getAllMethods().stream().filter(m -> m.getName().equals("containsAll")).findFirst().get().getDeclaration();
+        ResolvedMethodDeclaration subList = list.getAllMethods().stream().filter(m -> m.getName().equals("subList")).findFirst().get().getDeclaration();
+
+        assertEquals("hashCode()", hashCode.getSignature());
+        assertEquals("equals(java.lang.Object)", equals.getSignature());
+        assertEquals("containsAll(java.util.Collection<? extends java.lang.Object>)", containsAll.getSignature());
+        assertEquals("subList(int, int)", subList.getSignature());
+    }
+
+    @Test
+    public void testGetGenericReturnType() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedInterfaceDeclaration map = new ReflectionInterfaceDeclaration(Map.class, typeResolver);
+
+        ResolvedMethodDeclaration put = map.getAllMethods().stream().filter(m -> m.getName().equals("put")).findFirst().get().getDeclaration();
+        assertEquals(true, put.getReturnType().isTypeVariable());
+        assertEquals(true, put.getReturnType().asTypeParameter().declaredOnType());
+        assertEquals("java.util.Map.V", put.getReturnType().asTypeParameter().getQualifiedName());
+    }
+
+    @Test
+    public void testGetGenericParameters() {
+        TypeSolver typeResolver = new ReflectionTypeSolver();
+
+        ResolvedInterfaceDeclaration map = new ReflectionInterfaceDeclaration(Map.class, typeResolver);
+
+        ResolvedMethodDeclaration put = map.getAllMethods().stream().filter(m -> m.getName().equals("put")).findFirst().get().getDeclaration();
+        assertEquals(true, put.getParam(0).getType().isTypeVariable());
+        assertEquals(true, put.getParam(0).getType().asTypeParameter().declaredOnType());
+        assertEquals("java.util.Map.K", put.getParam(0).getType().asTypeParameter().getQualifiedName());
+
+        assertEquals(true, put.getParam(1).getType().isTypeVariable());
+        assertEquals(true, put.getParam(1).getType().asTypeParameter().declaredOnType());
+        assertEquals("java.util.Map.V", put.getParam(1).getType().asTypeParameter().getQualifiedName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AbstractResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AbstractResolutionTest.java
new file mode 100644
index 000000000..ded9267d8
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AbstractResolutionTest.java
@@ -0,0 +1,46 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.symbolsolver.AbstractTest;
+
+import java.io.InputStream;
+
+/**
+ * @author Federico Tomassetti
+ */
+public abstract class AbstractResolutionTest extends AbstractTest {
+
+    protected CompilationUnit parseSampleWithStandardExtension(String sampleName) {
+        return parseSample(sampleName, "java");
+    }
+
+    protected CompilationUnit parseSample(String sampleName) {
+        return parseSample(sampleName, "java.txt");
+    }
+
+    private CompilationUnit parseSample(String sampleName, String extension) {
+        InputStream is = this.getClass().getClassLoader().getResourceAsStream(sampleName + "." + extension);
+        if (is == null) {
+            throw new RuntimeException("Unable to find sample " + sampleName);
+        }
+        return JavaParser.parse(is);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaParserTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaParserTest.java
new file mode 100644
index 000000000..7b9f61b29
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaParserTest.java
@@ -0,0 +1,267 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.SlowTest;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.SourceFileInfoExtractor;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+@Category(SlowTest.class)
+public class AnalyseJavaParserTest extends AbstractTest {
+
+    private static final File src = adaptPath(new File("src/test/test_sourcecode/javaparser_src/proper_source"));
+
+    private SourceFileInfoExtractor getSourceFileInfoExtractor() {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_src/generated"))));
+        SourceFileInfoExtractor sourceFileInfoExtractor = new SourceFileInfoExtractor();
+        sourceFileInfoExtractor.setTypeSolver(combinedTypeSolver);
+        sourceFileInfoExtractor.setPrintFileName(false);
+        return sourceFileInfoExtractor;
+    }
+
+    static String readFile(File file)
+            throws IOException {
+        byte[] encoded = Files.readAllBytes(Paths.get(file.getAbsolutePath()));
+        return new String(encoded, StandardCharsets.UTF_8);
+    }
+
+    private static final boolean DEBUG = true;
+
+    private void parse(String fileName) throws IOException, ParseException {
+        File sourceFile = new File(src.getAbsolutePath() + "/" + fileName + ".java");
+        SourceFileInfoExtractor sourceFileInfoExtractor = getSourceFileInfoExtractor();
+        OutputStream outErrStream = new ByteArrayOutputStream();
+        PrintStream outErr = new PrintStream(outErrStream);
+
+        sourceFileInfoExtractor.setOut(outErr);
+        sourceFileInfoExtractor.setErr(outErr);
+        sourceFileInfoExtractor.solve(sourceFile);
+        String output = outErrStream.toString();
+
+        String path = "src/test/resources/javaparser_expected_output/" + fileName.replaceAll("/", "_") + ".txt";
+        File dstFile = adaptPath(new File(path));
+
+        if (DEBUG && (sourceFileInfoExtractor.getKo() != 0 || sourceFileInfoExtractor.getUnsupported() != 0)) {
+            System.err.println(output);
+        }
+
+        assertTrue("No failures expected when analyzing " + path, 0 == sourceFileInfoExtractor.getKo());
+        assertTrue("No UnsupportedOperationException expected when analyzing " + path, 0 == sourceFileInfoExtractor.getUnsupported());
+
+        String expected = readFile(dstFile);
+
+        String[] outputLines = output.split("\n");
+        String[] expectedLines = expected.split("\n");
+
+        for (int i = 0; i < Math.min(outputLines.length, expectedLines.length); i++) {
+            assertEquals("Line " + (i + 1) + " of " + path + " is different from what is expected", expectedLines[i].trim(), outputLines[i].trim());
+        }
+
+        assertEquals(expectedLines.length, outputLines.length);
+
+        JavaParserFacade.clearInstances();
+
+        // If we need to update the file uncomment these lines
+        //PrintWriter writer = new PrintWriter(dstFile.getAbsoluteFile(), "UTF-8");
+        //writer.print(output);
+        //writer.close();
+    }
+
+    @Test
+    public void parsePositionUtils() throws IOException, ParseException {
+        parse("com/github/javaparser/PositionUtils");
+    }
+
+    @Test
+    public void parseJavaParser() throws IOException, ParseException {
+        parse("com/github/javaparser/JavaParser");
+    }
+
+    @Test
+    public void parseStatement() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/stmt/Statement");
+    }
+
+    @Test
+    public void parseCatchClause() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/stmt/CatchClause");
+    }
+
+    @Test
+    public void parseStatements() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/stmt/LabeledStmt");
+        parse("com/github/javaparser/ast/stmt/BreakStmt");
+        parse("com/github/javaparser/ast/stmt/ReturnStmt");
+        parse("com/github/javaparser/ast/stmt/DoStmt");
+        parse("com/github/javaparser/ast/stmt/AssertStmt");
+        parse("com/github/javaparser/ast/stmt/ContinueStmt");
+        parse("com/github/javaparser/ast/stmt/BlockStmt");
+        parse("com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt");
+        parse("com/github/javaparser/ast/stmt/ExpressionStmt");
+        parse("com/github/javaparser/ast/stmt/EmptyStmt");
+        parse("com/github/javaparser/ast/stmt/SwitchStmt");
+        parse("com/github/javaparser/ast/stmt/IfStmt");
+        parse("com/github/javaparser/ast/stmt/SwitchEntryStmt");
+        parse("com/github/javaparser/ast/stmt/SynchronizedStmt");
+        parse("com/github/javaparser/ast/stmt/ForeachStmt");
+        parse("com/github/javaparser/ast/stmt/ForStmt");
+        parse("com/github/javaparser/ast/stmt/WhileStmt");
+        parse("com/github/javaparser/ast/stmt/ThrowStmt");
+        parse("com/github/javaparser/ast/stmt/TryStmt");
+        parse("com/github/javaparser/ast/stmt/TypeDeclarationStmt");
+    }
+
+    @Test
+    public void parseExpressions() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/expr/NameExpr");
+        parse("com/github/javaparser/ast/expr/FieldAccessExpr");
+        parse("com/github/javaparser/ast/expr/CharLiteralExpr");
+        parse("com/github/javaparser/ast/expr/IntegerLiteralMinValueExpr");
+        parse("com/github/javaparser/ast/expr/IntegerLiteralExpr");
+        parse("com/github/javaparser/ast/expr/ArrayCreationExpr");
+        parse("com/github/javaparser/ast/expr/VariableDeclarationExpr");
+        parse("com/github/javaparser/ast/expr/SuperExpr");
+        parse("com/github/javaparser/ast/expr/ArrayInitializerExpr");
+        parse("com/github/javaparser/ast/expr/EnclosedExpr");
+        parse("com/github/javaparser/ast/expr/Expression");
+        parse("com/github/javaparser/ast/expr/SingleMemberAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/MethodReferenceExpr");
+        parse("com/github/javaparser/ast/expr/ThisExpr");
+        parse("com/github/javaparser/ast/expr/LiteralExpr");
+        parse("com/github/javaparser/ast/expr/AnnotationExpr");
+        parse("com/github/javaparser/ast/expr/InstanceOfExpr");
+        parse("com/github/javaparser/ast/expr/LongLiteralExpr");
+        parse("com/github/javaparser/ast/expr/StringLiteralExpr");
+        parse("com/github/javaparser/ast/expr/NullLiteralExpr");
+        parse("com/github/javaparser/ast/expr/ObjectCreationExpr");
+        parse("com/github/javaparser/ast/expr/TypeExpr");
+        parse("com/github/javaparser/ast/expr/DoubleLiteralExpr");
+        parse("com/github/javaparser/ast/expr/LongLiteralMinValueExpr");
+        parse("com/github/javaparser/ast/expr/MarkerAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/LambdaExpr");
+        parse("com/github/javaparser/ast/expr/AssignExpr");
+        parse("com/github/javaparser/ast/expr/NormalAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/QualifiedNameExpr");
+        parse("com/github/javaparser/ast/expr/MemberValuePair");
+        parse("com/github/javaparser/ast/expr/ArrayAccessExpr");
+        parse("com/github/javaparser/ast/expr/ClassExpr");
+        parse("com/github/javaparser/ast/expr/MethodCallExpr");
+        parse("com/github/javaparser/ast/expr/ConditionalExpr");
+        parse("com/github/javaparser/ast/expr/CastExpr");
+        parse("com/github/javaparser/ast/expr/BooleanLiteralExpr");
+        parse("com/github/javaparser/ast/expr/BinaryExpr");
+        parse("com/github/javaparser/ast/expr/UnaryExpr");
+    }
+
+    @Test
+    public void parseTypes() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/type/ClassOrInterfaceType");
+        parse("com/github/javaparser/ast/type/PrimitiveType");
+        parse("com/github/javaparser/ast/type/WildcardType");
+        parse("com/github/javaparser/ast/type/UnknownType");
+        parse("com/github/javaparser/ast/type/ReferenceType");
+        parse("com/github/javaparser/ast/type/VoidType");
+        parse("com/github/javaparser/ast/type/Type");
+    }
+
+    @Test
+    public void parseVisitors() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/visitor/EqualsVisitor");
+        parse("com/github/javaparser/ast/visitor/ModifierVisitorAdapter");
+        parse("com/github/javaparser/ast/visitor/DumpVisitor");
+        parse("com/github/javaparser/ast/visitor/VoidVisitor");
+        parse("com/github/javaparser/ast/visitor/GenericVisitor");
+        parse("com/github/javaparser/ast/visitor/VoidVisitorAdapter");
+        parse("com/github/javaparser/ast/visitor/GenericVisitorAdapter");
+    }
+
+    @Test
+    public void parseCloneVisitor() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/visitor/CloneVisitor");
+    }
+
+    @Test
+    public void parseSourcesHelper() throws IOException, ParseException {
+        parse("com/github/javaparser/SourcesHelper");
+    }
+
+    @Test
+    public void parseComments() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/comments/LineComment");
+        parse("com/github/javaparser/ast/comments/Comment");
+        parse("com/github/javaparser/ast/comments/CommentsParser");
+        parse("com/github/javaparser/ast/comments/JavadocComment");
+        parse("com/github/javaparser/ast/comments/BlockComment");
+        parse("com/github/javaparser/ast/comments/CommentsCollection");
+    }
+
+    @Test
+    public void parseTheRest() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/internal/Utils");
+        parse("com/github/javaparser/ast/body/AnnotationMemberDeclaration");
+        parse("com/github/javaparser/ast/body/EnumDeclaration");
+        parse("com/github/javaparser/ast/body/Parameter");
+        parse("com/github/javaparser/ast/body/EnumConstantDeclaration");
+        parse("com/github/javaparser/ast/body/VariableDeclarator");
+        parse("com/github/javaparser/ast/body/TypeDeclaration");
+        parse("com/github/javaparser/ast/body/EmptyMemberDeclaration");
+        parse("com/github/javaparser/ast/body/ModifierSet");
+        parse("com/github/javaparser/ast/body/VariableDeclaratorId");
+        parse("com/github/javaparser/ast/body/BaseParameter");
+        parse("com/github/javaparser/ast/body/AnnotableNode");
+        parse("com/github/javaparser/ast/body/AnnotationDeclaration");
+        parse("com/github/javaparser/ast/body/MethodDeclaration");
+        parse("com/github/javaparser/ast/body/EmptyTypeDeclaration");
+        parse("com/github/javaparser/ast/body/InitializerDeclaration");
+        parse("com/github/javaparser/ast/body/BodyDeclaration");
+        parse("com/github/javaparser/ast/body/FieldDeclaration");
+        parse("com/github/javaparser/ast/body/ConstructorDeclaration");
+        parse("com/github/javaparser/ast/body/WithDeclaration");
+        parse("com/github/javaparser/ast/body/MultiTypeParameter");
+        parse("com/github/javaparser/ast/body/ClassOrInterfaceDeclaration");
+        parse("com/github/javaparser/ast/TreeVisitor");
+        parse("com/github/javaparser/ast/PackageDeclaration");
+        parse("com/github/javaparser/ast/DocumentableNode");
+        parse("com/github/javaparser/ast/NamedNode");
+        parse("com/github/javaparser/ast/Node");
+        parse("com/github/javaparser/ast/AccessSpecifier");
+        parse("com/github/javaparser/ast/CompilationUnit");
+        parse("com/github/javaparser/ast/TypeParameter");
+        parse("com/github/javaparser/ast/ImportDeclaration");
+        parse("com/github/javaparser/Position");
+        parse("com/github/javaparser/ASTHelper");
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaSymbolSolver060Test.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaSymbolSolver060Test.java
new file mode 100644
index 000000000..1cce12aa8
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseJavaSymbolSolver060Test.java
@@ -0,0 +1,349 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.SlowTest;
+import com.github.javaparser.symbolsolver.SourceFileInfoExtractor;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * We analyze JavaParser version 0.6.0.
+ */
+@Category(SlowTest.class)
+public class AnalyseJavaSymbolSolver060Test extends AbstractResolutionTest {
+
+    private static final File root = adaptPath(new File("src/test/resources/javasymbolsolver_0_6_0"));
+    private static final File src = adaptPath(new File(root + "/src"));
+    private static final File lib = adaptPath(new File(root + "/lib"));
+    private static final File expectedOutput = adaptPath(new File(root + "/expected_output"));
+
+    private static SourceFileInfoExtractor getSourceFileInfoExtractor() {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(new File(src + "/java-symbol-solver-core")));
+        combinedTypeSolver.add(new JavaParserTypeSolver(new File(src + "/java-symbol-solver-logic")));
+        combinedTypeSolver.add(new JavaParserTypeSolver(new File(src + "/java-symbol-solver-model")));
+        try {
+			combinedTypeSolver.add(new JarTypeSolver(lib + "/guava-21.0.jar"));
+			combinedTypeSolver.add(new JarTypeSolver(lib + "/javaparser-core-3.3.0.jar"));
+			combinedTypeSolver.add(new JarTypeSolver(lib + "/javaslang-2.0.3.jar"));
+			combinedTypeSolver.add(new JarTypeSolver(lib + "/javassist-3.19.0-GA.jar"));
+		} catch (IOException e) {
+			Assert.fail("one or more jar dependencies could not be found.");
+			e.printStackTrace();
+		}
+        SourceFileInfoExtractor sourceFileInfoExtractor = new SourceFileInfoExtractor();
+        sourceFileInfoExtractor.setTypeSolver(combinedTypeSolver);
+        sourceFileInfoExtractor.setPrintFileName(false);
+        sourceFileInfoExtractor.setVerbose(true);
+        return sourceFileInfoExtractor;
+    }
+
+    private static SourceFileInfoExtractor sourceFileInfoExtractor = getSourceFileInfoExtractor();
+
+    static String readFile(File file)
+            throws IOException {
+        byte[] encoded = Files.readAllBytes(Paths.get(file.getAbsolutePath()));
+        return new String(encoded, StandardCharsets.UTF_8);
+    }
+
+    private static final boolean DEBUG = true;
+
+    /**
+     * @param projectName is one of "java-symbol-solver-core", "java-symbol-solver-logic", "java-symbol-solver-model"
+     * @param fileName describes the file being analyzed
+     * @throws IOException
+     * @throws ParseException
+     */
+    private void parse(String projectName, String fileName) throws IOException, ParseException {
+        File sourceFile = new File(src.getAbsolutePath() + "/" + projectName + "/" + fileName + ".java");
+        OutputStream outErrStream = new ByteArrayOutputStream();
+        PrintStream outErr = new PrintStream(outErrStream);
+
+        sourceFileInfoExtractor.setOut(outErr);
+        sourceFileInfoExtractor.setErr(outErr);
+        sourceFileInfoExtractor.solveMethodCalls(sourceFile);
+        String output = outErrStream.toString();
+
+        String path = adaptPath(expectedOutput).getPath() + "/" + projectName + "/" + fileName.replaceAll("/", "_") + ".txt";
+        File dstFile = new File(path);
+
+        if (isJava9()) {
+            String path9 = adaptPath(expectedOutput).getPath() + "/" + projectName + "/" + fileName.replaceAll("/", "_") + "_J9.txt";
+            File dstFile9 = new File(path9);
+            if (dstFile9.exists()) {
+                path = path9;
+                dstFile = dstFile9;
+            }
+        }
+
+        if (DEBUG && (sourceFileInfoExtractor.getKo() != 0 || sourceFileInfoExtractor.getUnsupported() != 0)) {
+            System.err.println(output);
+        }
+
+        assertTrue("No failures expected when analyzing " + path, 0 == sourceFileInfoExtractor.getKo());
+        assertTrue("No UnsupportedOperationException expected when analyzing " + path, 0 == sourceFileInfoExtractor.getUnsupported());
+
+        if (!dstFile.exists()) {
+            // If we need to update the file uncomment these lines
+//            PrintWriter writer = new PrintWriter(dstFile.getAbsoluteFile(), "UTF-8");
+//            writer.print(output);
+//            writer.close();
+        }
+
+        String expected = readFile(dstFile);
+
+        String[] outputLines = output.split("\n");
+        String[] expectedLines = expected.split("\n");
+
+        for (int i = 0; i < Math.min(outputLines.length, expectedLines.length); i++) {
+            assertEquals("Line " + (i + 1) + " of " + path + " is different from what is expected", expectedLines[i].trim(), outputLines[i].trim());
+        }
+
+        assertEquals(expectedLines.length, outputLines.length);
+
+        JavaParserFacade.clearInstances();
+    }
+
+    @Test
+    public void parseCoreSourceFileInfoExtractor() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/SourceFileInfoExtractor");
+    }
+
+    @Test
+    public void parseCoreCoreResolution() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/core/resolution/Context");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/core/resolution/ContextHelper");
+    }
+
+    @Test
+    public void parseCoreDeclarationsCommon() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/declarations/common/MethodDeclarationCommonLogic");
+    }
+
+    @Test
+    public void parseCoreJavaparserNavigator() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparser/Navigator");
+    }
+
+    @Test
+    public void parseCoreJavaparsermodel() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/DefaultVisitorAdapter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFacade");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/JavaParserFactory");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/LambdaArgumentTypePlaceholder");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/TypeExtractor");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/UnsolvedSymbolException");
+    }
+
+    @Test
+    public void parseCoreJavaparsermodelContexts() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/AbstractJavaParserContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/AbstractMethodLikeDeclarationContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/AnonymousClassDeclarationContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/CatchClauseContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/ClassOrInterfaceDeclarationContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/CompilationUnitContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/ConstructorContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/ContextHelper");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/EnumDeclarationContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/FieldAccessContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForechStatementContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/ForStatementContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/JavaParserTypeDeclarationAdapter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/LambdaExprContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodCallExprContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/MethodContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/StatementContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/SwitchEntryContext");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/contexts/TryWithResourceContext");
+    }
+
+    @Test
+    public void parseCoreJavaparsermodelDeclarations() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/DefaultConstructorDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/Helper");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnnotationDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserAnonymousClassDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserClassDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserConstructorDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumConstantDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserEnumDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserFieldDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserInterfaceDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserMethodDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserParameterDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserSymbolDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeAdapter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeParameter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarations/JavaParserTypeVariableDeclaration");
+    }
+
+    @Test
+    public void parseCoreJavaparsermodelDeclarators() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarators/AbstractSymbolDeclarator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarators/FieldSymbolDeclarator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarators/NoSymbolDeclarator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarators/ParameterSymbolDeclarator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javaparsermodel/declarators/VariableSymbolDeclarator");
+    }
+
+    @Test
+    public void parseCoreJavassistmodel() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistClassDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistConstructorDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistEnumDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistFactory");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistFieldDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistInterfaceDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistMethodDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistParameterDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistTypeDeclarationAdapter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistTypeParameter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/javassistmodel/JavassistUtils");
+    }
+
+    @Test
+    public void parseCoreModelTypesystem() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/model/typesystem/LazyType");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/model/typesystem/ReferenceTypeImpl");
+    }
+
+    @Test
+    public void parseCoreReflectionmodel() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/MyObjectProvider");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionClassAdapter");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionClassDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionConstructorDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionEnumDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFactory");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionFieldDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionInterfaceDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionMethodDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionMethodResolutionLogic");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionParameterDeclaration");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/ReflectionTypeParameter");
+    }
+
+    @Test
+    public void parseCoreReflectionmodelComparators() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/comparators/ClassComparator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/comparators/MethodComparator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/reflectionmodel/comparators/ParameterComparator");
+    }
+
+    @Test
+    public void parseCoreResolution() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/ConstructorResolutionLogic");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/MethodResolutionLogic");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/SymbolDeclarator");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/SymbolSolver");
+    }
+
+    @Test
+    public void parseCoreResolutionTypesolvers() throws IOException, ParseException {
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/typesolvers/CombinedTypeSolver");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/typesolvers/JarTypeSolver");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/typesolvers/JavaParserTypeSolver");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/typesolvers/MemoryTypeSolver");
+        parse("java-symbol-solver-core", "com/github/javaparser/symbolsolver/resolution/typesolvers/ReflectionTypeSolver");
+    }
+
+    @Test
+    public void parseLogic() throws IOException, ParseException {
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/AbstractClassDeclaration");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/AbstractTypeDeclaration");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/ConfilictingGenericTypesException");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/FunctionalInterfaceLogic");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/InferenceContext");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/InferenceVariableType");
+		parse("java-symbol-solver-logic", "com/github/javaparser/symbolsolver/logic/ObjectProvider");
+    }
+
+    @Test
+    public void parseModelDeclarations() throws IOException, ParseException {
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/AccessLevel");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/AnnotationDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/ClassDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/ConstructorDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/Declaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/EnumDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/FieldDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/HasAccessLevel");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/InterfaceDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/MethodAmbiguityException");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/MethodDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/MethodLikeDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/ParameterDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/ReferenceTypeDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/TypeDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/TypeParameterDeclaration");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/TypeParametrizable");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/declarations/ValueDeclaration");
+    }
+
+    @Test
+    public void parseModelMethodsMethodUsage() throws IOException, ParseException {
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/methods/MethodUsage");
+    }
+
+    @Test
+    public void parseModelResolution() throws IOException, ParseException {
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/resolution/SymbolReference");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/resolution/TypeSolver");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/resolution/UnsolvedSymbolException");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/resolution/Value");
+    }
+
+    @Test
+    public void parseModelTypesystem() throws IOException, ParseException {
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/ArrayType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/LambdaConstraintType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/NullType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/PrimitiveType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/ReferenceType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/Type");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/TypeTransformer");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/TypeVariable");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/VoidType");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/Wildcard");
+    }
+
+    @Test
+    public void parseModelTypesystemParametrization() throws IOException, ParseException {
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/parametrization/TypeParametersMap");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/parametrization/TypeParameterValueProvider");
+        parse("java-symbol-solver-model", "com/github/javaparser/symbolsolver/model/typesystem/parametrization/TypeParametrized");
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserHelpersTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserHelpersTest.java
new file mode 100644
index 000000000..254609e0c
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserHelpersTest.java
@@ -0,0 +1,98 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * We analize a more recent version of JavaParser, after the project moved to Java 8.
+ */
+public class AnalyseNewJavaParserHelpersTest extends AbstractResolutionTest {
+
+    private static final File src = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+
+    private static TypeSolver TYPESOLVER = typeSolver();
+
+    private static TypeSolver typeSolver() {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        return combinedTypeSolver;
+    }
+
+    private CompilationUnit parse(String fileName) throws IOException {
+        File sourceFile = new File(src.getAbsolutePath() + "/" + fileName + ".java");
+        return JavaParser.parse(sourceFile);
+    }
+
+//    @Test
+//    public void o1TypeIsCorrect() throws IOException, ParseException {
+//        CompilationUnit cu = parse("com/github/javaparser/utils/PositionUtils");
+//        NameExpr o1 = Navigator.findAllNodesOfGivenClass(cu, NameExpr.class).stream().filter(it -> it.getName()!=null && it.getName().equals("o1")).findFirst().get();
+//        System.out.println(JavaParserFacade.get(TYPESOLVER).solve(o1).getCorrespondingDeclaration().getType());
+//    }
+//
+//    @Test
+//    public void o2TypeIsCorrect() throws IOException, ParseException {
+//        CompilationUnit cu = parse("com/github/javaparser/utils/PositionUtils");
+//        NameExpr o2 = Navigator.findAllNodesOfGivenClass(cu, NameExpr.class).stream().filter(it -> it.getName()!=null && it.getName().equals("o2")).findFirst().get();
+//        System.out.println(JavaParserFacade.get(TYPESOLVER).solve(o2).getCorrespondingDeclaration().getType());
+//    }
+//
+//    // To calculate the type of o1 and o2 I need to first calculate the type of the lambda
+//    @Test
+//    public void lambdaTypeIsCorrect() throws IOException, ParseException {
+//        CompilationUnit cu = parse("com/github/javaparser/utils/PositionUtils");
+//        LambdaExpr lambda = Navigator.findAllNodesOfGivenClass(cu, LambdaExpr.class).stream().filter(it -> it.getRange().begin.line == 50).findFirst().get();
+//        System.out.println(JavaParserFacade.get(TYPESOLVER).getType(lambda));
+//    }
+
+    @Test
+    public void nodesTypeIsCorrect() throws IOException {
+        CompilationUnit cu = parse("com/github/javaparser/utils/PositionUtils");
+        NameExpr nodes = cu.findAll(NameExpr.class).stream().filter(it -> it.getName() != null && it.getName().getId().equals("nodes")).findFirst().get();
+        ResolvedType type = JavaParserFacade.get(TYPESOLVER).solve(nodes).getCorrespondingDeclaration().getType();
+        assertEquals("java.util.List<T>", type.describe());
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals(true, type.asReferenceType().typeParametersValues().get(0).isTypeVariable());
+        assertEquals("T", type.asReferenceType().typeParametersValues().get(0).asTypeParameter().getName());
+        assertEquals("com.github.javaparser.utils.PositionUtils.sortByBeginPosition(java.util.List<T>).T", type.asReferenceType().typeParametersValues().get(0).asTypeParameter().getQualifiedName());
+        assertEquals(1, type.asReferenceType().typeParametersValues().get(0).asTypeParameter().getBounds().size());
+        ResolvedTypeParameterDeclaration.Bound bound = type.asReferenceType().typeParametersValues().get(0).asTypeParameter().getBounds().get(0);
+        assertEquals(true, bound.isExtends());
+        assertEquals("com.github.javaparser.ast.Node", bound.getType().describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserTest.java
new file mode 100644
index 000000000..53c0e040e
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/AnalyseNewJavaParserTest.java
@@ -0,0 +1,328 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.SlowTest;
+import com.github.javaparser.symbolsolver.SourceFileInfoExtractor;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * We analyze a more recent version of JavaParser, after the project moved to Java 8.
+ */
+@Category(SlowTest.class)
+public class AnalyseNewJavaParserTest extends AbstractResolutionTest {
+
+    private static final File src = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+
+    private static SourceFileInfoExtractor getSourceFileInfoExtractor() {
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        SourceFileInfoExtractor sourceFileInfoExtractor = new SourceFileInfoExtractor();
+        sourceFileInfoExtractor.setTypeSolver(combinedTypeSolver);
+        sourceFileInfoExtractor.setPrintFileName(false);
+        sourceFileInfoExtractor.setVerbose(true);
+        return sourceFileInfoExtractor;
+    }
+
+    private static SourceFileInfoExtractor sourceFileInfoExtractor = getSourceFileInfoExtractor();
+
+    static String readFile(File file)
+            throws IOException {
+        byte[] encoded = Files.readAllBytes(Paths.get(file.getAbsolutePath()));
+        return new String(encoded, StandardCharsets.UTF_8);
+    }
+
+    private static final boolean DEBUG = true;
+
+    private void parse(String fileName) throws IOException, ParseException {
+        File sourceFile = new File(src.getAbsolutePath() + "/" + fileName + ".java");
+        OutputStream outErrStream = new ByteArrayOutputStream();
+        PrintStream outErr = new PrintStream(outErrStream);
+
+        sourceFileInfoExtractor.setOut(outErr);
+        sourceFileInfoExtractor.setErr(outErr);
+        sourceFileInfoExtractor.solveMethodCalls(sourceFile);
+        String output = outErrStream.toString();
+
+        File expectedOutput = new File("src/test/resources/javaparser_methodcalls_expected_output");
+        String path = adaptPath(expectedOutput).getPath() + "/" + fileName.replaceAll("/", "_") + ".txt";
+        File dstFile = new File(path);
+
+        if (isJava9()) {
+            String path9 = adaptPath(expectedOutput).getPath() + "/" + fileName.replaceAll("/", "_") + "_J9.txt";
+            File dstFile9 = new File(path9);
+            if (dstFile9.exists()) {
+                path = path9;
+                dstFile = dstFile9;
+            }
+        }
+
+        if (DEBUG && (sourceFileInfoExtractor.getKo() != 0 || sourceFileInfoExtractor.getUnsupported() != 0)) {
+            System.err.println(output);
+        }
+
+        assertTrue("No failures expected when analyzing " + path, 0 == sourceFileInfoExtractor.getKo());
+        assertTrue("No UnsupportedOperationException expected when analyzing " + path, 0 == sourceFileInfoExtractor.getUnsupported());
+
+        if (!dstFile.exists()) {
+            // If we need to update the file uncomment these lines
+            PrintWriter writer = new PrintWriter(dstFile.getAbsoluteFile(), "UTF-8");
+            writer.print(output);
+            writer.close();
+        }
+
+        String expected = readFile(dstFile);
+
+        String[] outputLines = output.split("\n");
+        String[] expectedLines = expected.split("\n");
+
+        for (int i = 0; i < Math.min(outputLines.length, expectedLines.length); i++) {
+            assertEquals("Line " + (i + 1) + " of " + path + " is different from what is expected", expectedLines[i].trim(), outputLines[i].trim());
+        }
+
+        assertEquals(expectedLines.length, outputLines.length);
+
+        JavaParserFacade.clearInstances();
+    }
+
+    @Test
+    public void parseUtilsUtils() throws IOException, ParseException {
+        parse("com/github/javaparser/utils/Utils");
+    }
+
+    @Test
+    public void parseCommentsInserter() throws IOException, ParseException {
+        parse("com/github/javaparser/CommentsInserter");
+    }
+
+    @Test
+    public void parsePositionUtils() throws IOException, ParseException {
+        parse("com/github/javaparser/utils/PositionUtils");
+    }
+
+    @Test
+    public void parseModifier() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/Modifier");
+    }
+
+    @Test
+    public void parseNodeWithMembers() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithMembers");
+    }
+
+    @Test
+    public void parseAstStmts() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/stmt/AssertStmt");
+        parse("com/github/javaparser/ast/stmt/BlockStmt");
+        parse("com/github/javaparser/ast/stmt/BreakStmt");
+        parse("com/github/javaparser/ast/stmt/CatchClause");
+        parse("com/github/javaparser/ast/stmt/ContinueStmt");
+        parse("com/github/javaparser/ast/stmt/DoStmt");
+        parse("com/github/javaparser/ast/stmt/EmptyStmt");
+        parse("com/github/javaparser/ast/stmt/ExplicitConstructorInvocationStmt");
+        parse("com/github/javaparser/ast/stmt/ExpressionStmt");
+        parse("com/github/javaparser/ast/stmt/ForStmt");
+        parse("com/github/javaparser/ast/stmt/ForeachStmt");
+        parse("com/github/javaparser/ast/stmt/IfStmt");
+        parse("com/github/javaparser/ast/stmt/LabeledStmt");
+        parse("com/github/javaparser/ast/stmt/ReturnStmt");
+        parse("com/github/javaparser/ast/stmt/Statement");
+        parse("com/github/javaparser/ast/stmt/SwitchEntryStmt");
+        parse("com/github/javaparser/ast/stmt/SwitchStmt");
+        parse("com/github/javaparser/ast/stmt/SynchronizedStmt");
+        parse("com/github/javaparser/ast/stmt/ThrowStmt");
+        parse("com/github/javaparser/ast/stmt/TryStmt");
+        parse("com/github/javaparser/ast/stmt/TypeDeclarationStmt");
+        parse("com/github/javaparser/ast/stmt/WhileStmt");
+    }
+
+    @Test
+    public void parseAstExprs() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/expr/AnnotationExpr");
+        parse("com/github/javaparser/ast/expr/ArrayAccessExpr");
+        parse("com/github/javaparser/ast/expr/ArrayCreationExpr");
+        parse("com/github/javaparser/ast/expr/ArrayInitializerExpr");
+        parse("com/github/javaparser/ast/expr/AssignExpr");
+        parse("com/github/javaparser/ast/expr/BinaryExpr");
+        parse("com/github/javaparser/ast/expr/BooleanLiteralExpr");
+        parse("com/github/javaparser/ast/expr/CastExpr");
+        parse("com/github/javaparser/ast/expr/CharLiteralExpr");
+        parse("com/github/javaparser/ast/expr/ClassExpr");
+        parse("com/github/javaparser/ast/expr/ConditionalExpr");
+        parse("com/github/javaparser/ast/expr/DoubleLiteralExpr");
+        parse("com/github/javaparser/ast/expr/EnclosedExpr");
+        parse("com/github/javaparser/ast/expr/Expression");
+        parse("com/github/javaparser/ast/expr/FieldAccessExpr");
+        parse("com/github/javaparser/ast/expr/InstanceOfExpr");
+        parse("com/github/javaparser/ast/expr/IntegerLiteralExpr");
+        parse("com/github/javaparser/ast/expr/IntegerLiteralMinValueExpr");
+        parse("com/github/javaparser/ast/expr/LambdaExpr");
+        parse("com/github/javaparser/ast/expr/LiteralExpr");
+        parse("com/github/javaparser/ast/expr/LongLiteralExpr");
+        parse("com/github/javaparser/ast/expr/LongLiteralMinValueExpr");
+        parse("com/github/javaparser/ast/expr/MarkerAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/MemberValuePair");
+        parse("com/github/javaparser/ast/expr/MethodCallExpr");
+        parse("com/github/javaparser/ast/expr/MethodReferenceExpr");
+        parse("com/github/javaparser/ast/expr/NameExpr");
+        parse("com/github/javaparser/ast/expr/NormalAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/NullLiteralExpr");
+        parse("com/github/javaparser/ast/expr/ObjectCreationExpr");
+        parse("com/github/javaparser/ast/expr/QualifiedNameExpr");
+        parse("com/github/javaparser/ast/expr/SingleMemberAnnotationExpr");
+        parse("com/github/javaparser/ast/expr/StringLiteralExpr");
+        parse("com/github/javaparser/ast/expr/SuperExpr");
+        parse("com/github/javaparser/ast/expr/ThisExpr");
+        parse("com/github/javaparser/ast/expr/TypeExpr");
+        parse("com/github/javaparser/ast/expr/UnaryExpr");
+    }
+
+    @Test
+    public void parseVariableDeclarationExpr() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/expr/VariableDeclarationExpr");
+    }
+
+    @Test
+    public void parseAstBody() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/body/AnnotationDeclaration");
+        parse("com/github/javaparser/ast/body/AnnotationMemberDeclaration");
+        parse("com/github/javaparser/ast/body/BodyDeclaration");
+        parse("com/github/javaparser/ast/body/ClassOrInterfaceDeclaration");
+        parse("com/github/javaparser/ast/body/ConstructorDeclaration");
+        parse("com/github/javaparser/ast/body/EmptyMemberDeclaration");
+        parse("com/github/javaparser/ast/body/EmptyTypeDeclaration");
+        parse("com/github/javaparser/ast/body/EnumConstantDeclaration");
+        parse("com/github/javaparser/ast/body/EnumDeclaration");
+        parse("com/github/javaparser/ast/body/FieldDeclaration");
+        parse("com/github/javaparser/ast/body/InitializerDeclaration");
+        parse("com/github/javaparser/ast/body/MethodDeclaration");
+        parse("com/github/javaparser/ast/body/Parameter");
+        parse("com/github/javaparser/ast/body/TypeDeclaration");
+        parse("com/github/javaparser/ast/body/VariableDeclarator");
+        parse("com/github/javaparser/ast/body/VariableDeclaratorId");
+    }
+
+    @Test
+    public void parseAstComments() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/comments/BlockComment");
+        parse("com/github/javaparser/ast/comments/Comment");
+        parse("com/github/javaparser/ast/comments/CommentsCollection");
+        parse("com/github/javaparser/ast/comments/JavadocComment");
+        parse("com/github/javaparser/ast/comments/LineComment");
+    }
+
+    @Test
+    public void parseAstRest() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/AccessSpecifier");
+        parse("com/github/javaparser/ast/ArrayBracketPair");
+        parse("com/github/javaparser/ast/ArrayCreationLevel");
+        parse("com/github/javaparser/ast/CompilationUnit");
+        parse("com/github/javaparser/ast/Example");
+        parse("com/github/javaparser/ast/ImportDeclaration");
+        parse("com/github/javaparser/ast/Node");
+        parse("com/github/javaparser/ast/PackageDeclaration");
+        parse("com/github/javaparser/ast/UserDataKey");
+    }
+
+    @Test
+    public void parseAstNodeTypes() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithAnnotations");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithBlockStmt");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithBody");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithDeclaration");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithElementType");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithExtends");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithImplements");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithJavaDoc");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithModifiers");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithName");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithParameters");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithStatements");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithThrowable");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithType");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithTypeArguments");
+        parse("com/github/javaparser/ast/nodeTypes/NodeWithVariables");
+    }
+
+    @Test
+    public void parseAstTypes() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/type/ArrayType");
+        parse("com/github/javaparser/ast/type/ClassOrInterfaceType");
+        parse("com/github/javaparser/ast/type/IntersectionType");
+        parse("com/github/javaparser/ast/type/PrimitiveType");
+        parse("com/github/javaparser/ast/type/ReferenceType");
+        parse("com/github/javaparser/ast/type/Type");
+        parse("com/github/javaparser/ast/type/TypeParameter");
+        parse("com/github/javaparser/ast/type/UnionType");
+        parse("com/github/javaparser/ast/type/UnknownType");
+        parse("com/github/javaparser/ast/type/VoidType");
+        parse("com/github/javaparser/ast/type/WildcardType");
+    }
+
+    @Test
+    public void parseAstVisitor() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/visitor/CloneVisitor");
+        parse("com/github/javaparser/ast/visitor/EqualsVisitor");
+        parse("com/github/javaparser/ast/visitor/GenericVisitor");
+        parse("com/github/javaparser/ast/visitor/GenericVisitorAdapter");
+        parse("com/github/javaparser/ast/visitor/ModifierVisitorAdapter");
+        parse("com/github/javaparser/ast/visitor/TreeVisitor");
+        parse("com/github/javaparser/ast/visitor/VoidVisitor");
+        parse("com/github/javaparser/ast/visitor/VoidVisitorAdapter");
+    }
+
+    @Test
+    public void parseDumpVisitor() throws IOException, ParseException {
+        parse("com/github/javaparser/ast/visitor/DumpVisitor");
+    }
+
+    @Test
+    public void parseUtils() throws IOException, ParseException {
+        parse("com/github/javaparser/utils/ClassUtils");
+        parse("com/github/javaparser/utils/Pair");
+    }
+
+    @Test
+    public void parseAllOtherNodes() throws IOException, ParseException {
+        parse("com/github/javaparser/JavaParser");
+        parse("com/github/javaparser/ParseProblemException");
+        parse("com/github/javaparser/ParseResult");
+        parse("com/github/javaparser/ParseStart");
+        parse("com/github/javaparser/ParserConfiguration");
+        parse("com/github/javaparser/Position");
+        parse("com/github/javaparser/Problem");
+        parse("com/github/javaparser/Providers");
+        parse("com/github/javaparser/Range");
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ArrayExprTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ArrayExprTest.java
new file mode 100644
index 000000000..92b973396
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ArrayExprTest.java
@@ -0,0 +1,26 @@
+package com.github.javaparser.symbolsolver.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * See issue #17
+ */
+public class ArrayExprTest {
+
+    @Test
+    public void verifyAnArrayAccessExprTypeIsCalculatedProperly() {
+        String code = "class A { String[] arrSQL; String toExamine = arrSQL[1]; }";
+        FieldDeclaration field = JavaParser.parse(code).getClassByName("A").get().getFieldByName("toExamine").get();
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(field.getVariables().get(0).getInitializer().get());
+        assertEquals(true, type.isReferenceType());
+        assertEquals("java.lang.String", type.asReferenceType().getQualifiedName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ContextTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ContextTest.java
new file mode 100644
index 000000000..45cc56ea6
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/ContextTest.java
@@ -0,0 +1,475 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.AssignExpr;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedClassDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.*;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ContextTest extends AbstractTest {
+
+    private TypeSolver typeSolver = new CombinedTypeSolver(new MemoryTypeSolver(), new ReflectionTypeSolver());
+
+    private CompilationUnit parseSample(String sampleName) {
+        InputStream is = ContextTest.class.getClassLoader().getResourceAsStream(sampleName + ".java.txt");
+        return JavaParser.parse(is);
+    }
+
+    @Test
+    public void resolveDeclaredFieldReference() {
+        CompilationUnit cu = parseSample("ReferencesToField");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "ReferencesToField");
+        MethodDeclaration method1 = Navigator.demandMethod(referencesToField, "method1");
+        ExpressionStmt stmt = (ExpressionStmt) method1.getBody().get().getStatements().get(0);
+        AssignExpr assignExpr = (AssignExpr) stmt.getExpression();
+
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        SymbolReference symbolReference = symbolSolver.solveSymbol("i", assignExpr.getTarget());
+
+        assertEquals(true, symbolReference.isSolved());
+        assertEquals("i", symbolReference.getCorrespondingDeclaration().getName());
+        assertEquals(true, symbolReference.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void resolveInheritedFieldReference() {
+        CompilationUnit cu = parseSample("ReferencesToField");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "ReferencesToFieldExtendingClass");
+        MethodDeclaration method1 = Navigator.demandMethod(referencesToField, "method2");
+        ExpressionStmt stmt = (ExpressionStmt) method1.getBody().get().getStatements().get(0);
+        AssignExpr assignExpr = (AssignExpr) stmt.getExpression();
+
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        SymbolReference symbolReference = symbolSolver.solveSymbol("i", assignExpr.getTarget());
+
+        assertEquals(true, symbolReference.isSolved());
+        assertEquals("i", symbolReference.getCorrespondingDeclaration().getName());
+        assertEquals(true, symbolReference.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void resolveParameterReference() {
+        CompilationUnit cu = parseSample("ReferencesToParameter");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "ReferenceToParameter");
+        MethodDeclaration method1 = Navigator.demandMethod(referencesToField, "aMethod");
+        NameExpr foo = Navigator.findNameExpression(method1, "foo").get();
+
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        SymbolReference symbolReference = symbolSolver.solveSymbol("foo", foo);
+
+        assertEquals(true, symbolReference.isSolved());
+        assertEquals("foo", symbolReference.getCorrespondingDeclaration().getName());
+        assertEquals(true, symbolReference.getCorrespondingDeclaration().isParameter());
+    }
+
+    @Test
+    public void resolveReferenceToImportedType() {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        Parameter param = method.getParameters().get(0);
+
+        ResolvedClassDeclaration compilationUnitDecl = mock(ResolvedClassDeclaration.class);
+        when(compilationUnitDecl.getName()).thenReturn("CompilationUnit");
+        when(compilationUnitDecl.getQualifiedName()).thenReturn("com.github.javaparser.ast.CompilationUnit");
+        TypeSolver typeSolver = mock(TypeSolver.class);
+        when(typeSolver.getRoot()).thenReturn(typeSolver);
+        when(typeSolver.solveType("java.lang.Object")).thenReturn(new ReflectionClassDeclaration(Object.class, typeSolver));
+        when(typeSolver.tryToSolveType("com.github.javaparser.ast.CompilationUnit")).thenReturn(SymbolReference.solved(compilationUnitDecl));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+
+        SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("CompilationUnit", param);
+
+        assertEquals(true, ref.isSolved());
+        assertEquals("CompilationUnit", ref.getCorrespondingDeclaration().getName());
+        assertEquals("com.github.javaparser.ast.CompilationUnit", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceUsingQualifiedName() {
+        CompilationUnit cu = parseSample("Navigator2");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        Parameter param = method.getParameters().get(0);
+
+        ResolvedClassDeclaration compilationUnitDecl = mock(ResolvedClassDeclaration.class);
+        when(compilationUnitDecl.getName()).thenReturn("CompilationUnit");
+        when(compilationUnitDecl.getQualifiedName()).thenReturn("com.github.javaparser.ast.CompilationUnit");
+        TypeSolver typeSolver = mock(TypeSolver.class);
+        //when(typeSolver.tryToSolveType("java.lang.com.github.javaparser.ast.CompilationUnit")).thenReturn(SymbolReference.unsolved(ClassDeclaration.class));
+        when(typeSolver.getRoot()).thenReturn(typeSolver);
+        when(typeSolver.solveType("java.lang.Object")).thenReturn(new ReflectionClassDeclaration(Object.class, typeSolver));
+        when(typeSolver.tryToSolveType("com.github.javaparser.ast.CompilationUnit")).thenReturn(SymbolReference.solved(compilationUnitDecl));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        
+        SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("com.github.javaparser.ast.CompilationUnit", param);
+
+        assertEquals(true, ref.isSolved());
+        assertEquals("CompilationUnit", ref.getCorrespondingDeclaration().getName());
+        assertEquals("com.github.javaparser.ast.CompilationUnit", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToClassesInTheSamePackage() {
+        CompilationUnit cu = parseSample("Navigator3");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        Parameter param = method.getParameters().get(0);
+
+        ResolvedClassDeclaration compilationUnitDecl = mock(ResolvedClassDeclaration.class);
+        when(compilationUnitDecl.getName()).thenReturn("CompilationUnit");
+        when(compilationUnitDecl.getQualifiedName()).thenReturn("my.packagez.CompilationUnit");
+        TypeSolver typeSolver = mock(TypeSolver.class);
+        when(typeSolver.getRoot()).thenReturn(typeSolver);
+        when(typeSolver.solveType("java.lang.Object")).thenReturn(new ReflectionClassDeclaration(Object.class, typeSolver));
+        when(typeSolver.tryToSolveType("my.packagez.CompilationUnit")).thenReturn(SymbolReference.solved(compilationUnitDecl));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+
+        SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("CompilationUnit", param);
+
+        assertEquals(true, ref.isSolved());
+        assertEquals("CompilationUnit", ref.getCorrespondingDeclaration().getName());
+        assertEquals("my.packagez.CompilationUnit", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToClassInJavaLang() {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        Parameter param = method.getParameters().get(1);
+
+        ResolvedClassDeclaration stringDecl = mock(ResolvedClassDeclaration.class);
+        when(stringDecl.getName()).thenReturn("String");
+        when(stringDecl.getQualifiedName()).thenReturn("java.lang.String");
+        TypeSolver typeSolver = mock(TypeSolver.class);
+        when(typeSolver.tryToSolveType("me.tomassetti.symbolsolver.javaparser.String")).thenReturn(SymbolReference.unsolved(ResolvedReferenceTypeDeclaration.class));
+        when(typeSolver.getRoot()).thenReturn(typeSolver);
+        when(typeSolver.solveType("java.lang.Object")).thenReturn(new ReflectionClassDeclaration(Object.class, typeSolver));
+        when(typeSolver.tryToSolveType("java.lang.String")).thenReturn(SymbolReference.solved(stringDecl));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+
+        SymbolReference<? extends ResolvedTypeDeclaration> ref = symbolSolver.solveType("String", param);
+
+        assertEquals(true, ref.isSolved());
+        assertEquals("String", ref.getCorrespondingDeclaration().getName());
+        assertEquals("java.lang.String", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToMethod() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        MethodCallExpr callToGetTypes = Navigator.findMethodCall(method, "getTypes").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToJar), new ReflectionTypeSolver(true));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+
+        MethodUsage ref = symbolSolver.solveMethod("getTypes", Collections.emptyList(), callToGetTypes);
+
+        assertEquals("getTypes", ref.getName());
+        assertEquals("com.github.javaparser.ast.CompilationUnit", ref.declaringType().getQualifiedName());
+
+        //verify(typeSolver);
+    }
+
+    @Test
+    public void resolveCascadeOfReferencesToMethod() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "findType");
+        MethodCallExpr callToStream = Navigator.findMethodCall(method, "stream").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToJar), new ReflectionTypeSolver(true));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        MethodUsage ref = symbolSolver.solveMethod("stream", Collections.emptyList(), callToStream);
+
+        assertEquals("stream", ref.getName());
+        assertEquals("java.util.Collection", ref.declaringType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToMethodCalledOnArrayAccess() {
+        CompilationUnit cu = parseSample("ArrayAccess");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ArrayAccess");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "access");
+        MethodCallExpr callToTrim = Navigator.findMethodCall(method, "trim").get();
+
+        File src = adaptPath(new File("src/test/resources"));
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(src));
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        MethodUsage ref = symbolSolver.solveMethod("trim", Collections.emptyList(), callToTrim);
+
+        assertEquals("trim", ref.getName());
+        assertEquals("java.lang.String", ref.declaringType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToJreType() {
+        CompilationUnit cu = parseSample("NavigatorSimplified");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
+        com.github.javaparser.ast.type.Type streamJavaParserType = method.getParameters().get(0).getType();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType streamType = JavaParserFacade.get(typeSolver).convert(streamJavaParserType, method);
+
+        assertEquals("java.util.stream.Stream<java.lang.String>", streamType.describe());
+    }
+
+    @Test
+    public void resolveReferenceToMethodWithLambda() {
+        CompilationUnit cu = parseSample("NavigatorSimplified");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr methodCallExpr = Navigator.findMethodCall(method, "filter").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType ref = JavaParserFacade.get(typeSolver).getType(methodCallExpr);
+
+        assertEquals("java.util.stream.Stream<java.lang.String>", ref.describe());
+        assertEquals(1, ref.asReferenceType().typeParametersValues().size());
+        assertEquals("java.lang.String", ref.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveReferenceToLambdaParamBase() {
+        CompilationUnit cu = parseSample("NavigatorSimplified");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        NameExpr refToT = Navigator.findNameExpression(method, "t").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        ResolvedType ref = javaParserFacade.getType(refToT);
+
+        assertEquals("? super java.lang.String", ref.describe());
+    }
+
+    @Test
+    public void resolveReferenceToLambdaParamSimplified() {
+        CompilationUnit cu = parseSample("NavigatorSimplified");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr call = Navigator.findMethodCall(method, "isEmpty").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        MethodUsage ref = symbolSolver.solveMethod("isEmpty", Collections.emptyList(), call);
+
+        assertEquals("isEmpty", ref.getName());
+        assertEquals("java.lang.String", ref.declaringType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveGenericReturnTypeOfMethodInJar() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr call = Navigator.findMethodCall(method, "getTypes").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+
+        assertEquals("getTypes", methodUsage.getName());
+        assertEquals("java.util.List<com.github.javaparser.ast.body.TypeDeclaration>", methodUsage.returnType().describe());
+        assertEquals(1, methodUsage.returnType().asReferenceType().typeParametersValues().size());
+        assertEquals("com.github.javaparser.ast.body.TypeDeclaration", methodUsage.returnType().asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveTypeUsageOfFirstMethodInGenericClass() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToGetTypes = Navigator.findMethodCall(method, "getTypes").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        MethodUsage filterUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(callToGetTypes);
+
+        assertEquals("java.util.List<com.github.javaparser.ast.body.TypeDeclaration>", filterUsage.returnType().describe());
+        assertEquals(1, filterUsage.returnType().asReferenceType().typeParametersValues().size());
+        assertEquals("com.github.javaparser.ast.body.TypeDeclaration", filterUsage.returnType().asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveTypeUsageOfMethodInGenericClass() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToStream = Navigator.findMethodCall(method, "stream").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        MethodUsage filterUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(callToStream);
+
+        assertEquals("java.util.stream.Stream<com.github.javaparser.ast.body.TypeDeclaration>", filterUsage.returnType().describe());
+    }
+
+    @Test
+    public void resolveTypeUsageOfCascadeMethodInGenericClass() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToFilter = Navigator.findMethodCall(method, "filter").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        MethodUsage filterUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(callToFilter);
+
+        assertEquals("java.util.stream.Stream<com.github.javaparser.ast.body.TypeDeclaration>", filterUsage.returnType().describe());
+    }
+
+    @Test
+    public void resolveLambdaType() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToFilter = Navigator.findMethodCall(method, "filter").get();
+        Expression lambdaExpr = callToFilter.getArguments().get(0);
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        ResolvedType typeOfLambdaExpr = JavaParserFacade.get(typeSolver).getType(lambdaExpr);
+
+        assertEquals("java.util.function.Predicate<? super com.github.javaparser.ast.body.TypeDeclaration>", typeOfLambdaExpr.describe());
+    }
+
+    @Test
+    public void resolveReferenceToLambdaParam() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToGetName = Navigator.findMethodCall(method, "getName").get();
+        Expression referenceToT = callToGetName.getScope().get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        ResolvedType typeOfT = JavaParserFacade.get(typeSolver).getType(referenceToT);
+
+        assertEquals("? super com.github.javaparser.ast.body.TypeDeclaration", typeOfT.describe());
+    }
+
+    @Test
+    public void resolveReferenceToCallOnLambdaParam() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("Navigator");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Navigator");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "findType");
+        MethodCallExpr callToGetName = Navigator.findMethodCall(method, "getName").get();
+
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JarTypeSolver(pathToJar));
+        MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(callToGetName);
+
+        assertEquals("getName", methodUsage.getName());
+        assertEquals("com.github.javaparser.ast.body.TypeDeclaration", methodUsage.declaringType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveReferenceToOverloadMethodWithNullParam() {
+        CompilationUnit cu = parseSample("OverloadedMethods");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "m1");
+        MethodCallExpr call = Navigator.findMethodCall(method, "overloaded").get();
+
+        ReflectionTypeSolver typeSolver = new ReflectionTypeSolver();
+        MethodUsage ref = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+
+        assertEquals("overloaded", ref.getName());
+        assertEquals(1, ref.getNoParams());
+        assertEquals("java.lang.String", ref.getParamTypes().get(0).describe());
+    }
+
+    @Test
+    public void resolveReferenceToOverloadMethodFindStricter() {
+        CompilationUnit cu = parseSample("OverloadedMethods");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "m2");
+        MethodCallExpr call = Navigator.findMethodCall(method, "overloaded").get();
+
+        ReflectionTypeSolver typeSolver = new ReflectionTypeSolver();
+        MethodUsage ref = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+
+        assertEquals("overloaded", ref.getName());
+        assertEquals(1, ref.getNoParams());
+        assertEquals("java.lang.String", ref.getParamTypes().get(0).describe());
+    }
+
+    @Test
+    public void resolveInheritedMethodFromInterface() {
+        CompilationUnit cu = parseSample("InterfaceInheritance");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Test");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "test");
+        MethodCallExpr call = Navigator.findMethodCall(method, "foobar").get();
+
+        File src = adaptPath(new File("src/test/resources"));
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(src));
+        ResolvedType type = JavaParserFacade.get(typeSolver).getType(call);
+
+        assertEquals("double", type.describe());
+    }
+
+    @Test
+    public void resolveReferenceToOverloadMethodFindOnlyCompatible() {
+        CompilationUnit cu = parseSample("OverloadedMethods");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "m3");
+        MethodCallExpr call = Navigator.findMethodCall(method, "overloaded").get();
+
+        ReflectionTypeSolver typeSolver = new ReflectionTypeSolver();
+        MethodUsage ref = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+
+        assertEquals("overloaded", ref.getName());
+        assertEquals(1, ref.getNoParams());
+        assertEquals("java.lang.Object", ref.getParamTypes().get(0).describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/DefaultPackageTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/DefaultPackageTest.java
new file mode 100644
index 000000000..5fcead08f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/DefaultPackageTest.java
@@ -0,0 +1,158 @@
+package com.github.javaparser.symbolsolver.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.AccessSpecifier;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.*;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.logic.AbstractClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.MemoryTypeSolver;
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * See issue #16
+ */
+public class DefaultPackageTest {
+
+    private class MyClassDeclaration extends AbstractClassDeclaration {
+
+        private String qualifiedName;
+
+        private MyClassDeclaration(String qualifiedName) {
+            this.qualifiedName = qualifiedName;
+        }
+
+        @Override
+        public AccessSpecifier accessSpecifier() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public List<ResolvedTypeParameterDeclaration> getTypeParameters() {
+            return new LinkedList<>();
+        }
+
+        @Override
+        public Set<ResolvedReferenceTypeDeclaration> internalTypes() {
+            return new HashSet<>();
+        }
+
+        @Override
+        public String getName() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public List<ResolvedReferenceType> getAncestors() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public List<ResolvedFieldDeclaration> getAllFields() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public Set<ResolvedMethodDeclaration> getDeclaredMethods() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAssignableBy(ResolvedType type) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAssignableBy(ResolvedReferenceTypeDeclaration other) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean hasDirectlyAnnotation(String qualifiedName) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public ResolvedReferenceType getSuperClass() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public List<ResolvedReferenceType> getInterfaces() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public List<ResolvedConstructorDeclaration> getConstructors() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        protected ResolvedReferenceType object() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public String getPackageName() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public String getClassName() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public String getQualifiedName() {
+            return qualifiedName;
+        }
+
+        @Override
+        public Optional<ResolvedReferenceTypeDeclaration> containerType() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    @Test
+    public void aClassInDefaultPackageCanBeAccessedFromTheDefaultPackage() {
+        String code = "class A extends B {}";
+        MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver();
+        memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B"));
+
+        ClassOrInterfaceType jpType = JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0);
+        ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(jpType);
+        assertEquals("B", resolvedType.asReferenceType().getQualifiedName());
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void aClassInDefaultPackageCanBeAccessedFromOutsideTheDefaultPackageImportingIt() {
+        String code = "package myPackage; import B; class A extends B {}";
+        MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver();
+        memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B"));
+
+        ClassOrInterfaceType jpType = JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0);
+        ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(jpType);
+        assertEquals("B", resolvedType.asReferenceType().getQualifiedName());
+    }
+
+    @Test(expected = UnsolvedSymbolException.class)
+    public void aClassInDefaultPackageCanBeAccessedFromOutsideTheDefaultPackageWithoutImportingIt() {
+        String code = "package myPackage; class A extends B {}";
+        MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver();
+        memoryTypeSolver.addDeclaration("B", new MyClassDeclaration("B"));
+
+        ResolvedType resolvedType = JavaParserFacade.get(memoryTypeSolver).convertToUsage(JavaParser.parse(code).getClassByName("A").get().getExtendedTypes(0));
+        assertEquals("B", resolvedType.asReferenceType().getQualifiedName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/EnumResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/EnumResolutionTest.java
new file mode 100644
index 000000000..edeaf8043
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/EnumResolutionTest.java
@@ -0,0 +1,61 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.SwitchStmt;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class EnumResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void switchOnEnum() {
+        CompilationUnit cu = parseSample("SwitchOnEnum");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SwitchOnEnum");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
+        SwitchStmt switchStmt = Navigator.findSwitch(method);
+        Expression expression = switchStmt.getEntries().get(0).getLabel().get();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+        assertTrue(ref.isSolved());
+        assertEquals("SwitchOnEnum.MyEnum", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void enumAndStaticInitializer() {
+        CompilationUnit cu = parseSample("EnumAndStaticInitializer");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MyClass");
+        MethodCallExpr call = Navigator.findMethodCall(clazz, "put").get();
+
+        ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(call);
+        assertEquals("MyClass.Primitive", ref.describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/FieldsResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/FieldsResolutionTest.java
new file mode 100644
index 000000000..fd95e7314
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/FieldsResolutionTest.java
@@ -0,0 +1,107 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.*;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class FieldsResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void accessClassFieldThroughThis() {
+        CompilationUnit cu = parseSample("AccessClassMemberThroughThis");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessClassMemberThroughThis");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "getLabel2");
+        ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = returnStmt.getExpression().get();
+
+        ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+
+    @Test
+    public void accessClassFieldThroughThisWithCompetingSymbolInParentContext() {
+        CompilationUnit cu = parseSample("AccessClassMemberThroughThis");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessClassMemberThroughThis");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "setLabel");
+        ExpressionStmt expressionStmt = (ExpressionStmt) method.getBody().get().getStatements().get(0);
+        AssignExpr assignExpr = (AssignExpr) expressionStmt.getExpression();
+        FieldAccessExpr fieldAccessExpr = (FieldAccessExpr) assignExpr.getTarget();
+
+        File src = adaptPath(new File("src/test/resources"));
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver(new JavaParserTypeSolver(src), new ReflectionTypeSolver());
+        SymbolSolver symbolSolver = new SymbolSolver(typeSolver);
+        SymbolReference<? extends ResolvedValueDeclaration> ref = symbolSolver.solveSymbol(fieldAccessExpr.getName().getId(), fieldAccessExpr);
+
+        assertTrue(ref.isSolved());
+        assertTrue(ref.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void accessEnumFieldThroughThis() {
+        CompilationUnit cu = parseSample("AccessEnumMemberThroughThis");
+        com.github.javaparser.ast.body.EnumDeclaration enumDecl = Navigator.demandEnum(cu, "AccessEnumMemberThroughThis");
+        MethodDeclaration method = Navigator.demandMethod(enumDecl, "getLabel");
+        SimpleName expression = Navigator.findSimpleName(method, "label").get();
+
+        SymbolReference ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+        assertTrue(ref.isSolved());
+        assertEquals("label", ref.getCorrespondingDeclaration().getName());
+    }
+
+    @Test
+    public void accessEnumMethodThroughThis() {
+        CompilationUnit cu = parseSample("AccessEnumMemberThroughThis");
+        com.github.javaparser.ast.body.EnumDeclaration enumDecl = Navigator.demandEnum(cu, "AccessEnumMemberThroughThis");
+        MethodDeclaration method = Navigator.demandMethod(enumDecl, "getLabel2");
+        ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = returnStmt.getExpression().get();
+
+        ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+
+    @Test
+    public void accessFieldThroughSuper() {
+        CompilationUnit cu = parseSample("AccessThroughSuper");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessThroughSuper.SubClass");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "fieldTest");
+        ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = returnStmt.getExpression().get();
+
+        ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/GenericsResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/GenericsResolutionTest.java
new file mode 100644
index 000000000..bfc4bfd58
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/GenericsResolutionTest.java
@@ -0,0 +1,440 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.expr.ThisExpr;
+import com.github.javaparser.ast.stmt.ExpressionStmt;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.resolution.Value;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+public class GenericsResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void resolveFieldWithGenericTypeToString() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Generics");
+        VariableDeclarator fieldS = Navigator.demandField(clazz, "s");
+
+        SymbolSolver symbolSolver = new SymbolSolver(new ReflectionTypeSolver());
+        Optional<Value> symbolReference = symbolSolver.solveSymbolAsValue("s", fieldS);
+
+        assertEquals(true, symbolReference.isPresent());
+        assertEquals("s", symbolReference.get().getName());
+
+        ResolvedType type = symbolReference.get().getType();
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals("java.lang.String", type.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveFieldWithGenericTypeToDeclaredClass() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Generics");
+        VariableDeclarator fieldS = Navigator.demandField(clazz, "g");
+
+        SymbolSolver symbolSolver = new SymbolSolver(new ReflectionTypeSolver());
+        Optional<Value> symbolReference = symbolSolver.solveSymbolAsValue("g", fieldS);
+
+        assertEquals(true, symbolReference.isPresent());
+        assertEquals("g", symbolReference.get().getName());
+
+        ResolvedType type = symbolReference.get().getType();
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals("me.tomassetti.symbolsolver.javaparser.Generics", type.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveFieldWithGenericTypeToInteger() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Generics");
+        VariableDeclarator fieldS = Navigator.demandField(clazz, "i");
+
+        SymbolSolver symbolSolver = new SymbolSolver(new ReflectionTypeSolver());
+        Optional<Value> symbolReference = symbolSolver.solveSymbolAsValue("i", fieldS);
+
+        assertEquals(true, symbolReference.isPresent());
+        assertEquals("i", symbolReference.get().getName());
+
+        ResolvedType type = symbolReference.get().getType();
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals("java.lang.Integer", type.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveFieldOfVariableType() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+        VariableDeclarator field = Navigator.demandField(clazz, "a");
+
+        SymbolSolver symbolSolver = new SymbolSolver(new ReflectionTypeSolver());
+        Optional<Value> symbolReference = symbolSolver.solveSymbolAsValue("a", field);
+
+        assertEquals(true, symbolReference.isPresent());
+        assertEquals("a", symbolReference.get().getName());
+
+        ResolvedType type = symbolReference.get().getType();
+        assertEquals(true, type.isTypeVariable());
+        assertEquals("A", type.describe());
+    }
+
+    @Test
+    public void resolveFieldOfGenericReferringToVariableType() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+        VariableDeclarator field = Navigator.demandField(clazz, "as");
+
+        SymbolSolver symbolSolver = new SymbolSolver(new ReflectionTypeSolver());
+        Optional<Value> symbolReference = symbolSolver.solveSymbolAsValue("as", field);
+
+        assertEquals(true, symbolReference.isPresent());
+        assertEquals("as", symbolReference.get().getName());
+
+        ResolvedType type = symbolReference.get().getType();
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.util.List<A>", type.describe());
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        ResolvedType typeParam = type.asReferenceType().typeParametersValues().get(0);
+        assertEquals(true, typeParam.isTypeVariable());
+        assertEquals("A", typeParam.describe());
+    }
+
+    @Test
+    public void resolveUsageOfGenericFieldSimpleCase() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo1");
+
+        ExpressionStmt stmt = (ExpressionStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = stmt.getExpression();
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.lang.String", type.describe());
+    }
+
+    //PRIMA UN TEST CHE DICA CHE IL TIPO DEL CAMPO AS e' LIST<A> NON LIST<E>
+    @Test
+    public void resolveUsageOfGenericFieldIntermediateCase() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+
+        VariableDeclarator field = Navigator.demandField(clazz, "as");
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(field);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.util.List<A>", type.describe());
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals(true, type.asReferenceType().typeParametersValues().get(0).isTypeVariable());
+        assertEquals("A", type.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveUsageOfGenericFieldAdvancedCase() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo2");
+
+        ExpressionStmt stmt = (ExpressionStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = stmt.getExpression();
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.util.List<java.lang.String>", type.describe());
+        assertEquals(1, type.asReferenceType().typeParametersValues().size());
+        assertEquals(false, type.asReferenceType().typeParametersValues().get(0).isTypeVariable());
+        assertEquals("java.lang.String", type.asReferenceType().typeParametersValues().get(0).describe());
+    }
+
+    @Test
+    public void resolveUsageOfMethodOfGenericClass() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "GenericMethodCalls.Derived");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "caller");
+        MethodCallExpr expression = Navigator.findMethodCall(method, "callee").get();
+
+        MethodUsage methodUsage = JavaParserFacade.get(new ReflectionTypeSolver()).solveMethodAsUsage(expression);
+
+        assertEquals("callee", methodUsage.getName());
+    }
+
+    @Test
+    public void resolveElementOfList() {
+        CompilationUnit cu = parseSample("ElementOfList");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ElementOfList");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
+        VariableDeclarator variableDeclarator = Navigator.demandVariableDeclaration(method, "a").get();
+        Expression expression = variableDeclarator.getInitializer().get();
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("Comment", type.describe());
+    }
+
+    @Test
+    public void resolveElementOfListAdvancedExample() {
+        CompilationUnit cu = parseSample("ElementOfList");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ElementOfList");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "annotations");
+        VariableDeclarator variableDeclarator = Navigator.demandVariableDeclaration(method, "a").get();
+        Expression expression = variableDeclarator.getInitializer().get();
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("AnnotationExpr", type.describe());
+    }
+
+    @Test
+    public void genericsInheritance() {
+        CompilationUnit cu = parseSample("MethodTypeParams");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "VoidVisitorAdapter");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "visit");
+        MethodCallExpr call = Navigator.findMethodCall(method, "accept").get();
+        Expression thisRef = call.getArguments().get(0);
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        ResolvedType voidVisitorAdapterOfA = javaParserFacade.getType(thisRef);
+        List<ResolvedReferenceType> allAncestors = voidVisitorAdapterOfA.asReferenceType().getAllAncestors();
+        assertEquals(2, allAncestors.size());
+    }
+
+    @Test
+    public void methodTypeParams() {
+        CompilationUnit cu = parseSample("MethodTypeParams");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "VoidVisitorAdapter");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "visit");
+        MethodCallExpr call = Navigator.findMethodCall(method, "accept").get();
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(call);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("void", type.describe());
+    }
+
+    @Test
+    public void classCastScope() {
+        CompilationUnit cu = parseSample("ClassCast");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassCast");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "getNodesByType");
+        MethodCallExpr call = Navigator.findMethodCall(method, "cast").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        Expression scope = call.getScope().get();
+        ResolvedType type = JavaParserFacade.get(typeSolver).getType(scope);
+
+        //System.out.println(typeUsage);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.lang.Class<N>", type.describe());
+    }
+
+    @Test
+    public void classCast() {
+        CompilationUnit cu = parseSample("ClassCast");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassCast");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "getNodesByType");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(returnStmt.getExpression().get());
+
+        assertEquals(true, type.isTypeVariable());
+        assertEquals("N", type.describe());
+    }
+
+    @Test
+    public void typeParamOnReturnTypeStep1() {
+        CompilationUnit cu = parseSample("TypeParamOnReturnType");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypeParamOnReturnType");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "nodeEquals");
+        ThisExpr thisExpr = Navigator.findNodeOfGivenClass(method, ThisExpr.class);
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(thisExpr);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("TypeParamOnReturnType", type.describe());
+    }
+
+    @Test
+    public void typeParamOnReturnTypeStep2() {
+        CompilationUnit cu = parseSample("TypeParamOnReturnType");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypeParamOnReturnType");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "nodeEquals");
+        NameExpr n1 = Navigator.findNameExpression(method, "n1").get();
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(n1);
+
+        assertEquals(true, type.isTypeVariable());
+        assertEquals("T", type.describe());
+    }
+
+    @Test
+    public void typeParamOnReturnTypeStep3() {
+        CompilationUnit cu = parseSample("TypeParamOnReturnType");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypeParamOnReturnType");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "nodeEquals");
+        MethodCallExpr call = Navigator.findMethodCall(method, "accept").get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(call);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("java.lang.Boolean", type.describe());
+    }
+
+    @Test
+    public void typeParamOnReturnType() {
+        CompilationUnit cu = parseSample("TypeParamOnReturnType");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypeParamOnReturnType");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "nodeEquals");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(returnStmt.getExpression().get());
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("boolean", type.describe());
+    }
+
+    /*@Test
+    public void genericCollectionWithWildcardsAndExtensionsPrep() {
+        CompilationUnit cu = parseSample("GenericCollectionWithExtension");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bar");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+
+        TypeSolver typeSolver = new JreTypeSolver();
+        MethodCallExpr call = (MethodCallExpr) returnStmt.getExpr();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        List<TypeUsage> params = new ArrayList<>();
+        if (call.getArgs() != null) {
+            for (Expression param : call.getArgs()) {
+                params.add(javaParserFacade.getType(param, false));
+            }
+        }
+        Context context = JavaParserFactory.getContext(call, typeSolver);
+
+        ReferenceTypeUsage typeOfScope = javaParserFacade.getType(call.getScope()).asReferenceType();
+        me.tomassetti.symbolsolver.model.declarations.TypeDeclaration typeDeclaration = typeOfScope.getTypeDeclaration();
+        List<TypeUsage> typeParametersValues = typeOfScope.typeParametersValues();
+
+        List<MethodUsage> methods = new ArrayList<>();
+        for (Method m : List.class.getMethods()) {
+            if (m.getName().equals("addAll") && !m.isBridge() && !m.isSynthetic()) {
+                me.tomassetti.symbolsolver.model.declarations.MethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(m, typeSolver);
+                if (methods.size() == 0) {
+                    // ok, e' il primo
+                    ReferenceTypeUsage paramType = methodDeclaration.getParam(0).getType(typeSolver).asReferenceType();
+                    assertTrue(paramType.asReferenceType().typeParametersValues().get(0).isWildcard());
+                }
+                MethodUsage mu = new MethodUsage(methodDeclaration, typeSolver);
+                int i = 0;
+                for (TypeParameter tp : typeDeclaration.getTypeParameters()) {
+                    mu = mu.replaceTypeParameter(tp.getName(), typeParametersValues.get(i));
+                    i++;
+                }
+                methods.add(mu);
+            }
+
+        }
+
+        assertTrue(MethodResolutionLogic.isApplicable(methods.get(0), "addAll", params, typeSolver));
+        //Optional<MethodUsage> methodUsage = MethodResolutionLogic.findMostApplicableUsage(methods, "addAll", params, typeSolver);
+
+        //Optional<MethodUsage> methodUsage = typeDeclaration.solveMethodAsUsage("addAll", params, typeSolver, context, typeParametersValues);
+
+        //Optional<MethodUsage> methodUsage = context.solveMethodAsUsage("addAll", params, typeSolver);
+
+        //assertTrue(methodUsage.isPresent());
+
+    }*/
+
+    @Test
+    public void genericCollectionWithWildcardsAndExtensions() {
+        CompilationUnit cu = parseSample("GenericCollectionWithExtension");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bar");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        Expression returnStmtExpr = returnStmt.getExpression().get();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        ResolvedType type = javaParserFacade.getType(returnStmtExpr);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("boolean", type.describe());
+    }
+
+    @Test
+    public void methodWithGenericParameterTypes() {
+        CompilationUnit cu = parseSample("GenericCollectionWithExtension");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bar");
+        MethodCallExpr methodCall = Navigator.findMethodCall(method, "foo").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        MethodUsage methodUsage = javaParserFacade.solveMethodAsUsage(methodCall);
+
+        assertEquals("foo", methodUsage.getName());
+    }
+
+    @Test
+    public void genericCollectionWithWildcards() {
+        CompilationUnit cu = parseSample("GenericCollection");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bar");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        Expression returnStmtExpr = returnStmt.getExpression().get();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+
+        ResolvedType type = javaParserFacade.getType(returnStmtExpr);
+
+        assertEquals(false, type.isTypeVariable());
+        assertEquals("boolean", type.describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/JavaParserFacadeResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/JavaParserFacadeResolutionTest.java
new file mode 100644
index 000000000..37fec2647
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/JavaParserFacadeResolutionTest.java
@@ -0,0 +1,163 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.*;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.stmt.CatchClause;
+import com.github.javaparser.ast.stmt.TryStmt;
+import com.github.javaparser.ast.type.Type;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedUnionType;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class JavaParserFacadeResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void typeDeclarationSuperClassImplicitlyIncludeObject() {
+        CompilationUnit cu = parseSample("Generics");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Generics");
+        ResolvedTypeDeclaration typeDeclaration = JavaParserFacade.get(new ReflectionTypeSolver()).getTypeDeclaration(clazz);
+        ResolvedReferenceType superclass = typeDeclaration.asClass().getSuperClass();
+        assertEquals(Object.class.getCanonicalName(), superclass.getQualifiedName());
+    }
+
+    // See issue 42
+    @Test
+    public void solvingReferenceToUnsupportedOperationException() {
+        String code = "public class Bla {\n" +
+                "    public void main()\n" +
+                "    {\n" +
+                "        try\n" +
+                "        {\n" +
+                "            int i = 0;\n" +
+                "        }\n" +
+                "        catch (UnsupportedOperationException e)\n" +
+                "        {\n" +
+                "            String s;\n" +
+                "            e.getMessage();\n" +
+                "        }\n" +
+                "    }\n" +
+                "}";
+        MethodCallExpr methodCallExpr = Navigator.findNodeOfGivenClass(JavaParser.parse(code), MethodCallExpr.class);
+        MethodUsage methodUsage = JavaParserFacade.get(new ReflectionTypeSolver()).solveMethodAsUsage(methodCallExpr);
+        assertEquals("java.lang.Throwable.getMessage()", methodUsage.getQualifiedSignature());
+    }
+
+    // See issue 46
+    @Test
+    public void solvingReferenceToCatchClauseParam() {
+        String code = "public class Bla {\n" +
+                "    public void main()\n" +
+                "    {\n" +
+                "        try\n" +
+                "        {\n" +
+                "            int i = 0;\n" +
+                "        }\n" +
+                "        catch (UnsupportedOperationException e)\n" +
+                "        {\n" +
+                "            String s;\n" +
+                "            e.getMessage();\n" +
+                "        }\n" +
+                "    }\n" +
+                "}";
+        MethodCallExpr methodCallExpr = Navigator.findNodeOfGivenClass(JavaParser.parse(code), MethodCallExpr.class);
+        NameExpr nameE = (NameExpr)methodCallExpr.getScope().get();
+        SymbolReference<? extends ResolvedValueDeclaration> symbolReference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(nameE);
+        assertEquals(true, symbolReference.isSolved());
+        assertEquals(true, symbolReference.getCorrespondingDeclaration().isParameter());
+        assertEquals("e", symbolReference.getCorrespondingDeclaration().asParameter().getName());
+        assertEquals("java.lang.UnsupportedOperationException", symbolReference.getCorrespondingDeclaration().asParameter().getType().asReferenceType().getQualifiedName());
+    }
+
+    // See issue 47
+    @Test
+    public void solvingReferenceToAnAncestorInternalClass() {
+        String code = "public class Foo {\n" +
+                "    public class Base {\n" +
+                "        public class X {\n" +
+                "        }\n" +
+                "    }\n" +
+                "\n" +
+                "    public class Derived extends Base {\n" +
+                "        public X x = null;\n" +
+                "    }\n" +
+                "}";
+        FieldDeclaration fieldDeclaration = Navigator.findNodeOfGivenClass(JavaParser.parse(code), FieldDeclaration.class);
+        Type jpType = fieldDeclaration.getCommonType();
+        ResolvedType jssType = JavaParserFacade.get(new ReflectionTypeSolver()).convertToUsage(jpType);
+        assertEquals("Foo.Base.X", jssType.asReferenceType().getQualifiedName());
+    }
+
+    // See issue 119
+    @Test
+    public void solveTryWithResourceVariable() {
+        String code = "import java.util.Scanner; class A { void foo() { try (Scanner sc = new Scanner(System.in)) {\n" +
+                "    sc.nextLine();\n" +
+                "} } }";
+        CompilationUnit cu = JavaParser.parse(code);
+        MethodCallExpr methodCallExpr = Navigator.findMethodCall(cu, "nextLine").get();
+        Expression scope = methodCallExpr.getScope().get();
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(scope);
+        assertEquals(true, type.isReferenceType());
+        assertEquals("java.util.Scanner", type.asReferenceType().getQualifiedName());
+    }
+
+    private CompilationUnit parseWithTypeSolver(String code) {
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ParserConfiguration parserConfiguration = new ParserConfiguration();
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+        JavaParser javaParser = new JavaParser(parserConfiguration);
+        return javaParser.parse(ParseStart.COMPILATION_UNIT, new StringProvider(code)).getResult().get();
+    }
+
+    @Test
+    public void solveMultiCatchType() {
+        String code = "class A {\n" +
+                "        public void foo() {\n" +
+                "            try {\n" +
+                "                \n" +
+                "            } catch (IllegalStateException | IllegalArgumentException e) {\n" +
+                "                \n" +
+                "            }\n" +
+                "        }\n" +
+                "    }";
+        CompilationUnit cu = parseWithTypeSolver(code);
+        CatchClause catchClause = Navigator.findNodeOfGivenClass(cu, CatchClause.class);
+        Type jpType = catchClause.getParameter().getType();
+        ResolvedType jssType = jpType.resolve();
+        assertEquals(true, jssType instanceof ResolvedUnionType);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/LambdaResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/LambdaResolutionTest.java
new file mode 100644
index 000000000..3620c5230
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/LambdaResolutionTest.java
@@ -0,0 +1,177 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LambdaResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void lambdaMapParameter() {
+        CompilationUnit cu = parseSample("Lambda");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get();
+        Expression expression = methodCallExpr.getArguments().get(0);
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.util.function.Function<? super java.lang.String, ? extends java.lang.String>", type.describe());
+    }
+
+    @Test
+    public void personsStream() {
+        CompilationUnit cu = parseSample("Lambda");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+        expression = Navigator.findMethodCall(expression, "stream").get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.util.stream.Stream<java.lang.String>", type.describe());
+    }
+
+    @Test
+    public void lambdaMap() {
+        CompilationUnit cu = parseSample("Lambda");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration m1 = Navigator.demandMethod(clazz, "lambdaMap");
+        MethodDeclaration m2 = Navigator.demandMethod(clazz, "lambdaMap2");
+        ReturnStmt returnStmt1 = Navigator.findReturnStmt(m1);
+        ReturnStmt returnStmt2 = Navigator.findReturnStmt(m2);
+        Expression e1 = returnStmt1.getExpression().get();
+        Expression e2 = returnStmt2.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type1 = javaParserFacade.getType(e1);
+        ResolvedType type2 = javaParserFacade.getType(e2);
+        assertEquals("java.util.stream.Stream<java.lang.String>", type1.describe());
+        assertEquals("java.util.stream.Stream<java.util.stream.IntStream>", type2.describe());
+    }
+
+    @Test
+    public void lambdaReduce() {
+        CompilationUnit cu = parseSample("Lambda");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "reduce");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expr = returnStmt.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type1 = javaParserFacade.getType(expr);
+        assertEquals("java.util.Optional<java.lang.Integer>", type1.describe());
+    }
+
+    @Test
+    public void lambdaBifunc() {
+        CompilationUnit cu = parseSample("Lambda");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bifunc");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expr = returnStmt.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type1 = javaParserFacade.getType(expr);
+        assertEquals("double", type1.describe());
+    }
+
+    @Test
+    public void lambdaCollectParam() {
+        CompilationUnit cu = parseSample("LambdaCollect");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get();
+        // Collectors.toList()
+        Expression expression = methodCallExpr.getArguments().get(0);
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.util.stream.Collector<T, ? extends java.lang.Object, java.util.List<T>>", type.describe());
+    }
+
+    @Test
+    public void lambdaCollect() {
+        CompilationUnit cu = parseSample("LambdaCollect");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.util.List<java.lang.String>", type.describe());
+    }
+
+    @Test
+    public void lambdaBlockExplicitReturn() {
+        CompilationUnit cu = parseSample("LambdaMulti");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaSingleReturn");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.lang.String", type.describe());
+    }
+
+    @Test
+    public void lambdaBlockMultiLineReturn() {
+        CompilationUnit cu = parseSample("LambdaMulti");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "multiLineReturn");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals("java.lang.String", type.describe());
+    }
+
+    @Test
+    public void typeOfVoidLambda() {
+        CompilationUnit cu = parseSample("LambdaVoid");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaEmpty");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+        LambdaExpr lambdaExpr = Navigator.findNodeOfGivenClass(expression, LambdaExpr.class);
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(lambdaExpr);
+        assertEquals("void", type.describe());
+    }
+
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionLogicTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionLogicTest.java
new file mode 100644
index 000000000..b53607dbd
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionLogicTest.java
@@ -0,0 +1,83 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionFactory;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+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.File;
+
+import static org.junit.Assert.assertEquals;
+
+public class MethodsResolutionLogicTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        File srcNewCode = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(srcNewCode));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolver = combinedTypeSolverNewCode;
+    }
+
+    @Test
+    public void compatibilityShouldConsiderAlsoTypeVariablesNegative() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        ResolvedReferenceType stringType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(String.class, typeSolver);
+        ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolver);
+        assertEquals(true, rawClassType.isRawType());
+        ResolvedReferenceType classOfStringType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), stringType);
+        MethodUsage mu = constructorDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().getSignature().equals("isThrows(java.lang.Class<? extends java.lang.Throwable>)")).findFirst().get();
+
+        assertEquals(false, MethodResolutionLogic.isApplicable(mu, "isThrows", ImmutableList.of(classOfStringType), typeSolver));
+    }
+
+    @Test
+    public void compatibilityShouldConsiderAlsoTypeVariablesRaw() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolver);
+        MethodUsage mu = constructorDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().getSignature().equals("isThrows(java.lang.Class<? extends java.lang.Throwable>)")).findFirst().get();
+
+        assertEquals(true, MethodResolutionLogic.isApplicable(mu, "isThrows", ImmutableList.of(rawClassType), typeSolver));
+    }
+
+    @Test
+    public void compatibilityShouldConsiderAlsoTypeVariablesPositive() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolver.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        ResolvedReferenceType runtimeException = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(RuntimeException.class, typeSolver);
+        ResolvedReferenceType rawClassType = (ResolvedReferenceType) ReflectionFactory.typeUsageFor(Class.class, typeSolver);
+        ResolvedReferenceType classOfRuntimeType = (ResolvedReferenceType) rawClassType.replaceTypeVariables(rawClassType.getTypeDeclaration().getTypeParameters().get(0), runtimeException);
+        MethodUsage mu = constructorDeclaration.getAllMethods().stream().filter(m -> m.getDeclaration().getSignature().equals("isThrows(java.lang.Class<? extends java.lang.Throwable>)")).findFirst().get();
+
+        assertEquals(true, MethodResolutionLogic.isApplicable(mu, "isThrows", ImmutableList.of(classOfRuntimeType), typeSolver));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionTest.java
new file mode 100644
index 000000000..2e6dc946d
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/MethodsResolutionTest.java
@@ -0,0 +1,361 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.ThisExpr;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserAnonymousClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class MethodsResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void solveMethodAccessThroughSuper() {
+        CompilationUnit cu = parseSample("AccessThroughSuper");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessThroughSuper.SubClass");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "methodTest");
+        ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = returnStmt.getExpression().get();
+
+        ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+
+    @Test
+    public void solveMethodWithClassExpressionAsParameter() {
+        CompilationUnit cu = parseSample("ClassExpression");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassExpression");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
+        MethodCallExpr expression = Navigator.findMethodCall(method, "noneOf").get();
+
+        MethodUsage methodUsage = JavaParserFacade.get(new ReflectionTypeSolver()).solveMethodAsUsage(expression);
+        assertEquals("noneOf", methodUsage.getName());
+    }
+
+    @Test
+    public void solveMethodInInterfaceParent() {
+        CompilationUnit cu = parseSample("MethodCalls");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "inheritedInterfaceMethod");
+        MethodCallExpr expression = Navigator.findMethodCall(method, "toString").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodUsage call1 = javaParserFacade.solveMethodAsUsage(expression);
+        assertEquals("java.lang.Object.toString()", call1.getQualifiedSignature());
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToLong() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingLong");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToInt() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingInt");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToShort() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingShort");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToByte() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingByte");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("byteParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToLongWithExtraParam() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingLong");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToIntWithExtraParam() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingInt");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToShortWithExtraParam() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingShort");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void solveMethodWithTypePromotionsToByteWithExtraParam() {
+        CompilationUnit cu = parseSample("Issue338");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "callingByte");
+
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(true, reference.isSolved());
+            assertEquals("byteParam", reference.getCorrespondingDeclaration().getName());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+        {
+            MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
+            SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
+            assertEquals(false, reference.isSolved());
+        }
+
+    }
+
+    @Test
+    public void callOnThisInAnonymousClass() {
+        CompilationUnit cu = parseSample("ThisInAnonymousClass");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Bar");
+
+        MethodCallExpr fooCall = Navigator.findMethodCall(clazz, "foo").get();
+
+        SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(fooCall);
+        assertEquals(true, reference.isSolved());
+    }
+
+    @Test
+    public void thisInAnonymousClass() {
+        CompilationUnit cu = parseSample("ThisInAnonymousClass");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Bar");
+
+        ThisExpr thisExpression = Navigator.findNodeOfGivenClass(clazz, ThisExpr.class);
+
+        ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(thisExpression);
+        assertEquals(true, type.isReferenceType());
+        assertEquals(true, type.asReferenceType().getTypeDeclaration() instanceof JavaParserAnonymousClassDeclaration);
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/QualifiedNameResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/QualifiedNameResolutionTest.java
new file mode 100644
index 000000000..906ac68e6
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/QualifiedNameResolutionTest.java
@@ -0,0 +1,47 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class QualifiedNameResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void resolveLocalVariableInParentOfParent() {
+        CompilationUnit cu = parseSample("QualifiedNameTest");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "QualifiedNameTest");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo1");
+        NameExpr nameExpr = Navigator.findNameExpression(method, "s").get();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(nameExpr);
+        assertTrue(ref.isSolved());
+        assertEquals("java.util.Scanner", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/StatementContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/StatementContextResolutionTest.java
new file mode 100644
index 000000000..b96abf721
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/StatementContextResolutionTest.java
@@ -0,0 +1,108 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class StatementContextResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void resolveLocalVariableInParentOfParent() {
+        CompilationUnit cu = parseSample("LocalVariableInParent");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo1");
+        NameExpr nameExpr = Navigator.findNameExpression(method, "s").get();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(nameExpr);
+        assertTrue(ref.isSolved());
+        assertEquals("java.lang.String", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveLocalVariableInParent() {
+        CompilationUnit cu = parseSample("LocalVariableInParent");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo3");
+        NameExpr nameExpr = Navigator.findNameExpression(method, "s").get();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(nameExpr);
+        assertTrue(ref.isSolved());
+        assertEquals("java.lang.String", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveLocalVariableInSameParent() {
+        CompilationUnit cu = parseSample("LocalVariableInParent");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo2");
+        NameExpr nameExpr = Navigator.findNameExpression(method, "s").get();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(new ReflectionTypeSolver()).solve(nameExpr);
+        assertTrue(ref.isSolved());
+        assertEquals("java.lang.String", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void resolveLocalAndSeveralAnnidatedLevels() {
+        CompilationUnit cu = parseSample("LocalVariableInParent");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo4");
+        MethodCallExpr call = Navigator.findMethodCall(method, "add").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(typeSolver).solve(call.getScope().get());
+        assertTrue(ref.isSolved());
+        assertEquals("java.util.List<Comment>", ref.getCorrespondingDeclaration().getType().describe());
+
+        MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+        assertEquals("add", methodUsage.getName());
+    }
+
+    @Test
+    public void resolveMethodOnGenericClass() {
+        CompilationUnit cu = parseSample("LocalVariableInParent");
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration referencesToField = Navigator.demandClass(cu, "LocalVariableInParent");
+        MethodDeclaration method = Navigator.demandMethod(referencesToField, "foo5");
+        MethodCallExpr call = Navigator.findMethodCall(method, "add").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = JavaParserFacade.get(typeSolver).solve(call.getScope().get());
+        assertTrue(ref.isSolved());
+        assertEquals("java.util.List<Comment>", ref.getCorrespondingDeclaration().getType().describe());
+
+        MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(call);
+        assertEquals("add", methodUsage.getName());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverTest.java
new file mode 100644
index 000000000..eafe60122
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverTest.java
@@ -0,0 +1,100 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.visitor.VoidVisitor;
+import com.github.javaparser.ast.visitor.VoidVisitorAdapter;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Federico Tomassetti
+ */
+public class SymbolSolverTest extends AbstractTest {
+
+    private TypeSolver typeSolverNewCode;
+    private SymbolSolver symbolSolver;
+
+    @Before
+    public void setup() {
+
+        File srcNewCode = adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-core"));
+        CombinedTypeSolver combinedTypeSolverNewCode = new CombinedTypeSolver();
+        combinedTypeSolverNewCode.add(new ReflectionTypeSolver());
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(srcNewCode));
+        combinedTypeSolverNewCode.add(new JavaParserTypeSolver(adaptPath(new File("src/test/test_sourcecode/javaparser_new_src/javaparser-generated-sources"))));
+        typeSolverNewCode = combinedTypeSolverNewCode;
+
+        symbolSolver = new SymbolSolver(typeSolverNewCode);
+    }
+
+    @Test
+    public void testSolveSymbolUnexisting() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ResolvedValueDeclaration> res = symbolSolver.solveSymbolInType(constructorDeclaration, "unexisting");
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolveSymbolToDeclaredField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ResolvedValueDeclaration> res = symbolSolver.solveSymbolInType(constructorDeclaration, "name");
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPublicField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ResolvedValueDeclaration> res = symbolSolver.solveSymbolInType(constructorDeclaration, "NODE_BY_BEGIN_POSITION");
+        assertEquals(true, res.isSolved());
+        assertEquals(true, res.getCorrespondingDeclaration().isField());
+    }
+
+    @Test
+    public void testSolveSymbolToInheritedPrivateField() {
+        JavaParserClassDeclaration constructorDeclaration = (JavaParserClassDeclaration) typeSolverNewCode.solveType("com.github.javaparser.ast.body.ConstructorDeclaration");
+
+        SymbolReference<? extends ResolvedValueDeclaration> res = symbolSolver.solveSymbolInType(constructorDeclaration, "parentNode");
+        assertEquals(false, res.isSolved());
+    }
+
+    @Test
+    public void testSolvePackageLocalClass() {
+        assertTrue(typeSolverNewCode.solveType("com.github.javaparser.FooClass").isClass());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistClassTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistClassTest.java
new file mode 100644
index 000000000..cf103f156
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistClassTest.java
@@ -0,0 +1,139 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javassistmodel.JavassistClassDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+
+public class SymbolSolverWithJavassistClassTest extends AbstractTest {
+    private TypeSolver typeSolver;
+    private SymbolSolver symbolSolver;
+    private JavassistClassDeclaration classDeclarationConcreteClass;
+    private JavassistClassDeclaration classDeclarationSubClassOwnJar;
+    private JavassistClassDeclaration classDeclarationInterfaceUserOwnJar;
+    private JavassistClassDeclaration classDeclarationSubClassIncludedJar;
+    private JavassistClassDeclaration classDeclarationInterfaceUserIncludedJar;
+    private JavassistClassDeclaration classDeclarationSubClassExcludedJar;
+    private JavassistClassDeclaration classDeclarationInterfaceUserExcludedJar;
+
+    @Before
+    public void setup() throws IOException {
+        final String pathToMainJar = adaptPath("src/test/resources/javassist_symbols/main_jar/main_jar.jar");
+        final String pathToIncludedJar = adaptPath("src/test/resources/javassist_symbols/included_jar/included_jar.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToIncludedJar), new JarTypeSolver(pathToMainJar), new ReflectionTypeSolver());
+
+        symbolSolver = new SymbolSolver(typeSolver);
+
+        classDeclarationConcreteClass = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.ConcreteClass");
+        classDeclarationSubClassOwnJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubClassOwnJar");
+        classDeclarationSubClassIncludedJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubClassIncludedJar");
+        classDeclarationSubClassExcludedJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubClassExcludedJar");
+        classDeclarationInterfaceUserOwnJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.InterfaceUserOwnJar");
+        classDeclarationInterfaceUserIncludedJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.InterfaceUserIncludedJar");
+        classDeclarationInterfaceUserExcludedJar = (JavassistClassDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.InterfaceUserExcludedJar");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanSolveFirstOwnField() {
+        assertCanSolveSymbol("STATIC_STRING", classDeclarationConcreteClass);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanSolveSecondOwnField() {
+        assertCanSolveSymbol("SECOND_STRING", classDeclarationConcreteClass);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCantResolveNonExistentField() {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(classDeclarationConcreteClass, "FIELD_THAT_DOES_NOT_EXIST");
+
+        assertFalse(solvedSymbol.isSolved());
+
+        try {
+            solvedSymbol.getCorrespondingDeclaration();
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+            assertEquals("CorrespondingDeclaration not available for unsolved symbol.", e.getMessage());
+            return;
+        }
+        fail("Expected UnsupportedOperationException when requesting CorrespondingDeclaration on unsolved SymbolRefernce");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInSuper() {
+        assertCanSolveSymbol("SUPER_FIELD", classDeclarationSubClassOwnJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInSuperIncludedJar() {
+        assertCanSolveSymbol("SUPER_FIELD", classDeclarationSubClassIncludedJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeThrowsExceptionOnResolveFieldInSuperExcludedJar() {
+        try {
+            symbolSolver.solveSymbolInType(classDeclarationSubClassExcludedJar, "SUPER_FIELD");
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsolvedSymbolException);
+            assertEquals("Unsolved symbol : com.github.javaparser.javasymbolsolver.javassist_symbols.excluded_jar.SuperClassExcludedJar", e.getMessage());
+            return;
+        }
+        fail("Excepted NotFoundException wrapped in a RuntimeException, but got no exception.");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInInterface() {
+        assertCanSolveSymbol("INTERFACE_FIELD", classDeclarationInterfaceUserOwnJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInInterfaceIncludedJar() {
+        assertCanSolveSymbol("INTERFACE_FIELD", classDeclarationInterfaceUserIncludedJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeThrowsExceptionOnResolveFieldInInterfaceExcludedJar() {
+        try {
+            symbolSolver.solveSymbolInType(classDeclarationInterfaceUserExcludedJar, "INTERFACE_FIELD");
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsolvedSymbolException);
+            assertEquals("Unsolved symbol : com.github.javaparser.javasymbolsolver.javassist_symbols.excluded_jar.InterfaceExcludedJar", e.getMessage());
+            return;
+        }
+        fail("Excepted NotFoundException wrapped in a RuntimeException, but got no exception.");
+    }
+
+    private void assertCanSolveSymbol(String symbolName, JavassistClassDeclaration classDeclaration) {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(classDeclaration, symbolName);
+
+        assertTrue(solvedSymbol.isSolved());
+        assertEquals(symbolName, solvedSymbol.getCorrespondingDeclaration().asField().getName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistEnumTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistEnumTest.java
new file mode 100644
index 000000000..120d2f14d
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistEnumTest.java
@@ -0,0 +1,106 @@
+package com.github.javaparser.symbolsolver.resolution;
+
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javassistmodel.JavassistEnumDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.fail;
+
+public class SymbolSolverWithJavassistEnumTest extends AbstractTest {
+    private TypeSolver typeSolver;
+    private SymbolSolver symbolSolver;
+    private JavassistEnumDeclaration enumDeclarationConcrete;
+    private JavassistEnumDeclaration enumDeclarationInterfaceUserOwnJar;
+    private JavassistEnumDeclaration enumDeclarationInterfaceUserIncludedJar;
+    private JavassistEnumDeclaration enumDeclarationInterfaceUserExcludedJar;
+
+    @Before
+    public void setup() throws IOException {
+        final String pathToMainJar = adaptPath("src/test/resources/javassist_symbols/main_jar/main_jar.jar");
+        final String pathToIncludedJar = adaptPath("src/test/resources/javassist_symbols/included_jar/included_jar.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToIncludedJar), new JarTypeSolver(pathToMainJar), new ReflectionTypeSolver());
+
+        symbolSolver = new SymbolSolver(typeSolver);
+
+        enumDeclarationConcrete = (JavassistEnumDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.ConcreteEnum");
+        enumDeclarationInterfaceUserOwnJar = (JavassistEnumDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.EnumInterfaceUserOwnJar");
+        enumDeclarationInterfaceUserIncludedJar = (JavassistEnumDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.EnumInterfaceUserIncludedJar");
+        enumDeclarationInterfaceUserExcludedJar = (JavassistEnumDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.EnumInterfaceUserExcludedJar");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFirstEnumValue() {
+        assertCanSolveSymbol("ENUM_VAL_ONE", enumDeclarationConcrete);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveSecondEnumValue() {
+        assertCanSolveSymbol("ENUM_VAL_TWO", enumDeclarationConcrete);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFirstNormalField() {
+        assertCanSolveSymbol("STATIC_STRING", enumDeclarationConcrete);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveSecondNormalField() {
+        assertCanSolveSymbol("SECOND_STRING", enumDeclarationConcrete);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCantResolveNonExistentField() {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(enumDeclarationConcrete, "FIELD_THAT_DOES_NOT_EXIST");
+
+        assertFalse(solvedSymbol.isSolved());
+
+        try {
+            solvedSymbol.getCorrespondingDeclaration();
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+            assertEquals("CorrespondingDeclaration not available for unsolved symbol.", e.getMessage());
+            return;
+        }
+        fail("Expected UnsupportedOperationException when requesting CorrespondingDeclaration on unsolved SymbolRefernce");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInInterface() {
+        assertCanSolveSymbol("INTERFACE_FIELD", enumDeclarationInterfaceUserOwnJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInInterfaceIncludedJar() {
+        assertCanSolveSymbol("INTERFACE_FIELD", enumDeclarationInterfaceUserIncludedJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeThrowsExceptionOnResolveFieldInInterfaceExcludedJar() {
+        try {
+            symbolSolver.solveSymbolInType(enumDeclarationInterfaceUserExcludedJar, "INTERFACE_FIELD");
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsolvedSymbolException);
+            assertEquals("Unsolved symbol : com.github.javaparser.javasymbolsolver.javassist_symbols.excluded_jar.InterfaceExcludedJar", e.getMessage());
+            return;
+        }
+        fail("Excepted NotFoundException wrapped in a RuntimeException, but got no exception.");
+    }
+
+    private void assertCanSolveSymbol(String symbolName, JavassistEnumDeclaration enumDeclaration) {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(enumDeclaration, symbolName);
+
+        assertTrue(solvedSymbol.isSolved());
+        assertEquals(symbolName, solvedSymbol.getCorrespondingDeclaration().asField().getName());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistInterfaceTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistInterfaceTest.java
new file mode 100644
index 000000000..7745e813f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/SymbolSolverWithJavassistInterfaceTest.java
@@ -0,0 +1,96 @@
+package com.github.javaparser.symbolsolver.resolution;
+
+import com.github.javaparser.resolution.UnsolvedSymbolException;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.AbstractTest;
+import com.github.javaparser.symbolsolver.javassistmodel.JavassistInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.*;
+
+public class SymbolSolverWithJavassistInterfaceTest extends AbstractTest {
+    private TypeSolver typeSolver;
+    private SymbolSolver symbolSolver;
+    private JavassistInterfaceDeclaration interfaceDeclarationStandalone;
+    private JavassistInterfaceDeclaration interfaceDeclarationSubInterfaceOwnJar;
+    private JavassistInterfaceDeclaration interfaceDeclarationSubInterfaceIncludedJar;
+    private JavassistInterfaceDeclaration interfaceDeclarationSubInterfaceExcludedJar;
+
+    @Before
+    public void setup() throws IOException {
+        final String pathToMainJar = adaptPath("src/test/resources/javassist_symbols/main_jar/main_jar.jar");
+        final String pathToIncludedJar = adaptPath("src/test/resources/javassist_symbols/included_jar/included_jar.jar");
+        typeSolver = new CombinedTypeSolver(new JarTypeSolver(pathToIncludedJar), new JarTypeSolver(pathToMainJar), new ReflectionTypeSolver());
+
+        symbolSolver = new SymbolSolver(typeSolver);
+
+        interfaceDeclarationStandalone = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.StandaloneInterface");
+        interfaceDeclarationSubInterfaceOwnJar = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubInterfaceOwnJar");
+        interfaceDeclarationSubInterfaceIncludedJar = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubInterfaceIncludedJar");
+        interfaceDeclarationSubInterfaceExcludedJar = (JavassistInterfaceDeclaration) typeSolver.solveType("com.github.javaparser.javasymbolsolver.javassist_symbols.main_jar.SubInterfaceExcludedJar");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFirstNormalField() {
+        assertCanSolveSymbol("STATIC_STRING", interfaceDeclarationStandalone);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveSecondNormalField() {
+        assertCanSolveSymbol("SECOND_STRING", interfaceDeclarationStandalone);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCantResolveNonExistentField() {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(interfaceDeclarationStandalone, "FIELD_THAT_DOES_NOT_EXIST");
+
+        assertFalse(solvedSymbol.isSolved());
+
+        try {
+            solvedSymbol.getCorrespondingDeclaration();
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+            assertEquals("CorrespondingDeclaration not available for unsolved symbol.", e.getMessage());
+            return;
+        }
+        fail("Expected UnsupportedOperationException when requesting CorrespondingDeclaration on unsolved SymbolRefernce");
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInExtendedInterfaceOwnJar() {
+        assertCanSolveSymbol("INTERFACE_FIELD", interfaceDeclarationSubInterfaceOwnJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeCanResolveFieldInExtendedInterfaceIncludedJar() {
+        assertCanSolveSymbol("INTERFACE_FIELD", interfaceDeclarationSubInterfaceIncludedJar);
+    }
+
+    @Test
+    public void testSolveSymbolInTypeThrowsExceptionOnResolveFieldInExtendedInterfaceExcludedJar() {
+        try {
+            symbolSolver.solveSymbolInType(interfaceDeclarationSubInterfaceExcludedJar, "INTERFACE_FIELD");
+        } catch (Exception e) {
+            assertTrue(e instanceof UnsolvedSymbolException);
+            assertEquals("Unsolved symbol : com.github.javaparser.javasymbolsolver.javassist_symbols.excluded_jar.InterfaceExcludedJar", e.getMessage());
+            return;
+        }
+        fail("Excepted NotFoundException wrapped in a RuntimeException, but got no exception.");
+    }
+
+    private void assertCanSolveSymbol(String symbolName, JavassistInterfaceDeclaration interfaceDeclaration) {
+        SymbolReference<? extends ResolvedValueDeclaration> solvedSymbol = symbolSolver.solveSymbolInType(interfaceDeclaration, symbolName);
+
+        assertTrue(solvedSymbol.isSolved());
+        assertEquals(symbolName, solvedSymbol.getCorrespondingDeclaration().asField().getName());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/VariadicResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/VariadicResolutionTest.java
new file mode 100644
index 000000000..48c0ca708
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/VariadicResolutionTest.java
@@ -0,0 +1,104 @@
+/*
+ * 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.resolution;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class VariadicResolutionTest extends AbstractResolutionTest {
+
+	@Test
+    public void issue7() {
+        CompilationUnit cu = parseSample("Generics_issue7");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "SomeCollection");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo3");
+
+        ReturnStmt stmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
+        Expression expression = stmt.getExpression().get();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(new ReflectionTypeSolver());
+        ResolvedType type = javaParserFacade.getType(expression);
+        assertEquals(true, type.isReferenceType());
+        assertEquals(List.class.getCanonicalName(), type.asReferenceType().getQualifiedName());
+        assertEquals("java.util.List<java.lang.Long>", type.describe());
+    }
+	
+	@Test
+    public void methodCallWithReferenceTypeAsVaridicArgumentIsSolved() {
+        CompilationUnit cu = parseSample("MethodCalls");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "variadicMethod");
+        MethodCallExpr callExpr = Navigator.findMethodCall(method, "variadicMethod").get();
+        
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodUsage callee = javaParserFacade.solveMethodAsUsage(callExpr);
+        assertEquals("variadicMethod", callee.getName());
+    }
+
+    @Test
+    public void resolveVariadicMethodWithGenericArgument() {
+        CompilationUnit cu = parseSample("MethodCalls");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "genericMethodTest");
+        MethodCallExpr callExpr = Navigator.findMethodCall(method, "variadicWithGenericArg").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodUsage callee = javaParserFacade.solveMethodAsUsage(callExpr);
+        assertEquals("variadicWithGenericArg", callee.getName());
+    }
+
+    @Test
+    public void selectMostSpecificVariadic() {
+        CompilationUnit cu = parseSample("MethodCalls");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+
+        MethodDeclaration method = Navigator.demandMethod(clazz, "variadicTest");
+        List<MethodCallExpr> calls = method.findAll(MethodCallExpr.class);
+
+        File src = adaptPath(new File("src/test/resources"));
+        TypeSolver typeSolver = new CombinedTypeSolver(new ReflectionTypeSolver(), new JavaParserTypeSolver(src));
+
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        MethodUsage call1 = javaParserFacade.solveMethodAsUsage(calls.get(0));
+        MethodUsage call2 = javaParserFacade.solveMethodAsUsage(calls.get(1));
+        assertEquals("int", call1.returnType().describe());
+        assertEquals("void", call2.returnType().describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/VarTypeTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/VarTypeTest.java
new file mode 100644
index 000000000..d8d0eafe0
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/VarTypeTest.java
@@ -0,0 +1,62 @@
+package com.github.javaparser.symbolsolver.resolution.javaparser;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseStart;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.type.VarType;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static com.github.javaparser.ParserConfiguration.LanguageLevel.JAVA_10;
+import static com.github.javaparser.Providers.provider;
+import static org.junit.Assert.assertEquals;
+
+public class VarTypeTest {
+    private final TypeSolver typeSolver = new ReflectionTypeSolver();
+    private final JavaParser javaParser = new JavaParser(new ParserConfiguration()
+            .setLanguageLevel(JAVA_10)
+            .setSymbolResolver(new JavaSymbolSolver(typeSolver)));
+
+    @Test
+    public void resolveAPrimitive() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{void x(){var abc = 1;}}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        ResolvedType resolvedType = varType.resolve();
+
+        assertEquals(ResolvedPrimitiveType.INT, resolvedType);
+    }
+
+    @Test
+    public void resolveAReferenceType() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{void x(){var abc = \"\";}}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        ResolvedType resolvedType = varType.resolve();
+
+        assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver), resolvedType);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void failResolveNoInitializer() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{void x(){var abc;}}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        varType.resolve();
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void failResolveWrongLocation() {
+        CompilationUnit ast = javaParser.parse(ParseStart.COMPILATION_UNIT, provider("class X{void x(var x){};}")).getResult().get();
+        VarType varType = ast.findFirst(VarType.class).get();
+
+        varType.resolve();
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/ClassOrInterfaceDeclarationContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/ClassOrInterfaceDeclarationContextResolutionTest.java
new file mode 100644
index 000000000..a55941808
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/ClassOrInterfaceDeclarationContextResolutionTest.java
@@ -0,0 +1,490 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.resolution.MethodAmbiguityException;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.ClassOrInterfaceDeclarationContext;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.CompilationUnitContext;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.resolution.Value;
+import com.github.javaparser.symbolsolver.model.typesystem.NullType;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.reflectionmodel.ReflectionClassDeclaration;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.MemoryTypeSolver;
+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.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * @author Federico Tomassetti
+ */
+public class ClassOrInterfaceDeclarationContextResolutionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+    }
+
+    @Test
+    public void getParentForTopClass() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        assertFalse(null == context.getParent());
+        assertEquals(new CompilationUnitContext(cu, typeSolver), context.getParent());
+    }
+
+    @Test
+    public void solveExistingGenericType() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<ResolvedType> a = context.solveGenericType("A", new MemoryTypeSolver());
+        Optional<ResolvedType> b = context.solveGenericType("B", new MemoryTypeSolver());
+        Optional<ResolvedType> c = context.solveGenericType("C", new MemoryTypeSolver());
+
+        assertEquals(true, a.isPresent());
+        assertEquals("A", a.get().describe());
+        assertEquals(true, a.get().isTypeVariable());
+        assertEquals(true, b.isPresent());
+        assertEquals("B", b.get().describe());
+        assertEquals(true, b.get().isTypeVariable());
+        assertEquals(true, c.isPresent());
+        assertEquals("C", c.get().describe());
+        assertEquals(true, c.get().isTypeVariable());
+    }
+
+    @Test
+    public void solveUnexistingGenericType() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<ResolvedType> d = context.solveGenericType("D", new MemoryTypeSolver());
+
+        assertEquals(false, d.isPresent());
+    }
+
+    @Test
+    public void solveSymbolReferringToDeclaredInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("i", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("int", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToDeclaredStaticField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("j", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("long", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToInheritedInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("k", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("boolean", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToInterfaceInheritedInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("o", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("int", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToInheritedStaticField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("m", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("char", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToUnknownElement() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("zzz", new MemoryTypeSolver());
+        assertEquals(false, ref.isSolved());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToDeclaredInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("i", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("int", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToDeclaredStaticField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("j", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("long", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToInheritedInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("k", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("boolean", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToInterfaceInheritedInstanceField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        ClassOrInterfaceDeclarationContext context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("o", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("int", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToInheritedStaticField() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("m", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("char", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToUnknownElement() {
+        CompilationUnit cu = parseSample("ClassWithSymbols");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("zzz", new MemoryTypeSolver());
+        assertEquals(false, ref.isPresent());
+    }
+
+    @Test
+    public void solveTypeRefToItself() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("A", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToUnexisting() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("Foo", new MemoryTypeSolver());
+        assertEquals(false, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToObject() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("Object", new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToJavaLangObject() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("java.lang.Object", new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToInternalClass() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("B", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToInternalEnum() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("E", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToInternalOfInternalClass() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("C", new MemoryTypeSolver());
+        assertEquals(false, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToAnotherClassInFile() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("Super", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToQualifiedInternalClass() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("A.B", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToQualifiedInternalOfInternalClass() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("B.C", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveTypeRefToMoreQualifiedInternalOfInternalClass() {
+        CompilationUnit cu = parseSample("ClassWithTypes");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("A.B.C", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+
+    @Test
+    public void solveMethodSimpleCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo0", ImmutableList.of(), false, new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName());
+        assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams());
+    }
+
+    @Test
+    public void solveMethodOverrideCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo1", ImmutableList.of(), false, new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName());
+        assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams());
+    }
+
+    @Test
+    public void solveMethodInheritedCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo2", ImmutableList.of(), false, new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("Super", ref.getCorrespondingDeclaration().declaringType().getName());
+        assertEquals(0, ref.getCorrespondingDeclaration().getNumberOfParams());
+    }
+
+    @Test
+    public void solveMethodWithPrimitiveParameters() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        ResolvedType intType = ResolvedPrimitiveType.INT;
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo3", ImmutableList.of(intType), false, new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName());
+        assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams());
+    }
+
+    @Test
+    public void solveMethodWithMoreSpecializedParameter() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo4", ImmutableList.of(stringType), false, new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName());
+        assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams());
+    }
+
+    @Test(expected = MethodAmbiguityException.class)
+    public void solveMethodWithAmbiguosCall() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo5", ImmutableList.of(NullType.INSTANCE), false, new ReflectionTypeSolver());
+    }
+
+    @Test
+    public void solveMethodAsUsageSimpleCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo0", ImmutableList.of(), new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("A", ref.get().declaringType().getName());
+        assertEquals(0, ref.get().getNoParams());
+    }
+
+    @Test
+    public void solveMethodAsUsageOverrideCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo1", ImmutableList.of(), new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("A", ref.get().declaringType().getName());
+        assertEquals(0, ref.get().getNoParams());
+    }
+
+    @Test
+    public void solveMethodAsUsageInheritedCase() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo2", ImmutableList.of(), new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("Super", ref.get().declaringType().getName());
+        assertEquals(0, ref.get().getNoParams());
+    }
+
+    @Test
+    public void solveMethodAsUsageWithPrimitiveParameters() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        ResolvedType intType = ResolvedPrimitiveType.INT;
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo3", ImmutableList.of(intType), new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("A", ref.get().declaringType().getName());
+        assertEquals(1, ref.get().getNoParams());
+    }
+
+    @Test
+    public void solveMethodAsUsageWithMoreSpecializedParameter() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo4", ImmutableList.of(stringType), new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("A", ref.get().declaringType().getName());
+        assertEquals(1, ref.get().getNoParams());
+    }
+
+    @Test(expected = MethodAmbiguityException.class)
+    public void solveMethodAsUsageWithAmbiguosCall() {
+        CompilationUnit cu = parseSample("ClassWithMethods");
+        ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A");
+        Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo5", ImmutableList.of(NullType.INSTANCE), new ReflectionTypeSolver());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/CompilationUnitContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/CompilationUnitContextResolutionTest.java
new file mode 100644
index 000000000..c079e5982
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/CompilationUnitContextResolutionTest.java
@@ -0,0 +1,236 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.types.ResolvedPrimitiveType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.CompilationUnitContext;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.resolution.Value;
+import com.github.javaparser.symbolsolver.model.typesystem.NullType;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.MemoryTypeSolver;
+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.IOException;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * @author Federico Tomassetti
+ */
+public class CompilationUnitContextResolutionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+    }
+
+    @Test
+    public void getParent() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        assertTrue(null == context.getParent());
+    }
+
+    @Test
+    public void solveExistingGenericType() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        Optional<ResolvedType> a = context.solveGenericType("A", new MemoryTypeSolver());
+        Optional<ResolvedType> b = context.solveGenericType("B", new MemoryTypeSolver());
+        Optional<ResolvedType> c = context.solveGenericType("C", new MemoryTypeSolver());
+
+        assertEquals(false, a.isPresent());
+        assertEquals(false, b.isPresent());
+        assertEquals(false, c.isPresent());
+    }
+
+    @Test
+    public void solveUnexistingGenericType() {
+        CompilationUnit cu = parseSample("ClassWithTypeVariables");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        Optional<ResolvedType> d = context.solveGenericType("D", new MemoryTypeSolver());
+
+        assertEquals(false, d.isPresent());
+    }
+
+    @Test
+    public void solveSymbolReferringToStaticallyImportedValue() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new ReflectionTypeSolver());
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("out", typeSolver);
+        assertEquals(true, ref.isSolved());
+        assertEquals("java.io.PrintStream", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void solveSymbolReferringToStaticallyImportedUsingAsteriskValue() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new ReflectionTypeSolver());
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("err", typeSolver);
+        assertEquals(true, ref.isSolved());
+        assertEquals("java.io.PrintStream", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void solveSymbolReferringToStaticField() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("java.lang.System.out", new ReflectionTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("java.io.PrintStream", ref.getCorrespondingDeclaration().getType().asReferenceType().getQualifiedName());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToStaticallyImportedValue() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new ReflectionTypeSolver());
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        Optional<Value> ref = context.solveSymbolAsValue("out", typeSolver);
+        assertEquals(true, ref.isPresent());
+        assertEquals("java.io.PrintStream", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToStaticallyImportedUsingAsteriskValue() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new ReflectionTypeSolver());
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        Optional<Value> ref = context.solveSymbolAsValue("err", typeSolver);
+        assertEquals(true, ref.isPresent());
+        assertEquals("java.io.PrintStream", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToStaticField() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("java.lang.System.out", new ReflectionTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("java.io.PrintStream", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveTypeInSamePackage() {
+        CompilationUnit cu = parseSample("CompilationUnitWithImports");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        ResolvedReferenceTypeDeclaration otherClass = mock(ResolvedReferenceTypeDeclaration.class);
+        when(otherClass.getQualifiedName()).thenReturn("com.foo.OtherClassInSamePackage");
+        MemoryTypeSolver memoryTypeSolver = new MemoryTypeSolver();
+        memoryTypeSolver.addDeclaration("com.foo.OtherClassInSamePackage", otherClass);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("OtherClassInSamePackage", memoryTypeSolver);
+        assertEquals(true, ref.isSolved());
+        assertEquals("com.foo.OtherClassInSamePackage", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void solveTypeImported() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitWithImports");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("Assert", new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        assertEquals(true, ref.isSolved());
+        assertEquals("org.junit.Assert", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void solveTypeNotImported() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitWithImports");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("org.junit.Assume", new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        assertEquals(true, ref.isSolved());
+        assertEquals("org.junit.Assume", ref.getCorrespondingDeclaration().getQualifiedName());
+    }
+
+    @Test
+    public void solveMethodStaticallyImportedWithAsterisk() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitWithImports");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        typeSolver.add(new ReflectionTypeSolver());
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("assertFalse", ImmutableList.of(ResolvedPrimitiveType.BOOLEAN), false, typeSolver);
+        assertEquals(true, ref.isSolved());
+        assertEquals("assertFalse", ref.getCorrespondingDeclaration().getName());
+        assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams());
+        assertEquals("boolean", ref.getCorrespondingDeclaration().getParam(0).getType().describe());
+        assertEquals(true, ref.getCorrespondingDeclaration().getParam(0).getType().isPrimitive());
+    }
+
+    @Test
+    public void solveMethodStaticallyImportedWithoutAsterisk() throws ParseException, IOException {
+        CompilationUnit cu = parseSample("CompilationUnitSymbols");
+        Context context = new CompilationUnitContext(cu, typeSolver);
+
+        CombinedTypeSolver typeSolver = new CombinedTypeSolver();
+        typeSolver.add(new JarTypeSolver(adaptPath("src/test/resources/junit-4.8.1.jar")));
+        typeSolver.add(new ReflectionTypeSolver());
+
+        SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("assertEquals", ImmutableList.of(NullType.INSTANCE, NullType.INSTANCE), false, typeSolver);
+        assertEquals(true, ref.isSolved());
+        assertEquals("assertEquals", ref.getCorrespondingDeclaration().getName());
+        assertEquals(2, ref.getCorrespondingDeclaration().getNumberOfParams());
+        assertEquals("java.lang.Object", ref.getCorrespondingDeclaration().getParam(0).getType().asReferenceType().getQualifiedName());
+        assertEquals("java.lang.Object", ref.getCorrespondingDeclaration().getParam(1).getType().asReferenceType().getQualifiedName());
+
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/EnumDeclarationContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/EnumDeclarationContextResolutionTest.java
new file mode 100644
index 000000000..93af30e48
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/EnumDeclarationContextResolutionTest.java
@@ -0,0 +1,116 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.EnumDeclarationContext;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.resolution.Value;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.MemoryTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Federico Tomassetti
+ */
+public class EnumDeclarationContextResolutionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+    }
+
+    @Test
+    public void solveSymbolReferringToDeclaredInstanceField() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("i", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("int", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToDeclaredStaticField() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("j", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("long", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolReferringToValue() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        SymbolReference<? extends ResolvedValueDeclaration> ref = context.solveSymbol("E1", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+        assertEquals("MyEnum", ref.getCorrespondingDeclaration().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToDeclaredInstanceField() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("i", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("int", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToDeclaredStaticField() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("j", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("long", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveSymbolAsValueReferringToValue() {
+        CompilationUnit cu = parseSample("AnEnum");
+        com.github.javaparser.ast.body.EnumDeclaration enumDeclaration = Navigator.demandEnum(cu, "MyEnum");
+        Context context = new EnumDeclarationContext(enumDeclaration, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("E1", new MemoryTypeSolver());
+        assertEquals(true, ref.isPresent());
+        assertEquals("MyEnum", ref.get().getType().describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/FieldAccessContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/FieldAccessContextResolutionTest.java
new file mode 100644
index 000000000..b13737e51
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/FieldAccessContextResolutionTest.java
@@ -0,0 +1,51 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Malte Langkabel
+ */
+public class FieldAccessContextResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void solveMethodCallInFieldAccessContext() {
+        CompilationUnit cu = parseSample("MethodCalls");
+
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "bar2");
+        MethodCallExpr methodCallExpr = Navigator.findMethodCall(method, "getSelf").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        MethodUsage methodUsage = JavaParserFacade.get(typeSolver).solveMethodAsUsage(methodCallExpr);
+
+        assertEquals(methodUsage.getName(), "getSelf");
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/LambdaExprContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/LambdaExprContextResolutionTest.java
new file mode 100644
index 000000000..63e513c7a
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/LambdaExprContextResolutionTest.java
@@ -0,0 +1,112 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.LambdaExprContext;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.resolution.Value;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Malte Langkabel
+ */
+public class LambdaExprContextResolutionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+    }
+
+    @Test
+    public void solveParameterOfLambdaInMethodCallExpr() {
+        CompilationUnit cu = parseSample("Lambda");
+
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "lambdaMap");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        MethodCallExpr methodCallExpr = (MethodCallExpr) returnStmt.getExpression().get();
+        LambdaExpr lambdaExpr = (LambdaExpr) methodCallExpr.getArguments().get(0);
+
+        Context context = new LambdaExprContext(lambdaExpr, typeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("p", typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("? super java.lang.String", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveParameterOfLambdaInFieldDecl() {
+        CompilationUnit cu = parseSample("Lambda");
+
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        VariableDeclarator field = Navigator.demandField(clazz, "functional");
+        LambdaExpr lambdaExpr = (LambdaExpr) field.getInitializer().get();
+
+        File src = new File("src/test/resources");
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(adaptPath(src)));
+
+        Context context = new LambdaExprContext(lambdaExpr, combinedTypeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("p", typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("java.lang.String", ref.get().getType().describe());
+    }
+
+    @Test
+    public void solveParameterOfLambdaInVarDecl() {
+        CompilationUnit cu = parseSample("Lambda");
+
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Agenda");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "testFunctionalVar");
+        VariableDeclarator varDecl = Navigator.demandVariableDeclaration(method, "a").get();
+        LambdaExpr lambdaExpr = (LambdaExpr) varDecl.getInitializer().get();
+
+        File src = adaptPath(new File("src/test/resources"));
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+
+        Context context = new LambdaExprContext(lambdaExpr, combinedTypeSolver);
+
+        Optional<Value> ref = context.solveSymbolAsValue("p", typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("java.lang.String", ref.get().getType().describe());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodCallExprContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodCallExprContextResolutionTest.java
new file mode 100644
index 000000000..7fdaf73fd
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodCallExprContextResolutionTest.java
@@ -0,0 +1,126 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.MethodUsage;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.MethodCallExprContext;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @author Malte Langkabel
+ */
+public class MethodCallExprContextResolutionTest extends AbstractResolutionTest {
+    private MethodCallExpr getMethodCallExpr(String methodName, String callingMethodName) {
+        CompilationUnit cu = parseSample("MethodCalls");
+
+        com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
+        MethodDeclaration method = Navigator.demandMethod(clazz, methodName);
+        return Navigator.findMethodCall(method, callingMethodName).get();
+    }
+
+    private CombinedTypeSolver createTypeSolver() {
+        File src = adaptPath(new File("src/test/resources"));
+        CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+        combinedTypeSolver.add(new ReflectionTypeSolver());
+        combinedTypeSolver.add(new JavaParserTypeSolver(src));
+        return combinedTypeSolver;
+    }
+
+    @Test
+    public void solveNestedMethodCallExprContextWithoutScope() {
+        MethodCallExpr methodCallExpr = getMethodCallExpr("bar1", "foo");
+        CombinedTypeSolver typeSolver = createTypeSolver();
+
+        Context context = new MethodCallExprContext(methodCallExpr, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage("foo", Collections.emptyList(), typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName());
+    }
+
+    @Test
+    public void solveGenericMethodCallMustUseProvidedTypeArgs() {
+        assertCanSolveGenericMethodCallMustUseProvidedTypeArgs("genericMethod0");
+    }
+
+    @Test
+    public void solveStaticGenericMethodCallMustUseProvidedTypeArgs() {
+        assertCanSolveGenericMethodCallMustUseProvidedTypeArgs("staticGenericMethod0");
+    }
+
+    private void assertCanSolveGenericMethodCallMustUseProvidedTypeArgs(String callMethodName) {
+        MethodCallExpr methodCallExpr = getMethodCallExpr("genericMethodTest", callMethodName);
+        CombinedTypeSolver typeSolver = createTypeSolver();
+
+        MethodCallExprContext context = new MethodCallExprContext(methodCallExpr, typeSolver);
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage(callMethodName, Collections.emptyList(), typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName());
+        assertEquals(Collections.singletonList("java.lang.Integer"), ref.get().typeParametersMap().getTypes().stream().map(ty -> ty.asReferenceType().describe()).collect(Collectors.toList()));
+    }
+
+    @Test
+    public void solveGenericMethodCallCanInferFromArguments() {
+        assertCanSolveGenericMethodCallCanInferFromArguments("genericMethod1");
+    }
+
+    @Test
+    public void solveStaticGenericMethodCallCanInferFromArguments() {
+        assertCanSolveGenericMethodCallCanInferFromArguments("staticGenericMethod1");
+    }
+
+    private void assertCanSolveGenericMethodCallCanInferFromArguments(String callMethodName) {
+        MethodCallExpr methodCallExpr = getMethodCallExpr("genericMethodTest", callMethodName);
+        CombinedTypeSolver typeSolver = createTypeSolver();
+
+        MethodCallExprContext context = new MethodCallExprContext(methodCallExpr, typeSolver);
+
+        ResolvedReferenceTypeDeclaration stringType = typeSolver.solveType("java.lang.String");
+
+        List<ResolvedType> argumentsTypes = new ArrayList<>();
+        argumentsTypes.add(new ReferenceTypeImpl(stringType, typeSolver));
+
+        Optional<MethodUsage> ref = context.solveMethodAsUsage(callMethodName, argumentsTypes, typeSolver);
+        assertTrue(ref.isPresent());
+        assertEquals("MethodCalls", ref.get().declaringType().getQualifiedName());
+        assertEquals(Collections.singletonList("java.lang.String"), ref.get().typeParametersMap().getTypes().stream().map(ty -> ty.asReferenceType().describe()).collect(Collectors.toList()));
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodContextResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodContextResolutionTest.java
new file mode 100644
index 000000000..17d978079
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/contexts/MethodContextResolutionTest.java
@@ -0,0 +1,59 @@
+/*
+ * 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.resolution.javaparser.contexts;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.symbolsolver.core.resolution.Context;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.contexts.MethodContext;
+import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.MemoryTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * @author Malte Langkabel
+ */
+public class MethodContextResolutionTest extends AbstractResolutionTest {
+
+    private TypeSolver typeSolver;
+
+    @Before
+    public void setup() {
+        typeSolver = new ReflectionTypeSolver();
+    }
+
+    @Test
+    public void solveTypeRefToLocalClass() {
+        CompilationUnit cu = parseSample("MethodWithTypes");
+        ClassOrInterfaceDeclaration cd = Navigator.demandClass(cu, "Main");
+        MethodDeclaration md = Navigator.demandMethod(cd, "methodWithLocalTypes");
+        Context context = new MethodContext(md, typeSolver);
+
+        SymbolReference<ResolvedTypeDeclaration> ref = context.solveType("LocalClass", new MemoryTypeSolver());
+        assertEquals(true, ref.isSolved());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/declarations/JavaParserTypeParameterResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/declarations/JavaParserTypeParameterResolutionTest.java
new file mode 100644
index 000000000..c72e7727f
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/javaparser/declarations/JavaParserTypeParameterResolutionTest.java
@@ -0,0 +1,100 @@
+/*
+ * 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.resolution.javaparser.declarations;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserTypeParameter;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class JavaParserTypeParameterResolutionTest extends AbstractResolutionTest {
+
+    private void testGenericArguments(String containingMethodName) {
+        CompilationUnit cu = parseSample("GenericMethodArguments");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        ClassOrInterfaceDeclaration classDecl = Navigator.demandClass(cu, "GenericMethodArguments");
+        MethodDeclaration containingMethod = Navigator.demandMethod(classDecl, containingMethodName);
+        MethodCallExpr bar = Navigator.findMethodCall(containingMethod, "apply").get();
+
+        assertTrue(javaParserFacade.solve(bar).isSolved());
+    }
+
+    @Test
+    public void genericMethodWithGenericClassBasedArgument() {
+        testGenericArguments("useCase1");
+    }
+
+    @Test
+    public void genericMethodWithGenericClassArgument() {
+        testGenericArguments("useCase2");
+    }
+
+    @Test
+    public void declaredOnMethodPositiveCase() {
+        CompilationUnit cu = parseSample("MethodTypeParameter");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        ClassOrInterfaceDeclaration classDecl = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration methodDecl = Navigator.demandMethod(classDecl, "usage");
+        MethodCallExpr callToFoo = (MethodCallExpr) Navigator.findReturnStmt(methodDecl).getExpression().get();
+        ResolvedMethodDeclaration methodDeclaration = javaParserFacade.solve(callToFoo).getCorrespondingDeclaration();
+        for (ResolvedTypeParameterDeclaration tp : methodDeclaration.getTypeParameters()) {
+            assertTrue(tp instanceof JavaParserTypeParameter);
+            assertEquals("C", tp.getName());
+            assertEquals(true, tp.declaredOnMethod());
+            assertEquals(false, tp.declaredOnType());
+        }
+    }
+
+    @Test
+    public void declaredOnMethodNegativeCase() {
+        CompilationUnit cu = parseSample("ClassTypeParameter");
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
+        ClassOrInterfaceDeclaration classDecl = Navigator.demandClass(cu, "Foo");
+        MethodDeclaration methodDecl = Navigator.demandMethod(classDecl, "usage");
+        MethodCallExpr callToFoo = (MethodCallExpr) Navigator.findReturnStmt(methodDecl).getExpression().get();
+        ResolvedMethodDeclaration methodDeclaration = javaParserFacade.solve(callToFoo).getCorrespondingDeclaration();
+        ResolvedReferenceTypeDeclaration typeDeclaration = methodDeclaration.declaringType();
+        assertEquals(2, typeDeclaration.getTypeParameters().size());
+        assertTrue(typeDeclaration.getTypeParameters().get(0) instanceof JavaParserTypeParameter);
+        assertEquals("A", typeDeclaration.getTypeParameters().get(0).getName());
+        assertEquals(false, typeDeclaration.getTypeParameters().get(0).declaredOnMethod());
+        assertEquals(true, typeDeclaration.getTypeParameters().get(0).declaredOnType());
+        assertTrue(typeDeclaration.getTypeParameters().get(1) instanceof JavaParserTypeParameter);
+        assertEquals("B", typeDeclaration.getTypeParameters().get(1).getName());
+        assertEquals(false, typeDeclaration.getTypeParameters().get(1).declaredOnMethod());
+        assertEquals(true, typeDeclaration.getTypeParameters().get(1).declaredOnType());
+
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/reflectionmodel/SymbolResolutionResolutionTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/reflectionmodel/SymbolResolutionResolutionTest.java
new file mode 100644
index 000000000..8e0989f24
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/reflectionmodel/SymbolResolutionResolutionTest.java
@@ -0,0 +1,86 @@
+/*
+ * 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.resolution.reflectionmodel;
+
+import com.github.javaparser.ParseException;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.stmt.ReturnStmt;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.javaparser.Navigator;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class SymbolResolutionResolutionTest extends AbstractResolutionTest {
+
+    @Test
+    public void getTypeOfField() {
+        CompilationUnit cu = parseSample("ReflectionFieldOfItself");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MyClass");
+        VariableDeclarator field = Navigator.demandField(clazz, "PUBLIC");
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType ref = JavaParserFacade.get(typeSolver).getType(field);
+        assertEquals("int", ref.describe());
+    }
+
+    @Test
+    public void getTypeOfFieldAccess() {
+        CompilationUnit cu = parseSample("ReflectionFieldOfItself");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MyClass");
+        VariableDeclarator field = Navigator.demandField(clazz, "PUBLIC");
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType ref = JavaParserFacade.get(typeSolver).getType(field.getInitializer().get());
+        assertEquals("int", ref.describe());
+    }
+
+    @Test
+    public void conditionalExpressionExample() {
+        CompilationUnit cu = parseSample("JreConditionalExpression");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MyClass");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo1");
+        ReturnStmt returnStmt = Navigator.findReturnStmt(method);
+        Expression expression = returnStmt.getExpression().get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType ref = JavaParserFacade.get(typeSolver).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+
+    @Test
+    public void conditionalExpressionExampleFollowUp1() {
+        CompilationUnit cu = parseSample("JreConditionalExpression");
+        ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MyClass");
+        MethodDeclaration method = Navigator.demandMethod(clazz, "foo1");
+        MethodCallExpr expression = Navigator.findMethodCall(method, "next").get();
+
+        TypeSolver typeSolver = new ReflectionTypeSolver();
+        ResolvedType ref = JavaParserFacade.get(typeSolver).getType(expression);
+        assertEquals("java.lang.String", ref.describe());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SameAsBoundTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SameAsBoundTest.java
new file mode 100644
index 000000000..ba58dc797
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SameAsBoundTest.java
@@ -0,0 +1,32 @@
+package com.github.javaparser.symbolsolver.resolution.typeinference.bounds;
+
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typeinference.Bound;
+import com.github.javaparser.symbolsolver.resolution.typeinference.InferenceVariable;
+import com.github.javaparser.symbolsolver.resolution.typeinference.Instantiation;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+
+public class SameAsBoundTest {
+
+    private TypeSolver typeSolver = new ReflectionTypeSolver();
+    private ResolvedType stringType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(String.class.getCanonicalName()), typeSolver);
+
+    @Test
+    public void recognizeInstantiation() {
+        // { α = String } contains a single bound, instantiating α as String.
+        InferenceVariable inferenceVariable = new InferenceVariable("α", null);
+        Bound bound1 = new SameAsBound(inferenceVariable, stringType);
+        Bound bound2 = new SameAsBound(stringType, inferenceVariable);
+
+        assertEquals(Optional.of(new Instantiation(inferenceVariable, stringType)), bound1.isAnInstantiation());
+        assertEquals(Optional.of(new Instantiation(inferenceVariable, stringType)), bound2.isAnInstantiation());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SubtypeOfBoundTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SubtypeOfBoundTest.java
new file mode 100644
index 000000000..ecda07701
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/bounds/SubtypeOfBoundTest.java
@@ -0,0 +1,86 @@
+package com.github.javaparser.symbolsolver.resolution.typeinference.bounds;
+
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.resolution.types.ResolvedWildcard;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typeinference.*;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import static com.github.javaparser.symbolsolver.resolution.typeinference.TypeHelper.isProperType;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+public class SubtypeOfBoundTest {
+
+    private TypeSolver typeSolver = new ReflectionTypeSolver();
+    private ResolvedReferenceType iterableType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(Iterable.class.getCanonicalName()), typeSolver);
+    private ResolvedReferenceType listType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(List.class.getCanonicalName()), typeSolver);
+    private ResolvedType integerType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(Integer.class.getCanonicalName()), typeSolver);
+    private ResolvedType doubleType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(Double.class.getCanonicalName()), typeSolver);
+    private ResolvedType objectType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(Object.class.getCanonicalName()), typeSolver);
+
+    @Test
+    public void recognizeProperLowerBound1() {
+        ResolvedTypeParameterDeclaration typeParameterDeclaration = mock(ResolvedTypeParameterDeclaration.class);
+
+        // { Integer <: α, Double <: α, α <: Object } describes two proper lower bounds and one proper upper bound for α.
+
+        InferenceVariable inferenceVariable = new InferenceVariable("α", typeParameterDeclaration);
+        Bound bound = new SubtypeOfBound(integerType, inferenceVariable);
+
+        assertEquals(Optional.of(new ProperLowerBound(inferenceVariable, integerType)), bound.isProperLowerBound());
+    }
+
+    @Test
+    public void recognizeProperLowerBound2() {
+        ResolvedTypeParameterDeclaration typeParameterDeclaration = mock(ResolvedTypeParameterDeclaration.class);
+
+        // { Integer <: α, Double <: α, α <: Object } describes two proper lower bounds and one proper upper bound for α.
+
+        InferenceVariable inferenceVariable = new InferenceVariable("α", typeParameterDeclaration);
+        Bound bound = new SubtypeOfBound(doubleType, inferenceVariable);
+
+        assertEquals(Optional.of(new ProperLowerBound(inferenceVariable, doubleType)), bound.isProperLowerBound());
+    }
+
+    @Test
+    public void recognizeProperUpperBound1() {
+        ResolvedTypeParameterDeclaration typeParameterDeclaration = mock(ResolvedTypeParameterDeclaration.class);
+
+        // { Integer <: α, Double <: α, α <: Object } describes two proper lower bounds and one proper upper bound for α.
+
+        InferenceVariable inferenceVariable = new InferenceVariable("α", typeParameterDeclaration);
+        Bound bound = new SubtypeOfBound(inferenceVariable, objectType);
+
+        assertEquals(Optional.of(new ProperUpperBound(inferenceVariable, objectType)), bound.isProperUpperBound());
+    }
+
+    @Test
+    public void recognizeProperUpperBound2() {
+        ResolvedTypeParameterDeclaration typeParameterDeclaration1 = mock(ResolvedTypeParameterDeclaration.class);
+        ResolvedTypeParameterDeclaration typeParameterDeclaration2 = mock(ResolvedTypeParameterDeclaration.class);
+        // { α <: Iterable<?>, β <: Object, α <: List<β> } describes a proper upper bound for each of α and β, along with a dependency between them.
+
+        InferenceVariable alpha = new InferenceVariable("α", typeParameterDeclaration1);
+        InferenceVariable beta = new InferenceVariable("β", typeParameterDeclaration2);
+        ResolvedType iterableOfWildcard = new ReferenceTypeImpl(iterableType.getTypeDeclaration(), Arrays.asList(ResolvedWildcard.UNBOUNDED), typeSolver);
+        ResolvedType listOfBeta = new ReferenceTypeImpl(listType.getTypeDeclaration(), Arrays.asList(beta), typeSolver);
+
+        Bound bound1 = new SubtypeOfBound(alpha, iterableOfWildcard);
+        Bound bound2 = new SubtypeOfBound(beta, objectType);
+        Bound bound3 = new SubtypeOfBound(alpha, listOfBeta);
+
+        assertEquals(false, isProperType(listOfBeta));
+        assertEquals(Optional.of(new ProperUpperBound(alpha, iterableOfWildcard)), bound1.isProperUpperBound());
+        assertEquals(Optional.of(new ProperUpperBound(beta, objectType)), bound2.isProperUpperBound());
+        assertEquals(true, bound3.isADependency());
+    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/constraintformulas/ConstraintFormulaTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/constraintformulas/ConstraintFormulaTest.java
new file mode 100644
index 000000000..0563ca5b3
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typeinference/constraintformulas/ConstraintFormulaTest.java
@@ -0,0 +1,70 @@
+package com.github.javaparser.symbolsolver.resolution.typeinference.constraintformulas;
+
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.resolution.declarations.ResolvedTypeParameterDeclaration;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
+import com.github.javaparser.symbolsolver.resolution.typeinference.BoundSet;
+import com.github.javaparser.symbolsolver.resolution.typeinference.ConstraintFormula;
+import com.github.javaparser.symbolsolver.resolution.typeinference.InferenceVariable;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+
+public class ConstraintFormulaTest {
+
+    private TypeSolver typeSolver = new ReflectionTypeSolver();
+    private ResolvedType stringType = new ReferenceTypeImpl(new ReflectionTypeSolver().solveType(String.class.getCanonicalName()), typeSolver);
+
+    /**
+     * From JLS 18.1.2
+     *
+     * From Collections.singleton("hi"), we have the constraint formula ‹"hi" → α›.
+     * Through reduction, this will become the constraint formula: ‹String <: α›.
+     */
+    @Test
+    public void testExpressionCompatibleWithTypeReduce1() {
+        ResolvedTypeParameterDeclaration tp = mock(ResolvedTypeParameterDeclaration.class);
+
+        Expression e = new StringLiteralExpr("hi");
+        InferenceVariable inferenceVariable = new InferenceVariable("α", tp);
+
+        ExpressionCompatibleWithType formula = new ExpressionCompatibleWithType(typeSolver, e, inferenceVariable);
+
+        ConstraintFormula.ReductionResult res1 = formula.reduce(BoundSet.empty());
+        assertEquals(
+                ConstraintFormula.ReductionResult.empty().withConstraint(new TypeCompatibleWithType(typeSolver, stringType, inferenceVariable)),
+                res1);
+
+        assertEquals(
+                ConstraintFormula.ReductionResult.empty().withConstraint(new TypeSubtypeOfType(typeSolver, stringType, inferenceVariable)),
+                res1.getConstraint(0).reduce(BoundSet.empty()));
+    }
+
+//    /**
+//     * From JLS 18.1.2
+//     *
+//     * From Arrays.asList(1, 2.0), we have the constraint formulas ‹1 → α› and ‹2.0 → α›. Through reduction,
+//     * these will become the constraint formulas ‹int → α› and ‹double → α›, and then ‹Integer <: α› and ‹Double <: α›.
+//     */
+//    @Test
+//    public void testExpressionCompatibleWithTypeReduce2() {
+//        throw new UnsupportedOperationException();
+//    }
+//
+//    /**
+//     * From JLS 18.1.2
+//     *
+//     * From the target type of the constructor invocation List<Thread> lt = new ArrayList<>(), we have the constraint
+//     * formula ‹ArrayList<α> → List<Thread>›. Through reduction, this will become the constraint formula ‹α <= Thread›,
+//     * and then ‹α = Thread›.
+//     */
+//    @Test
+//    public void testExpressionCompatibleWithTypeReduce3() {
+//        throw new UnsupportedOperationException();
+//    }
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/AarTypeSolverTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/AarTypeSolverTest.java
new file mode 100644
index 000000000..b9be96899
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/AarTypeSolverTest.java
@@ -0,0 +1,43 @@
+/*
+ * 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.resolution.typesolvers;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+public class AarTypeSolverTest extends AbstractTest {
+
+    @Test
+    public void initial() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/aars/support-compat-24.2.0.aar");
+        AarTypeSolver aarTypeSolver = new AarTypeSolver(new File(pathToJar));
+        assertEquals(true, aarTypeSolver.tryToSolveType("android.support.v4.app.ActivityCompat").isSolved());
+        assertEquals(true, aarTypeSolver.tryToSolveType("android.support.v4.app.ActivityManagerCompat").isSolved());
+        assertEquals(true, aarTypeSolver.tryToSolveType("android.support.v4.app.NotificationCompat").isSolved());
+        assertEquals(true, aarTypeSolver.tryToSolveType("android.support.v4.app.NotificationCompat.Action").isSolved());
+        assertEquals(true, aarTypeSolver.tryToSolveType("android.support.v4.app.NotificationCompat.Action.Builder").isSolved());
+        assertEquals(false, aarTypeSolver.tryToSolveType("com.github.javaparser.ASTParser.Foo").isSolved());
+        assertEquals(false, aarTypeSolver.tryToSolveType("com.github.javaparser.Foo").isSolved());
+        assertEquals(false, aarTypeSolver.tryToSolveType("Foo").isSolved());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/JarTypeSolverTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/JarTypeSolverTest.java
new file mode 100644
index 000000000..346fcfd60
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/resolution/typesolvers/JarTypeSolverTest.java
@@ -0,0 +1,41 @@
+/*
+ * 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.resolution.typesolvers;
+
+import com.github.javaparser.symbolsolver.AbstractTest;
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class JarTypeSolverTest extends AbstractTest {
+
+    @Test
+    public void initial() throws IOException {
+        String pathToJar = adaptPath("src/test/resources/javaparser-core-2.1.0.jar");
+        JarTypeSolver jarTypeSolver = new JarTypeSolver(pathToJar);
+        assertEquals(true, jarTypeSolver.tryToSolveType("com.github.javaparser.SourcesHelper").isSolved());
+        assertEquals(true, jarTypeSolver.tryToSolveType("com.github.javaparser.Token").isSolved());
+        assertEquals(true, jarTypeSolver.tryToSolveType("com.github.javaparser.ASTParser.JJCalls").isSolved());
+        assertEquals(false, jarTypeSolver.tryToSolveType("com.github.javaparser.ASTParser.Foo").isSolved());
+        assertEquals(false, jarTypeSolver.tryToSolveType("com.github.javaparser.Foo").isSolved());
+        assertEquals(false, jarTypeSolver.tryToSolveType("Foo").isSolved());
+    }
+
+}
diff --git a/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java
new file mode 100644
index 000000000..ddc1bc622
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/java/com/github/javaparser/symbolsolver/utils/SymbolSolverQuickSetupTest.java
@@ -0,0 +1,50 @@
+package com.github.javaparser.symbolsolver.utils;
+
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
+import com.github.javaparser.utils.SourceRoot;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+
+/**
+ * Try to resolve all the ClassOrInterfaceDeclaration and MethodCallExpr in some resources folder. If it fails to do
+ * so, an IllegalStateException is thrown.
+ */
+public class SymbolSolverQuickSetupTest {
+
+    private Path root = Paths.get("src/test/resources/symbolsolver_quicksetup");
+    private ParserConfiguration parserConfiguration = new ParserConfiguration();
+
+    @Before
+    public void setUp() throws IOException {
+        SymbolSolverQuickSetup ssr = new SymbolSolverQuickSetup(root);
+        TypeSolver typeSolver = ssr.walk();
+
+        parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver));
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void notResolve() throws IOException {
+        SourceRoot sourceRoot = new SourceRoot(root);
+        sourceRoot.tryToParse();
+        // try to resolve, this will fail
+        sourceRoot.getCompilationUnits().forEach(compilationUnit ->
+                compilationUnit.findAll(ClassOrInterfaceDeclaration.class).forEach(ClassOrInterfaceDeclaration::resolve));
+    }
+
+    @Test
+    public void resolve() throws IOException {
+        SourceRoot sourceRoot = new SourceRoot(root, parserConfiguration);
+        sourceRoot.tryToParse();
+        // try to resolve, this should succeed
+        sourceRoot.getCompilationUnits().forEach(compilationUnit ->
+                compilationUnit.findAll(ClassOrInterfaceDeclaration.class).forEach(ClassOrInterfaceDeclaration::resolve));
+    }
+}
\ No newline at end of file