anchor.diff:      sourcePath = convertPath('$testPackageLibPath/test.dart');
     }
   
  -  Future<void> test_annotations() async {
  +  Future<void> test_annotations_class() async {
  +    var content = '''
  +@folded.classAnnotation1/*[0*/()
  +@foldedClassAnnotation2/*0]*/
  +class MyClass {}
  +''';
  +
  +    await _computeRegions(content);
  +    expectRegions({
  +      0: FoldingKind.ANNOTATIONS,
  +    });
  +  }
  +
  +  Future<void> test_annotations_class_constructor() async {
  +    var content = '''
  +class MyClass {
  +  @constructorAnnotation1/*[0*/
  +  @constructorAnnotation1/*0]*/
  +  MyClass() {}
  +
  +  @constructorAnnotation1/*[1*/
  +  @constructorAnnotation1/*1]*/
  +  MyClass.named() {}
  +}
  +''';
  +
  +    await _computeRegions(content);
  +    expectRegions({
  +      0: FoldingKind.ANNOTATIONS,
  +      1: 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() {}
  -
  -@noFoldNecessary
  -main2() {}
  -
  -@multipleAnnotations1/*[1*/(
  +''';
  +
  +    await _computeRegions(content);
  +    expectRegions({
  +      0: FoldingKind.ANNOTATIONS,
  +    });
  +  }
  +
  +  Future<void> test_annotations_multiple() async {
  +    var content = '''
  +@multipleAnnotations1/*[0*/(
     "this",
     "is a test"
   )
   @multipleAnnotations2()
  -@multipleAnnotations3/*1]*/
  +@multipleAnnotations3/*0]*/
   main3() {}
  +''';
  +
  +    await _computeRegions(content);
  +    expectRegions({
  +      0: FoldingKind.ANNOTATIONS,
  +    });
  +  }
  +
  +  Future<void> test_annotations_singleLine() async {
  +    var content = '''
  +@noFoldNecessary
  +main2() {}
   
   @noFoldsForSingleClassAnnotation
   class MyClass {}
  -
  -@folded.classAnnotation1/*[2*/()
  -@foldedClassAnnotation2/*2]*/
  -class MyClass2 {/*[3*/
  -  @fieldAnnotation1/*[4*/
  -  @fieldAnnotation2/*4]*/
  -  int myField;
  -
  -  @getterAnnotation1/*[5*/
  -  @getterAnnotation2/*5]*/
  -  int get myThing => 1;
  -
  -  @setterAnnotation1/*[6*/
  -  @setterAnnotation2/*6]*/
  -  void set myThing(int value) {}
  -
  -  @methodAnnotation1/*[7*/
  -  @methodAnnotation2/*7]*/
  -  void myMethod() {}
  -
  -  @constructorAnnotation1/*[8*/
  -  @constructorAnnotation1/*8]*/
  -  MyClass2() {}
  -/*3]*/}
  -''';
  -
  -    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,
  -    });
  +''';
  +
  +    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*/}
  -''';
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content);
  +  /*1]*/);
  +/*0]*/}
  +''';
  +    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*/}
  -''';
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content);
  +  /*1]*/);
  +/*0]*/}
  +''';
  +    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*/}
  -
  -  void sayHello() {/*3:INC*/
  +  /*1]*/}
  +
  +  void sayHello() {/*[2*/
       print("Hello, world!");
  -  /*3:INC:FUNCTION_BODY*/}
  -/*1:INC:CLASS_BODY*/}
  -
  -// Content after
  -''';
  -
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content);
  +  /*2]*/}
  +/*0]*/}
  +
  +// Content after
  +''';
  +
  +    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 = '''
  +/*/*[0*/
  + * comment 1
  + *//*0]*/
  +
  +/* this comment starts on the same line as delimeters/*[1*/
  + * second line
  + *//*1]*/
  +void f() {}
  +''';
  +
  +    await _computeRegions(content);
  +    expectRegions({
  +      0: FoldingKind.COMMENT,
  +      1: FoldingKind.COMMENT,
  +    });
  +  }
  +
  +  Future<void> test_comment_singleFollowedByBlankLine() async {
  +    var content = '''
   void f() {
  -/*/*1:EXC*/
  - * comment 1
  - *//*1:EXC:COMMENT*/
  -
  -/* this comment starts on the same line as delimeters/*2:EXC*/
  - * second line
  - *//*2:EXC:COMMENT*/
  -}
  -''';
  -
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content, commentKinds);
  -  }
  -
  -  Future<void> test_comment_singleFollowedByBlankLine() async {
  +// this is/*[0*/
  +// a comment/*0]*/
  +/// this is not part of it
  +}
  +''';
  +
  +    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 not part of it
  -}
  -''';
  -
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content, 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*/}
  -
  -// Content after
  -''';
  -
  -    final regions = await _computeRegions(content);
  -    _compareRegions(regions, content);
  +final a = new Text(/*[0*/
  +  "Hello, world!",
  +/*0]*/);
  +
  +// Content after
  +''';
  +
  +    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 {
  
positive.code: void f() {}
  """;
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content, {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*/
  
  void f() {}
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content, {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*/
  /* This shouldn't be part of the file header */
  
  void f() {}
  """;
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content, {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*/
  
  // This is not the file header
  // It's just a comment
  void f() {}
  """;
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content, {FoldingKind.FILE_HEADER});
    }
  
    Future<void> test_fileHeader_singleFollowedByBlank() async {
      var content = '''
  // this is/*1:EXC*/
  // a file header/*1:INC:FILE_HEADER*/
  
  // this is not part of it
  void f() {}
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_function() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    print("Hello, world!");
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_function_expression_invocation() async {
      var content = '''
  // Content before
  
  getFunc() => (String a, String b) {/*1:INC*/
    print(a);
  /*1:INC:FUNCTION_BODY*/};
  
  main2() {/*2:INC*/
    getFunc()(/*3:INC*/
      "one",
      "two"
    /*3:INC:INVOCATION*/);
  /*2:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    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*/
    print("Hello, world!");
  /*2:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_invocations() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    print(/*2:INC*/
      "Hello, world!",
    /*2:INC:INVOCATION*/);
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_literal_list() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    final List<String> things = <String>[/*2:INC*/
      "one",
      "two"
    /*2:INC:LITERAL*/];
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_literal_map() async {
      var content = '''
  // Content before
  
  main2() {/*1:INC*/
    final Map<String, String> things = <String, String>{/*2:INC*/
      "one": "one",
      "two": "two"
      /*2:INC:LITERAL*/};
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_literal_record() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    final r = (/*2:INC*/
      "one",
      2,
      (/*3:INC*/
      'nested',
      3,
      'field record',
      /*3:INC:LITERAL*/),
    /*2:INC:LITERAL*/);
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_mixin() async {
      var content = '''
  // Content before
  
  mixin M {/*1:INC*/
    void m() {/*3:INC*/
      print("Got to m");
    /*3:INC:FUNCTION_BODY*/}
  /*1:INC:CLASS_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_multiple_directive_types() async {
      var content = """
  import/*1:INC*/ 'dart:async';
  
  // We can have comments
  import 'package:a/b.dart';
  import 'package:b/c.dart';
  
  export '../a.dart';/*1:EXC:DIRECTIVES*/
  
  void f() {}
  """;
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_multiple_import_directives() async {
      var content = """
  import/*1:INC*/ 'dart:async';
  
  // We can have comments
  import 'package:a/b.dart';
  import 'package:b/c.dart';
  
  import '../a.dart';/*1:EXC:DIRECTIVES*/
  
  void f() {}
  """;
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_nested_function() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    doPrint() {/*2:INC*/
      print("Hello, world!");
    /*2:INC:FUNCTION_BODY*/}
    doPrint();
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_nested_invocations() async {
      var content = '''
  // Content before
  
  void f() {/*1:INC*/
    a(/*2:INC*/
      b(/*3:INC*/
        c(/*4:INC*/
          d()
        /*4:INC:INVOCATION*/),
      /*3:INC:INVOCATION*/),
    /*2:INC:INVOCATION*/);
  /*1:INC:FUNCTION_BODY*/}
  
  // Content after
  ''';
  
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_parameters_function() async {
      var content = '''
  foo(/*1:INC*/
    String aaaaa,
    String bbbbb, {
    String ccccc,
    }/*1:INC:PARAMETERS*/) {}
  ''';
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_parameters_method() async {
      var content = '''
  class C {/*1:INC*/
    C(/*2:INC*/
      String aaaaa,
      String bbbbb,
    /*2:INC:PARAMETERS*/) : super();
  /*1:INC:CLASS_BODY*/}
  ''';
      final regions = await _computeRegions(content);
      _compareRegions(regions, content);
    }
  
    Future<void> test_single_import_directives() async {
  
negative.code:   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].
    ///
    /// 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();
  
      final actualRegions = onlyVerify == null
          ? regions.toSet()
          : regions.where((region) => onlyVerify.contains(region.kind)).toSet();
  
      expect(actualRegions, expectedRegions);
    }
  
    @override
  