[analysis_server] Migrate remaining FoldingRegion tests to use TestCode.parse() + split large annotations test up Change-Id: I5071f4310ea3bf784e40ae1bcd1f9e497551e912 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/260540 Reviewed-by: Brian Wilkerson <brianwilkerson@google.com> Commit-Queue: Brian Wilkerson <brianwilkerson@google.com>
diff --git a/pkg/analysis_server/test/src/computer/folding_computer_test.dart b/pkg/analysis_server/test/src/computer/folding_computer_test.dart index 5ceb1fe..a2b993d 100644 --- a/pkg/analysis_server/test/src/computer/folding_computer_test.dart +++ b/pkg/analysis_server/test/src/computer/folding_computer_test.dart
@@ -29,15 +29,30 @@ late TestCode code; List<FoldingRegion> regions = []; + /// Expects no [FoldingRegion]s. + /// + /// If [onlyVerify] is provided, folding regions of other kinds are allowed. + void expectNoRegions({Set<FoldingKind>? onlyVerify}) { + expectRegions({}, onlyVerify: onlyVerify); + } + /// Expects to find a [FoldingRegion] for the code marked [index] with a /// [FoldingKind] of [kind]. - void expectRegions(Map<int, FoldingKind> expected) { + /// + /// If [onlyVerify] is provided, only folding regions with matching kinds will + /// be verified. + void expectRegions(Map<int, FoldingKind> expected, + {Set<FoldingKind>? onlyVerify}) { final expectedRegions = expected.entries.map((entry) { final range = code.ranges[entry.key].sourceRange; return FoldingRegion(entry.value, range.offset, range.length); }).toSet(); - expect(regions, expectedRegions); + final actualRegions = onlyVerify == null + ? regions.toSet() + : regions.where((region) => onlyVerify.contains(region.kind)).toSet(); + + expect(actualRegions, expectedRegions); } @override @@ -46,213 +61,310 @@ sourcePath = convertPath('$testPackageLibPath/test.dart'); } - Future<void> test_annotations() async { + Future<void> test_annotations_class() async { var content = ''' -@myMultilineAnnotation/*[0*/( - "this", - "is a test" -)/*0]*/ -void f() {} - -@noFoldNecessary -main2() {} - -@multipleAnnotations1/*[1*/( - "this", - "is a test" -) -@multipleAnnotations2() -@multipleAnnotations3/*1]*/ -main3() {} - -@noFoldsForSingleClassAnnotation +@folded.classAnnotation1/*[0*/() +@foldedClassAnnotation2/*0]*/ class MyClass {} +'''; -@folded.classAnnotation1/*[2*/() -@foldedClassAnnotation2/*2]*/ -class MyClass2 {/*[3*/ - @fieldAnnotation1/*[4*/ - @fieldAnnotation2/*4]*/ - int myField; + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + }); + } - @getterAnnotation1/*[5*/ - @getterAnnotation2/*5]*/ - int get myThing => 1; + Future<void> test_annotations_class_constructor() async { + var content = ''' +class MyClass { + @constructorAnnotation1/*[0*/ + @constructorAnnotation1/*0]*/ + MyClass() {} - @setterAnnotation1/*[6*/ - @setterAnnotation2/*6]*/ - void set myThing(int value) {} - - @methodAnnotation1/*[7*/ - @methodAnnotation2/*7]*/ - void myMethod() {} - - @constructorAnnotation1/*[8*/ - @constructorAnnotation1/*8]*/ - MyClass2() {} -/*3]*/} + @constructorAnnotation1/*[1*/ + @constructorAnnotation1/*1]*/ + MyClass.named() {} +} '''; await _computeRegions(content); expectRegions({ 0: FoldingKind.ANNOTATIONS, 1: FoldingKind.ANNOTATIONS, - 2: FoldingKind.ANNOTATIONS, - 3: FoldingKind.CLASS_BODY, - 4: FoldingKind.ANNOTATIONS, - 5: FoldingKind.ANNOTATIONS, - 6: FoldingKind.ANNOTATIONS, - 7: FoldingKind.ANNOTATIONS, - 8: FoldingKind.ANNOTATIONS, + }, onlyVerify: { + FoldingKind.ANNOTATIONS }); } + Future<void> test_annotations_class_field() async { + var content = ''' +class MyClass { + @fieldAnnotation1/*[0*/ + @fieldAnnotation2/*0]*/ + int myField; +} +'''; + + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + }, onlyVerify: { + FoldingKind.ANNOTATIONS + }); + } + + Future<void> test_annotations_class_getterSetter() async { + var content = ''' +class MyClass { + @getterAnnotation1/*[0*/ + @getterAnnotation2/*0]*/ + int get myThing => 1; + + @setterAnnotation1/*[1*/ + @setterAnnotation2/*1]*/ + void set myThing(int value) {} +} +'''; + + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + 1: FoldingKind.ANNOTATIONS, + }, onlyVerify: { + FoldingKind.ANNOTATIONS + }); + } + + Future<void> test_annotations_class_method() async { + var content = ''' +class MyClass { + @methodAnnotation1/*[0*/ + @methodAnnotation2/*0]*/ + void myMethod() {} +} +'''; + + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + }, onlyVerify: { + FoldingKind.ANNOTATIONS + }); + } + + Future<void> test_annotations_multiline() async { + var content = ''' +@myMultilineAnnotation/*[0*/( + "this", + "is a test" +)/*0]*/ +void f() {} +'''; + + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + }); + } + + Future<void> test_annotations_multiple() async { + var content = ''' +@multipleAnnotations1/*[0*/( + "this", + "is a test" +) +@multipleAnnotations2() +@multipleAnnotations3/*0]*/ +main3() {} +'''; + + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.ANNOTATIONS, + }); + } + + Future<void> test_annotations_singleLine() async { + var content = ''' +@noFoldNecessary +main2() {} + +@noFoldsForSingleClassAnnotation +class MyClass {} +'''; + + await _computeRegions(content); + expectNoRegions(); + } + Future<void> test_assertInitializer() async { var content = ''' -class C {/*1:INC*/ - C() : assert(/*2:INC*/ +class C {/*[0*/ + C() : assert(/*[1*/ true, '' - /*2:INC:INVOCATION*/); -/*1:INC:CLASS_BODY*/} + /*1]*/); +/*0]*/} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.CLASS_BODY, + 1: FoldingKind.INVOCATION, + }); } Future<void> test_assertStatement() async { var content = ''' -void f() {/*1:INC*/ - assert(/*2:INC*/ +void f() {/*[0*/ + assert(/*[1*/ true, '' - /*2:INC:INVOCATION*/); -/*1:INC:FUNCTION_BODY*/} + /*1]*/); +/*0]*/} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.INVOCATION, + }); } Future<void> test_class() async { var content = ''' // Content before -class Person {/*1:INC*/ - Person() {/*2:INC*/ +class Person {/*[0*/ + Person() {/*[1*/ print("Hello, world!"); - /*2:INC:FUNCTION_BODY*/} + /*1]*/} - void sayHello() {/*3:INC*/ + void sayHello() {/*[2*/ print("Hello, world!"); - /*3:INC:FUNCTION_BODY*/} -/*1:INC:CLASS_BODY*/} + /*2]*/} +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.CLASS_BODY, + 1: FoldingKind.FUNCTION_BODY, + 2: FoldingKind.FUNCTION_BODY, + }); } Future<void> test_comment_is_not_considered_file_header() async { var content = """ -// This is not the file header/*1:EXC*/ -// It's just a comment/*1:INC:COMMENT*/ +// This is not the file header/*[0*/ +// It's just a comment/*0]*/ void f() {} """; - // Since there are no region comment markers above - // just check the length instead of the contents - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.COMMENT, + }); } Future<void> test_comment_multiline() async { var content = ''' -void f() { -/*/*1:EXC*/ +/*/*[0*/ * comment 1 - *//*1:EXC:COMMENT*/ + *//*0]*/ -/* this comment starts on the same line as delimeters/*2:EXC*/ +/* this comment starts on the same line as delimeters/*[1*/ * second line - *//*2:EXC:COMMENT*/ -} + *//*1]*/ +void f() {} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content, commentKinds); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.COMMENT, + 1: FoldingKind.COMMENT, + }); } Future<void> test_comment_singleFollowedByBlankLine() async { var content = ''' void f() { -// this is/*1:EXC*/ -// a comment/*1:INC:COMMENT*/ +// this is/*[0*/ +// a comment/*0]*/ /// this is not part of it } '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content, commentKinds); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.COMMENT, + }, onlyVerify: commentKinds); } Future<void> test_comment_singleFollowedByMulti() async { var content = ''' void f() { - // this is/*1:EXC*/ - // a comment/*1:INC:COMMENT*/ + // this is/*[0*/ + // a comment/*0]*/ /* this is not part of it */ String foo; } '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content, commentKinds); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.COMMENT, + }, onlyVerify: commentKinds); } Future<void> test_comment_singleFollowedByTripleSlash() async { var content = ''' void f() { -// this is/*1:EXC*/ -// a comment/*1:INC:COMMENT*/ +// this is/*[0*/ +// a comment/*0]*/ /// this is not part of it } '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content, commentKinds); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.COMMENT, + }, onlyVerify: commentKinds); } Future<void> test_constructor_invocations() async { var content = ''' // Content before -void f() {/*1:INC*/ - return new Text(/*2:INC*/ - "Hello, world!", - /*2:INC:INVOCATION*/); -/*1:INC:FUNCTION_BODY*/} +final a = new Text(/*[0*/ + "Hello, world!", +/*0]*/); // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.INVOCATION, + }); } Future<void> test_file_header() async { var content = """ -// Copyright some year by some people/*1:EXC*/ -// See LICENCE etc./*1:INC:FILE_HEADER*/ +// Copyright some year by some people/*[0*/ +// See LICENCE etc./*0]*/ // This is not the file header // It's just a comment void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content, {FoldingKind.FILE_HEADER}); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FILE_HEADER, + }, onlyVerify: { + FoldingKind.FILE_HEADER + }); } Future<void> test_file_header_does_not_include_block_comments() async { @@ -266,306 +378,358 @@ void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content, {FoldingKind.FILE_HEADER}); + await _computeRegions(content); + expectNoRegions(onlyVerify: {FoldingKind.FILE_HEADER}); } Future<void> test_file_header_with_no_function_comment() async { var content = ''' -// Copyright some year by some people/*1:EXC*/ -// See LICENCE etc./*1:INC:FILE_HEADER*/ +// Copyright some year by some people/*[0*/ +// See LICENCE etc./*0]*/ void f() {} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content, {FoldingKind.FILE_HEADER}); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FILE_HEADER, + }); } Future<void> test_file_header_with_non_end_of_line_comment() async { var content = """ -// Copyright some year by some people/*1:EXC*/ -// See LICENCE etc./*1:INC:FILE_HEADER*/ +// Copyright some year by some people/*[0*/ +// See LICENCE etc./*0]*/ /* This shouldn't be part of the file header */ void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content, {FoldingKind.FILE_HEADER}); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FILE_HEADER, + }); } Future<void> test_file_header_with_script_prefix() async { var content = """ #! /usr/bin/dart -// Copyright some year by some people/*1:EXC*/ -// See LICENCE etc./*1:INC:FILE_HEADER*/ +// Copyright some year by some people/*[0*/ +// See LICENCE etc./*0]*/ // This is not the file header // It's just a comment void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content, {FoldingKind.FILE_HEADER}); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FILE_HEADER, + }, onlyVerify: { + FoldingKind.FILE_HEADER + }); } Future<void> test_fileHeader_singleFollowedByBlank() async { var content = ''' -// this is/*1:EXC*/ -// a file header/*1:INC:FILE_HEADER*/ +// this is/*[0*/ +// a file header/*0]*/ // this is not part of it void f() {} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FILE_HEADER, + }); } Future<void> test_function() async { var content = ''' // Content before -void f() {/*1:INC*/ +void f() {/*[0*/ print("Hello, world!"); -/*1:INC:FUNCTION_BODY*/} +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + }); } Future<void> test_function_expression_invocation() async { var content = ''' // Content before -getFunc() => (String a, String b) {/*1:INC*/ +getFunc() => (String a, String b) {/*[0*/ print(a); -/*1:INC:FUNCTION_BODY*/}; +/*0]*/}; -main2() {/*2:INC*/ - getFunc()(/*3:INC*/ +main2() {/*[1*/ + getFunc()(/*[2*/ "one", "two" - /*3:INC:INVOCATION*/); -/*2:INC:FUNCTION_BODY*/} + /*2]*/); +/*1]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.FUNCTION_BODY, + 2: FoldingKind.INVOCATION, + }); } Future<void> test_function_with_dart_doc() async { var content = ''' // Content before -/// This is a doc comment/*1:EXC*/ -/// that spans lines/*1:INC:DOCUMENTATION_COMMENT*/ -void f() {/*2:INC*/ +/// This is a doc comment/*[0*/ +/// that spans lines/*0]*/ +void f() {/*[1*/ print("Hello, world!"); -/*2:INC:FUNCTION_BODY*/} +/*1]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.DOCUMENTATION_COMMENT, + 1: FoldingKind.FUNCTION_BODY, + }); } Future<void> test_invocations() async { var content = ''' // Content before -void f() {/*1:INC*/ - print(/*2:INC*/ +void f() {/*[0*/ + print(/*[1*/ "Hello, world!", - /*2:INC:INVOCATION*/); -/*1:INC:FUNCTION_BODY*/} + /*1]*/); +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.INVOCATION, + }); } Future<void> test_literal_list() async { var content = ''' // Content before -void f() {/*1:INC*/ - final List<String> things = <String>[/*2:INC*/ +void f() {/*[0*/ + final List<String> things = <String>[/*[1*/ "one", "two" - /*2:INC:LITERAL*/]; -/*1:INC:FUNCTION_BODY*/} + /*1]*/]; +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.LITERAL, + }); } Future<void> test_literal_map() async { var content = ''' // Content before -main2() {/*1:INC*/ - final Map<String, String> things = <String, String>{/*2:INC*/ +main2() {/*[0*/ + final Map<String, String> things = <String, String>{/*[1*/ "one": "one", "two": "two" - /*2:INC:LITERAL*/}; -/*1:INC:FUNCTION_BODY*/} + /*1]*/}; +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.LITERAL, + }); } Future<void> test_literal_record() async { var content = ''' // Content before -void f() {/*1:INC*/ - final r = (/*2:INC*/ +void f() {/*[0*/ + final r = (/*[1*/ "one", 2, - (/*3:INC*/ + (/*[2*/ 'nested', 3, 'field record', - /*3:INC:LITERAL*/), - /*2:INC:LITERAL*/); -/*1:INC:FUNCTION_BODY*/} + /*2]*/), + /*1]*/); +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.LITERAL, + 2: FoldingKind.LITERAL, + }); } Future<void> test_mixin() async { var content = ''' // Content before -mixin M {/*1:INC*/ - void m() {/*3:INC*/ +mixin M {/*[0*/ + void m() {/*[1*/ print("Got to m"); - /*3:INC:FUNCTION_BODY*/} -/*1:INC:CLASS_BODY*/} + /*1]*/} +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.CLASS_BODY, + 1: FoldingKind.FUNCTION_BODY, + }); } Future<void> test_multiple_directive_types() async { var content = """ -import/*1:INC*/ 'dart:async'; +import/*[0*/ 'dart:async'; // We can have comments import 'package:a/b.dart'; import 'package:b/c.dart'; -export '../a.dart';/*1:EXC:DIRECTIVES*/ +export '../a.dart';/*0]*/ void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.DIRECTIVES, + }); } Future<void> test_multiple_import_directives() async { var content = """ -import/*1:INC*/ 'dart:async'; +import/*[0*/ 'dart:async'; // We can have comments import 'package:a/b.dart'; import 'package:b/c.dart'; -import '../a.dart';/*1:EXC:DIRECTIVES*/ +import '../a.dart';/*0]*/ void f() {} """; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.DIRECTIVES, + }); } Future<void> test_nested_function() async { var content = ''' // Content before -void f() {/*1:INC*/ - doPrint() {/*2:INC*/ +void f() {/*[0*/ + doPrint() {/*[1*/ print("Hello, world!"); - /*2:INC:FUNCTION_BODY*/} + /*1]*/} doPrint(); -/*1:INC:FUNCTION_BODY*/} +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.FUNCTION_BODY, + }); } Future<void> test_nested_invocations() async { var content = ''' // Content before -void f() {/*1:INC*/ - a(/*2:INC*/ - b(/*3:INC*/ - c(/*4:INC*/ +void f() {/*[0*/ + a(/*[1*/ + b(/*[2*/ + c(/*[3*/ d() - /*4:INC:INVOCATION*/), - /*3:INC:INVOCATION*/), - /*2:INC:INVOCATION*/); -/*1:INC:FUNCTION_BODY*/} + /*3]*/), + /*2]*/), + /*1]*/); +/*0]*/} // Content after '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.FUNCTION_BODY, + 1: FoldingKind.INVOCATION, + 2: FoldingKind.INVOCATION, + 3: FoldingKind.INVOCATION, + }); } Future<void> test_parameters_function() async { var content = ''' -foo(/*1:INC*/ +foo(/*[0*/ String aaaaa, String bbbbb, { String ccccc, - }/*1:INC:PARAMETERS*/) {} + }/*0]*/) {} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.PARAMETERS, + }); } Future<void> test_parameters_method() async { var content = ''' -class C {/*1:INC*/ - C(/*2:INC*/ +class C {/*[0*/ + C(/*[1*/ String aaaaa, String bbbbb, - /*2:INC:PARAMETERS*/) : super(); -/*1:INC:CLASS_BODY*/} + /*1]*/) : super(); +/*0]*/} '''; - final regions = await _computeRegions(content); - _compareRegions(regions, content); + await _computeRegions(content); + expectRegions({ + 0: FoldingKind.CLASS_BODY, + 1: FoldingKind.PARAMETERS, + }); } Future<void> test_single_import_directives() async { @@ -575,64 +739,16 @@ void f() {} """; - // Since there are no region comment markers above - // just check the length instead of the contents - final regions = await _computeRegions(content); - expect(regions, hasLength(0)); + await _computeRegions(content); + expectNoRegions(); } - /// Compares provided folding regions with expected - /// regions extracted from the comments in the provided content. - /// - /// If [onlyKinds] is supplied only regions of that type will be compared. - void _compareRegions(List<FoldingRegion> regions, String content, - [Set<FoldingKind>? onlyKinds]) { - // Find all numeric markers for region starts. - final regex = RegExp(r'/\*(\d+):(INC|EXC)\*/'); - final expectedRegions = regex.allMatches(content); - - if (onlyKinds != null) { - regions = - regions.where((region) => onlyKinds.contains(region.kind)).toList(); - } - - // Check we didn't get more than expected, since the loop below only - // checks for the presence of matches, not absence. - expect(regions, hasLength(expectedRegions.length)); - - // Go through each marker, find the expected region start/end and - // ensure it's in the results. - for (var m in expectedRegions) { - final i = m.group(1); - final inclusiveStart = m.group(2) == 'INC'; - // Find the end marker. - final endMatch = - RegExp('/\\*$i:(INC|EXC):(.+?)\\*/').firstMatch(content)!; - - final inclusiveEnd = endMatch.group(1) == 'INC'; - final expectedKindString = endMatch.group(2); - final expectedKind = FoldingKind.VALUES.firstWhere( - (f) => f.toString() == 'FoldingKind.$expectedKindString', - orElse: () => throw Exception( - 'Annotated test code references $expectedKindString but ' - 'this does not exist in FoldingKind')); - - final expectedStart = inclusiveStart ? m.start : m.end; - final expectedLength = - (inclusiveEnd ? endMatch.end : endMatch.start) - expectedStart; - - expect(regions, - contains(FoldingRegion(expectedKind, expectedStart, expectedLength))); - } - } - - Future<List<FoldingRegion>> _computeRegions(String sourceContent) async { + Future<void> _computeRegions(String sourceContent) async { code = TestCode.parse(sourceContent); newFile(sourcePath, code.code); var result = await (await session).getResolvedUnit(sourcePath) as ResolvedUnitResult; var computer = DartUnitFoldingComputer(result.lineInfo, result.unit); regions = computer.compute(); - return regions; } }