Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(15)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/analysis_server/test/analysis/notification_highlights_test2.dart

Issue 1478513002: Use async/await in all analysis domain tests. (Closed) Base URL: git@github.com:dart-lang/sdk.git@master
Patch Set: Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/analysis_server/test/analysis/notification_highlights_test.dart ('k') | pkg/analysis_server/test/analysis/notification_navigation_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/analysis_server/test/analysis/notification_highlights_test2.dart
diff --git a/pkg/analysis_server/test/analysis/notification_highlights_test2.dart b/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
index 28eda944faef360ccc84acae76c1bae9f923ec39..0342c8921b0eb3978568462de0fa1082f4edac76 100644
--- a/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
+++ b/pkg/analysis_server/test/analysis/notification_highlights_test2.dart
@@ -109,58 +109,54 @@ class AnalysisNotificationHighlightsTest extends AbstractAnalysisTest {
createProject();
}
- test_ANNOTATION_hasArguments() {
+ test_ANNOTATION_hasArguments() async {
addTestFile('''
class AAA {
const AAA(a, b, c);
}
@AAA(1, 2, 3) main() {}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length);
- assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length);
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length);
+ assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length);
}
- test_ANNOTATION_noArguments() {
+ test_ANNOTATION_noArguments() async {
addTestFile('''
const AAA = 42;
@AAA main() {}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA');
}
- test_BUILT_IN_abstract() {
+ test_BUILT_IN_abstract() async {
addTestFile('''
abstract class A {};
abstract class B = Object with A;
main() {
var abstract = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42');
}
- test_BUILT_IN_as() {
+ test_BUILT_IN_as() async {
addTestFile('''
import 'dart:math' as math;
main() {
p as int;
var as = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'as math');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'as int');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'as math');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'as int');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42');
}
- test_BUILT_IN_async() {
+ test_BUILT_IN_async() async {
addTestFile('''
fa() async {}
fb() async* {}
@@ -168,14 +164,13 @@ main() {
bool async = false;
}
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async');
- assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async');
+ assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false');
}
- test_BUILT_IN_await() {
+ test_BUILT_IN_await() async {
addTestFile('''
main() async {
await 42;
@@ -184,37 +179,34 @@ main() async {
}
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'await for');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'await for');
}
- test_BUILT_IN_deferred() {
+ test_BUILT_IN_deferred() async {
addTestFile('''
import 'dart:math' deferred as math;
main() {
var deferred = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42');
}
- test_BUILT_IN_export() {
+ test_BUILT_IN_export() async {
addTestFile('''
export "dart:math";
main() {
var export = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42');
}
- test_BUILT_IN_external() {
+ test_BUILT_IN_external() async {
addTestFile('''
class A {
external A();
@@ -223,15 +215,14 @@ class A {
external main() {
var external = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42');
}
- test_BUILT_IN_factory() {
+ test_BUILT_IN_factory() async {
addTestFile('''
class A {
factory A() => null;
@@ -239,13 +230,12 @@ class A {
main() {
var factory = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42');
}
- test_BUILT_IN_get() {
+ test_BUILT_IN_get() async {
addTestFile('''
get aaa => 1;
class A {
@@ -254,63 +244,58 @@ class A {
main() {
var get = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42');
}
- test_BUILT_IN_hide() {
+ test_BUILT_IN_hide() async {
addTestFile('''
import 'foo.dart' hide Foo;
main() {
var hide = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42');
}
- test_BUILT_IN_implements() {
+ test_BUILT_IN_implements() async {
addTestFile('''
class A {}
class B implements A {}
main() {
var implements = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42');
}
- test_BUILT_IN_import() {
+ test_BUILT_IN_import() async {
addTestFile('''
import "foo.dart";
main() {
var import = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'import "');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'import "');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42');
}
- test_BUILT_IN_library() {
+ test_BUILT_IN_library() async {
addTestFile('''
library lib;
main() {
var library = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42');
}
- test_BUILT_IN_native() {
+ test_BUILT_IN_native() async {
addTestFile('''
class A native "A_native" {}
class B {
@@ -319,14 +304,13 @@ class B {
main() {
var native = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42');
}
- test_BUILT_IN_on() {
+ test_BUILT_IN_on() async {
addTestFile('''
main() {
try {
@@ -334,13 +318,12 @@ main() {
}
var on = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'on int');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'on int');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42');
}
- test_BUILT_IN_operator() {
+ test_BUILT_IN_operator() async {
addTestFile('''
class A {
operator +(x) => null;
@@ -348,26 +331,24 @@ class A {
main() {
var operator = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +(');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +(');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42');
}
- test_BUILT_IN_part() {
+ test_BUILT_IN_part() async {
addTestFile('''
part "my_part.dart";
main() {
var part = 42;
}''');
addFile('/project/bin/my_part.dart', 'part of lib;');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42');
}
- test_BUILT_IN_partOf() {
+ test_BUILT_IN_partOf() async {
addTestFile('''
part of lib;
main() {
@@ -375,15 +356,13 @@ main() {
var of = 2;
}''');
_addLibraryForTestPart();
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.BUILT_IN, 'part of', 'part of'.length);
- assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'part of', 'part of'.length);
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2');
}
- test_BUILT_IN_set() {
+ test_BUILT_IN_set() async {
addTestFile('''
set aaa(x) {}
class A
@@ -392,26 +371,24 @@ class A
main() {
var set = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa(');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb(');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa(');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb(');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42');
}
- test_BUILT_IN_show() {
+ test_BUILT_IN_show() async {
addTestFile('''
import 'foo.dart' show Foo;
main() {
var show = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42');
}
- test_BUILT_IN_static() {
+ test_BUILT_IN_static() async {
addTestFile('''
class A {
static aaa;
@@ -420,14 +397,13 @@ class A {
main() {
var static = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;');
- assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;');
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42');
}
- test_BUILT_IN_sync() {
+ test_BUILT_IN_sync() async {
addTestFile('''
fa() sync {}
fb() sync* {}
@@ -435,81 +411,74 @@ main() {
bool sync = false;
}
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync');
- assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync');
+ assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false');
}
- test_BUILT_IN_typedef() {
+ test_BUILT_IN_typedef() async {
addTestFile('''
typedef A();
main() {
var typedef = 42;
}''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();');
- assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();');
+ assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42');
}
- test_BUILT_IN_yield() {
+ test_BUILT_IN_yield() async {
addTestFile('''
main() async* {
yield 42;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42');
}
- test_BUILT_IN_yieldStar() {
+ test_BUILT_IN_yieldStar() async {
addTestFile('''
main() async* {
yield* [];
}
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*');
}
- test_CLASS() {
+ test_CLASS() async {
addTestFile('''
class AAA {}
AAA aaa;
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.CLASS, 'AAA {}');
- assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.CLASS, 'AAA {}');
+ assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa');
}
- test_CLASS_notDynamic() {
+ test_CLASS_notDynamic() async {
addTestFile('''
dynamic f() {}
''');
- return prepareHighlights().then((_) {
- assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()');
- });
+ await prepareHighlights();
+ assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()');
}
- test_CLASS_notVoid() {
+ test_CLASS_notVoid() async {
addTestFile('''
void f() {}
''');
- return prepareHighlights().then((_) {
- assertNoRegion(HighlightRegionType.CLASS, 'void f()');
- });
+ await prepareHighlights();
+ assertNoRegion(HighlightRegionType.CLASS, 'void f()');
}
- test_COMMENT() {
+ test_COMMENT() async {
addTestFile('''
/**
* documentation comment
- */
+ */
void main() {
// end-of-line comment
my_function(1);
@@ -519,14 +488,13 @@ void my_function(String a) {
/* block comment */
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32);
- assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22);
- assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19);
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32);
+ assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22);
+ assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19);
}
- test_CONSTRUCTOR() {
+ test_CONSTRUCTOR() async {
addTestFile('''
class AAA {
AAA() {}
@@ -537,42 +505,37 @@ main() {
new AAA.name(42);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)');
- assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)');
- assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}');
- assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)');
+ assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)');
+ assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}');
+ assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();');
}
- test_DIRECTIVE() {
+ test_DIRECTIVE() async {
addTestFile('''
library lib;
import 'dart:math';
export 'dart:math';
part 'part.dart';
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;");
- assertHasStringRegion(
- HighlightRegionType.DIRECTIVE, "import 'dart:math';");
- assertHasStringRegion(
- HighlightRegionType.DIRECTIVE, "export 'dart:math';");
- assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';");
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;");
+ assertHasStringRegion(HighlightRegionType.DIRECTIVE, "import 'dart:math';");
+ assertHasStringRegion(HighlightRegionType.DIRECTIVE, "export 'dart:math';");
+ assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';");
}
- test_DIRECTIVE_partOf() {
+ test_DIRECTIVE_partOf() async {
addTestFile('''
part of lib;
''');
_addLibraryForTestPart();
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;");
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;");
}
- test_DYNAMIC_LOCAL_VARIABLE() {
+ test_DYNAMIC_LOCAL_VARIABLE() async {
addTestFile('''
f() {}
main(p) {
@@ -580,27 +543,24 @@ main(p) {
v;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION, 'v = f()');
- assertHasRegion(
- HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE, 'v;');
- });
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION, 'v = f()');
+ assertHasRegion(HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE, 'v;');
}
- test_DYNAMIC_PARAMETER() {
+ test_DYNAMIC_PARAMETER() async {
addTestFile('''
main(p) {
print(p);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION, 'p)');
- assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE, 'p);');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION, 'p)');
+ assertHasRegion(HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE, 'p);');
}
- test_DYNAMIC_VARIABLE_field() {
+ test_DYNAMIC_VARIABLE_field() async {
addTestFile('''
class A {
var f;
@@ -609,24 +569,22 @@ class A {
}
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
- assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'f = 1');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
+ assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'f = 1');
}
- test_ENUM() {
+ test_ENUM() async {
addTestFile('''
enum MyEnum {A, B, C}
MyEnum value;
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {');
- assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {');
+ assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;');
}
- test_ENUM_CONSTANT() {
+ test_ENUM_CONSTANT() async {
addTestFile('''
enum MyEnum {AAA, BBB}
main() {
@@ -634,27 +592,25 @@ main() {
print(MyEnum.BBB);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, ');
- assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}');
- assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);');
- assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, ');
+ assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}');
+ assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);');
+ assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);');
}
- test_FUNCTION_TYPE_ALIAS() {
+ test_FUNCTION_TYPE_ALIAS() async {
addTestFile('''
typedef FFF(p);
main(FFF fff) {
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)');
- assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)');
+ assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)');
}
- test_GETTER() {
+ test_GETTER() async {
addTestFile('''
get aaa => null;
class A {
@@ -667,20 +623,19 @@ main(A a) {
A.ccc;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION, 'aaa => null');
- assertHasRegion(
- HighlightRegionType.INSTANCE_GETTER_DECLARATION, 'bbb => null');
- assertHasRegion(
- HighlightRegionType.STATIC_GETTER_DECLARATION, 'ccc => null');
- assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'aaa;');
- assertHasRegion(HighlightRegionType.INSTANCE_GETTER_REFERENCE, 'bbb;');
- assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'ccc;');
- });
- }
-
- test_IDENTIFIER_DEFAULT() {
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION, 'aaa => null');
+ assertHasRegion(
+ HighlightRegionType.INSTANCE_GETTER_DECLARATION, 'bbb => null');
+ assertHasRegion(
+ HighlightRegionType.STATIC_GETTER_DECLARATION, 'ccc => null');
+ assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'aaa;');
+ assertHasRegion(HighlightRegionType.INSTANCE_GETTER_REFERENCE, 'bbb;');
+ assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'ccc;');
+ }
+
+ test_IDENTIFIER_DEFAULT() async {
addTestFile('''
main() {
aaa = 42;
@@ -688,27 +643,25 @@ main() {
CCC ccc;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42');
- assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)');
- assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42');
+ assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)');
+ assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc');
}
- test_IMPORT_PREFIX() {
+ test_IMPORT_PREFIX() async {
addTestFile('''
import 'dart:math' as ma;
main() {
ma.max(1, 2);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;');
- assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;');
+ assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max');
}
- test_INSTANCE_FIELD() {
+ test_INSTANCE_FIELD() async {
addTestFile('''
class A {
int aaa = 1;
@@ -720,31 +673,27 @@ main(A a) {
a.bbb = 5;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'aaa = 1');
- assertHasRegion(
- HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'bbb = 2');
- assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'bbb = 3');
- assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'aaa = 4');
- assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 5');
- });
- }
-
- test_INSTANCE_FIELD_dynamic() {
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'aaa = 1');
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'bbb = 2');
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'bbb = 3');
+ assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'aaa = 4');
+ assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 5');
+ }
+
+ test_INSTANCE_FIELD_dynamic() async {
addTestFile('''
class A {
var f;
A(this.f);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
- assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'f);');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_DECLARATION, 'f;');
+ assertHasRegion(HighlightRegionType.INSTANCE_FIELD_REFERENCE, 'f);');
}
- test_KEYWORD() {
+ test_KEYWORD() async {
addTestFile('''
main() {
assert(true);
@@ -777,49 +726,47 @@ class B extends A {
}
class C = Object with A;
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)');
- assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)');
- assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in');
- assertHasRegion(HighlightRegionType.KEYWORD, 'break;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:');
- assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}');
- assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}');
- assertHasRegion(HighlightRegionType.KEYWORD, 'const v1');
- assertHasRegion(HighlightRegionType.KEYWORD, 'continue;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'default:');
- assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while');
- assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)');
- assertHasRegion(HighlightRegionType.KEYWORD, 'false;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 =');
- assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}');
- assertHasRegion(HighlightRegionType.KEYWORD, 'in []');
- assertHasRegion(HighlightRegionType.KEYWORD, 'is int');
- assertHasRegion(HighlightRegionType.KEYWORD, 'new A();');
- assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'return this');
- assertHasRegion(HighlightRegionType.KEYWORD, 'super();');
- assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)');
- assertHasRegion(HighlightRegionType.KEYWORD, 'this;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'true;');
- assertHasRegion(HighlightRegionType.KEYWORD, 'try {');
- assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}');
- assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);');
- assertHasRegion(HighlightRegionType.KEYWORD, 'with A;');
- });
- }
-
- test_KEYWORD_void() {
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'break;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'const v1');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'continue;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'default:');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'false;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 =');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'in []');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'is int');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'new A();');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'return this');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'super();');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'this;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'true;');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'try {');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);');
+ assertHasRegion(HighlightRegionType.KEYWORD, 'with A;');
+ }
+
+ test_KEYWORD_void() async {
addTestFile('''
void main() {
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.KEYWORD, 'void main()');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.KEYWORD, 'void main()');
}
- test_LABEL() {
+ test_LABEL() async {
addTestFile('''
main() {
myLabel:
@@ -828,76 +775,67 @@ myLabel:
}
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.LABEL, 'myLabel:');
- assertHasRegion(HighlightRegionType.LABEL, 'myLabel;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LABEL, 'myLabel:');
+ assertHasRegion(HighlightRegionType.LABEL, 'myLabel;');
}
- test_LIBRARY_NAME_libraryDirective() {
+ test_LIBRARY_NAME_libraryDirective() async {
addTestFile('''
library my.lib.name;
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
}
- test_LIBRARY_NAME_partOfDirective() {
+ test_LIBRARY_NAME_partOfDirective() async {
_addLibraryForTestPart();
addTestFile('''
part of my.lib.name;
''');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.LIBRARY_NAME, 'my.lib.name');
}
- test_LITERAL_BOOLEAN() {
+ test_LITERAL_BOOLEAN() async {
addTestFile('var V = true;');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;');
}
- test_LITERAL_DOUBLE() {
+ test_LITERAL_DOUBLE() async {
addTestFile('var V = 4.2;');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length);
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length);
}
- test_LITERAL_INTEGER() {
+ test_LITERAL_INTEGER() async {
addTestFile('var V = 42;');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;');
}
- test_LITERAL_LIST() {
+ test_LITERAL_LIST() async {
addTestFile('var V = <int>[1, 2, 3];');
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]');
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]');
}
- test_LITERAL_MAP() {
+ test_LITERAL_MAP() async {
addTestFile("var V = const <int, String>{1: 'a', 2: 'b', 3: 'c'};");
- return prepareHighlights().then((_) {
- assertHasStringRegion(HighlightRegionType.LITERAL_MAP,
- "const <int, String>{1: 'a', 2: 'b', 3: 'c'}");
- });
+ await prepareHighlights();
+ assertHasStringRegion(HighlightRegionType.LITERAL_MAP,
+ "const <int, String>{1: 'a', 2: 'b', 3: 'c'}");
}
- test_LITERAL_STRING() {
+ test_LITERAL_STRING() async {
addTestFile('var V = "abc";');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length);
- });
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length);
}
- test_LOCAL_FUNCTION() {
+ test_LOCAL_FUNCTION() async {
addTestFile('''
main() {
fff() {}
@@ -905,15 +843,13 @@ main() {
fff;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.LOCAL_FUNCTION_DECLARATION, 'fff() {}');
- assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff();');
- assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_DECLARATION, 'fff() {}');
+ assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff();');
+ assertHasRegion(HighlightRegionType.LOCAL_FUNCTION_REFERENCE, 'fff;');
}
- test_LOCAL_VARIABLE() {
+ test_LOCAL_VARIABLE() async {
addTestFile('''
main() {
int vvv = 0;
@@ -921,15 +857,13 @@ main() {
vvv = 1;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0');
- assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv;');
- assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv = 1;');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0');
+ assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv;');
+ assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_REFERENCE, 'vvv = 1;');
}
- test_METHOD() {
+ test_METHOD() async {
addTestFile('''
class A {
aaa() {}
@@ -942,19 +876,17 @@ main(A a) {
A.bbb;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.INSTANCE_METHOD_DECLARATION, 'aaa() {}');
- assertHasRegion(
- HighlightRegionType.STATIC_METHOD_DECLARATION, 'bbb() {}');
- assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa();');
- assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa;');
- assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb();');
- assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb;');
- });
- }
-
- test_METHOD_bestType() {
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.INSTANCE_METHOD_DECLARATION, 'aaa() {}');
+ assertHasRegion(HighlightRegionType.STATIC_METHOD_DECLARATION, 'bbb() {}');
+ assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa();');
+ assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'aaa;');
+ assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb();');
+ assertHasRegion(HighlightRegionType.STATIC_METHOD_REFERENCE, 'bbb;');
+ }
+
+ test_METHOD_bestType() async {
addTestFile('''
main(p) {
if (p is List) {
@@ -962,27 +894,24 @@ main(p) {
}
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'add(null)');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.INSTANCE_METHOD_REFERENCE, 'add(null)');
}
- test_PARAMETER() {
+ test_PARAMETER() async {
addTestFile('''
main(int p) {
p;
p = 42;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.PARAMETER_DECLARATION, 'p) {');
- assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p;');
- assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.PARAMETER_DECLARATION, 'p) {');
+ assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p;');
+ assertHasRegion(HighlightRegionType.PARAMETER_REFERENCE, 'p = 42');
}
- test_SETTER_DECLARATION() {
+ test_SETTER_DECLARATION() async {
addTestFile('''
set aaa(x) {}
class A {
@@ -995,20 +924,16 @@ main(A a) {
A.ccc = 3;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION, 'aaa(x)');
- assertHasRegion(
- HighlightRegionType.INSTANCE_SETTER_DECLARATION, 'bbb(x)');
- assertHasRegion(HighlightRegionType.STATIC_SETTER_DECLARATION, 'ccc(x)');
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'aaa = 1');
- assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 2');
- assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
- });
- }
-
- test_STATIC_FIELD() {
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION, 'aaa(x)');
+ assertHasRegion(HighlightRegionType.INSTANCE_SETTER_DECLARATION, 'bbb(x)');
+ assertHasRegion(HighlightRegionType.STATIC_SETTER_DECLARATION, 'ccc(x)');
+ assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'aaa = 1');
+ assertHasRegion(HighlightRegionType.INSTANCE_SETTER_REFERENCE, 'bbb = 2');
+ assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
+ }
+
+ test_STATIC_FIELD() async {
addTestFile('''
class A {
static aaa = 1;
@@ -1021,30 +946,28 @@ main() {
A.ccc = 3;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.STATIC_FIELD_DECLARATION, 'aaa = 1');
- assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'aaa = 2');
- assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'bbb;');
- assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.STATIC_FIELD_DECLARATION, 'aaa = 1');
+ assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'aaa = 2');
+ assertHasRegion(HighlightRegionType.STATIC_GETTER_REFERENCE, 'bbb;');
+ assertHasRegion(HighlightRegionType.STATIC_SETTER_REFERENCE, 'ccc = 3');
}
- test_TOP_LEVEL_FUNCTION() {
+ test_TOP_LEVEL_FUNCTION() async {
addTestFile('''
fff(p) {}
main() {
fff(42);
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION, 'fff(p) {}');
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE, 'fff(42)');
- });
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION, 'fff(p) {}');
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE, 'fff(42)');
}
- test_TOP_LEVEL_VARIABLE() {
+ test_TOP_LEVEL_VARIABLE() async {
addTestFile('''
const V1 = 1;
var V2 = 2;
@@ -1054,47 +977,44 @@ main() {
V2 = 3;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V1 = 1');
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V2 = 2');
- assertHasRegion(
- HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1 // annotation');
- assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1);');
- assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'V2 = 3');
- });
- }
-
- test_TYPE_NAME_DYNAMIC() {
+ await prepareHighlights();
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V1 = 1');
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION, 'V2 = 2');
+ assertHasRegion(
+ HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1 // annotation');
+ assertHasRegion(HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE, 'V1);');
+ assertHasRegion(HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE, 'V2 = 3');
+ }
+
+ test_TYPE_NAME_DYNAMIC() async {
addTestFile('''
dynamic main() {
dynamic = 42;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()');
- assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()');
- assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()');
+ assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()');
+ assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42');
}
- test_TYPE_PARAMETER() {
+ test_TYPE_PARAMETER() async {
addTestFile('''
class A<T> {
T fff;
T mmm(T p) => null;
}
''');
- return prepareHighlights().then((_) {
- assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {');
- assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;');
- assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm(');
- assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)');
- });
+ await prepareHighlights();
+ assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {');
+ assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;');
+ assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm(');
+ assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)');
}
- test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_dynamicVarTarget() {
+ test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_dynamicVarTarget() async {
addTestFile('''
main(p) {
p.aaa;
@@ -1106,20 +1026,19 @@ main(p) {
''.length.ccc().ddd();
}
''');
- return prepareHighlights().then((_) {
- HighlightRegionType type =
- HighlightRegionType.UNRESOLVED_INSTANCE_MEMBER_REFERENCE;
- assertHasRegion(type, 'aaa');
- assertHasRegion(type, 'aaa++');
- assertHasRegion(type, 'aaa += 0');
- assertHasRegion(type, 'aaa; // ++');
- assertHasRegion(type, 'aaa =');
- assertHasRegion(type, 'bbb(');
- assertHasRegion(type, 'ddd()');
- });
- }
-
- test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_nonDynamicTarget() {
+ await prepareHighlights();
+ HighlightRegionType type =
+ HighlightRegionType.UNRESOLVED_INSTANCE_MEMBER_REFERENCE;
+ assertHasRegion(type, 'aaa');
+ assertHasRegion(type, 'aaa++');
+ assertHasRegion(type, 'aaa += 0');
+ assertHasRegion(type, 'aaa; // ++');
+ assertHasRegion(type, 'aaa =');
+ assertHasRegion(type, 'bbb(');
+ assertHasRegion(type, 'ddd()');
+ }
+
+ test_UNRESOLVED_INSTANCE_MEMBER_REFERENCE_nonDynamicTarget() async {
addTestFile('''
import 'dart:math' as math;
main(String str) {
@@ -1135,15 +1054,14 @@ class A {
}
}
''');
- return prepareHighlights().then((_) {
- HighlightRegionType type = HighlightRegionType.IDENTIFIER_DEFAULT;
- assertHasRegion(type, 'aaa()');
- assertHasRegion(type, 'bbb()');
- assertHasRegion(type, 'ccc()');
- assertHasRegion(type, 'unresolved(1)');
- assertHasRegion(type, 'unresolved(2)');
- assertHasRegion(type, 'unresolved(3)');
- });
+ await prepareHighlights();
+ HighlightRegionType type = HighlightRegionType.IDENTIFIER_DEFAULT;
+ assertHasRegion(type, 'aaa()');
+ assertHasRegion(type, 'bbb()');
+ assertHasRegion(type, 'ccc()');
+ assertHasRegion(type, 'unresolved(1)');
+ assertHasRegion(type, 'unresolved(2)');
+ assertHasRegion(type, 'unresolved(3)');
}
void _addLibraryForTestPart() {
« no previous file with comments | « pkg/analysis_server/test/analysis/notification_highlights_test.dart ('k') | pkg/analysis_server/test/analysis/notification_navigation_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698