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

1 files changed, 490 insertions, 0 deletions

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());
+    }
+}