| // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| library test.domain.analysis; |
| |
| import 'dart:async'; |
| |
| import 'package:analysis_server/src/computer/computer_highlights.dart'; |
| import 'package:analysis_server/src/analysis_server.dart'; |
| import 'package:analysis_server/src/constants.dart'; |
| import 'package:analysis_server/src/domain_analysis.dart'; |
| import 'package:analysis_server/src/protocol.dart'; |
| import 'package:analysis_server/src/resource.dart'; |
| import 'package:unittest/unittest.dart'; |
| |
| import 'mocks.dart'; |
| |
| |
| main() { |
| groupSep = ' | '; |
| |
| MockServerChannel serverChannel; |
| AnalysisServer server; |
| AnalysisDomainHandler handler; |
| MemoryResourceProvider resourceProvider = new MemoryResourceProvider(); |
| |
| setUp(() { |
| serverChannel = new MockServerChannel(); |
| server = new AnalysisServer(serverChannel, resourceProvider); |
| handler = new AnalysisDomainHandler(server); |
| }); |
| |
| group('notification.errors', testNotificationErrors); |
| group('notification.highlights', testNotificationHighlights); |
| group('notification.navigation', testNotificationNavigation); |
| group('updateContent', testUpdateContent); |
| group('setSubscriptions', test_setSubscriptions); |
| |
| group('AnalysisDomainHandler', () { |
| test('getFixes', () { |
| var request = new Request('0', METHOD_GET_FIXES); |
| request.setParameter(ERRORS, []); |
| var response = handler.handleRequest(request); |
| // TODO(scheglov) implement |
| expect(response, isNull); |
| }); |
| |
| test('getMinorRefactorings', () { |
| var request = new Request('0', METHOD_GET_MINOR_REFACTORINGS); |
| request.setParameter(FILE, 'test.dart'); |
| request.setParameter(OFFSET, 10); |
| request.setParameter(LENGTH, 20); |
| var response = handler.handleRequest(request); |
| // TODO(scheglov) implement |
| expect(response, isNull); |
| }); |
| |
| group('setAnalysisRoots', () { |
| Request request; |
| |
| setUp(() { |
| request = new Request('0', METHOD_SET_ANALYSIS_ROOTS); |
| request.setParameter(INCLUDED, []); |
| request.setParameter(EXCLUDED, []); |
| }); |
| |
| test('excluded', () { |
| request.setParameter(EXCLUDED, ['foo']); |
| // TODO(scheglov) implement |
| var response = handler.handleRequest(request); |
| expect(response, isResponseFailure('0')); |
| }); |
| |
| group('included', () { |
| test('new folder', () { |
| resourceProvider.newFolder('/project'); |
| resourceProvider.newFile('/project/pubspec.yaml', 'name: project'); |
| resourceProvider.newFile('/project/bin/test.dart', 'main() {}'); |
| request.setParameter( |
| INCLUDED, |
| ['/project']); |
| var response = handler.handleRequest(request); |
| var serverRef = server; |
| expect(response, isResponseSuccess('0')); |
| // verify that unit is resolved eventually |
| return waitForServerOperationsPerformed(server).then((_) { |
| var unit = serverRef.test_getResolvedCompilationUnit('/project/bin/test.dart'); |
| expect(unit, isNotNull); |
| }); |
| }); |
| }); |
| }); |
| |
| test('setPriorityFiles', () { |
| var request = new Request('0', METHOD_SET_PRIORITY_FILES); |
| request.setParameter( |
| FILES, |
| ['projectA/aa.dart', 'projectB/ba.dart']); |
| var response = handler.handleRequest(request); |
| // TODO(scheglov) implement |
| expect(response, isNull); |
| }); |
| |
| test('updateOptions', () { |
| var request = new Request('0', METHOD_UPDATE_OPTIONS); |
| request.setParameter( |
| OPTIONS, |
| { |
| 'analyzeAngular' : true, |
| 'enableDeferredLoading': true, |
| 'enableEnums': false |
| }); |
| var response = handler.handleRequest(request); |
| // TODO(scheglov) implement |
| expect(response, isNull); |
| }); |
| |
| test('updateSdks', () { |
| var request = new Request('0', METHOD_UPDATE_SDKS); |
| request.setParameter( |
| ADDED, |
| ['/dart/sdk-1.3', '/dart/sdk-1.4']); |
| request.setParameter( |
| REMOVED, |
| ['/dart/sdk-1.2']); |
| request.setParameter(DEFAULT, '/dart/sdk-1.4'); |
| var response = handler.handleRequest(request); |
| // TODO(scheglov) implement |
| expect(response, isNull); |
| }); |
| }); |
| } |
| |
| |
| class AnalysisError { |
| final String file; |
| final String errorCode; |
| final int offset; |
| final int length; |
| final String message; |
| final String correction; |
| AnalysisError(this.file, this.errorCode, this.offset, this.length, |
| this.message, this.correction); |
| |
| @override |
| String toString() { |
| return 'NotificationError(file=$file; errorCode=$errorCode; ' |
| 'offset=$offset; length=$length; message=$message)'; |
| } |
| } |
| |
| |
| AnalysisError jsonToAnalysisError(Map<String, Object> json) { |
| return new AnalysisError( |
| json['file'], |
| json['errorCode'], |
| json['offset'], |
| json['length'], |
| json['message'], |
| json['correction']); |
| } |
| |
| |
| /** |
| * A helper to test 'analysis.*' requests. |
| */ |
| class AnalysisTestHelper { |
| MockServerChannel serverChannel; |
| MemoryResourceProvider resourceProvider; |
| AnalysisServer server; |
| AnalysisDomainHandler handler; |
| |
| Map<String, List<String>> analysisSubscriptions = {}; |
| |
| Map<String, List<AnalysisError>> filesErrors = {}; |
| Map<String, List<Map<String, Object>>> filesHighlights = {}; |
| Map<String, List<Map<String, Object>>> filesNavigation = {}; |
| |
| String testFile = '/project/bin/test.dart'; |
| String testCode; |
| |
| AnalysisTestHelper() { |
| serverChannel = new MockServerChannel(); |
| resourceProvider = new MemoryResourceProvider(); |
| server = new AnalysisServer(serverChannel, resourceProvider); |
| handler = new AnalysisDomainHandler(server); |
| // listen for notifications |
| Stream<Notification> notificationStream = serverChannel.notificationController.stream; |
| notificationStream.listen((Notification notification) { |
| if (notification.event == NOTIFICATION_ERRORS) { |
| String file = notification.getParameter(FILE); |
| List<Map<String, Object>> errorMaps = notification.getParameter(ERRORS); |
| filesErrors[file] = errorMaps.map(jsonToAnalysisError).toList(); |
| } |
| if (notification.event == NOTIFICATION_HIGHLIGHTS) { |
| String file = notification.getParameter(FILE); |
| filesHighlights[file] = notification.getParameter(REGIONS); |
| } |
| if (notification.event == NOTIFICATION_NAVIGATION) { |
| String file = notification.getParameter(FILE); |
| filesNavigation[file] = notification.getParameter(REGIONS); |
| } |
| }); |
| } |
| |
| void addAnalysisSubscriptionHighlights(String file) { |
| addAnalysisSubscription(AnalysisService.HIGHLIGHTS, file); |
| } |
| |
| void addAnalysisSubscriptionNavigation(String file) { |
| addAnalysisSubscription(AnalysisService.NAVIGATION, file); |
| } |
| |
| void addAnalysisSubscription(AnalysisService service, String file) { |
| // add file to subscription |
| var files = analysisSubscriptions[service.name]; |
| if (files == null) { |
| files = <String>[]; |
| analysisSubscriptions[service.name] = files; |
| } |
| files.add(file); |
| // set subscriptions |
| Request request = new Request('0', METHOD_SET_ANALYSIS_SUBSCRIPTIONS); |
| request.setParameter(SUBSCRIPTIONS, analysisSubscriptions); |
| handleSuccessfulRequest(request); |
| } |
| |
| /** |
| * Returns a [Future] that completes when this this helper finished all its |
| * scheduled tasks. |
| */ |
| Future waitForOperationsFinished() { |
| return waitForServerOperationsPerformed(server); |
| } |
| |
| /** |
| * Returns the offset of [search] in [testCode]. |
| * Fails if not found. |
| */ |
| int findOffset(String search) { |
| int offset = testCode.indexOf(search); |
| expect(offset, isNot(-1)); |
| return offset; |
| } |
| |
| /** |
| * Returns [AnalysisError]s recorded for the given [file]. |
| * May be empty, but not `null`. |
| */ |
| List<AnalysisError> getErrors(String file) { |
| List<AnalysisError> errors = filesErrors[file]; |
| if (errors != null) { |
| return errors; |
| } |
| return <AnalysisError>[]; |
| } |
| |
| /** |
| * Returns highlights recorded for the given [file]. |
| * May be empty, but not `null`. |
| */ |
| List<Map<String, Object>> getHighlights(String file) { |
| List<Map<String, Object>> highlights = filesHighlights[file]; |
| if (highlights != null) { |
| return highlights; |
| } |
| return []; |
| } |
| |
| /** |
| * Returns navigation regions recorded for the given [file]. |
| * May be empty, but not `null`. |
| */ |
| List<Map<String, Object>> getNavigation(String file) { |
| List<Map<String, Object>> navigation = filesNavigation[file]; |
| if (navigation != null) { |
| return navigation; |
| } |
| return []; |
| } |
| |
| /** |
| * Returns [AnalysisError]s recorded for the [testFile]. |
| * May be empty, but not `null`. |
| */ |
| List<AnalysisError> getTestErrors() { |
| return getErrors(testFile); |
| } |
| |
| /** |
| * Returns highlights recorded for the given [testFile]. |
| * May be empty, but not `null`. |
| */ |
| List<Map<String, Object>> getTestHighlights() { |
| return getHighlights(testFile); |
| } |
| |
| /** |
| * Returns navigation information recorded for the given [testFile]. |
| * May be empty, but not `null`. |
| */ |
| List<Map<String, Object>> getTestNavigation() { |
| return getNavigation(testFile); |
| } |
| |
| /** |
| * Creates an empty project `/project`. |
| */ |
| void createEmptyProject() { |
| resourceProvider.newFolder('/project'); |
| Request request = new Request('0', METHOD_SET_ANALYSIS_ROOTS); |
| request.setParameter(INCLUDED, ['/project']); |
| request.setParameter(EXCLUDED, []); |
| handleSuccessfulRequest(request); |
| } |
| |
| /** |
| * Creates a project with a single Dart file `/project/bin/test.dart` with |
| * the given [code]. |
| */ |
| void createSingleFileProject(code) { |
| this.testCode = _getCodeString(code); |
| resourceProvider.newFolder('/project'); |
| resourceProvider.newFile(testFile, testCode); |
| Request request = new Request('0', METHOD_SET_ANALYSIS_ROOTS); |
| request.setParameter(INCLUDED, ['/project']); |
| request.setParameter(EXCLUDED, []); |
| handleSuccessfulRequest(request); |
| } |
| |
| String setFileContent(String path, String content) { |
| resourceProvider.newFile(path, content); |
| return path; |
| } |
| |
| /** |
| * Validates that the given [request] is handled successfully. |
| */ |
| void handleSuccessfulRequest(Request request) { |
| Response response = handler.handleRequest(request); |
| expect(response, isResponseSuccess('0')); |
| } |
| |
| /** |
| * Stops the associated server. |
| */ |
| void stopServer() { |
| server.done(); |
| } |
| |
| static String _getCodeString(code) { |
| if (code is List<String>) { |
| code = code.join('\n'); |
| } |
| return code as String; |
| } |
| } |
| |
| |
| testNotificationErrors() { |
| AnalysisTestHelper helper; |
| |
| setUp(() { |
| helper = new AnalysisTestHelper(); |
| }); |
| |
| test('ParserErrorCode', () { |
| helper.createSingleFileProject('library lib'); |
| return helper.waitForOperationsFinished().then((_) { |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, hasLength(1)); |
| AnalysisError error = errors[0]; |
| expect(error.file, '/project/bin/test.dart'); |
| expect(error.errorCode, 'ParserErrorCode.EXPECTED_TOKEN'); |
| expect(error.offset, isPositive); |
| expect(error.length, isNonNegative); |
| expect(error.message, isNotNull); |
| }); |
| }); |
| |
| test('StaticWarningCode', () { |
| helper.createSingleFileProject([ |
| 'main() {', |
| ' print(unknown);', |
| '}']); |
| return helper.waitForOperationsFinished().then((_) { |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, hasLength(1)); |
| AnalysisError error = errors[0]; |
| expect(error.errorCode, 'StaticWarningCode.UNDEFINED_IDENTIFIER'); |
| }); |
| }); |
| } |
| |
| |
| class NotificationHighlightHelper extends AnalysisTestHelper { |
| List<Map<String, Object>> regions; |
| |
| Future prepareRegions(then()) { |
| addAnalysisSubscriptionHighlights(testFile); |
| return waitForOperationsFinished().then((_) { |
| regions = getTestHighlights(); |
| then(); |
| }); |
| } |
| |
| void assertHasRawRegion(HighlightType type, int offset, int length) { |
| for (Map<String, Object> region in regions) { |
| if (region['offset'] == offset && region['length'] == length |
| && region['type'] == type.name) { |
| return; |
| } |
| } |
| fail('Expected to find (offset=$offset; length=$length; type=$type) in\n' |
| '${regions.join('\n')}'); |
| } |
| |
| void assertNoRawRegion(HighlightType type, int offset, int length) { |
| for (Map<String, Object> region in regions) { |
| if (region['offset'] == offset && region['length'] == length |
| && region['type'] == type.name) { |
| fail('Not expected to find (offset=$offset; length=$length; type=$type) in\n' |
| '${regions.join('\n')}'); |
| } |
| } |
| } |
| |
| void assertHasRegion(HighlightType type, String search, [int length = -1]) { |
| int offset = testCode.indexOf(search); |
| expect(offset, isNot(-1)); |
| length = findRegionLength(search, length); |
| assertHasRawRegion(type, offset, length); |
| } |
| |
| void assertNoRegion(HighlightType type, String search, [int length = -1]) { |
| int offset = testCode.indexOf(search); |
| expect(offset, isNot(-1)); |
| length = findRegionLength(search, length); |
| assertNoRawRegion(type, offset, length); |
| } |
| |
| int findRegionLength(String search, int length) { |
| if (length == -1) { |
| length = 0; |
| while (length < search.length) { |
| int c = search.codeUnitAt(length); |
| if (length == 0 && c == '@'.codeUnitAt(0)) { |
| length++; |
| continue; |
| } |
| if (!(c >= 'a'.codeUnitAt(0) && c <= 'z'.codeUnitAt(0) || |
| c >= 'A'.codeUnitAt(0) && c <= 'Z'.codeUnitAt(0) || |
| c >= '0'.codeUnitAt(0) && c <= '9'.codeUnitAt(0))) { |
| break; |
| } |
| length++; |
| } |
| } |
| return length; |
| } |
| } |
| |
| |
| testNotificationHighlights() { |
| Future testRegions(String code, then(NotificationHighlightHelper helper)) { |
| var helper = new NotificationHighlightHelper(); |
| helper.createSingleFileProject(code); |
| return helper.prepareRegions(() { |
| then(helper); |
| }); |
| } |
| |
| group('ANNOTATION', () { |
| test('no arguments', () { |
| var code = ''' |
| const AAA = 42; |
| @AAA main() {} |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.ANNOTATION, '@AAA'); |
| }); |
| }); |
| |
| test('has arguments', () { |
| var code = ''' |
| class AAA { |
| const AAA(a, b, c); |
| } |
| @AAA(1, 2, 3) main() {} |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.ANNOTATION, '@AAA(', '@AAA('.length); |
| helper.assertHasRegion(HighlightType.ANNOTATION, ') main', ')'.length); |
| }); |
| }); |
| }); |
| |
| group('BUILT_IN', () { |
| test('abstract', () { |
| var code = ''' |
| abstract class A {}; |
| main() { |
| var abstract = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'abstract class'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'abstract = 42'); |
| }); |
| }); |
| |
| test('as', () { |
| var code = ''' |
| import 'dart:math' as math; |
| main() { |
| p as int; |
| var as = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'as math'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'as int'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'as = 42'); |
| }); |
| }); |
| |
| test('deferred', () { |
| var code = ''' |
| import 'dart:math' deferred as math; |
| main() { |
| var deferred = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'deferred as math'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'deferred = 42'); |
| }); |
| }); |
| |
| test('export', () { |
| var code = ''' |
| export "dart:math"; |
| main() { |
| var export = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'export "dart:'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'export = 42'); |
| }); |
| }); |
| |
| test('external', () { |
| var code = ''' |
| class A { |
| external A(); |
| external aaa(); |
| } |
| external main() { |
| var external = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'external A()'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'external aaa()'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'external main()'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'external = 42'); |
| }); |
| }); |
| |
| test('factory', () { |
| var code = ''' |
| class A { |
| factory A() => null; |
| } |
| main() { |
| var factory = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'factory A()'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'factory = 42'); |
| }); |
| }); |
| |
| test('get', () { |
| var code = ''' |
| get aaa => 1; |
| class A { |
| get bbb => 2; |
| } |
| main() { |
| var get = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'get aaa =>'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'get bbb =>'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'get = 42'); |
| }); |
| }); |
| |
| test('hide', () { |
| var code = ''' |
| import 'foo.dart' hide Foo; |
| main() { |
| var hide = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'hide Foo'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'hide = 42'); |
| }); |
| }); |
| |
| test('implements', () { |
| var code = ''' |
| class A {} |
| class B implements A {} |
| main() { |
| var implements = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'implements A {}'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'implements = 42'); |
| }); |
| }); |
| |
| test('import', () { |
| var code = ''' |
| import "foo.dart"; |
| main() { |
| var import = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'import "'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'import = 42'); |
| }); |
| }); |
| |
| test('library', () { |
| var code = ''' |
| library lib; |
| main() { |
| var library = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'library lib;'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'library = 42'); |
| }); |
| }); |
| |
| test('native', () { |
| var code = ''' |
| class A native "A_native" {} |
| class B { |
| bbb() native "bbb_native"; |
| } |
| main() { |
| var native = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'native "A_'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'native "bbb_'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'native = 42'); |
| }); |
| }); |
| |
| test('on', () { |
| var code = ''' |
| main() { |
| try { |
| } on int catch (e) { |
| } |
| var on = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'on int'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'on = 42'); |
| }); |
| }); |
| |
| test('operator', () { |
| var code = ''' |
| class A { |
| operator +(x) => null; |
| } |
| main() { |
| var operator = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'operator +('); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'operator = 42'); |
| }); |
| }); |
| |
| test('part', () { |
| var helper = new NotificationHighlightHelper(); |
| var code = ''' |
| part "my_part.dart"; |
| main() { |
| var part = 42; |
| }'''; |
| helper.createSingleFileProject(code); |
| helper.setFileContent('/project/bin/my_part.dart', 'part of lib;'); |
| return helper.prepareRegions(() { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'part "my_'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'part = 42'); |
| }); |
| }); |
| |
| test('part', () { |
| var helper = new NotificationHighlightHelper(); |
| var code = ''' |
| part of lib; |
| main() { |
| var part = 1; |
| var of = 2; |
| }'''; |
| helper.createSingleFileProject(code); |
| helper.setFileContent('/project/bin/lib.dart', ''' |
| library lib; |
| part 'test.dart'; |
| '''); |
| return helper.prepareRegions(() { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'part of', 'part of'.length); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'part = 1'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'of = 2'); |
| }); |
| }); |
| |
| test('set', () { |
| var code = ''' |
| set aaa(x) {} |
| class A |
| set bbb(x) {} |
| } |
| main() { |
| var set = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'set aaa('); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'set bbb('); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'set = 42'); |
| }); |
| }); |
| |
| test('show', () { |
| var code = ''' |
| import 'foo.dart' show Foo; |
| main() { |
| var show = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'show Foo'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'show = 42'); |
| }); |
| }); |
| |
| test('static', () { |
| var code = ''' |
| class A { |
| static aaa; |
| static bbb() {} |
| } |
| main() { |
| var static = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'static aaa;'); |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'static bbb()'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'static = 42'); |
| }); |
| }); |
| |
| test('typedef', () { |
| var code = ''' |
| typedef A(); |
| main() { |
| var typedef = 42; |
| }'''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.BUILT_IN, 'typedef A();'); |
| helper.assertNoRegion(HighlightType.BUILT_IN, 'typedef = 42'); |
| }); |
| }); |
| }); |
| |
| group('CLASS', () { |
| test('CLASS', () { |
| var code = ''' |
| class AAA {} |
| AAA aaa; |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.CLASS, 'AAA {}'); |
| helper.assertHasRegion(HighlightType.CLASS, 'AAA aaa'); |
| }); |
| }); |
| |
| test('not dynamic', () { |
| var code = ''' |
| dynamic f() {} |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertNoRegion(HighlightType.CLASS, 'dynamic f()'); |
| }); |
| }); |
| |
| test('not void', () { |
| var code = ''' |
| void f() {} |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertNoRegion(HighlightType.CLASS, 'void f()'); |
| }); |
| }); |
| }); |
| |
| test('CONSTRUCTOR', () { |
| var code = ''' |
| class AAA { |
| AAA() {} |
| AAA.name(p) {} |
| } |
| main() { |
| new AAA(); |
| new AAA.name(42); |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.CONSTRUCTOR, 'name(p)'); |
| helper.assertHasRegion(HighlightType.CONSTRUCTOR, 'name(42)'); |
| helper.assertNoRegion(HighlightType.CONSTRUCTOR, 'AAA() {}'); |
| helper.assertNoRegion(HighlightType.CONSTRUCTOR, 'AAA();'); |
| }); |
| }); |
| |
| test('DYNAMIC_TYPE', () { |
| var code = ''' |
| f() {} |
| main(p) { |
| print(p); |
| var v1 = f(); |
| int v2; |
| var v3 = v2; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.DYNAMIC_TYPE, 'p)'); |
| helper.assertHasRegion(HighlightType.DYNAMIC_TYPE, 'v1 ='); |
| helper.assertNoRegion(HighlightType.DYNAMIC_TYPE, 'v2;'); |
| helper.assertNoRegion(HighlightType.DYNAMIC_TYPE, 'v3 ='); |
| }); |
| }); |
| |
| test('FIELD', () { |
| var code = ''' |
| class A { |
| int aaa = 1; |
| int bbb = 2; |
| A([this.bbb = 3]); |
| } |
| main(A a) { |
| a.aaa = 4; |
| a.bbb = 5; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.FIELD, 'aaa = 1'); |
| helper.assertHasRegion(HighlightType.FIELD, 'bbb = 2'); |
| helper.assertHasRegion(HighlightType.FIELD, 'bbb = 3'); |
| helper.assertHasRegion(HighlightType.FIELD, 'aaa = 4'); |
| helper.assertHasRegion(HighlightType.FIELD, 'bbb = 5'); |
| }); |
| }); |
| |
| test('FIELD_STATIC', () { |
| var code = ''' |
| class A { |
| static aaa = 1; |
| static get bbb => null; |
| static set ccc(x) {} |
| } |
| main() { |
| A.aaa = 2; |
| A.bbb; |
| A.ccc = 3; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'aaa = 1'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'aaa = 2'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'bbb;'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'ccc = 3'); |
| }); |
| }); |
| |
| test('FUNCTION', () { |
| var code = ''' |
| fff(p) {} |
| main() { |
| fff(42); |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.FUNCTION_DECLARATION, 'fff(p) {}'); |
| helper.assertHasRegion(HighlightType.FUNCTION, 'fff(42)'); |
| }); |
| }); |
| |
| test('FUNCTION_TYPE_ALIAS', () { |
| var code = ''' |
| typedef FFF(p); |
| main(FFF fff) { |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.FUNCTION_TYPE_ALIAS, 'FFF(p)'); |
| helper.assertHasRegion(HighlightType.FUNCTION_TYPE_ALIAS, 'FFF fff)'); |
| }); |
| }); |
| |
| test('GETTER_DECLARATION', () { |
| var code = ''' |
| get aaa => null; |
| class A { |
| get bbb => null; |
| } |
| main(A a) { |
| aaa; |
| a.bbb; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.GETTER_DECLARATION, 'aaa => null'); |
| helper.assertHasRegion(HighlightType.GETTER_DECLARATION, 'bbb => null'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'aaa;'); |
| helper.assertHasRegion(HighlightType.FIELD, 'bbb;'); |
| }); |
| }); |
| |
| test('IDENTIFIER_DEFAULT', () { |
| var code = ''' |
| main() { |
| aaa = 42; |
| bbb(84); |
| CCC ccc; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.IDENTIFIER_DEFAULT, 'aaa = 42'); |
| helper.assertHasRegion(HighlightType.IDENTIFIER_DEFAULT, 'bbb(84)'); |
| helper.assertHasRegion(HighlightType.IDENTIFIER_DEFAULT, 'CCC ccc'); |
| }); |
| }); |
| |
| test('IMPORT_PREFIX', () { |
| var code = ''' |
| import 'dart:math' as ma; |
| main() { |
| ma.max(1, 2); |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.IMPORT_PREFIX, 'ma;'); |
| helper.assertHasRegion(HighlightType.IMPORT_PREFIX, 'ma.max'); |
| }); |
| }); |
| |
| test('KEYWORD void', () { |
| var code = ''' |
| void main() { |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.KEYWORD, 'void main()'); |
| }); |
| }); |
| |
| test('LITERAL_BOOLEAN', () { |
| var code = 'var V = true;'; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.LITERAL_BOOLEAN, 'true;'); |
| }); |
| }); |
| |
| test('LITERAL_DOUBLE', () { |
| var code = 'var V = 4.2;'; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.LITERAL_DOUBLE, '4.2;', '4.2'.length); |
| }); |
| }); |
| |
| test('LITERAL_INTEGER', () { |
| var code = 'var V = 42;'; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.LITERAL_INTEGER, '42;'); |
| }); |
| }); |
| |
| test('LITERAL_STRING', () { |
| var code = 'var V = "abc";'; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.LITERAL_STRING, '"abc";', '"abc"'.length); |
| }); |
| }); |
| |
| test('LOCAL_VARIABLE', () { |
| var code = ''' |
| main() { |
| int vvv = 0; |
| vvv; |
| vvv = 1; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0'); |
| helper.assertHasRegion(HighlightType.LOCAL_VARIABLE, 'vvv;'); |
| helper.assertHasRegion(HighlightType.LOCAL_VARIABLE, 'vvv = 1;'); |
| }); |
| }); |
| |
| test('METHOD', () { |
| var code = ''' |
| class A { |
| aaa() {} |
| static bbb() {} |
| } |
| main(A a) { |
| a.aaa(); |
| a.aaa; |
| A.bbb(); |
| A.bbb; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.METHOD_DECLARATION, 'aaa() {}'); |
| helper.assertHasRegion(HighlightType.METHOD_DECLARATION_STATIC, 'bbb() {}'); |
| helper.assertHasRegion(HighlightType.METHOD, 'aaa();'); |
| helper.assertHasRegion(HighlightType.METHOD, 'aaa;'); |
| helper.assertHasRegion(HighlightType.METHOD_STATIC, 'bbb();'); |
| helper.assertHasRegion(HighlightType.METHOD_STATIC, 'bbb;'); |
| }); |
| }); |
| |
| test('METHOD best type', () { |
| var code = ''' |
| main(p) { |
| if (p is List) { |
| p.add(null); |
| } |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.METHOD, 'add(null)'); |
| }); |
| }); |
| |
| test('PARAMETER', () { |
| var code = ''' |
| main(int p) { |
| p; |
| p = 42; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.PARAMETER, 'p) {'); |
| helper.assertHasRegion(HighlightType.PARAMETER, 'p;'); |
| helper.assertHasRegion(HighlightType.PARAMETER, 'p = 42'); |
| }); |
| }); |
| |
| test('SETTER_DECLARATION', () { |
| var code = ''' |
| set aaa(x) {} |
| class A { |
| set bbb(x) {} |
| } |
| main(A a) { |
| aaa = 1; |
| a.bbb = 2; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.SETTER_DECLARATION, 'aaa(x)'); |
| helper.assertHasRegion(HighlightType.SETTER_DECLARATION, 'bbb(x)'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'aaa = 1'); |
| helper.assertHasRegion(HighlightType.FIELD, 'bbb = 2'); |
| }); |
| }); |
| |
| test('TOP_LEVEL_VARIABLE', () { |
| var code = ''' |
| var VVV = 0; |
| main() { |
| print(VVV); |
| VVV = 1; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.TOP_LEVEL_VARIABLE, 'VVV = 0'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'VVV);'); |
| helper.assertHasRegion(HighlightType.FIELD_STATIC, 'VVV = 1'); |
| }); |
| }); |
| |
| test('TYPE_NAME_DYNAMIC', () { |
| var code = ''' |
| dynamic main() { |
| dynamic = 42; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.TYPE_NAME_DYNAMIC, 'dynamic main()'); |
| helper.assertNoRegion(HighlightType.IDENTIFIER_DEFAULT, 'dynamic main()'); |
| helper.assertNoRegion(HighlightType.TYPE_NAME_DYNAMIC, 'dynamic = 42'); |
| }); |
| }); |
| |
| test('TYPE_PARAMETER', () { |
| var code = ''' |
| class A<T> { |
| T fff; |
| T mmm(T p) => null; |
| } |
| '''; |
| return testRegions(code, (NotificationHighlightHelper helper) { |
| helper.assertHasRegion(HighlightType.TYPE_PARAMETER, 'T> {'); |
| helper.assertHasRegion(HighlightType.TYPE_PARAMETER, 'T fff;'); |
| helper.assertHasRegion(HighlightType.TYPE_PARAMETER, 'T mmm('); |
| helper.assertHasRegion(HighlightType.TYPE_PARAMETER, 'T p)'); |
| }); |
| }); |
| } |
| |
| |
| |
| |
| class NotificationNavigationHelper extends AnalysisTestHelper { |
| List<Map<String, Object>> regions; |
| |
| Future prepareRegions(then()) { |
| addAnalysisSubscriptionNavigation(testFile); |
| return waitForOperationsFinished().then((_) { |
| regions = getTestNavigation(); |
| then(); |
| }); |
| } |
| |
| void assertHasRegion(String regionSearch, String targetSearch) { |
| var regionOffset = findOffset(regionSearch); |
| int regionLength = findIdentifierLength(regionSearch); |
| var targetOffset = findOffset(targetSearch); |
| var targetLength = findIdentifierLength(targetSearch); |
| asserHasRegionInts(regionOffset, regionLength, targetOffset, targetLength); |
| } |
| |
| void asserHasOperatorRegion(String search, int regionLength, int targetLength) { |
| var regionOffset = findOffset(search); |
| var region = asserHasRegionInts(regionOffset, regionLength, -1, 0); |
| if (targetLength != -1) { |
| expect(region['targets'][0]['length'], targetLength); |
| } |
| } |
| |
| asserHasRegionInts(int regionOffset, int regionLength, |
| int targetOffset, int targetLength) { |
| Map<String, Object> region = findRegion(regionOffset, regionLength); |
| if (region != null) { |
| List<Map<String, Object>> targets = region['targets']; |
| if (targetOffset == -1) { |
| return region; |
| } |
| var target = findTarget(targets, testFile, targetOffset, targetLength); |
| if (target != null) { |
| return target; |
| } |
| } |
| fail('Expected to find (offset=$regionOffset; length=$regionLength) => ' |
| '(offset=$targetOffset; length=$targetLength) in\n' |
| '${regions.join('\n')}'); |
| } |
| |
| Map<String, Object> findRegionString(String search, [bool notNull]) { |
| int offset = findOffset(search); |
| int length = search.length; |
| return findRegion(offset, length, notNull); |
| } |
| |
| Map<String, Object> findRegionAt(String search, [bool notNull]) { |
| int offset = findOffset(search); |
| for (Map<String, Object> region in regions) { |
| if (region['offset'] == offset) { |
| if (notNull == false) { |
| fail('Not expected to find at offset=$offset in\n' |
| '${regions.join('\n')}'); |
| } |
| return region; |
| } |
| } |
| if (notNull == true) { |
| fail('Expected to find at offset=$offset in\n' |
| '${regions.join('\n')}'); |
| } |
| return null; |
| } |
| |
| Map<String, Object> findRegionIdentifier(String search, [bool notNull]) { |
| int offset = findOffset(search); |
| int length = findIdentifierLength(search); |
| return findRegion(offset, length, notNull); |
| } |
| |
| Map<String, Object> findRegion(int offset, int length, [bool notNull]) { |
| for (Map<String, Object> region in regions) { |
| if (region['offset'] == offset && region['length'] == length) { |
| if (notNull == false) { |
| fail('Not expected to find (offset=$offset; length=$length) in\n' |
| '${regions.join('\n')}'); |
| } |
| return region; |
| } |
| } |
| if (notNull == true) { |
| fail('Expected to find (offset=$offset; length=$length) in\n' |
| '${regions.join('\n')}'); |
| } |
| return null; |
| } |
| |
| Map<String, Object> findTarget(List<Map<String, Object>> targets, |
| String file, int offset, int length) { |
| for (Map<String, Object> target in targets) { |
| if (target['file'] == file && |
| target['offset'] == offset && |
| target['length'] == length) { |
| return target; |
| } |
| } |
| return null; |
| } |
| |
| void assertNoRegion(String regionSearch) { |
| var regionOffset = findOffset(regionSearch); |
| var regionLength = findIdentifierLength(regionSearch); |
| for (Map<String, Object> region in regions) { |
| if (region['offset'] == regionOffset && region['length'] == regionLength) { |
| fail('Unexpected (offset=$regionOffset; length=$regionLength) in\n' |
| '${regions.join('\n')}'); |
| } |
| } |
| } |
| } |
| |
| |
| int findIdentifierLength(String search) { |
| int length = 0; |
| while (length < search.length) { |
| int c = search.codeUnitAt(length); |
| if (!(c >= 'a'.codeUnitAt(0) && c <= 'z'.codeUnitAt(0) || |
| c >= 'A'.codeUnitAt(0) && c <= 'Z'.codeUnitAt(0) || |
| c >= '0'.codeUnitAt(0) && c <= '9'.codeUnitAt(0))) { |
| break; |
| } |
| length++; |
| } |
| return length; |
| } |
| |
| |
| testNotificationNavigation() { |
| Future testNavigation(String code, then(NotificationNavigationHelper helper)) { |
| var helper = new NotificationNavigationHelper(); |
| helper.createSingleFileProject(code); |
| return helper.prepareRegions(() { |
| then(helper); |
| }); |
| } |
| |
| group('constructor', () { |
| test('named', () { |
| var code = ''' |
| class A { |
| A.named(int p) {} |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| // has region for complete "A.named" |
| helper.asserHasRegionInts( |
| helper.findOffset('A.named'), 'A.named'.length, |
| helper.findOffset('named(int'), 'named'.length); |
| // no separate regions for "A" and "named" |
| helper.assertNoRegion('A.named('); |
| helper.assertNoRegion('named('); |
| // validate that we don't forget to resolve parameters |
| helper.asserHasRegionInts( |
| helper.findOffset('int p'), 'int'.length, |
| -1, 0); |
| }); |
| }); |
| |
| test('unnamed', () { |
| var code = ''' |
| class A { |
| A(int p) {} |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| // has constructor region for "A()" |
| helper.asserHasRegionInts( |
| helper.findOffset('A(int p)'), 'A'.length, |
| helper.findOffset('A(int p)'), 0); |
| // validate that we don't forget to resolve parameters |
| helper.asserHasRegionInts( |
| helper.findOffset('int p'), 'int'.length, |
| -1, 0); |
| }); |
| }); |
| }); |
| |
| group('identifier', () { |
| test('resolved', () { |
| var code = ''' |
| class AAA {} |
| main() { |
| AAA aaa = null; |
| print(aaa); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.assertHasRegion('AAA aaa', 'AAA {}'); |
| helper.assertHasRegion('aaa);', 'aaa = null'); |
| helper.assertHasRegion('main() {', 'main() {'); |
| }); |
| }); |
| |
| test('unresolved', () { |
| var code = ''' |
| main() { |
| print(noo); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.assertNoRegion('noo);'); |
| }); |
| }); |
| }); |
| |
| test('fieldFormalParameter', () { |
| var code = ''' |
| class A { |
| int fff = 123; |
| A(this.fff); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.assertHasRegion('fff);', 'fff = 123'); |
| }); |
| }); |
| |
| group('instanceCreation', () { |
| test('implicit', () { |
| var code = ''' |
| class A { |
| } |
| main() { |
| new A(); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.asserHasRegionInts( |
| helper.findOffset('new A'), 'new A'.length, |
| helper.findOffset('A {'), 'A'.length); |
| }); |
| }); |
| |
| test('named', () { |
| var code = ''' |
| class A { |
| A.named() {} |
| } |
| main() { |
| new A.named(); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.asserHasRegionInts( |
| helper.findOffset('new A.named'), 'new A.named'.length, |
| helper.findOffset('named()'), 'named'.length); |
| }); |
| }); |
| |
| test('unnamed', () { |
| var code = ''' |
| class A { |
| A() {} |
| } |
| main() { |
| new A(); |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.asserHasRegionInts( |
| helper.findOffset('new A'), 'new A'.length, |
| helper.findOffset('A()'), ''.length); |
| }); |
| }); |
| }); |
| |
| group('operator', () { |
| test('int', () { |
| var code = ''' |
| main() { |
| var v = 0; |
| v - 1; |
| v + 2; |
| -v; // unary |
| --v; |
| ++v; |
| v--; // mm |
| v++; // pp |
| v -= 3; |
| v += 4; |
| v *= 5; |
| v /= 6; |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.asserHasOperatorRegion('- 1;', 1, 1); |
| helper.asserHasOperatorRegion('+ 2;', 1, 1); |
| helper.asserHasOperatorRegion('-v; // unary', 1, -1); |
| helper.asserHasOperatorRegion('--v;', 2, 1); |
| helper.asserHasOperatorRegion('++v;', 2, 1); |
| helper.asserHasOperatorRegion('--; // mm', 2, 1); |
| helper.asserHasOperatorRegion('++; // pp', 2, 1); |
| helper.asserHasOperatorRegion('-= 3;', 2, 1); |
| helper.asserHasOperatorRegion('+= 4;', 2, 1); |
| helper.asserHasOperatorRegion('*= 5;', 2, 1); |
| helper.asserHasOperatorRegion('/= 6;', 2, 1); |
| }); |
| }); |
| |
| test('list', () { |
| var code = ''' |
| main() { |
| List<int> v = [1, 2, 3]; |
| v[0]; // [] |
| v[1] = 1; // []= |
| v[2] += 2; |
| } |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.asserHasOperatorRegion(']; // []', 1, 2); |
| helper.asserHasOperatorRegion('] = 1', 1, 3); |
| helper.asserHasOperatorRegion('] += 2', 1, 3); |
| helper.asserHasOperatorRegion('+= 2', 2, 1); |
| }); |
| }); |
| }); |
| |
| test('partOf', () { |
| var helper = new NotificationNavigationHelper(); |
| var code = ''' |
| part of lib; |
| '''; |
| helper.createSingleFileProject(code); |
| var libPath = helper.setFileContent('/project/bin/lib.dart', ''' |
| library lib; |
| part 'test.dart'; |
| '''); |
| return helper.prepareRegions(() { |
| var region = helper.findRegionString('part of lib', true); |
| var target = region['targets'][0]; |
| expect(target['file'], libPath); |
| }); |
| }); |
| |
| group('string', () { |
| test('export', () { |
| var code = ''' |
| export "dart:math"; |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.findRegionString('export "dart:math"', true); |
| }); |
| }); |
| |
| test('export unresolved URI', () { |
| var code = ''' |
| export 'no.dart'; |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.findRegionAt('export ', false); |
| }); |
| }); |
| |
| test('import', () { |
| var code = ''' |
| import "dart:math" as m; |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.findRegionString('import "dart:math"', true); |
| }); |
| }); |
| |
| test('import no URI', () { |
| var code = ''' |
| import ; |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.findRegionAt('import ', false); |
| }); |
| }); |
| |
| test('import unresolved URI', () { |
| var code = ''' |
| import 'no.dart'; |
| '''; |
| return testNavigation(code, (NotificationNavigationHelper helper) { |
| helper.findRegionAt('import ', false); |
| }); |
| }); |
| |
| test('part', () { |
| var helper = new NotificationNavigationHelper(); |
| var code = ''' |
| library lib; |
| part "my_part.dart"; |
| '''; |
| helper.createSingleFileProject(code); |
| var unitPath = helper.setFileContent('/project/bin/my_part.dart', ''' |
| part of lib; |
| '''); |
| return helper.prepareRegions(() { |
| var region = helper.findRegionString('part "my_part.dart"', true); |
| var target = region['targets'][0]; |
| expect(target['file'], unitPath); |
| }); |
| }); |
| |
| test('part unresolved URI', () { |
| // TODO(scheglov) why do we throw MemoryResourceException here? |
| // This Source/File does not exist. |
| // var helper = new NotificationNavigationHelper(); |
| // var code = ''' |
| //library lib; |
| //part "my_part.dart"; |
| //'''; |
| // helper.createSingleFileProject(code); |
| // return helper.prepareRegions(() { |
| // helper.findRegionAt('part ', false); |
| // }); |
| }); |
| }); |
| } |
| |
| |
| testUpdateContent() { |
| test('full content', () { |
| AnalysisTestHelper helper = new AnalysisTestHelper(); |
| helper.createSingleFileProject('// empty'); |
| return helper.waitForOperationsFinished().then((_) { |
| // no errors initially |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, isEmpty); |
| // update code |
| { |
| Request request = new Request('0', METHOD_UPDATE_CONTENT); |
| request.setParameter('files', |
| { |
| helper.testFile : { |
| CONTENT : 'library lib' |
| } |
| }); |
| helper.handleSuccessfulRequest(request); |
| } |
| // wait, there is an error |
| return helper.waitForOperationsFinished().then((_) { |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, hasLength(1)); |
| }); |
| }); |
| }); |
| |
| test('incremental', () { |
| AnalysisTestHelper helper = new AnalysisTestHelper(); |
| helper.createSingleFileProject('library A;'); |
| return helper.waitForOperationsFinished().then((_) { |
| // no errors initially |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, isEmpty); |
| // update code |
| { |
| Request request = new Request('0', METHOD_UPDATE_CONTENT); |
| request.setParameter('files', |
| { |
| helper.testFile : { |
| CONTENT : 'library lib', |
| OFFSET : 'library '.length, |
| OLD_LENGTH : 'A;'.length, |
| NEW_LENGTH : 'lib'.length, |
| } |
| }); |
| helper.handleSuccessfulRequest(request); |
| } |
| // wait, there is an error |
| return helper.waitForOperationsFinished().then((_) { |
| List<AnalysisError> errors = helper.getTestErrors(); |
| expect(errors, hasLength(1)); |
| }); |
| }); |
| }); |
| } |
| |
| |
| void test_setSubscriptions() { |
| test('before analysis', () { |
| AnalysisTestHelper helper = new AnalysisTestHelper(); |
| // subscribe |
| helper.addAnalysisSubscriptionHighlights(helper.testFile); |
| // create project |
| helper.createSingleFileProject('int V = 42;'); |
| // wait, there are highlight regions |
| helper.waitForOperationsFinished().then((_) { |
| var highlights = helper.getHighlights(helper.testFile); |
| expect(highlights, isNot(isEmpty)); |
| }); |
| }); |
| |
| test('after analysis', () { |
| AnalysisTestHelper helper = new AnalysisTestHelper(); |
| // create project |
| helper.createSingleFileProject('int V = 42;'); |
| // wait, no regions initially |
| return helper.waitForOperationsFinished().then((_) { |
| var highlights = helper.getHighlights(helper.testFile); |
| expect(highlights, isEmpty); |
| // subscribe |
| helper.addAnalysisSubscriptionHighlights(helper.testFile); |
| // wait, has regions |
| return helper.waitForOperationsFinished().then((_) { |
| var highlights = helper.getHighlights(helper.testFile); |
| expect(highlights, isNot(isEmpty)); |
| }); |
| }); |
| }); |
| } |
