1 package com.github.javaparser.symbolsolver.resolution.naming;
2 
3 import com.github.javaparser.*;
4 import com.github.javaparser.ast.Node;
5 import com.github.javaparser.symbolsolver.JavaSymbolSolver;
6 import com.github.javaparser.symbolsolver.model.resolution.TypeSolver;
7 import com.github.javaparser.symbolsolver.resolution.AbstractResolutionTest;
8 
9 import java.util.List;
10 import java.util.Optional;
11 import java.util.stream.Collectors;
12 
13 import static org.junit.jupiter.api.Assertions.assertTrue;
14 
15 public abstract class AbstractNameLogicTest extends AbstractResolutionTest {
16 
getNameInCodeTollerant(String code, String name, ParseStart parseStart)17     protected Node getNameInCodeTollerant(String code, String name, ParseStart parseStart) {
18         return getNameInCode(code, name, parseStart, true, Optional.empty());
19     }
20 
getNameInCodeTollerant(String code, String name, ParseStart parseStart, TypeSolver typeSolver)21     protected Node getNameInCodeTollerant(String code, String name, ParseStart parseStart, TypeSolver typeSolver) {
22         return getNameInCode(code, name, parseStart, true, Optional.of(typeSolver));
23     }
24 
getNameInCode(String code, String name, ParseStart parseStart)25     protected Node getNameInCode(String code, String name, ParseStart parseStart) {
26         return getNameInCode(code, name, parseStart, false, Optional.empty());
27     }
28 
parse(String code, ParseStart<N> parseStart)29     protected <N extends Node> N parse(String code, ParseStart<N> parseStart) {
30         return parse(code, parseStart, Optional.empty());
31     }
32 
parse(String code, ParseStart<N> parseStart, Optional<TypeSolver> typeSolver)33     protected <N extends Node> N parse(String code, ParseStart<N> parseStart, Optional<TypeSolver> typeSolver) {
34         ParserConfiguration parserConfiguration = new ParserConfiguration();
35         parserConfiguration.setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_10);
36         if (typeSolver.isPresent()) {
37             parserConfiguration.setSymbolResolver(new JavaSymbolSolver(typeSolver.get()));
38         }
39         ParseResult<N> parseResult = new JavaParser(parserConfiguration).parse(parseStart, new StringProvider(code));
40         if (!parseResult.isSuccessful()) {
41             parseResult.getProblems().forEach(p -> System.out.println("ERR: " + p));
42         }
43         assertTrue(parseResult.isSuccessful());
44         N root = parseResult.getResult().get();
45         return root;
46     }
47 
getNameInCode(String code, String name, ParseStart parseStart, boolean tollerant, Optional<TypeSolver> typeSolver)48     private Node getNameInCode(String code, String name, ParseStart parseStart, boolean tollerant,
49                                Optional<TypeSolver> typeSolver) {
50         Node root = parse(code, parseStart, typeSolver);
51         List<Node> allNames = root.findAll(Node.class).stream()
52                 .filter(NameLogic::isAName)
53                 .collect(Collectors.toList());
54         List<Node> matchingNames = allNames.stream()
55                 .filter(n -> NameLogic.nameAsString(n).equals(name))
56                 .collect(Collectors.toList());
57         // In case of one name being contained in other as is, we remove it
58         for (int i=0;i<matchingNames.size();i++) {
59             Node container = matchingNames.get(i);
60             for (int j=i+1;j<matchingNames.size();j++) {
61                 Node contained = matchingNames.get(j);
62                 if (contained.getParentNode().isPresent() && contained.getParentNode().get() == container
63                         && NameLogic.nameAsString(contained).equals(NameLogic.nameAsString(container))) {
64                     matchingNames.remove(j);
65                     j--;
66                 }
67             }
68         }
69 
70         if (matchingNames.size() == 0) {
71             throw new IllegalArgumentException("Not found. Names found: " + String.join(", ",
72                     allNames.stream().map(NameLogic::nameAsString).collect(Collectors.toList())));
73         } else if (matchingNames.size() > 1) {
74             if (tollerant) {
75                 return matchingNames.get(matchingNames.size() - 1);
76             } else {
77                 throw new IllegalArgumentException("Ambiguous: there are several matching.");
78             }
79         } else {
80             return matchingNames.get(0);
81         }
82     }
83 
84 }
85