1 /*
2  * Copyright 2016 Federico Tomassetti
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.github.javaparser.symbolsolver.resolution;
18 
19 import com.github.javaparser.ParserConfiguration;
20 import com.github.javaparser.StaticJavaParser;
21 import com.github.javaparser.ast.CompilationUnit;
22 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
23 import com.github.javaparser.ast.body.MethodDeclaration;
24 import com.github.javaparser.ast.expr.Expression;
25 import com.github.javaparser.ast.expr.MethodCallExpr;
26 import com.github.javaparser.ast.expr.ThisExpr;
27 import com.github.javaparser.ast.stmt.*;
28 import com.github.javaparser.resolution.MethodUsage;
29 import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
30 import com.github.javaparser.resolution.types.ResolvedType;
31 import com.github.javaparser.symbolsolver.JavaSymbolSolver;
32 import com.github.javaparser.symbolsolver.javaparser.Navigator;
33 import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
34 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserAnonymousClassDeclaration;
35 import com.github.javaparser.symbolsolver.javaparsermodel.declarations.JavaParserClassDeclaration;
36 import com.github.javaparser.symbolsolver.model.resolution.SymbolReference;
37 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
38 import com.github.javaparser.symbolsolver.model.typesystem.ReferenceTypeImpl;
39 import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
40 import com.github.javaparser.utils.Log;
41 import org.junit.jupiter.api.AfterEach;
42 import org.junit.jupiter.api.Test;
43 
44 import static org.junit.jupiter.api.Assertions.assertEquals;
45 import static org.junit.jupiter.api.Assertions.assertTrue;
46 
47 class MethodsResolutionTest extends AbstractResolutionTest {
48 
49     @AfterEach
resetConfiguration()50     void resetConfiguration() {
51         StaticJavaParser.setConfiguration(new ParserConfiguration());
52         Log.setAdapter(new Log.SilentAdapter());
53     }
54 
55     @Test
testConsistentMethodResultion()56     void testConsistentMethodResultion() {
57         Log.setAdapter(new Log.StandardOutStandardErrorAdapter());
58         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
59 
60         CompilationUnit cu = parseSample("PlatformTestUtil");
61         ClassOrInterfaceDeclaration classDeclaration = Navigator.demandClass(cu, "PlatformTestUtil");
62         MethodDeclaration methodDeclaration =
63                 Navigator.demandMethod(classDeclaration, "assertComparisonContractNotViolated");
64 
65         ForStmt outerFor = (ForStmt) methodDeclaration.getBody().get().getStatement(0);
66         ForStmt innerFor = (ForStmt) ((BlockStmt) outerFor.getBody()).getStatement(0);
67         IfStmt ifStmt = (IfStmt) ((BlockStmt) innerFor.getBody()).getStatement(4);
68         MethodCallExpr assertCall = (MethodCallExpr) ((ExpressionStmt) ((BlockStmt) ifStmt.getThenStmt()).getStatement(0)).getExpression();
69         MethodCallExpr formatCall = (MethodCallExpr) assertCall.getArguments().get(0);
70 
71         boolean exception1, exception2, exception3, exception4;
72         try {
73             formatCall.resolve();
74             exception1 = false;
75         } catch (Exception e) {
76             exception1 = true;
77         }
78 
79         try {
80             formatCall.resolve();
81             exception2 = false;
82         } catch (Exception e) {
83             exception2 = true;
84         }
85 
86         try {
87             formatCall.resolve();
88             exception3 = false;
89         } catch (Exception e) {
90             exception3 = true;
91         }
92 
93         try {
94             formatCall.resolve();
95             exception4 = false;
96         } catch (Exception e) {
97             exception4 = true;
98         }
99 
100         assertEquals(exception1, exception2);
101         assertEquals(exception1, exception3);
102         assertEquals(exception1, exception4);
103     }
104 
105     @Test
solveMethodAccessThroughSuper()106     void solveMethodAccessThroughSuper() {
107         CompilationUnit cu = parseSample("AccessThroughSuper");
108         com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "AccessThroughSuper.SubClass");
109         MethodDeclaration method = Navigator.demandMethod(clazz, "methodTest");
110         ReturnStmt returnStmt = (ReturnStmt) method.getBody().get().getStatements().get(0);
111         Expression expression = returnStmt.getExpression().get();
112 
113         ResolvedType ref = JavaParserFacade.get(new ReflectionTypeSolver()).getType(expression);
114         assertEquals("java.lang.String", ref.describe());
115     }
116 
117     @Test
solveMethodWithClassExpressionAsParameter()118     void solveMethodWithClassExpressionAsParameter() {
119         CompilationUnit cu = parseSample("ClassExpression");
120         com.github.javaparser.ast.body.ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassExpression");
121         MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
122         MethodCallExpr expression = Navigator.findMethodCall(method, "noneOf").get();
123 
124         MethodUsage methodUsage = JavaParserFacade.get(new ReflectionTypeSolver()).solveMethodAsUsage(expression);
125         assertEquals("noneOf", methodUsage.getName());
126     }
127 
128     @Test
solveMethodInInterfaceParent()129     void solveMethodInInterfaceParent() {
130         CompilationUnit cu = parseSample("MethodCalls");
131         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "MethodCalls");
132 
133         MethodDeclaration method = Navigator.demandMethod(clazz, "inheritedInterfaceMethod");
134         MethodCallExpr expression = Navigator.findMethodCall(method, "toString").get();
135 
136         TypeSolver typeSolver = new ReflectionTypeSolver();
137 
138         JavaParserFacade javaParserFacade = JavaParserFacade.get(typeSolver);
139         MethodUsage call1 = javaParserFacade.solveMethodAsUsage(expression);
140         assertEquals("java.lang.Object.toString()", call1.getQualifiedSignature());
141     }
142 
143     @Test
solveMethodWithTypePromotionsToLong()144     void solveMethodWithTypePromotionsToLong() {
145         CompilationUnit cu = parseSample("Issue338");
146         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
147 
148         MethodDeclaration method = Navigator.demandMethod(clazz, "callingLong");
149 
150         {
151             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
152             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
153             assertEquals(true, reference.isSolved());
154             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
155         }
156         {
157             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
158             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
159             assertEquals(true, reference.isSolved());
160             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
161         }
162         {
163             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
164             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
165             assertEquals(true, reference.isSolved());
166             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
167         }
168         {
169             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
170             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
171             assertEquals(true, reference.isSolved());
172             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
173         }
174 
175     }
176 
177     @Test
solveMethodWithTypePromotionsToInt()178     void solveMethodWithTypePromotionsToInt() {
179         CompilationUnit cu = parseSample("Issue338");
180         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
181 
182         MethodDeclaration method = Navigator.demandMethod(clazz, "callingInt");
183 
184         {
185             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
186             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
187             assertEquals(true, reference.isSolved());
188             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
189         }
190         {
191             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
192             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
193             assertEquals(true, reference.isSolved());
194             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
195         }
196         {
197             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
198             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
199             assertEquals(true, reference.isSolved());
200             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
201         }
202         {
203             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
204             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
205             assertEquals(false, reference.isSolved());
206         }
207 
208     }
209 
210     @Test
solveMethodWithTypePromotionsToShort()211     void solveMethodWithTypePromotionsToShort() {
212         CompilationUnit cu = parseSample("Issue338");
213         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
214 
215         MethodDeclaration method = Navigator.demandMethod(clazz, "callingShort");
216 
217         {
218             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
219             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
220             assertEquals(true, reference.isSolved());
221             assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
222         }
223         {
224             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
225             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
226             assertEquals(true, reference.isSolved());
227             assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
228         }
229         {
230             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
231             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
232             assertEquals(false, reference.isSolved());
233         }
234         {
235             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
236             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
237             assertEquals(false, reference.isSolved());
238         }
239 
240     }
241 
242     @Test
solveMethodWithTypePromotionsToByte()243     void solveMethodWithTypePromotionsToByte() {
244         CompilationUnit cu = parseSample("Issue338");
245         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotions");
246 
247         MethodDeclaration method = Navigator.demandMethod(clazz, "callingByte");
248 
249         {
250             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
251             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
252             assertEquals(true, reference.isSolved());
253             assertEquals("byteParam", reference.getCorrespondingDeclaration().getName());
254         }
255         {
256             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
257             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
258             assertEquals(false, reference.isSolved());
259         }
260         {
261             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
262             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
263             assertEquals(false, reference.isSolved());
264         }
265         {
266             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
267             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
268             assertEquals(false, reference.isSolved());
269         }
270 
271     }
272 
273     @Test
solveMethodWithTypePromotionsToLongWithExtraParam()274     void solveMethodWithTypePromotionsToLongWithExtraParam() {
275         CompilationUnit cu = parseSample("Issue338");
276         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
277 
278         MethodDeclaration method = Navigator.demandMethod(clazz, "callingLong");
279 
280         {
281             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
282             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
283             assertEquals(true, reference.isSolved());
284             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
285         }
286         {
287             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
288             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
289             assertEquals(true, reference.isSolved());
290             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
291         }
292         {
293             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
294             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
295             assertEquals(true, reference.isSolved());
296             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
297         }
298         {
299             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
300             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
301             assertEquals(true, reference.isSolved());
302             assertEquals("longParam", reference.getCorrespondingDeclaration().getName());
303         }
304 
305     }
306 
307     @Test
solveMethodWithTypePromotionsToIntWithExtraParam()308     void solveMethodWithTypePromotionsToIntWithExtraParam() {
309         CompilationUnit cu = parseSample("Issue338");
310         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
311 
312         MethodDeclaration method = Navigator.demandMethod(clazz, "callingInt");
313 
314         {
315             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
316             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
317             assertEquals(true, reference.isSolved());
318             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
319         }
320         {
321             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
322             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
323             assertEquals(true, reference.isSolved());
324             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
325         }
326         {
327             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
328             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
329             assertEquals(true, reference.isSolved());
330             assertEquals("intParam", reference.getCorrespondingDeclaration().getName());
331         }
332         {
333             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
334             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
335             assertEquals(false, reference.isSolved());
336         }
337 
338     }
339 
340     @Test
solveMethodWithTypePromotionsToShortWithExtraParam()341     void solveMethodWithTypePromotionsToShortWithExtraParam() {
342         CompilationUnit cu = parseSample("Issue338");
343         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
344 
345         MethodDeclaration method = Navigator.demandMethod(clazz, "callingShort");
346 
347         {
348             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
349             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
350             assertEquals(true, reference.isSolved());
351             assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
352         }
353         {
354             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
355             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
356             assertEquals(true, reference.isSolved());
357             assertEquals("shortParam", reference.getCorrespondingDeclaration().getName());
358         }
359         {
360             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
361             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
362             assertEquals(false, reference.isSolved());
363         }
364         {
365             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
366             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
367             assertEquals(false, reference.isSolved());
368         }
369 
370     }
371 
372     @Test
solveMethodWithTypePromotionsToByteWithExtraParam()373     void solveMethodWithTypePromotionsToByteWithExtraParam() {
374         CompilationUnit cu = parseSample("Issue338");
375         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TypePromotionsWithExtraParam");
376 
377         MethodDeclaration method = Navigator.demandMethod(clazz, "callingByte");
378 
379         {
380             MethodCallExpr expression = method.getBody().get().getStatements().get(0).asExpressionStmt().getExpression().asMethodCallExpr();
381             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
382             assertEquals(true, reference.isSolved());
383             assertEquals("byteParam", reference.getCorrespondingDeclaration().getName());
384         }
385         {
386             MethodCallExpr expression = method.getBody().get().getStatements().get(1).asExpressionStmt().getExpression().asMethodCallExpr();
387             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
388             assertEquals(false, reference.isSolved());
389         }
390         {
391             MethodCallExpr expression = method.getBody().get().getStatements().get(2).asExpressionStmt().getExpression().asMethodCallExpr();
392             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
393             assertEquals(false, reference.isSolved());
394         }
395         {
396             MethodCallExpr expression = method.getBody().get().getStatements().get(3).asExpressionStmt().getExpression().asMethodCallExpr();
397             SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(expression);
398             assertEquals(false, reference.isSolved());
399         }
400 
401     }
402 
403     @Test
callOnThisInAnonymousClass()404     void callOnThisInAnonymousClass() {
405         CompilationUnit cu = parseSample("ThisInAnonymousClass");
406         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Bar");
407 
408         MethodCallExpr fooCall = Navigator.findMethodCall(clazz, "foo").get();
409 
410         SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(fooCall);
411         assertEquals(true, reference.isSolved());
412     }
413 
414     @Test
thisInAnonymousClass()415     void thisInAnonymousClass() {
416         CompilationUnit cu = parseSample("ThisInAnonymousClass");
417         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "Bar");
418 
419         ThisExpr thisExpression = Navigator.findNodeOfGivenClass(clazz, ThisExpr.class);
420 
421         ResolvedType type = JavaParserFacade.get(new ReflectionTypeSolver()).getType(thisExpression);
422         assertEquals(true, type.isReferenceType());
423         assertEquals(true, type.asReferenceType().getTypeDeclaration() instanceof JavaParserAnonymousClassDeclaration);
424     }
425 
426     @Test
resolveMethodCallWithScopeDeclarationInSwitchEntryStmt()427     void resolveMethodCallWithScopeDeclarationInSwitchEntryStmt() {
428         CompilationUnit cu = parseSample("TryInSwitch");
429         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "TryInSwitch");
430 
431         MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
432 
433         MethodCallExpr callExpr = method.getBody().get().getStatement(1)
434                 .asSwitchStmt().getEntry(0).getStatement(1)
435                 .asTryStmt().getTryBlock().getStatement(1)
436                 .asExpressionStmt().getExpression()
437                 .asMethodCallExpr();
438 
439         SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver()).solve(callExpr);
440 
441         assertTrue(reference.isSolved());
442         assertEquals("java.io.File.delete()", reference.getCorrespondingDeclaration().getQualifiedSignature());
443     }
444 
445     @Test
complexTypeSolving()446     void complexTypeSolving() {
447         CompilationUnit cu = parseSample("ComplexTypeResolving");
448         ClassOrInterfaceDeclaration mainClass = Navigator.demandClass(cu, "Main");
449 
450         ClassOrInterfaceDeclaration childDec = (ClassOrInterfaceDeclaration) mainClass.getMember(1);
451         ExpressionStmt stmt =
452                 (ExpressionStmt) Navigator.demandMethod(childDec, "foo").getBody().get().getStatement(0);
453         ReferenceTypeImpl resolvedType =
454                 (ReferenceTypeImpl) JavaParserFacade.get(new ReflectionTypeSolver()).getType(stmt.getExpression());
455         ClassOrInterfaceDeclaration resolvedTypeDeclaration
456                 = ((JavaParserClassDeclaration) resolvedType.getTypeDeclaration()).getWrappedNode();
457 
458         assertEquals(mainClass, resolvedTypeDeclaration.getParentNode().get());
459     }
460 
461     @Test
resolveMethodCallOfMethodInMemberClassOfAnotherClass()462     void resolveMethodCallOfMethodInMemberClassOfAnotherClass() {
463         CompilationUnit cu = parseSample("NestedClasses");
464         ClassOrInterfaceDeclaration classA = Navigator.demandClass(cu, "A");
465 
466         MethodDeclaration method = Navigator.demandMethod(classA, "foo");
467 
468         MethodCallExpr callExpr = method.getBody().get().getStatement(1)
469                 .asExpressionStmt().getExpression().asMethodCallExpr();
470 
471         SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver())
472                 .solve(callExpr);
473 
474         assertTrue(reference.isSolved());
475         assertEquals("X.Y.bar()", reference.getCorrespondingDeclaration().getQualifiedSignature());
476     }
477 
478     @Test
resolveMethodCallOfMethodInMemberInterfaceOfAnotherInterface()479     void resolveMethodCallOfMethodInMemberInterfaceOfAnotherInterface() {
480         CompilationUnit cu = parseSample("NestedInterfaces");
481         ClassOrInterfaceDeclaration classA = Navigator.demandInterface(cu, "A");
482 
483         MethodDeclaration method = Navigator.demandMethod(classA, "foo");
484 
485         MethodCallExpr callExpr = method.getBody().get().getStatement(1)
486                 .asExpressionStmt().getExpression().asMethodCallExpr();
487 
488         SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver())
489                 .solve(callExpr);
490 
491         assertTrue(reference.isSolved());
492         assertEquals("X.Y.bar()", reference.getCorrespondingDeclaration().getQualifiedSignature());
493     }
494 
495     @Test
resolveMethodCallOfMethodInMemberInterfaceWithIdenticalNameOfAnotherInterface()496     void resolveMethodCallOfMethodInMemberInterfaceWithIdenticalNameOfAnotherInterface() {
497         CompilationUnit cu = parseSample("NestedInterfacesWithIdenticalNames");
498         ClassOrInterfaceDeclaration classA = Navigator.demandInterface(cu, "A");
499 
500         MethodDeclaration method = Navigator.demandMethod(classA, "foo");
501 
502         MethodCallExpr callExpr = method.getBody().get().getStatement(1)
503                 .asExpressionStmt().getExpression().asMethodCallExpr();
504 
505         SymbolReference<ResolvedMethodDeclaration> reference = JavaParserFacade.get(new ReflectionTypeSolver())
506                 .solve(callExpr);
507 
508         assertTrue(reference.isSolved());
509         assertEquals("X.A.bar()", reference.getCorrespondingDeclaration().getQualifiedSignature());
510     }
511 
512     @Test
resolveLocalMethodInClassExtendingUnknownClass()513     void resolveLocalMethodInClassExtendingUnknownClass() {
514         // configure symbol solver before parsing
515         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
516 
517         // parse compilation unit and get field access expression
518         CompilationUnit cu = parseSample("ClassExtendingUnknownClass");
519         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "ClassExtendingUnknownClass");
520         MethodDeclaration method = Navigator.demandMethod(clazz, "foo");
521         MethodCallExpr methodCallExpr = method.getBody().get().getStatements().get(0).asExpressionStmt()
522                 .getExpression().asMethodCallExpr();
523 
524         // resolve field access expression
525         ResolvedMethodDeclaration resolvedMethodDeclaration = methodCallExpr.resolve();
526 
527         // check that the expected method declaration equals the resolved method declaration
528         assertEquals("ClassExtendingUnknownClass.bar(java.lang.String)", resolvedMethodDeclaration.getQualifiedSignature());
529     }
530 
531     @Test
resolveCorrectMethodWithComplexOverloading1()532     void resolveCorrectMethodWithComplexOverloading1() {
533         // configure symbol solver before parsing
534         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
535 
536         // parse compilation unit and get method call expression
537         CompilationUnit cu = parseSample("OverloadedMethods");
538         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
539         MethodDeclaration testingMethod = Navigator.demandMethod(clazz, "testComplex1");
540         MethodCallExpr methodCallExpr = testingMethod.getBody().get().getStatements().get(0).asExpressionStmt()
541                 .getExpression().asMethodCallExpr();
542 
543         // resolve method call expression
544         ResolvedMethodDeclaration resolvedMethodDeclaration = methodCallExpr.resolve();
545 
546         assertEquals("OverloadedMethods.complexOverloading1(java.lang.String, java.lang.String)", resolvedMethodDeclaration.getQualifiedSignature());
547     }
548 
549     @Test
resolveCorrectMethodWithComplexOverloading2()550     void resolveCorrectMethodWithComplexOverloading2() {
551         // configure symbol solver before parsing
552         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
553 
554         // parse compilation unit and get method call expression
555         CompilationUnit cu = parseSample("OverloadedMethods");
556         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
557         MethodDeclaration testingMethod = Navigator.demandMethod(clazz, "testComplex2");
558         MethodCallExpr methodCallExpr = testingMethod.getBody().get().getStatements().get(0).asExpressionStmt()
559                 .getExpression().asMethodCallExpr();
560 
561         // resolve method call expression
562         ResolvedMethodDeclaration resolvedMethodDeclaration = methodCallExpr.resolve();
563 
564         assertEquals("OverloadedMethods.complexOverloading2(java.lang.String...)", resolvedMethodDeclaration.getQualifiedSignature());
565     }
566 
567     @Test
resolveCorrectMethodWithComplexOverloading3()568     void resolveCorrectMethodWithComplexOverloading3() {
569         // configure symbol solver before parsing
570         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
571 
572         // parse compilation unit and get method call expression
573         CompilationUnit cu = parseSample("OverloadedMethods");
574         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
575         MethodDeclaration testingMethod = Navigator.demandMethod(clazz, "testComplex3");
576         MethodCallExpr methodCallExpr = testingMethod.getBody().get().getStatements().get(0).asExpressionStmt()
577                 .getExpression().asMethodCallExpr();
578 
579         // resolve method call expression
580         ResolvedMethodDeclaration resolvedMethodDeclaration = methodCallExpr.resolve();
581 
582         assertEquals("OverloadedMethods.complexOverloading3(long)", resolvedMethodDeclaration.getQualifiedSignature());
583     }
584 
585     @Test
resolveCorrectMethodWithComplexOverloading4()586     void resolveCorrectMethodWithComplexOverloading4() {
587         // configure symbol solver before parsing
588         StaticJavaParser.getConfiguration().setSymbolResolver(new JavaSymbolSolver(new ReflectionTypeSolver()));
589 
590         // parse compilation unit and get method call expression
591         CompilationUnit cu = parseSample("OverloadedMethods");
592         ClassOrInterfaceDeclaration clazz = Navigator.demandClass(cu, "OverloadedMethods");
593         MethodDeclaration testingMethod = Navigator.demandMethod(clazz, "testComplex4");
594         MethodCallExpr methodCallExpr = testingMethod.getBody().get().getStatements().get(0).asExpressionStmt()
595                 .getExpression().asMethodCallExpr();
596 
597         // resolve method call expression
598         ResolvedMethodDeclaration resolvedMethodDeclaration = methodCallExpr.resolve();
599 
600         assertEquals("OverloadedMethods.complexOverloading4(long, int)", resolvedMethodDeclaration.getQualifiedSignature());
601     }
602 }
603