pkg/analysis_server/test/src/plugin/result_merger_test.dart

// Copyright (c) 2017, 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.

import 'package:analysis_server/protocol/protocol_generated.dart';
import 'package:analysis_server/src/plugin/result_merger.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';

void main() {
  defineReflectiveSuite(() {
    defineReflectiveTests(ResultMergerTest);
  });
}

@reflectiveTest
class ResultMergerTest {
  //
  // The tests in this class should always perform the merge operation twice
  // using the same input values in order to ensure that the input values are
  // not modified by the merge operation.
  //

  ResultMerger merger = ResultMerger();

  void test_mergeAnalysisErrorFixes() {
    AnalysisError createError(int offset) {
      var severity = AnalysisErrorSeverity.ERROR;
      var type = AnalysisErrorType.HINT;
      var location = Location(
        'test.dart',
        offset,
        2,
        3,
        4,
        endLine: 5,
        endColumn: 6,
      );
      return AnalysisError(severity, type, location, '', '');
    }

    var error1 = createError(10);
    var error2 = createError(20);
    var error3 = createError(30);
    var error4 = createError(40);
    var change1 = plugin.PrioritizedSourceChange(1, SourceChange('a'));
    var change2 = plugin.PrioritizedSourceChange(2, SourceChange('b'));
    var change3 = plugin.PrioritizedSourceChange(3, SourceChange('c'));
    var change4 = plugin.PrioritizedSourceChange(4, SourceChange('d'));
    var change5 = plugin.PrioritizedSourceChange(5, SourceChange('e'));
    var fix1 = plugin.AnalysisErrorFixes(error1, fixes: [change1]);
    var fix2 = plugin.AnalysisErrorFixes(error2, fixes: [change2]);
    var fix3 = plugin.AnalysisErrorFixes(error2, fixes: [change3]);
    var fix4 = plugin.AnalysisErrorFixes(error3, fixes: [change4]);
    var fix5 = plugin.AnalysisErrorFixes(error4, fixes: [change5]);
    var fix2and3 = plugin.AnalysisErrorFixes(error2, fixes: [change2, change3]);

    void runTest() {
      expect(
        merger.mergeAnalysisErrorFixes([
          [fix1, fix2],
          [fix3, fix4],
          [fix5],
          [],
        ]),
        unorderedEquals([fix1, fix2and3, fix4, fix5]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeAnalysisErrors() {
    AnalysisError createError(int offset) {
      var severity = AnalysisErrorSeverity.ERROR;
      var type = AnalysisErrorType.HINT;
      var location = Location(
        'test.dart',
        offset,
        2,
        3,
        4,
        endLine: 5,
        endColumn: 6,
      );
      return AnalysisError(severity, type, location, '', '');
    }

    var error1 = createError(10);
    var error2 = createError(20);
    var error3 = createError(30);
    var error4 = createError(40);

    void runTest() {
      expect(
        merger.mergeAnalysisErrors([
          [error1, error2],
          [error3],
          [],
          [error4],
        ]),
        unorderedEquals([error1, error2, error3, error4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeCompletionSuggestions() {
    CompletionSuggestion createSuggestion(String completion) =>
        CompletionSuggestion(
          CompletionSuggestionKind.IDENTIFIER,
          50,
          completion,
          0,
          3,
          false,
          false,
        );

    var suggestion1 = createSuggestion('a');
    var suggestion2 = createSuggestion('b');
    var suggestion3 = createSuggestion('c');
    var suggestion4 = createSuggestion('d');

    void runTest() {
      expect(
        merger.mergeCompletionSuggestions([
          [suggestion1],
          [suggestion2, suggestion3, suggestion4],
          [],
        ]),
        unorderedEquals([suggestion1, suggestion2, suggestion3, suggestion4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeFoldingRegion() {
    var kind = FoldingKind.FILE_HEADER;
    var region1 = FoldingRegion(kind, 30, 5);
    var region2 = FoldingRegion(kind, 0, 4);
    var region3 = FoldingRegion(kind, 20, 6);
    var region4 = FoldingRegion(kind, 10, 3);
    var region5 = FoldingRegion(kind, 2, 6); // overlaps

    void runTest() {
      expect(
        merger.mergeFoldingRegions([
          [region1, region2],
          [],
          [region3],
          [region4, region5],
        ]),
        unorderedEquals([region1, region2, region3, region4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeHighlightRegions() {
    var type = HighlightRegionType.COMMENT_BLOCK;
    var region1 = HighlightRegion(type, 30, 5);
    var region2 = HighlightRegion(type, 0, 4);
    var region3 = HighlightRegion(type, 20, 6);
    var region4 = HighlightRegion(type, 10, 3);

    void runTest() {
      expect(
        merger.mergeHighlightRegions([
          [region1, region2],
          [],
          [region3],
          [region4],
        ]),
        unorderedEquals([region1, region2, region3, region4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeNavigation() {
    NavigationTarget target(int fileIndex, int offset) {
      return NavigationTarget(
        ElementKind.CLASS,
        fileIndex,
        offset,
        1,
        0,
        0,
        codeOffset: offset,
        codeLength: 1,
      );
    }

    //
    // Create the parameters from the server.
    //
    var target1_1 = target(0, 1);
    var target1_2 = target(0, 2);
    var target2_1 = target(1, 3);
    var target2_2 = target(1, 4);
    var region1_1 = NavigationRegion(10, 4, [0]);
    var region1_2 = NavigationRegion(20, 4, [1]);
    var region2_1 = NavigationRegion(30, 4, [2]);
    var region2_2 = NavigationRegion(40, 4, [3]);
    var params1 = AnalysisNavigationParams(
      'a.dart',
      [region1_1, region1_2, region2_1, region2_2],
      [target1_1, target1_2, target2_1, target2_2],
      ['one.dart', 'two.dart'],
    );
    //
    // Create the parameters from the second plugin.
    //
    // same file and offset as target 2_2
    var target2_3 = target(0, 4);
    var target2_4 = target(0, 5);
    var target3_1 = target(1, 6);
    var target3_2 = target(1, 7);
    // same region and target as region2_2
    var region2_3 = NavigationRegion(40, 4, [0]);
    // same region as region2_2, but a different target
    var region2_4 = NavigationRegion(40, 4, [2]);
    var region2_5 = NavigationRegion(50, 4, [1]);
    var region3_1 = NavigationRegion(60, 4, [2]);
    var region3_2 = NavigationRegion(70, 4, [3]);
    var params2 = AnalysisNavigationParams(
      'a.dart',
      [region2_3, region2_4, region2_5, region3_1, region3_2],
      [target2_3, target2_4, target3_1, target3_2],
      ['two.dart', 'three.dart'],
    );
    var expected = AnalysisNavigationParams(
      'a.dart',
      [
        region1_1,
        region1_2,
        region2_1,
        NavigationRegion(40, 4, [3, 5]), // union of region2_2 and region2_4
        NavigationRegion(50, 4, [4]), // region2_5
        NavigationRegion(60, 4, [5]), // region3_1
        NavigationRegion(70, 4, [6]), // region3_2
      ],
      [
        target1_1,
        target1_2,
        target2_1,
        target2_2,
        target(1, 5), // target2_4
        target(2, 6), // target3_1
        target(2, 7), // target3_2
      ],
      ['one.dart', 'two.dart', 'three.dart'],
    );

    void runTest() {
      expect(merger.mergeNavigation([params1, params2]), expected);
    }

    runTest();
    runTest();
  }

  void test_mergeOccurrences() {
    var element1 = Element(ElementKind.CLASS, 'e1', 0);
    var element2 = Element(ElementKind.CLASS, 'e2', 0);
    var element3 = Element(ElementKind.CLASS, 'e3', 0);
    var occurrence1 = Occurrences(element1, [1, 2, 4], 2);
    var occurrence2 = Occurrences(element2, [5], 2);
    var occurrence3 = Occurrences(element1, [2, 3], 2);
    var occurrence4 = Occurrences(element3, [8], 2);
    var occurrence5 = Occurrences(element2, [6], 2);
    var occurrence6 = Occurrences(element3, [7, 9], 2);
    var result1 = Occurrences(element1, [1, 2, 3, 4], 2);
    var result2 = Occurrences(element2, [5, 6], 2);
    var result3 = Occurrences(element3, [7, 8, 9], 2);

    void runTest() {
      expect(
        merger.mergeOccurrences([
          [occurrence1, occurrence2],
          [],
          [occurrence3, occurrence4],
          [occurrence5, occurrence6],
        ]),
        unorderedEquals([result1, result2, result3]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeOutline() {
    Element element(ElementKind kind, int offset) {
      var location = Location('', offset, 0, 0, 0, endLine: 0, endColumn: 0);
      return Element(kind, '', 0, location: location);
    }

    var element1 = element(ElementKind.CLASS, 100);
    var element1_1 = element(ElementKind.METHOD, 110);
    var element1_2 = element(ElementKind.METHOD, 120);
    var element2 = element(ElementKind.CLASS, 200);
    var element2_1 = element(ElementKind.METHOD, 210);
    var element2_2 = element(ElementKind.METHOD, 220);
    var element3_1 = element(ElementKind.METHOD, 220); // same as 2_2
    var element3_2 = element(ElementKind.METHOD, 230);
    var element4 = element(ElementKind.CLASS, 300);
    var element4_1 = element(ElementKind.METHOD, 310);
    //
    // Unique, contributed from first plugin.
    //
    // element1
    // - element1_1
    // - element1_2
    //
    var outline1_1 = Outline(element1_1, 0, 0, 0, 0, children: []);
    var outline1_2 = Outline(element1_2, 0, 0, 0, 0, children: []);
    var outline1 = Outline(
      element1,
      0,
      0,
      0,
      0,
      children: [outline1_1, outline1_2],
    );
    //
    // Same top level element, common child.
    //
    // element2
    // - element2_1
    // - element2_2
    // element2
    // - element3_1
    // - element3_2
    //
    var outline2_1 = Outline(element2_1, 0, 0, 0, 0, children: []);
    var outline2_2 = Outline(element2_2, 0, 0, 0, 0, children: []);
    var outline3_1 = Outline(element3_1, 0, 0, 0, 0, children: []);
    var outline3_2 = Outline(element3_2, 0, 0, 0, 0, children: []);
    var outline2 = Outline(
      element2,
      0,
      0,
      0,
      0,
      children: [outline2_1, outline2_2],
    );
    var outline3 = Outline(
      element2,
      0,
      0,
      0,
      0,
      children: [outline3_1, outline3_2],
    );
    var outline2and3 = Outline(
      element2,
      0,
      0,
      0,
      0,
      children: [outline2_1, outline2_2, outline3_2],
    );
    //
    // Unique, contributed from second plugin.
    //
    // element4
    // - element4_1
    //
    var outline4_1 = Outline(element4_1, 0, 0, 0, 0, children: []);
    var outline4 = Outline(element4, 0, 0, 0, 0, children: [outline4_1]);

    void runTest() {
      expect(
        merger.mergeOutline([
          [outline1, outline2],
          [],
          [outline3, outline4],
        ]),
        unorderedEquals([outline1, outline2and3, outline4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergePrioritizedSourceChanges() {
    var kind1 = plugin.PrioritizedSourceChange(1, SourceChange(''));
    var kind2 = plugin.PrioritizedSourceChange(1, SourceChange(''));
    var kind3 = plugin.PrioritizedSourceChange(1, SourceChange(''));
    var kind4 = plugin.PrioritizedSourceChange(1, SourceChange(''));

    void runTest() {
      expect(
        merger.mergePrioritizedSourceChanges([
          [kind3, kind2],
          [],
          [kind4],
          [kind1],
        ]),
        unorderedEquals([kind1, kind2, kind3, kind4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_convertGetterToMethodFeedback() {
    RefactoringFeedback feedback1 = ConvertGetterToMethodFeedback();
    RefactoringFeedback feedback2 = ConvertGetterToMethodFeedback();

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(feedback1),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_convertMethodToGetterFeedback() {
    RefactoringFeedback feedback1 = ConvertMethodToGetterFeedback();
    RefactoringFeedback feedback2 = ConvertMethodToGetterFeedback();

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(feedback1),
      );
    }

    runTest();
    runTest();
  }

  void
  test_mergeRefactoringFeedbacks_extractLocalVariableFeedback_addEverything() {
    var names1 = <String>['a', 'b', 'c'];
    var offsets1 = <int>[10, 20];
    var lengths1 = <int>[4, 5];
    var coveringOffsets1 = <int>[100, 150, 200];
    var coveringLengths1 = <int>[200, 100, 20];
    RefactoringFeedback feedback1 = ExtractLocalVariableFeedback(
      names1,
      offsets1,
      lengths1,
      coveringExpressionOffsets: coveringOffsets1,
      coveringExpressionLengths: coveringLengths1,
    );
    var names2 = <String>['c', 'd'];
    var offsets2 = <int>[30];
    var lengths2 = <int>[6];
    var coveringOffsets2 = <int>[210];
    var coveringLengths2 = <int>[5];
    RefactoringFeedback feedback2 = ExtractLocalVariableFeedback(
      names2,
      offsets2,
      lengths2,
      coveringExpressionOffsets: coveringOffsets2,
      coveringExpressionLengths: coveringLengths2,
    );
    var resultNames = <String>['a', 'b', 'c', 'd'];
    var resultOffsets = List<int>.from(offsets1)..addAll(offsets2);
    var resultLengths = List<int>.from(lengths1)..addAll(lengths2);
    var resultCoveringOffsets = List<int>.from(coveringOffsets1)
      ..addAll(coveringOffsets2);
    var resultCoveringLengths = List<int>.from(coveringLengths1)
      ..addAll(coveringLengths2);
    RefactoringFeedback result = ExtractLocalVariableFeedback(
      resultNames,
      resultOffsets,
      resultLengths,
      coveringExpressionOffsets: resultCoveringOffsets,
      coveringExpressionLengths: resultCoveringLengths,
    );

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(result),
      );
    }

    runTest();
    runTest();
  }

  void
  test_mergeRefactoringFeedbacks_extractLocalVariableFeedback_addOffsetsAndLengths() {
    var names1 = <String>['a', 'b', 'c'];
    var offsets1 = <int>[10, 20];
    var lengths1 = <int>[4, 5];
    var coveringOffsets1 = <int>[100, 150, 200];
    var coveringLengths1 = <int>[200, 100, 20];
    RefactoringFeedback feedback1 = ExtractLocalVariableFeedback(
      names1,
      offsets1,
      lengths1,
      coveringExpressionOffsets: coveringOffsets1,
      coveringExpressionLengths: coveringLengths1,
    );
    var names2 = <String>[];
    var offsets2 = <int>[30];
    var lengths2 = <int>[6];
    RefactoringFeedback feedback2 = ExtractLocalVariableFeedback(
      names2,
      offsets2,
      lengths2,
    );
    var resultOffsets = List<int>.from(offsets1)..addAll(offsets2);
    var resultLengths = List<int>.from(lengths1)..addAll(lengths2);
    RefactoringFeedback result = ExtractLocalVariableFeedback(
      names1,
      resultOffsets,
      resultLengths,
      coveringExpressionOffsets: coveringOffsets1,
      coveringExpressionLengths: coveringLengths1,
    );

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(result),
      );
    }

    runTest();
    runTest();
  }

  void
  test_mergeRefactoringFeedbacks_extractLocalVariableFeedback_noCoverings() {
    var names1 = <String>['a', 'b', 'c'];
    var offsets1 = <int>[10, 20];
    var lengths1 = <int>[4, 5];
    RefactoringFeedback feedback1 = ExtractLocalVariableFeedback(
      names1,
      offsets1,
      lengths1,
    );
    var names2 = <String>[];
    var offsets2 = <int>[30];
    var lengths2 = <int>[6];
    RefactoringFeedback feedback2 = ExtractLocalVariableFeedback(
      names2,
      offsets2,
      lengths2,
    );
    var resultOffsets = List<int>.from(offsets1)..addAll(offsets2);
    var resultLengths = List<int>.from(lengths1)..addAll(lengths2);
    RefactoringFeedback result = ExtractLocalVariableFeedback(
      names1,
      resultOffsets,
      resultLengths,
    );

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(result),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_extractMethodFeedback() {
    var offset1 = 20;
    var length1 = 5;
    var returnType1 = 'int';
    var names1 = <String>['a', 'b', 'c'];
    var canCreateGetter1 = false;
    var parameters1 = <RefactoringMethodParameter>[];
    var offsets1 = <int>[10, 20];
    var lengths1 = <int>[4, 5];
    RefactoringFeedback feedback1 = ExtractMethodFeedback(
      offset1,
      length1,
      returnType1,
      names1,
      canCreateGetter1,
      parameters1,
      offsets1,
      lengths1,
    );
    var names2 = <String>['c', 'd'];
    var canCreateGetter2 = true;
    var parameters2 = <RefactoringMethodParameter>[];
    var offsets2 = <int>[30];
    var lengths2 = <int>[6];
    RefactoringFeedback feedback2 = ExtractMethodFeedback(
      0,
      0,
      '',
      names2,
      canCreateGetter2,
      parameters2,
      offsets2,
      lengths2,
    );
    var resultNames = <String>['a', 'b', 'c', 'd'];
    var resultOffsets = List<int>.from(offsets1)..addAll(offsets2);
    var resultLengths = List<int>.from(lengths1)..addAll(lengths2);
    RefactoringFeedback result = ExtractMethodFeedback(
      offset1,
      length1,
      returnType1,
      resultNames,
      false,
      parameters1,
      resultOffsets,
      resultLengths,
    );

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(result),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_inlineLocalVariableFeedback() {
    RefactoringFeedback feedback1 = InlineLocalVariableFeedback('a', 2);
    RefactoringFeedback feedback2 = InlineLocalVariableFeedback('a', 3);
    RefactoringFeedback result = InlineLocalVariableFeedback('a', 5);

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(result),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_inlineMethodFeedback() {
    RefactoringFeedback feedback1 = InlineMethodFeedback('a', false);
    RefactoringFeedback feedback2 = InlineMethodFeedback('a', false);

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(feedback1),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_moveFileFeedback() {
    RefactoringFeedback feedback1 = MoveFileFeedback();
    RefactoringFeedback feedback2 = MoveFileFeedback();

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(feedback1),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringFeedbacks_renameFeedback() {
    RefactoringFeedback feedback1 = RenameFeedback(10, 0, '', '');
    RefactoringFeedback feedback2 = RenameFeedback(20, 0, '', '');

    void runTest() {
      expect(
        merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
        equals(feedback1),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactoringKinds() {
    var kind1 = RefactoringKind.CONVERT_GETTER_TO_METHOD;
    var kind2 = RefactoringKind.EXTRACT_LOCAL_VARIABLE;
    var kind3 = RefactoringKind.INLINE_LOCAL_VARIABLE;
    var kind4 = RefactoringKind.MOVE_FILE;
    var kind5 = RefactoringKind.EXTRACT_LOCAL_VARIABLE;

    void runTest() {
      expect(
        merger.mergeRefactoringKinds([
          [kind1, kind2],
          [kind3],
          [],
          [kind4, kind5],
        ]),
        unorderedEquals([kind1, kind2, kind3, kind4]),
      );
    }

    runTest();
    runTest();
  }

  void test_mergeRefactorings() {
    RefactoringProblem problem(String message) =>
        RefactoringProblem(RefactoringProblemSeverity.ERROR, message);
    var problem1 = problem('1');
    var problem2 = problem('2');
    var problem3 = problem('3');
    var problem4 = problem('4');
    var problem5 = problem('5');
    var problem6 = problem('6');

    var initialProblems1 = <RefactoringProblem>[problem1, problem2];
    var optionsProblems1 = <RefactoringProblem>[problem3];
    var finalProblems1 = <RefactoringProblem>[problem4];
    RefactoringFeedback feedback1 = RenameFeedback(10, 0, '', '');
    var edit1 = SourceFileEdit(
      'file1.dart',
      11,
      edits: <SourceEdit>[
        SourceEdit(12, 2, 'w', id: 'e1'),
        SourceEdit(13, 3, 'x'),
      ],
    );
    var change1 = SourceChange('c1', edits: <SourceFileEdit>[edit1]);
    var potentialEdits1 = <String>['e1'];
    var result1 = EditGetRefactoringResult(
      initialProblems1,
      optionsProblems1,
      finalProblems1,
      feedback: feedback1,
      change: change1,
      potentialEdits: potentialEdits1,
    );
    var initialProblems2 = <RefactoringProblem>[problem5];
    var optionsProblems2 = <RefactoringProblem>[];
    var finalProblems2 = <RefactoringProblem>[problem6];
    RefactoringFeedback feedback2 = RenameFeedback(20, 0, '', '');
    var edit2 = SourceFileEdit(
      'file2.dart',
      21,
      edits: <SourceEdit>[
        SourceEdit(12, 2, 'y', id: 'e2'),
        SourceEdit(13, 3, 'z'),
      ],
    );
    var change2 = SourceChange('c2', edits: <SourceFileEdit>[edit2]);
    var potentialEdits2 = <String>['e2'];
    var result2 = EditGetRefactoringResult(
      initialProblems2,
      optionsProblems2,
      finalProblems2,
      feedback: feedback2,
      change: change2,
      potentialEdits: potentialEdits2,
    );
    var mergedInitialProblems = <RefactoringProblem>[
      problem1,
      problem2,
      problem5,
    ];
    var mergedOptionsProblems = <RefactoringProblem>[problem3];
    var mergedFinalProblems = <RefactoringProblem>[problem4, problem6];
    var mergedChange = SourceChange(
      'c1',
      edits: <SourceFileEdit>[edit1, edit2],
    );
    var mergedPotentialEdits = <String>['e1', 'e2'];
    var mergedResult = EditGetRefactoringResult(
      mergedInitialProblems,
      mergedOptionsProblems,
      mergedFinalProblems,
      feedback: merger.mergeRefactoringFeedbacks([feedback1, feedback2]),
      change: mergedChange,
      potentialEdits: mergedPotentialEdits,
    );

    void runTest() {
      expect(merger.mergeRefactorings([result1, result2]), mergedResult);
    }

    runTest();
    runTest();
  }

  void test_mergeSourceChanges() {
    var kind1 = SourceChange('');
    var kind2 = SourceChange('');
    var kind3 = SourceChange('');
    var kind4 = SourceChange('');

    void runTest() {
      expect(
        merger.mergeSourceChanges([
          [kind1, kind2],
          [],
          [kind3],
          [kind4],
        ]),
        unorderedEquals([kind1, kind2, kind3, kind4]),
      );
    }

    runTest();
    runTest();
  }

  void test_overlaps_false_nested_left() {
    expect(merger.overlaps(3, 5, 1, 7, allowNesting: true), isFalse);
  }

  void test_overlaps_false_nested_right() {
    expect(merger.overlaps(1, 7, 3, 5, allowNesting: true), isFalse);
  }

  void test_overlaps_false_onLeft() {
    expect(merger.overlaps(1, 3, 5, 7), isFalse);
  }

  void test_overlaps_false_onRight() {
    expect(merger.overlaps(5, 7, 1, 3), isFalse);
  }

  void test_overlaps_true_nested_left() {
    expect(merger.overlaps(3, 5, 1, 7), isTrue);
  }

  void test_overlaps_true_nested_right() {
    expect(merger.overlaps(1, 7, 3, 5), isTrue);
  }

  void test_overlaps_true_onLeft() {
    expect(merger.overlaps(1, 5, 3, 7), isTrue);
  }

  void test_overlaps_true_onRight() {
    expect(merger.overlaps(3, 7, 1, 5), isTrue);
  }
}