OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. |
| 4 |
| 5 library test.services.completion.computer.dart.relevance; |
| 6 |
| 7 import 'dart:async'; |
| 8 |
| 9 import 'package:analysis_server/src/constants.dart'; |
| 10 import 'package:analysis_server/src/domain_completion.dart'; |
| 11 import 'package:analysis_server/src/protocol.dart'; |
| 12 import 'package:analysis_server/src/services/completion/common_usage_computer.da
rt'; |
| 13 import 'package:analysis_server/src/services/completion/dart_completion_cache.da
rt'; |
| 14 import 'package:analysis_server/src/services/completion/dart_completion_manager.
dart'; |
| 15 import 'package:analysis_server/src/services/index/index.dart'; |
| 16 import 'package:analysis_server/src/services/index/local_memory_index.dart'; |
| 17 import 'package:analyzer/src/generated/engine.dart'; |
| 18 import 'package:analyzer/src/generated/source.dart'; |
| 19 import 'package:unittest/unittest.dart'; |
| 20 |
| 21 import '../../analysis_abstract.dart'; |
| 22 import '../../mocks.dart'; |
| 23 import '../../reflective_tests.dart'; |
| 24 |
| 25 main() { |
| 26 groupSep = ' | '; |
| 27 runReflectiveTests(CommonUsageComputerTest); |
| 28 } |
| 29 |
| 30 @reflectiveTest |
| 31 class CommonUsageComputerTest extends AbstractAnalysisTest { |
| 32 String completionId; |
| 33 int completionOffset; |
| 34 int replacementOffset; |
| 35 int replacementLength; |
| 36 List<CompletionSuggestion> suggestions = []; |
| 37 bool suggestionsDone = false; |
| 38 |
| 39 String addTestFile(String content) { |
| 40 completionOffset = content.indexOf('^'); |
| 41 expect(completionOffset, isNot(equals(-1)), reason: 'missing ^'); |
| 42 int nextOffset = content.indexOf('^', completionOffset + 1); |
| 43 expect(nextOffset, equals(-1), reason: 'too many ^'); |
| 44 return super.addTestFile( |
| 45 content.substring(0, completionOffset) + |
| 46 content.substring(completionOffset + 1)); |
| 47 } |
| 48 |
| 49 void assertHasResult(CompletionSuggestionKind kind, String completion, |
| 50 [int relevance = DART_RELEVANCE_DEFAULT, bool isDeprecated = false, |
| 51 bool isPotential = false]) { |
| 52 var cs; |
| 53 suggestions.forEach((s) { |
| 54 if (s.completion == completion) { |
| 55 if (cs == null) { |
| 56 cs = s; |
| 57 } else { |
| 58 fail('expected exactly one $completion but found > 1'); |
| 59 } |
| 60 } |
| 61 }); |
| 62 if (cs == null) { |
| 63 var completions = suggestions.map((s) => s.completion).toList(); |
| 64 fail('expected "$completion" but found\n $completions'); |
| 65 } |
| 66 expect(cs.kind, equals(kind)); |
| 67 expect(cs.relevance, equals(relevance)); |
| 68 expect(cs.selectionOffset, equals(completion.length)); |
| 69 expect(cs.selectionLength, equals(0)); |
| 70 expect(cs.isDeprecated, equals(isDeprecated)); |
| 71 expect(cs.isPotential, equals(isPotential)); |
| 72 } |
| 73 |
| 74 void assertNoResult(String completion) { |
| 75 if (suggestions.any((cs) => cs.completion == completion)) { |
| 76 fail('did not expect completion: $completion'); |
| 77 } |
| 78 } |
| 79 |
| 80 void assertValidId(String id) { |
| 81 expect(id, isNotNull); |
| 82 expect(id.isNotEmpty, isTrue); |
| 83 } |
| 84 |
| 85 @override |
| 86 Index createIndex() { |
| 87 return createLocalMemoryIndex(); |
| 88 } |
| 89 |
| 90 Future getSuggestions(Map<String, List<String>> selectorRelevance) async { |
| 91 await waitForTasksFinished(); |
| 92 CompletionGetSuggestionsParams params = |
| 93 new CompletionGetSuggestionsParams(testFile, completionOffset); |
| 94 Request request = params.toRequest('0'); |
| 95 CompletionDomainHandler domainHandler = new CompletionDomainHandler(server); |
| 96 handler = domainHandler; |
| 97 |
| 98 AnalysisContext context = server.getAnalysisContext(params.file); |
| 99 Source source = server.getSource(params.file); |
| 100 DartCompletionManager completionManager = new DartCompletionManager( |
| 101 context, |
| 102 server.searchEngine, |
| 103 source, |
| 104 new DartCompletionCache(context, source), |
| 105 null, |
| 106 new CommonUsageComputer(selectorRelevance)); |
| 107 |
| 108 Response response = |
| 109 domainHandler.processRequest(request, completionManager); |
| 110 expect(response, isResponseSuccess('0')); |
| 111 completionId = response.id; |
| 112 assertValidId(completionId); |
| 113 await pumpEventQueue(); |
| 114 expect(suggestionsDone, isTrue); |
| 115 } |
| 116 |
| 117 void processNotification(Notification notification) { |
| 118 if (notification.event == COMPLETION_RESULTS) { |
| 119 var params = new CompletionResultsParams.fromNotification(notification); |
| 120 String id = params.id; |
| 121 assertValidId(id); |
| 122 if (id == completionId) { |
| 123 expect(suggestionsDone, isFalse); |
| 124 replacementOffset = params.replacementOffset; |
| 125 replacementLength = params.replacementLength; |
| 126 suggestionsDone = params.isLast; |
| 127 expect(suggestionsDone, isNotNull); |
| 128 suggestions = params.results; |
| 129 } |
| 130 } |
| 131 } |
| 132 |
| 133 @override |
| 134 void setUp() { |
| 135 super.setUp(); |
| 136 createProject(); |
| 137 } |
| 138 |
| 139 test_ConstructorName() async { |
| 140 // SimpleIdentifier ConstructorName InstanceCreationExpression |
| 141 addTestFile('import "dart:async"; class A {x() {new Future.^}}'); |
| 142 await getSuggestions({ |
| 143 'dart.async.Future': ['value', 'wait'] |
| 144 }); |
| 145 expect(replacementOffset, equals(completionOffset)); |
| 146 expect(replacementLength, equals(0)); |
| 147 assertHasResult(CompletionSuggestionKind.INVOCATION, 'delayed'); |
| 148 assertHasResult( |
| 149 CompletionSuggestionKind.INVOCATION, |
| 150 'value', |
| 151 DART_RELEVANCE_COMMON_USAGE); |
| 152 assertNoResult('Future'); |
| 153 assertNoResult('Object'); |
| 154 assertNoResult('A'); |
| 155 } |
| 156 |
| 157 test_PrefixedIdentifier_field() async { |
| 158 // SimpleIdentifier PrefixedIdentifeir ExpressionStatement |
| 159 addTestFile('class A {static int s1; static int s2; x() {A.^}}'); |
| 160 await getSuggestions({ |
| 161 '.A': ['s2'] |
| 162 }); |
| 163 expect(replacementOffset, equals(completionOffset)); |
| 164 expect(replacementLength, equals(0)); |
| 165 assertHasResult(CompletionSuggestionKind.INVOCATION, 's1'); |
| 166 assertHasResult( |
| 167 CompletionSuggestionKind.INVOCATION, |
| 168 's2', |
| 169 DART_RELEVANCE_COMMON_USAGE); |
| 170 assertNoResult('Future'); |
| 171 assertNoResult('Object'); |
| 172 assertNoResult('A'); |
| 173 } |
| 174 |
| 175 test_PrefixedIdentifier_getter() async { |
| 176 // SimpleIdentifier PrefixedIdentifeir ExpressionStatement |
| 177 addTestFile('class A {int get g1 => 1; int get g2 => 2; x() {new A().^}}'); |
| 178 await getSuggestions({ |
| 179 '.A': ['g2'] |
| 180 }); |
| 181 expect(replacementOffset, equals(completionOffset)); |
| 182 expect(replacementLength, equals(0)); |
| 183 assertHasResult(CompletionSuggestionKind.INVOCATION, 'g1'); |
| 184 assertHasResult( |
| 185 CompletionSuggestionKind.INVOCATION, |
| 186 'g2', |
| 187 DART_RELEVANCE_COMMON_USAGE); |
| 188 assertNoResult('Future'); |
| 189 assertNoResult('Object'); |
| 190 assertNoResult('A'); |
| 191 } |
| 192 |
| 193 test_PrefixedIdentifier_setter() async { |
| 194 // SimpleIdentifier PrefixedIdentifeir ExpressionStatement |
| 195 addTestFile('class A {set s1(v) {}; set s2(v) {}; x() {new A().^}}'); |
| 196 await getSuggestions({ |
| 197 '.A': ['s2'] |
| 198 }); |
| 199 expect(replacementOffset, equals(completionOffset)); |
| 200 expect(replacementLength, equals(0)); |
| 201 assertHasResult(CompletionSuggestionKind.INVOCATION, 's1'); |
| 202 assertHasResult( |
| 203 CompletionSuggestionKind.INVOCATION, |
| 204 's2', |
| 205 DART_RELEVANCE_COMMON_USAGE); |
| 206 assertNoResult('Future'); |
| 207 assertNoResult('Object'); |
| 208 assertNoResult('A'); |
| 209 } |
| 210 |
| 211 test_PrefixedIdentifier_static_method() async { |
| 212 // SimpleIdentifier PrefixedIdentifeir ExpressionStatement |
| 213 addTestFile('import "dart:async"; class A {x() {Future.^}}'); |
| 214 await getSuggestions({ |
| 215 'dart.async.Future': ['value', 'wait'] |
| 216 }); |
| 217 expect(replacementOffset, equals(completionOffset)); |
| 218 expect(replacementLength, equals(0)); |
| 219 assertHasResult( |
| 220 CompletionSuggestionKind.INVOCATION, |
| 221 'wait', |
| 222 DART_RELEVANCE_COMMON_USAGE - 1); |
| 223 assertNoResult('Future'); |
| 224 assertNoResult('Object'); |
| 225 assertNoResult('A'); |
| 226 } |
| 227 |
| 228 test_PropertyAccess() async { |
| 229 // SimpleIdentifier PropertyAccess ExpressionStatement |
| 230 addTestFile('import "dart:math"; class A {x() {new Random().^}}'); |
| 231 await getSuggestions({ |
| 232 'dart.math.Random': ['nextInt', 'nextDouble'] |
| 233 }); |
| 234 expect(replacementOffset, equals(completionOffset)); |
| 235 expect(replacementLength, equals(0)); |
| 236 assertHasResult(CompletionSuggestionKind.INVOCATION, 'nextBool'); |
| 237 assertHasResult( |
| 238 CompletionSuggestionKind.INVOCATION, |
| 239 'nextDouble', |
| 240 DART_RELEVANCE_COMMON_USAGE - 1); |
| 241 assertHasResult( |
| 242 CompletionSuggestionKind.INVOCATION, |
| 243 'nextInt', |
| 244 DART_RELEVANCE_COMMON_USAGE); |
| 245 assertNoResult('Random'); |
| 246 assertNoResult('Object'); |
| 247 assertNoResult('A'); |
| 248 } |
| 249 } |
OLD | NEW |