| /* |
| * Copyright (c) 2013, the Dart project authors. |
| * |
| * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html |
| * |
| * 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.google.dart.engine.internal.search; |
| |
| import com.google.common.base.Objects; |
| import com.google.common.collect.Lists; |
| import com.google.dart.engine.EngineTestCase; |
| import com.google.dart.engine.context.AnalysisContext; |
| import com.google.dart.engine.element.ClassElement; |
| import com.google.dart.engine.element.CompilationUnitElement; |
| import com.google.dart.engine.element.ConstructorElement; |
| import com.google.dart.engine.element.Element; |
| import com.google.dart.engine.element.ElementKind; |
| import com.google.dart.engine.element.ElementLocation; |
| import com.google.dart.engine.element.FieldElement; |
| import com.google.dart.engine.element.FunctionElement; |
| import com.google.dart.engine.element.FunctionTypeAliasElement; |
| import com.google.dart.engine.element.ImportElement; |
| import com.google.dart.engine.element.LibraryElement; |
| import com.google.dart.engine.element.LocalVariableElement; |
| import com.google.dart.engine.element.MethodElement; |
| import com.google.dart.engine.element.ParameterElement; |
| import com.google.dart.engine.element.PropertyAccessorElement; |
| import com.google.dart.engine.element.TopLevelVariableElement; |
| import com.google.dart.engine.element.TypeParameterElement; |
| import com.google.dart.engine.element.angular.AngularComponentElement; |
| import com.google.dart.engine.element.angular.AngularControllerElement; |
| import com.google.dart.engine.element.angular.AngularFormatterElement; |
| import com.google.dart.engine.element.angular.AngularPropertyElement; |
| import com.google.dart.engine.element.angular.AngularScopePropertyElement; |
| import com.google.dart.engine.element.angular.AngularSelectorElement; |
| import com.google.dart.engine.index.Index; |
| import com.google.dart.engine.index.IndexFactory; |
| import com.google.dart.engine.index.IndexStore; |
| import com.google.dart.engine.index.Location; |
| import com.google.dart.engine.index.LocationWithData; |
| import com.google.dart.engine.internal.element.ElementLocationImpl; |
| import com.google.dart.engine.internal.element.member.MethodMember; |
| import com.google.dart.engine.internal.index.IndexConstants; |
| import com.google.dart.engine.internal.index.IndexImpl; |
| import com.google.dart.engine.internal.index.NameElementImpl; |
| import com.google.dart.engine.internal.index.file.MemoryNodeManager; |
| import com.google.dart.engine.internal.index.operation.IndexOperation; |
| import com.google.dart.engine.internal.index.operation.OperationProcessor; |
| import com.google.dart.engine.internal.index.operation.OperationQueue; |
| import com.google.dart.engine.internal.search.scope.LibrarySearchScope; |
| import com.google.dart.engine.search.MatchKind; |
| import com.google.dart.engine.search.MatchQuality; |
| import com.google.dart.engine.search.SearchEngine; |
| import com.google.dart.engine.search.SearchEngineFactory; |
| import com.google.dart.engine.search.SearchFilter; |
| import com.google.dart.engine.search.SearchListener; |
| import com.google.dart.engine.search.SearchMatch; |
| import com.google.dart.engine.search.SearchPattern; |
| import com.google.dart.engine.search.SearchPatternFactory; |
| import com.google.dart.engine.search.SearchScope; |
| import com.google.dart.engine.search.SearchScopeFactory; |
| import com.google.dart.engine.source.Source; |
| import com.google.dart.engine.type.Type; |
| import com.google.dart.engine.utilities.source.SourceRange; |
| |
| import static org.fest.assertions.Assertions.assertThat; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.when; |
| |
| import java.util.List; |
| import java.util.Set; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| public class SearchEngineImplTest extends EngineTestCase { |
| private static class ExpectedMatch { |
| Element element; |
| MatchKind kind; |
| MatchQuality quality; |
| SourceRange range; |
| boolean qualified; |
| |
| public ExpectedMatch(Element element, MatchKind kind, int offset, int length) { |
| this(element, kind, MatchQuality.EXACT, offset, length); |
| } |
| |
| public ExpectedMatch(Element element, MatchKind kind, int offset, int length, boolean qualified) { |
| this(element, kind, MatchQuality.EXACT, offset, length, qualified); |
| } |
| |
| public ExpectedMatch(Element element, MatchKind kind, MatchQuality quality, int offset, |
| int length) { |
| this(element, kind, quality, offset, length, false); |
| } |
| |
| public ExpectedMatch(Element element, MatchKind kind, MatchQuality quality, int offset, |
| int length, boolean qualified) { |
| this.element = element; |
| this.kind = kind; |
| this.quality = quality; |
| this.range = new SourceRange(offset, length); |
| this.qualified = qualified; |
| } |
| } |
| |
| private static interface SearchRunner<T> { |
| T run(OperationQueue queue, OperationProcessor processor, Index index, SearchEngine engine) |
| throws Exception; |
| } |
| |
| private static void assertMatches(List<SearchMatch> matches, ExpectedMatch... expectedMatches) { |
| assertThat(matches).hasSize(expectedMatches.length); |
| for (SearchMatch match : matches) { |
| boolean found = false; |
| String msg = match.toString(); |
| for (ExpectedMatch expectedMatch : expectedMatches) { |
| if (Objects.equal(match.getElement(), expectedMatch.element) |
| && match.getKind() == expectedMatch.kind && match.getQuality() == expectedMatch.quality |
| && Objects.equal(match.getSourceRange(), expectedMatch.range) |
| && match.isQualified() == expectedMatch.qualified) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| fail("Not found: " + msg); |
| } |
| } |
| } |
| |
| private IndexStore indexStore = IndexFactory.newSplitIndexStore(new MemoryNodeManager()); |
| |
| private static final AnalysisContext CONTEXT = mock(AnalysisContext.class); |
| private int nextLocationId = 0; |
| private SearchScope scope; |
| private SearchPattern pattern = null; |
| private SearchFilter filter = null; |
| |
| private final Source source = mock(Source.class); |
| private final CompilationUnitElement unitElement = mock(CompilationUnitElement.class); |
| private final LibraryElement libraryElement = mock(LibraryElement.class); |
| private final Element elementA = mockElement(Element.class, ElementKind.CLASS); |
| private final Element elementB = mockElement(Element.class, ElementKind.CLASS); |
| private final Element elementC = mockElement(Element.class, ElementKind.CLASS); |
| private final Element elementD = mockElement(Element.class, ElementKind.CLASS); |
| private final Element elementE = mockElement(Element.class, ElementKind.CLASS); |
| |
| public void fail_searchAssignedTypes_assignments() throws Exception { |
| // TODO(scheglov) does not work - new split index store cannot store types (yet?) |
| final PropertyAccessorElement setterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.SETTER); |
| final FieldElement fieldElement = mockElement(FieldElement.class, ElementKind.FIELD); |
| when(fieldElement.getSetter()).thenReturn(setterElement); |
| final Type typeA = mock(Type.class); |
| final Type typeB = mock(Type.class); |
| final Type typeC = mock(Type.class); |
| indexStore.aboutToIndexDart(CONTEXT, unitElement); |
| { |
| Location location = new Location(elementA, 1, 10); |
| location = new LocationWithData<Type>(location, typeA); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| location = new LocationWithData<Type>(location, typeB); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| // will be filtered by scope |
| { |
| Location location = new Location(elementC, 3, 30); |
| location = new LocationWithData<Type>(location, typeC); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| // not LocationWithData |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // ask types |
| Set<Type> types = runSearch(new SearchRunner<Set<Type>>() { |
| @Override |
| public Set<Type> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| return engine.searchAssignedTypes(fieldElement, new SearchScope() { |
| @Override |
| public boolean encloses(Element element) { |
| return element != elementC; |
| } |
| }); |
| } |
| }); |
| assertThat(types).containsOnly(typeA, typeB); |
| } |
| |
| public void fail_searchAssignedTypes_initializers() throws Exception { |
| // TODO(scheglov) does not work - new split index store cannot store types (yet?) |
| final FieldElement fieldElement = mockElement(FieldElement.class, ElementKind.FIELD); |
| final Type typeA = mock(Type.class); |
| final Type typeB = mock(Type.class); |
| { |
| Location location = new Location(elementA, 10, 1); |
| location = new LocationWithData<Type>(location, typeA); |
| indexStore.recordRelationship(fieldElement, IndexConstants.IS_DEFINED_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 20, 1); |
| location = new LocationWithData<Type>(location, typeB); |
| indexStore.recordRelationship(fieldElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // ask types |
| Set<Type> types = runSearch(new SearchRunner<Set<Type>>() { |
| @Override |
| public Set<Type> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| return engine.searchAssignedTypes(fieldElement, null); |
| } |
| }); |
| assertThat(types).containsOnly(typeA, typeB); |
| } |
| |
| public void test_searchDeclarations_String() throws Exception { |
| Element referencedElement = new NameElementImpl("test"); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_DEFINED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_DEFINED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = runSearch(new SearchRunner<List<SearchMatch>>() { |
| @Override |
| public List<SearchMatch> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| return engine.searchDeclarations("test", scope, filter); |
| } |
| }); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.NAME_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.NAME_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchFunctionDeclarations() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineFunctionsAB(library); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FUNCTION_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.FUNCTION_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchFunctionDeclarations_async() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineFunctionsAB(library); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchFunctionDeclarationsAsync(); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FUNCTION_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.FUNCTION_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchFunctionDeclarations_inUniverse() throws Exception { |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship( |
| IndexConstants.UNIVERSE, |
| IndexConstants.DEFINES_FUNCTION, |
| locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship( |
| IndexConstants.UNIVERSE, |
| IndexConstants.DEFINES_FUNCTION, |
| locationB); |
| } |
| indexStore.doneIndex(); |
| scope = SearchScopeFactory.createUniverseScope(); |
| // search matches |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FUNCTION_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.FUNCTION_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchFunctionDeclarations_useFilter() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineFunctionsAB(library); |
| scope = new LibrarySearchScope(library); |
| // search "elementA" |
| { |
| filter = new SearchFilter() { |
| @Override |
| public boolean passes(SearchMatch match) { |
| return match.getElement() == elementA; |
| } |
| }; |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.FUNCTION_DECLARATION, 1, 2)); |
| } |
| // search "elementB" |
| { |
| filter = new SearchFilter() { |
| @Override |
| public boolean passes(SearchMatch match) { |
| return match.getElement() == elementB; |
| } |
| }; |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementB, MatchKind.FUNCTION_DECLARATION, 10, 20)); |
| } |
| } |
| |
| public void test_searchFunctionDeclarations_usePattern() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineFunctionsAB(library); |
| scope = new LibrarySearchScope(library); |
| // search "A" |
| { |
| pattern = SearchPatternFactory.createExactPattern("A", true); |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.FUNCTION_DECLARATION, 1, 2)); |
| } |
| // search "B" |
| { |
| pattern = SearchPatternFactory.createExactPattern("B", true); |
| List<SearchMatch> matches = searchFunctionDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementB, MatchKind.FUNCTION_DECLARATION, 10, 20)); |
| } |
| } |
| |
| public void test_searchReferences_AngularComponentElement() throws Exception { |
| AngularComponentElement referencedElement = mockElement( |
| AngularComponentElement.class, |
| ElementKind.ANGULAR_COMPONENT); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE, |
| locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_CLOSING_TAG_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_AngularControllerElement() throws Exception { |
| AngularControllerElement referencedElement = mockElement( |
| AngularControllerElement.class, |
| ElementKind.ANGULAR_CONTROLLER); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_AngularFilterElement() throws Exception { |
| AngularFormatterElement referencedElement = mockElement( |
| AngularFormatterElement.class, |
| ElementKind.ANGULAR_FORMATTER); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_AngularPropertyElement() throws Exception { |
| AngularPropertyElement referencedElement = mockElement( |
| AngularPropertyElement.class, |
| ElementKind.ANGULAR_PROPERTY); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_AngularScopePropertyElement() throws Exception { |
| AngularScopePropertyElement referencedElement = mockElement( |
| AngularScopePropertyElement.class, |
| ElementKind.ANGULAR_SCOPE_PROPERTY); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_AngularSelectorElement() throws Exception { |
| AngularSelectorElement referencedElement = mockElement( |
| AngularSelectorElement.class, |
| ElementKind.ANGULAR_SELECTOR); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.ANGULAR_REFERENCE, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.ANGULAR_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.ANGULAR_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_ClassElement() throws Exception { |
| ClassElement referencedElement = mockElement(ClassElement.class, ElementKind.CLASS); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.TYPE_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.TYPE_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_ClassElement_useScope() throws Exception { |
| LibraryElement libraryA = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| LibraryElement libraryB = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| ClassElement referencedElement = mockElement(ClassElement.class, ElementKind.CLASS); |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(libraryA); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationA); |
| } |
| { |
| when(elementB.getAncestor(LibraryElement.class)).thenReturn(libraryB); |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches, in "libraryA" |
| scope = SearchScopeFactory.createLibraryScope(libraryA); |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.TYPE_REFERENCE, 1, 2)); |
| } |
| |
| public void test_searchReferences_CompilationUnitElement() throws Exception { |
| CompilationUnitElement referencedElement = mockElement( |
| CompilationUnitElement.class, |
| ElementKind.COMPILATION_UNIT); |
| { |
| Location location = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.UNIT_REFERENCE, 1, 2)); |
| } |
| |
| public void test_searchReferences_ConstructorElement() throws Exception { |
| ConstructorElement referencedElement = mockElement( |
| ConstructorElement.class, |
| ElementKind.CONSTRUCTOR); |
| { |
| Location location = new Location(elementA, 10, 1); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_DEFINED_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 20, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| { |
| Location location = new Location(elementC, 30, 3); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.CONSTRUCTOR_DECLARATION, 10, 1), |
| new ExpectedMatch(elementB, MatchKind.CONSTRUCTOR_REFERENCE, 20, 2), |
| new ExpectedMatch(elementC, MatchKind.CONSTRUCTOR_REFERENCE, 30, 3)); |
| } |
| |
| public void test_searchReferences_Element_unknown() throws Exception { |
| List<SearchMatch> matches = searchReferencesSync(Element.class, null); |
| assertThat(matches).isEmpty(); |
| } |
| |
| public void test_searchReferences_FieldElement() throws Exception { |
| PropertyAccessorElement getterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.GETTER); |
| PropertyAccessorElement setterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.SETTER); |
| FieldElement fieldElement = mockElement(FieldElement.class, ElementKind.FIELD); |
| when(fieldElement.getGetter()).thenReturn(getterElement); |
| when(fieldElement.getSetter()).thenReturn(setterElement); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship( |
| getterElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship( |
| getterElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementC, 3, 30); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, fieldElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FIELD_READ, 1, 10, false), |
| new ExpectedMatch(elementB, MatchKind.FIELD_READ, 2, 20, true), |
| new ExpectedMatch(elementC, MatchKind.FIELD_WRITE, 3, 30, false), |
| new ExpectedMatch(elementD, MatchKind.FIELD_WRITE, 4, 40, true)); |
| } |
| |
| public void test_searchReferences_FieldElement_invocation() throws Exception { |
| PropertyAccessorElement getterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.GETTER); |
| FieldElement fieldElement = mockElement(FieldElement.class, ElementKind.FIELD); |
| when(fieldElement.getGetter()).thenReturn(getterElement); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(getterElement, IndexConstants.IS_INVOKED_BY_QUALIFIED, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship( |
| getterElement, |
| IndexConstants.IS_INVOKED_BY_UNQUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, fieldElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FIELD_INVOCATION, 1, 10, true), |
| new ExpectedMatch(elementB, MatchKind.FIELD_INVOCATION, 2, 20, false)); |
| } |
| |
| public void test_searchReferences_FieldElement2() throws Exception { |
| FieldElement fieldElement = mockElement(FieldElement.class, ElementKind.FIELD); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(fieldElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship( |
| fieldElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, fieldElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FIELD_REFERENCE, 1, 10, false), |
| new ExpectedMatch(elementB, MatchKind.FIELD_REFERENCE, 2, 20, true)); |
| } |
| |
| public void test_searchReferences_FunctionElement() throws Exception { |
| FunctionElement referencedElement = mockElement(FunctionElement.class, ElementKind.FUNCTION); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_INVOKED_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FUNCTION_EXECUTION, 1, 10), |
| new ExpectedMatch(elementB, MatchKind.FUNCTION_REFERENCE, 2, 20)); |
| } |
| |
| public void test_searchReferences_ImportElement() throws Exception { |
| ImportElement referencedElement = mockElement(ImportElement.class, ElementKind.IMPORT); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 0); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.IMPORT_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.IMPORT_REFERENCE, 10, 0)); |
| } |
| |
| public void test_searchReferences_LibraryElement() throws Exception { |
| LibraryElement referencedElement = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| { |
| Location location = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.LIBRARY_REFERENCE, 1, 2)); |
| } |
| |
| public void test_searchReferences_MethodElement() throws Exception { |
| MethodElement referencedElement = mockElement(MethodElement.class, ElementKind.METHOD); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_INVOKED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_INVOKED_BY_QUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementC, 3, 30); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.METHOD_INVOCATION, 1, 10, false), |
| new ExpectedMatch(elementB, MatchKind.METHOD_INVOCATION, 2, 20, true), |
| new ExpectedMatch(elementC, MatchKind.METHOD_REFERENCE, 3, 30, false), |
| new ExpectedMatch(elementD, MatchKind.METHOD_REFERENCE, 4, 40, true)); |
| } |
| |
| public void test_searchReferences_MethodMember() throws Exception { |
| MethodElement referencedElement = mockElement(MethodElement.class, ElementKind.METHOD); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_INVOKED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_INVOKED_BY_QUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementC, 3, 30); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| MethodMember referencedMember = new MethodMember(referencedElement, null); |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedMember); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.METHOD_INVOCATION, 1, 10, false), |
| new ExpectedMatch(elementB, MatchKind.METHOD_INVOCATION, 2, 20, true), |
| new ExpectedMatch(elementC, MatchKind.METHOD_REFERENCE, 3, 30, false), |
| new ExpectedMatch(elementD, MatchKind.METHOD_REFERENCE, 4, 40, true)); |
| } |
| |
| public void test_searchReferences_notSupported() throws Exception { |
| Element referencedElement = mockElement(Element.class, ElementKind.UNIVERSE); |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| assertThat(matches).isEmpty(); |
| } |
| |
| public void test_searchReferences_ParameterElement() throws Exception { |
| ParameterElement referencedElement = mockElement(ParameterElement.class, ElementKind.PARAMETER); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_READ_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_WRITTEN_BY, location); |
| } |
| { |
| Location location = new Location(elementC, 3, 30); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_READ_WRITTEN_BY, location); |
| } |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, location); |
| } |
| { |
| Location location = new Location(elementD, 5, 50); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_INVOKED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| // TODO(scheglov) why no MatchKind.FIELD_READ_WRITE ? |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.VARIABLE_READ, 1, 10), |
| new ExpectedMatch(elementB, MatchKind.VARIABLE_WRITE, 2, 20), |
| new ExpectedMatch(elementC, MatchKind.VARIABLE_READ_WRITE, 3, 30), |
| new ExpectedMatch(elementD, MatchKind.NAMED_PARAMETER_REFERENCE, 4, 40), |
| new ExpectedMatch(elementD, MatchKind.FUNCTION_EXECUTION, 5, 50)); |
| } |
| |
| public void test_searchReferences_PropertyAccessorElement_getter() throws Exception { |
| PropertyAccessorElement accessor = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.GETTER); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(accessor, IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship(accessor, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, accessor); |
| // verify |
| assertMatches(matches, new ExpectedMatch( |
| elementA, |
| MatchKind.PROPERTY_ACCESSOR_REFERENCE, |
| 1, |
| 10, |
| false), new ExpectedMatch(elementB, MatchKind.PROPERTY_ACCESSOR_REFERENCE, 2, 20, true)); |
| } |
| |
| public void test_searchReferences_PropertyAccessorElement_setter() throws Exception { |
| PropertyAccessorElement accessor = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.SETTER); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(accessor, IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship(accessor, IndexConstants.IS_REFERENCED_BY_QUALIFIED, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, accessor); |
| // verify |
| assertMatches(matches, new ExpectedMatch( |
| elementA, |
| MatchKind.PROPERTY_ACCESSOR_REFERENCE, |
| 1, |
| 10, |
| false), new ExpectedMatch(elementB, MatchKind.PROPERTY_ACCESSOR_REFERENCE, 2, 20, true)); |
| } |
| |
| public void test_searchReferences_TopLevelVariableElement() throws Exception { |
| PropertyAccessorElement getterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.GETTER); |
| PropertyAccessorElement setterElement = mockElement( |
| PropertyAccessorElement.class, |
| ElementKind.SETTER); |
| TopLevelVariableElement topVariableElement = mockElement( |
| TopLevelVariableElement.class, |
| ElementKind.TOP_LEVEL_VARIABLE); |
| when(topVariableElement.getGetter()).thenReturn(getterElement); |
| when(topVariableElement.getSetter()).thenReturn(setterElement); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship( |
| getterElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| { |
| Location location = new Location(elementC, 2, 20); |
| indexStore.recordRelationship( |
| setterElement, |
| IndexConstants.IS_REFERENCED_BY_UNQUALIFIED, |
| location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, topVariableElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FIELD_READ, 1, 10, false), |
| new ExpectedMatch(elementC, MatchKind.FIELD_WRITE, 2, 20, false)); |
| } |
| |
| public void test_searchReferences_TypeAliasElement() throws Exception { |
| FunctionTypeAliasElement referencedElement = mockElement( |
| FunctionTypeAliasElement.class, |
| ElementKind.FUNCTION_TYPE_ALIAS); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.FUNCTION_TYPE_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.FUNCTION_TYPE_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_TypeParameterElement() throws Exception { |
| TypeParameterElement referencedElement = mockElement( |
| TypeParameterElement.class, |
| ElementKind.TYPE_PARAMETER); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_REFERENCED_BY, locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.TYPE_PARAMETER_REFERENCE, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.TYPE_PARAMETER_REFERENCE, 10, 20)); |
| } |
| |
| public void test_searchReferences_VariableElement() throws Exception { |
| LocalVariableElement referencedElement = mockElement( |
| LocalVariableElement.class, |
| ElementKind.LOCAL_VARIABLE); |
| { |
| Location location = new Location(elementA, 1, 10); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_READ_BY, location); |
| } |
| { |
| Location location = new Location(elementB, 2, 20); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_WRITTEN_BY, location); |
| } |
| { |
| Location location = new Location(elementC, 3, 30); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_READ_WRITTEN_BY, location); |
| } |
| { |
| Location location = new Location(elementD, 4, 40); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_INVOKED_BY, location); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync(Element.class, referencedElement); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.VARIABLE_READ, 1, 10), |
| new ExpectedMatch(elementB, MatchKind.VARIABLE_WRITE, 2, 20), |
| new ExpectedMatch(elementC, MatchKind.VARIABLE_READ_WRITE, 3, 30), |
| new ExpectedMatch(elementD, MatchKind.FUNCTION_EXECUTION, 4, 40)); |
| } |
| |
| public void test_searchSubtypes() throws Exception { |
| final ClassElement referencedElement = mockElement(ClassElement.class, ElementKind.CLASS); |
| { |
| Location locationA = new Location(elementA, 10, 1); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_EXTENDED_BY, locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 20, 2); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_MIXED_IN_BY, locationB); |
| } |
| { |
| Location locationC = new Location(elementC, 30, 3); |
| indexStore.recordRelationship(referencedElement, IndexConstants.IS_IMPLEMENTED_BY, locationC); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = runSearch(new SearchRunner<List<SearchMatch>>() { |
| @Override |
| public List<SearchMatch> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| return engine.searchSubtypes(referencedElement, scope, filter); |
| } |
| }); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.EXTENDS_REFERENCE, 10, 1), |
| new ExpectedMatch(elementB, MatchKind.WITH_REFERENCE, 20, 2), |
| new ExpectedMatch(elementC, MatchKind.IMPLEMENTS_REFERENCE, 30, 3)); |
| } |
| |
| public void test_searchTypeDeclarations_async() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_CLASS, locationA); |
| } |
| indexStore.doneIndex(); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchTypeDeclarationsAsync(); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.CLASS_DECLARATION, 1, 2)); |
| } |
| |
| public void test_searchTypeDeclarations_class() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_CLASS, locationA); |
| } |
| indexStore.doneIndex(); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchTypeDeclarationsSync(); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.CLASS_DECLARATION, 1, 2)); |
| } |
| |
| public void test_searchTypeDeclarations_classAlias() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_CLASS_ALIAS, locationA); |
| } |
| indexStore.doneIndex(); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchTypeDeclarationsSync(); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.CLASS_ALIAS_DECLARATION, 1, 2)); |
| } |
| |
| public void test_searchTypeDeclarations_functionType() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_FUNCTION_TYPE, locationA); |
| } |
| indexStore.doneIndex(); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchTypeDeclarationsSync(); |
| // verify |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.FUNCTION_TYPE_DECLARATION, 1, 2)); |
| } |
| |
| public void test_searchUnresolvedQualifiedReferences() throws Exception { |
| Element referencedElement = new NameElementImpl("test"); |
| { |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED_RESOLVED, |
| locationA); |
| } |
| { |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship( |
| referencedElement, |
| IndexConstants.IS_REFERENCED_BY_QUALIFIED_UNRESOLVED, |
| locationB); |
| } |
| indexStore.doneIndex(); |
| // search matches |
| List<SearchMatch> matches = searchReferencesSync( |
| "searchQualifiedMemberReferences", |
| String.class, |
| "test"); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.NAME_REFERENCE_RESOLVED, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.NAME_REFERENCE_UNRESOLVED, 10, 20)); |
| } |
| |
| public void test_searchVariableDeclarations() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineVariablesAB(library); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchVariableDeclarationsSync(); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.VARIABLE_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.VARIABLE_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchVariableDeclarations_async() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineVariablesAB(library); |
| scope = new LibrarySearchScope(library); |
| // search matches |
| List<SearchMatch> matches = searchVariableDeclarationsAsync(); |
| // verify |
| assertMatches( |
| matches, |
| new ExpectedMatch(elementA, MatchKind.VARIABLE_DECLARATION, 1, 2), |
| new ExpectedMatch(elementB, MatchKind.VARIABLE_DECLARATION, 10, 20)); |
| } |
| |
| public void test_searchVariableDeclarations_usePattern() throws Exception { |
| LibraryElement library = mockElement(LibraryElement.class, ElementKind.LIBRARY); |
| defineVariablesAB(library); |
| scope = new LibrarySearchScope(library); |
| // search "A" |
| { |
| pattern = SearchPatternFactory.createExactPattern("A", true); |
| List<SearchMatch> matches = searchVariableDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementA, MatchKind.VARIABLE_DECLARATION, 1, 2)); |
| } |
| // search "B" |
| { |
| pattern = SearchPatternFactory.createExactPattern("B", true); |
| List<SearchMatch> matches = searchVariableDeclarationsSync(); |
| assertMatches(matches, new ExpectedMatch(elementB, MatchKind.VARIABLE_DECLARATION, 10, 20)); |
| } |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| // library |
| when(unitElement.getLibrary()).thenReturn(libraryElement); |
| when(libraryElement.getDefiningCompilationUnit()).thenReturn(unitElement); |
| when(unitElement.getSource()).thenReturn(source); |
| when(libraryElement.getSource()).thenReturn(source); |
| when(libraryElement.getParts()).thenReturn(new CompilationUnitElement[0]); |
| // elements |
| when(elementA.toString()).thenReturn("A"); |
| when(elementB.toString()).thenReturn("B"); |
| when(elementC.toString()).thenReturn("C"); |
| when(elementD.toString()).thenReturn("D"); |
| when(elementE.toString()).thenReturn("E"); |
| when(elementA.getDisplayName()).thenReturn("A"); |
| when(elementB.getDisplayName()).thenReturn("B"); |
| when(elementC.getDisplayName()).thenReturn("C"); |
| when(elementD.getDisplayName()).thenReturn("D"); |
| when(elementE.getDisplayName()).thenReturn("E"); |
| when(elementA.getSource()).thenReturn(source); |
| when(elementB.getSource()).thenReturn(source); |
| when(elementC.getSource()).thenReturn(source); |
| when(elementD.getSource()).thenReturn(source); |
| when(elementE.getSource()).thenReturn(source); |
| when(elementA.getContext()).thenReturn(CONTEXT); |
| when(elementB.getContext()).thenReturn(CONTEXT); |
| when(elementC.getContext()).thenReturn(CONTEXT); |
| when(elementD.getContext()).thenReturn(CONTEXT); |
| when(elementE.getContext()).thenReturn(CONTEXT); |
| when(CONTEXT.getElement(elementA.getLocation())).thenReturn(elementA); |
| when(CONTEXT.getElement(elementB.getLocation())).thenReturn(elementB); |
| when(CONTEXT.getElement(elementC.getLocation())).thenReturn(elementC); |
| when(CONTEXT.getElement(elementD.getLocation())).thenReturn(elementD); |
| when(CONTEXT.getElement(elementE.getLocation())).thenReturn(elementE); |
| // start indexing |
| assertTrue(indexStore.aboutToIndexDart(CONTEXT, unitElement)); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| indexStore = null; |
| super.tearDown(); |
| } |
| |
| private void defineFunctionsAB(LibraryElement library) { |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_FUNCTION, locationA); |
| } |
| { |
| when(elementB.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_FUNCTION, locationB); |
| } |
| indexStore.doneIndex(); |
| } |
| |
| private void defineVariablesAB(LibraryElement library) { |
| { |
| when(elementA.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationA = new Location(elementA, 1, 2); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_VARIABLE, locationA); |
| } |
| { |
| when(elementB.getAncestor(LibraryElement.class)).thenReturn(library); |
| Location locationB = new Location(elementB, 10, 20); |
| indexStore.recordRelationship(library, IndexConstants.DEFINES_VARIABLE, locationB); |
| } |
| indexStore.doneIndex(); |
| } |
| |
| private <T extends Element> T mockElement(Class<T> clazz, ElementKind kind) { |
| T element = mock(clazz); |
| when(element.getContext()).thenReturn(CONTEXT); |
| when(element.getSource()).thenReturn(source); |
| when(element.getKind()).thenReturn(kind); |
| ElementLocation elementLocation = new ElementLocationImpl("mockLocation" + nextLocationId++); |
| when(element.getLocation()).thenReturn(elementLocation); |
| when(CONTEXT.getElement(element.getLocation())).thenReturn(element); |
| return element; |
| } |
| |
| private <T> T runSearch(SearchRunner<T> runner) throws Exception { |
| final OperationQueue queue = new OperationQueue(); |
| final OperationProcessor processor = new OperationProcessor(queue); |
| final Index index = new IndexImpl(indexStore, queue, processor); |
| final SearchEngine engine = SearchEngineFactory.createSearchEngine(index); |
| try { |
| new Thread() { |
| @Override |
| public void run() { |
| processor.run(); |
| } |
| }.start(); |
| processor.waitForRunning(); |
| return runner.run(queue, processor, index, engine); |
| } finally { |
| processor.stop(false); |
| } |
| } |
| |
| private List<SearchMatch> searchDeclarationsAsync(final String methodName) throws Exception { |
| return runSearch(new SearchRunner<List<SearchMatch>>() { |
| @Override |
| public List<SearchMatch> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| final CountDownLatch latch = new CountDownLatch(1); |
| final List<SearchMatch> matches = Lists.newArrayList(); |
| engine.getClass().getMethod( |
| methodName, |
| SearchScope.class, |
| SearchPattern.class, |
| SearchFilter.class, |
| SearchListener.class).invoke(engine, scope, pattern, filter, new SearchListener() { |
| @Override |
| public void matchFound(SearchMatch match) { |
| matches.add(match); |
| } |
| |
| @Override |
| public void searchComplete() { |
| latch.countDown(); |
| } |
| }); |
| latch.await(30, TimeUnit.SECONDS); |
| return matches; |
| } |
| }); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private List<SearchMatch> searchDeclarationsSync(final String methodName) throws Exception { |
| return runSearch(new SearchRunner<List<SearchMatch>>() { |
| @Override |
| public List<SearchMatch> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| return (List<SearchMatch>) engine.getClass().getMethod( |
| methodName, |
| SearchScope.class, |
| SearchPattern.class, |
| SearchFilter.class).invoke(engine, scope, pattern, filter); |
| } |
| }); |
| } |
| |
| private List<SearchMatch> searchFunctionDeclarationsAsync() throws Exception { |
| return searchDeclarationsAsync("searchFunctionDeclarations"); |
| } |
| |
| private List<SearchMatch> searchFunctionDeclarationsSync() throws Exception { |
| return searchDeclarationsSync("searchFunctionDeclarations"); |
| } |
| |
| private List<SearchMatch> searchReferencesSync(Class<?> clazz, Object element) throws Exception { |
| return searchReferencesSync("searchReferences", clazz, element); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private List<SearchMatch> searchReferencesSync(final String methodName, final Class<?> clazz, |
| final Object element) throws Exception { |
| return runSearch(new SearchRunner<List<SearchMatch>>() { |
| @Override |
| public List<SearchMatch> run(OperationQueue queue, OperationProcessor processor, Index index, |
| SearchEngine engine) throws Exception { |
| // pass some operation to wait if search will not call processor |
| queue.enqueue(mock(IndexOperation.class)); |
| // run actual search |
| return (List<SearchMatch>) engine.getClass().getMethod( |
| methodName, |
| clazz, |
| SearchScope.class, |
| SearchFilter.class).invoke(engine, element, scope, filter); |
| } |
| }); |
| } |
| |
| private List<SearchMatch> searchTypeDeclarationsAsync() throws Exception { |
| return searchDeclarationsAsync("searchTypeDeclarations"); |
| } |
| |
| private List<SearchMatch> searchTypeDeclarationsSync() throws Exception { |
| return searchDeclarationsSync("searchTypeDeclarations"); |
| } |
| |
| private List<SearchMatch> searchVariableDeclarationsAsync() throws Exception { |
| return searchDeclarationsAsync("searchVariableDeclarations"); |
| } |
| |
| private List<SearchMatch> searchVariableDeclarationsSync() throws Exception { |
| return searchDeclarationsSync("searchVariableDeclarations"); |
| } |
| } |
