| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2014, 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.toplevel; | |
| 6 | |
| 7 import 'package:analysis_server/src/protocol.dart' as protocol | |
| 8 show Element, ElementKind; | |
| 9 import 'package:analysis_server/src/protocol.dart' hide Element, ElementKind; | |
| 10 import 'package:analysis_server/src/services/completion/completion_manager.dart'
; | |
| 11 import 'package:analysis_server/src/services/completion/dart_completion_cache.da
rt'; | |
| 12 import 'package:analysis_server/src/services/completion/dart_completion_manager.
dart'; | |
| 13 import 'package:analysis_server/src/services/completion/imported_computer.dart'; | |
| 14 import 'package:analyzer/src/generated/ast.dart'; | |
| 15 import 'package:analyzer/src/generated/element.dart'; | |
| 16 import 'package:analyzer/src/generated/engine.dart'; | |
| 17 import 'package:analyzer/src/generated/source.dart'; | |
| 18 import 'package:unittest/unittest.dart'; | |
| 19 | |
| 20 import '../../abstract_context.dart'; | |
| 21 import '../../reflective_tests.dart'; | |
| 22 import 'completion_test_util.dart'; | |
| 23 | |
| 24 main() { | |
| 25 groupSep = ' | '; | |
| 26 runReflectiveTests(ImportedReferenceContributorTest); | |
| 27 } | |
| 28 | |
| 29 @reflectiveTest | |
| 30 class ImportedReferenceContributorTest extends AbstractSelectorSuggestionTest { | |
| 31 void assertCached(String completion) { | |
| 32 DartCompletionCache cache = request.cache; | |
| 33 if (!isCached(cache.importedTypeSuggestions, completion) && | |
| 34 !isCached(cache.importedVoidReturnSuggestions, completion) && | |
| 35 !isCached(cache.libraryPrefixSuggestions, completion) && | |
| 36 !isCached(cache.otherImportedSuggestions, completion)) { | |
| 37 fail('expected $completion to be cached'); | |
| 38 } | |
| 39 } | |
| 40 | |
| 41 /** | |
| 42 * Assert that the ImportedReferenceContributor uses cached results | |
| 43 * to produce identical suggestions to the original set of suggestions. | |
| 44 */ | |
| 45 @override | |
| 46 assertCachedCompute(_) { | |
| 47 if (!(contributor as ImportedReferenceContributor).shouldWaitForLowPriorityS
uggestions) { | |
| 48 return null; | |
| 49 } | |
| 50 expect(request.unit.element, isNotNull); | |
| 51 List<CompletionSuggestion> oldSuggestions = request.suggestions; | |
| 52 /* | |
| 53 * Simulate a source change to flush the cached compilation unit | |
| 54 */ | |
| 55 ChangeSet changes = new ChangeSet(); | |
| 56 changes.addedSource(testSource); | |
| 57 context.applyChanges(changes); | |
| 58 /* | |
| 59 * Calculate a new completion at the same location | |
| 60 */ | |
| 61 setUpContributor(); | |
| 62 int replacementOffset = request.replacementOffset; | |
| 63 int replacementLength = request.replacementLength; | |
| 64 request = new DartCompletionRequest(context, searchEngine, testSource, | |
| 65 completionOffset, cache, new CompletionPerformance()); | |
| 66 request.replacementOffset = replacementOffset; | |
| 67 request.replacementLength = replacementLength; | |
| 68 | |
| 69 void assertResultsFromCache(List<CompletionSuggestion> oldSuggestions) { | |
| 70 List<CompletionSuggestion> newSuggestions = request.suggestions; | |
| 71 if (newSuggestions.length == oldSuggestions.length) { | |
| 72 if (!oldSuggestions | |
| 73 .any((CompletionSuggestion s) => !newSuggestions.contains(s))) { | |
| 74 return; | |
| 75 } | |
| 76 } | |
| 77 StringBuffer sb = new StringBuffer( | |
| 78 'suggestions based upon cached results do not match expectations'); | |
| 79 sb.write('\n Expected:'); | |
| 80 oldSuggestions.toList() | |
| 81 ..sort(suggestionComparator) | |
| 82 ..forEach((CompletionSuggestion suggestion) { | |
| 83 sb.write('\n ${suggestion.completion} -> $suggestion'); | |
| 84 }); | |
| 85 sb.write('\n Actual:'); | |
| 86 newSuggestions.toList() | |
| 87 ..sort(suggestionComparator) | |
| 88 ..forEach((CompletionSuggestion suggestion) { | |
| 89 sb.write('\n ${suggestion.completion} -> $suggestion'); | |
| 90 }); | |
| 91 fail(sb.toString()); | |
| 92 } | |
| 93 | |
| 94 if (computeFast()) { | |
| 95 expect(request.unit.element, isNull); | |
| 96 assertResultsFromCache(oldSuggestions); | |
| 97 } else { | |
| 98 // Results from cache might need to be adjusted | |
| 99 // if target is a function argument in an argument list | |
| 100 resolve(false); | |
| 101 return contributor.computeFull(request).then((bool result) { | |
| 102 expect(result, isTrue); | |
| 103 expect(request.unit.element, isNotNull); | |
| 104 assertResultsFromCache(oldSuggestions); | |
| 105 }); | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 void assertNotCached(String completion) { | |
| 110 DartCompletionCache cache = request.cache; | |
| 111 if (isCached(cache.importedTypeSuggestions, completion) || | |
| 112 isCached(cache.importedVoidReturnSuggestions, completion) || | |
| 113 isCached(cache.libraryPrefixSuggestions, completion) || | |
| 114 isCached(cache.otherImportedSuggestions, completion)) { | |
| 115 fail('expected $completion NOT to be cached'); | |
| 116 } | |
| 117 } | |
| 118 | |
| 119 @override | |
| 120 CompletionSuggestion assertSuggestImportedConstructor(String name, | |
| 121 {int relevance: DART_RELEVANCE_DEFAULT}) { | |
| 122 return assertSuggestConstructor(name, relevance: relevance); | |
| 123 } | |
| 124 | |
| 125 @override | |
| 126 CompletionSuggestion assertSuggestImportedField(String name, String type, | |
| 127 {int relevance: DART_RELEVANCE_INHERITED_FIELD}) { | |
| 128 return assertSuggestField(name, type, relevance: relevance); | |
| 129 } | |
| 130 | |
| 131 @override | |
| 132 CompletionSuggestion assertSuggestImportedFunction( | |
| 133 String name, String returnType, | |
| 134 {CompletionSuggestionKind kind: CompletionSuggestionKind.INVOCATION, | |
| 135 bool deprecated: false, int relevance: DART_RELEVANCE_DEFAULT}) { | |
| 136 return assertSuggestFunction(name, returnType, | |
| 137 kind: kind, deprecated: deprecated, relevance: relevance); | |
| 138 } | |
| 139 | |
| 140 CompletionSuggestion assertSuggestImportedGetter( | |
| 141 String name, String returnType, | |
| 142 {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) { | |
| 143 return assertSuggestGetter(name, returnType, relevance: relevance); | |
| 144 } | |
| 145 | |
| 146 CompletionSuggestion assertSuggestImportedMethod( | |
| 147 String name, String declaringType, String returnType, | |
| 148 {int relevance: DART_RELEVANCE_INHERITED_METHOD}) { | |
| 149 return assertSuggestMethod(name, declaringType, returnType, | |
| 150 relevance: relevance); | |
| 151 } | |
| 152 | |
| 153 CompletionSuggestion assertSuggestImportedSetter(String name, | |
| 154 {int relevance: DART_RELEVANCE_INHERITED_ACCESSOR}) { | |
| 155 return assertSuggestSetter(name, relevance); | |
| 156 } | |
| 157 | |
| 158 @override | |
| 159 CompletionSuggestion assertSuggestLibraryPrefix(String prefix, | |
| 160 [int relevance = DART_RELEVANCE_DEFAULT, | |
| 161 CompletionSuggestionKind kind = CompletionSuggestionKind.INVOCATION]) { | |
| 162 CompletionSuggestion cs = | |
| 163 assertSuggest(prefix, csKind: kind, relevance: relevance); | |
| 164 protocol.Element element = cs.element; | |
| 165 expect(element, isNotNull); | |
| 166 expect(element.kind, equals(protocol.ElementKind.LIBRARY)); | |
| 167 expect(element.parameters, isNull); | |
| 168 expect(element.returnType, isNull); | |
| 169 assertHasNoParameterInfo(cs); | |
| 170 return cs; | |
| 171 } | |
| 172 | |
| 173 bool isCached(List<CompletionSuggestion> suggestions, String completion) => | |
| 174 suggestions.any((CompletionSuggestion s) => s.completion == completion); | |
| 175 | |
| 176 @override | |
| 177 void setUpContributor() { | |
| 178 contributor = new ImportedReferenceContributor(shouldWaitForLowPrioritySugge
stions: true); | |
| 179 } | |
| 180 | |
| 181 @override | |
| 182 test_ArgumentList() { | |
| 183 return super.test_ArgumentList().then((_) { | |
| 184 expect(request.cache.importKey, "import '/libA.dart';"); | |
| 185 ClassElement objClassElem1 = request.cache.importedClassMap['Object']; | |
| 186 expect(objClassElem1, isNotNull); | |
| 187 ClassElement objClassElem2 = request.cache.objectClassElement; | |
| 188 expect(objClassElem1, same(objClassElem2)); | |
| 189 }); | |
| 190 } | |
| 191 | |
| 192 @override | |
| 193 test_ArgumentList_imported_function() { | |
| 194 return super.test_ArgumentList_imported_function().then((_) { | |
| 195 expect(request.cache.importKey, "import '/libA.dart';"); | |
| 196 }); | |
| 197 } | |
| 198 | |
| 199 @override | |
| 200 test_AssignmentExpression_RHS() { | |
| 201 return super.test_AssignmentExpression_RHS().then((_) { | |
| 202 expect(request.cache.importKey, ''); | |
| 203 }); | |
| 204 } | |
| 205 | |
| 206 @override | |
| 207 test_Block() { | |
| 208 return super.test_Block().then((_) { | |
| 209 expect(request.cache.importKey, | |
| 210 'import "/testAB.dart";import "/testCD.dart" hide D;import "/testEEF.d
art" show EE;import "/testG.dart" as g;'); | |
| 211 assertCached('A'); | |
| 212 assertCached('T3'); | |
| 213 }); | |
| 214 } | |
| 215 | |
| 216 @override | |
| 217 test_Block_inherited_imported() { | |
| 218 return super.test_Block_inherited_imported().then((_) { | |
| 219 assertCached('E'); | |
| 220 assertCached('F'); | |
| 221 assertNotCached('e1'); | |
| 222 assertNotCached('i2'); | |
| 223 assertNotCached('m1'); | |
| 224 assertNotCached('_pf'); | |
| 225 }); | |
| 226 } | |
| 227 | |
| 228 test_Block_partial_results() { | |
| 229 // Block BlockFunctionBody MethodDeclaration | |
| 230 addSource('/testAB.dart', ''' | |
| 231 export "dart:math" hide max; | |
| 232 class A {int x;} | |
| 233 @deprecated D1() {int x;} | |
| 234 class _B { }'''); | |
| 235 addSource('/testCD.dart', ''' | |
| 236 String T1; | |
| 237 var _T2; | |
| 238 class C { } | |
| 239 class D { }'''); | |
| 240 addSource('/testEEF.dart', ''' | |
| 241 class EE { } | |
| 242 class F { }'''); | |
| 243 addSource('/testG.dart', 'class G { }'); | |
| 244 addSource('/testH.dart', ''' | |
| 245 class H { } | |
| 246 int T3; | |
| 247 var _T4;'''); // not imported | |
| 248 addTestSource(''' | |
| 249 import "/testAB.dart"; | |
| 250 import "/testCD.dart" hide D; | |
| 251 import "/testEEF.dart" show EE; | |
| 252 import "/testG.dart" as g; | |
| 253 int T5; | |
| 254 var _T6; | |
| 255 Z D2() {int x;} | |
| 256 class X {a() {var f; {var x;} ^ var r;} void b() { }} | |
| 257 class Z { }'''); | |
| 258 (contributor as ImportedReferenceContributor).shouldWaitForLowPrioritySugges
tions = false; | |
| 259 computeFast(); | |
| 260 return computeFull((bool result) { | |
| 261 assertSuggestImportedClass('C'); | |
| 262 // Assert contributor does not wait for or include low priority results | |
| 263 // from non-imported libraries unless instructed to do so. | |
| 264 assertNotSuggested('H'); | |
| 265 }); | |
| 266 } | |
| 267 | |
| 268 test_function_parameters_mixed_required_and_named() { | |
| 269 addSource('/libA.dart', ''' | |
| 270 void m(x, {int y}) {} | |
| 271 '''); | |
| 272 addTestSource(''' | |
| 273 import '/libA.dart'; | |
| 274 class B extends A { | |
| 275 main() {^} | |
| 276 } | |
| 277 '''); | |
| 278 return computeFull((bool result) { | |
| 279 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 280 expect(suggestion.parameterNames, hasLength(2)); | |
| 281 expect(suggestion.parameterNames[0], 'x'); | |
| 282 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 283 expect(suggestion.parameterNames[1], 'y'); | |
| 284 expect(suggestion.parameterTypes[1], 'int'); | |
| 285 expect(suggestion.requiredParameterCount, 1); | |
| 286 expect(suggestion.hasNamedParameters, true); | |
| 287 }); | |
| 288 } | |
| 289 | |
| 290 test_function_parameters_mixed_required_and_positional() { | |
| 291 addSource('/libA.dart', ''' | |
| 292 void m(x, [int y]) {} | |
| 293 '''); | |
| 294 addTestSource(''' | |
| 295 import '/libA.dart'; | |
| 296 class B extends A { | |
| 297 main() {^} | |
| 298 } | |
| 299 '''); | |
| 300 return computeFull((bool result) { | |
| 301 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 302 expect(suggestion.parameterNames, hasLength(2)); | |
| 303 expect(suggestion.parameterNames[0], 'x'); | |
| 304 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 305 expect(suggestion.parameterNames[1], 'y'); | |
| 306 expect(suggestion.parameterTypes[1], 'int'); | |
| 307 expect(suggestion.requiredParameterCount, 1); | |
| 308 expect(suggestion.hasNamedParameters, false); | |
| 309 }); | |
| 310 } | |
| 311 | |
| 312 test_function_parameters_named() { | |
| 313 addSource('/libA.dart', ''' | |
| 314 void m({x, int y}) {} | |
| 315 '''); | |
| 316 addTestSource(''' | |
| 317 import '/libA.dart'; | |
| 318 class B extends A { | |
| 319 main() {^} | |
| 320 } | |
| 321 '''); | |
| 322 return computeFull((bool result) { | |
| 323 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 324 expect(suggestion.parameterNames, hasLength(2)); | |
| 325 expect(suggestion.parameterNames[0], 'x'); | |
| 326 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 327 expect(suggestion.parameterNames[1], 'y'); | |
| 328 expect(suggestion.parameterTypes[1], 'int'); | |
| 329 expect(suggestion.requiredParameterCount, 0); | |
| 330 expect(suggestion.hasNamedParameters, true); | |
| 331 }); | |
| 332 } | |
| 333 | |
| 334 test_function_parameters_none() { | |
| 335 addSource('/libA.dart', ''' | |
| 336 void m() {} | |
| 337 '''); | |
| 338 addTestSource(''' | |
| 339 import '/libA.dart'; | |
| 340 class B extends A { | |
| 341 main() {^} | |
| 342 } | |
| 343 '''); | |
| 344 computeFast(); | |
| 345 return computeFull((bool result) { | |
| 346 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 347 expect(suggestion.parameterNames, isEmpty); | |
| 348 expect(suggestion.parameterTypes, isEmpty); | |
| 349 expect(suggestion.requiredParameterCount, 0); | |
| 350 expect(suggestion.hasNamedParameters, false); | |
| 351 }); | |
| 352 } | |
| 353 | |
| 354 test_function_parameters_positional() { | |
| 355 addSource('/libA.dart', ''' | |
| 356 void m([x, int y]) {} | |
| 357 '''); | |
| 358 addTestSource(''' | |
| 359 import '/libA.dart'; | |
| 360 class B extends A { | |
| 361 main() {^} | |
| 362 } | |
| 363 '''); | |
| 364 return computeFull((bool result) { | |
| 365 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 366 expect(suggestion.parameterNames, hasLength(2)); | |
| 367 expect(suggestion.parameterNames[0], 'x'); | |
| 368 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 369 expect(suggestion.parameterNames[1], 'y'); | |
| 370 expect(suggestion.parameterTypes[1], 'int'); | |
| 371 expect(suggestion.requiredParameterCount, 0); | |
| 372 expect(suggestion.hasNamedParameters, false); | |
| 373 }); | |
| 374 } | |
| 375 | |
| 376 test_function_parameters_required() { | |
| 377 addSource('/libA.dart', ''' | |
| 378 void m(x, int y) {} | |
| 379 '''); | |
| 380 addTestSource(''' | |
| 381 import '/libA.dart'; | |
| 382 class B extends A { | |
| 383 main() {^} | |
| 384 } | |
| 385 '''); | |
| 386 return computeFull((bool result) { | |
| 387 CompletionSuggestion suggestion = assertSuggestFunction('m', 'void'); | |
| 388 expect(suggestion.parameterNames, hasLength(2)); | |
| 389 expect(suggestion.parameterNames[0], 'x'); | |
| 390 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 391 expect(suggestion.parameterNames[1], 'y'); | |
| 392 expect(suggestion.parameterTypes[1], 'int'); | |
| 393 expect(suggestion.requiredParameterCount, 2); | |
| 394 expect(suggestion.hasNamedParameters, false); | |
| 395 }); | |
| 396 } | |
| 397 | |
| 398 test_InstanceCreationExpression() { | |
| 399 addSource('/testA.dart', ''' | |
| 400 class A {foo(){var f; {var x;}}} | |
| 401 class B {B(this.x, [String boo]) { } int x;} | |
| 402 class C {C.bar({boo: 'hoo', int z: 0}) { } }'''); | |
| 403 addTestSource(''' | |
| 404 import "/testA.dart"; | |
| 405 import "dart:math" as math; | |
| 406 main() {new ^ String x = "hello";}'''); | |
| 407 computeFast(); | |
| 408 return computeFull((bool result) { | |
| 409 CompletionSuggestion suggestion; | |
| 410 | |
| 411 suggestion = assertSuggestImportedConstructor('Object'); | |
| 412 expect(suggestion.element.parameters, '()'); | |
| 413 expect(suggestion.parameterNames, hasLength(0)); | |
| 414 expect(suggestion.requiredParameterCount, 0); | |
| 415 expect(suggestion.hasNamedParameters, false); | |
| 416 | |
| 417 suggestion = assertSuggestImportedConstructor('A'); | |
| 418 expect(suggestion.element.parameters, '()'); | |
| 419 expect(suggestion.parameterNames, hasLength(0)); | |
| 420 expect(suggestion.requiredParameterCount, 0); | |
| 421 expect(suggestion.hasNamedParameters, false); | |
| 422 | |
| 423 suggestion = assertSuggestImportedConstructor('B'); | |
| 424 expect(suggestion.element.parameters, '(int x, [String boo])'); | |
| 425 expect(suggestion.parameterNames, hasLength(2)); | |
| 426 expect(suggestion.parameterNames[0], 'x'); | |
| 427 expect(suggestion.parameterTypes[0], 'int'); | |
| 428 expect(suggestion.parameterNames[1], 'boo'); | |
| 429 expect(suggestion.parameterTypes[1], 'String'); | |
| 430 expect(suggestion.requiredParameterCount, 1); | |
| 431 expect(suggestion.hasNamedParameters, false); | |
| 432 | |
| 433 suggestion = assertSuggestImportedConstructor('C.bar'); | |
| 434 expect( | |
| 435 suggestion.element.parameters, "({dynamic boo: 'hoo'}, {int z: 0})"); | |
| 436 expect(suggestion.parameterNames, hasLength(2)); | |
| 437 expect(suggestion.parameterNames[0], 'boo'); | |
| 438 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 439 expect(suggestion.parameterNames[1], 'z'); | |
| 440 expect(suggestion.parameterTypes[1], 'int'); | |
| 441 expect(suggestion.requiredParameterCount, 0); | |
| 442 expect(suggestion.hasNamedParameters, true); | |
| 443 | |
| 444 assertSuggestLibraryPrefix('math'); | |
| 445 }); | |
| 446 } | |
| 447 | |
| 448 test_method_parameters_mixed_required_and_named() { | |
| 449 addSource('/libA.dart', ''' | |
| 450 class A { | |
| 451 void m(x, {int y}) {} | |
| 452 } | |
| 453 '''); | |
| 454 addTestSource(''' | |
| 455 import '/libA.dart'; | |
| 456 class B extends A { | |
| 457 main() {^} | |
| 458 } | |
| 459 '''); | |
| 460 return computeFull((bool result) { | |
| 461 CompletionSuggestion suggestion = | |
| 462 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 463 expect(suggestion.parameterNames, hasLength(2)); | |
| 464 expect(suggestion.parameterNames[0], 'x'); | |
| 465 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 466 expect(suggestion.parameterNames[1], 'y'); | |
| 467 expect(suggestion.parameterTypes[1], 'int'); | |
| 468 expect(suggestion.requiredParameterCount, 1); | |
| 469 expect(suggestion.hasNamedParameters, true); | |
| 470 }); | |
| 471 } | |
| 472 | |
| 473 test_method_parameters_mixed_required_and_positional() { | |
| 474 addSource('/libA.dart', ''' | |
| 475 class A { | |
| 476 void m(x, [int y]) {} | |
| 477 } | |
| 478 '''); | |
| 479 addTestSource(''' | |
| 480 import '/libA.dart'; | |
| 481 class B extends A { | |
| 482 main() {^} | |
| 483 } | |
| 484 '''); | |
| 485 return computeFull((bool result) { | |
| 486 CompletionSuggestion suggestion = | |
| 487 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 488 expect(suggestion.parameterNames, hasLength(2)); | |
| 489 expect(suggestion.parameterNames[0], 'x'); | |
| 490 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 491 expect(suggestion.parameterNames[1], 'y'); | |
| 492 expect(suggestion.parameterTypes[1], 'int'); | |
| 493 expect(suggestion.requiredParameterCount, 1); | |
| 494 expect(suggestion.hasNamedParameters, false); | |
| 495 }); | |
| 496 } | |
| 497 | |
| 498 test_method_parameters_named() { | |
| 499 addSource('/libA.dart', ''' | |
| 500 class A { | |
| 501 void m({x, int y}) {} | |
| 502 } | |
| 503 '''); | |
| 504 addTestSource(''' | |
| 505 import '/libA.dart'; | |
| 506 class B extends A { | |
| 507 main() {^} | |
| 508 } | |
| 509 '''); | |
| 510 return computeFull((bool result) { | |
| 511 CompletionSuggestion suggestion = | |
| 512 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 513 expect(suggestion.parameterNames, hasLength(2)); | |
| 514 expect(suggestion.parameterNames[0], 'x'); | |
| 515 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 516 expect(suggestion.parameterNames[1], 'y'); | |
| 517 expect(suggestion.parameterTypes[1], 'int'); | |
| 518 expect(suggestion.requiredParameterCount, 0); | |
| 519 expect(suggestion.hasNamedParameters, true); | |
| 520 }); | |
| 521 } | |
| 522 | |
| 523 test_method_parameters_none() { | |
| 524 addSource('/libA.dart', ''' | |
| 525 class A { | |
| 526 void m() {} | |
| 527 } | |
| 528 '''); | |
| 529 addTestSource(''' | |
| 530 import '/libA.dart'; | |
| 531 class B extends A { | |
| 532 main() {^} | |
| 533 } | |
| 534 '''); | |
| 535 computeFast(); | |
| 536 return computeFull((bool result) { | |
| 537 CompletionSuggestion suggestion = | |
| 538 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 539 expect(suggestion.parameterNames, isEmpty); | |
| 540 expect(suggestion.parameterTypes, isEmpty); | |
| 541 expect(suggestion.requiredParameterCount, 0); | |
| 542 expect(suggestion.hasNamedParameters, false); | |
| 543 }); | |
| 544 } | |
| 545 | |
| 546 test_method_parameters_positional() { | |
| 547 addSource('/libA.dart', ''' | |
| 548 class A { | |
| 549 void m([x, int y]) {} | |
| 550 } | |
| 551 '''); | |
| 552 addTestSource(''' | |
| 553 import '/libA.dart'; | |
| 554 class B extends A { | |
| 555 main() {^} | |
| 556 } | |
| 557 '''); | |
| 558 return computeFull((bool result) { | |
| 559 CompletionSuggestion suggestion = | |
| 560 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 561 expect(suggestion.parameterNames, hasLength(2)); | |
| 562 expect(suggestion.parameterNames[0], 'x'); | |
| 563 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 564 expect(suggestion.parameterNames[1], 'y'); | |
| 565 expect(suggestion.parameterTypes[1], 'int'); | |
| 566 expect(suggestion.requiredParameterCount, 0); | |
| 567 expect(suggestion.hasNamedParameters, false); | |
| 568 }); | |
| 569 } | |
| 570 | |
| 571 test_method_parameters_required() { | |
| 572 addSource('/libA.dart', ''' | |
| 573 class A { | |
| 574 void m(x, int y) {} | |
| 575 } | |
| 576 '''); | |
| 577 addTestSource(''' | |
| 578 import '/libA.dart'; | |
| 579 class B extends A { | |
| 580 main() {^} | |
| 581 } | |
| 582 '''); | |
| 583 return computeFull((bool result) { | |
| 584 CompletionSuggestion suggestion = | |
| 585 assertSuggestImportedMethod('m', 'A', 'void'); | |
| 586 expect(suggestion.parameterNames, hasLength(2)); | |
| 587 expect(suggestion.parameterNames[0], 'x'); | |
| 588 expect(suggestion.parameterTypes[0], 'dynamic'); | |
| 589 expect(suggestion.parameterNames[1], 'y'); | |
| 590 expect(suggestion.parameterTypes[1], 'int'); | |
| 591 expect(suggestion.requiredParameterCount, 2); | |
| 592 expect(suggestion.hasNamedParameters, false); | |
| 593 }); | |
| 594 } | |
| 595 | |
| 596 test_mixin_ordering() { | |
| 597 addSource('/libA.dart', ''' | |
| 598 class B {} | |
| 599 class M1 { | |
| 600 void m() {} | |
| 601 } | |
| 602 class M2 { | |
| 603 void m() {} | |
| 604 } | |
| 605 '''); | |
| 606 addTestSource(''' | |
| 607 import '/libA.dart'; | |
| 608 class C extends B with M1, M2 { | |
| 609 void f() { | |
| 610 ^ | |
| 611 } | |
| 612 } | |
| 613 '''); | |
| 614 return computeFull((bool result) { | |
| 615 assertSuggestImportedMethod('m', 'M2', 'void'); | |
| 616 }); | |
| 617 } | |
| 618 | |
| 619 /** | |
| 620 * Ensure that completions in one context don't appear in another | |
| 621 */ | |
| 622 test_multiple_contexts() { | |
| 623 | |
| 624 // Create a 2nd context with source | |
| 625 var context2 = AnalysisEngine.instance.createAnalysisContext(); | |
| 626 context2.sourceFactory = | |
| 627 new SourceFactory([AbstractContextTest.SDK_RESOLVER, resourceResolver]); | |
| 628 String content2 = 'class ClassFromAnotherContext { }'; | |
| 629 Source source2 = | |
| 630 provider.newFile('/context2/foo.dart', content2).createSource(); | |
| 631 ChangeSet changeSet = new ChangeSet(); | |
| 632 changeSet.addedSource(source2); | |
| 633 context2.applyChanges(changeSet); | |
| 634 context2.setContents(source2, content2); | |
| 635 | |
| 636 // Resolve the source in the 2nd context and update the index | |
| 637 var result = context2.performAnalysisTask(); | |
| 638 while (result.hasMoreWork) { | |
| 639 result.changeNotices.forEach((ChangeNotice notice) { | |
| 640 CompilationUnit unit = notice.resolvedDartUnit; | |
| 641 if (unit != null) { | |
| 642 index.indexUnit(context2, unit); | |
| 643 } | |
| 644 }); | |
| 645 result = context2.performAnalysisTask(); | |
| 646 } | |
| 647 | |
| 648 // Check that source in 2nd context does not appear in completion in 1st | |
| 649 addSource('/context1/libA.dart', ''' | |
| 650 library libA; | |
| 651 class ClassInLocalContext {int x;}'''); | |
| 652 testFile = '/context1/completionTest.dart'; | |
| 653 addTestSource(''' | |
| 654 import "/context1/libA.dart"; | |
| 655 import "/foo.dart"; | |
| 656 main() {C^} | |
| 657 '''); | |
| 658 computeFast(); | |
| 659 return computeFull((bool result) { | |
| 660 assertSuggestImportedClass('ClassInLocalContext'); | |
| 661 // Assert contributor does not include results from 2nd context. | |
| 662 assertNotSuggested('ClassFromAnotherContext'); | |
| 663 }); | |
| 664 } | |
| 665 | |
| 666 test_no_parameters_field() { | |
| 667 addSource('/libA.dart', ''' | |
| 668 class A { | |
| 669 int x; | |
| 670 } | |
| 671 '''); | |
| 672 addTestSource(''' | |
| 673 import '/libA.dart'; | |
| 674 class B extends A { | |
| 675 main() {^} | |
| 676 } | |
| 677 '''); | |
| 678 return computeFull((bool result) { | |
| 679 CompletionSuggestion suggestion = assertSuggestImportedField('x', 'int'); | |
| 680 assertHasNoParameterInfo(suggestion); | |
| 681 }); | |
| 682 } | |
| 683 | |
| 684 test_no_parameters_getter() { | |
| 685 addSource('/libA.dart', ''' | |
| 686 class A { | |
| 687 int get x => null; | |
| 688 } | |
| 689 '''); | |
| 690 addTestSource(''' | |
| 691 import '/libA.dart'; | |
| 692 class B extends A { | |
| 693 main() {^} | |
| 694 } | |
| 695 '''); | |
| 696 return computeFull((bool result) { | |
| 697 CompletionSuggestion suggestion = assertSuggestImportedGetter('x', 'int'); | |
| 698 assertHasNoParameterInfo(suggestion); | |
| 699 }); | |
| 700 } | |
| 701 | |
| 702 test_no_parameters_setter() { | |
| 703 addSource('/libA.dart', ''' | |
| 704 class A { | |
| 705 set x(int value) {}; | |
| 706 } | |
| 707 '''); | |
| 708 addTestSource(''' | |
| 709 import '/libA.dart'; | |
| 710 class B extends A { | |
| 711 main() {^} | |
| 712 } | |
| 713 '''); | |
| 714 return computeFull((bool result) { | |
| 715 CompletionSuggestion suggestion = assertSuggestImportedSetter('x'); | |
| 716 assertHasNoParameterInfo(suggestion); | |
| 717 }); | |
| 718 } | |
| 719 | |
| 720 @override | |
| 721 test_partFile_TypeName() { | |
| 722 return super.test_partFile_TypeName().then((_) { | |
| 723 expect(request.cache.importKey, 'part of libA;'); | |
| 724 }); | |
| 725 } | |
| 726 | |
| 727 @override | |
| 728 test_partFile_TypeName2() { | |
| 729 return super.test_partFile_TypeName2().then((_) { | |
| 730 expect(request.cache.importKey, | |
| 731 'library libA;import "/testB.dart";part "/testA.dart";'); | |
| 732 }); | |
| 733 } | |
| 734 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1068483002:
rename completion source files to match content (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart