Extract Local refactoring: provide a linked edit group for the name.

pkg/analysis_server/test/services/refactoring/extract_local_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.services.refactoring.extract_local;
 
 import 'dart:async';
+import 'dart:convert';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/refactoring/extract_local.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../utils.dart';
 import 'abstract_refactoring.dart';
@@ skipping 509 matching lines @@
 main() {
   var s = 'Hello Bob... welcome to Dart!';
 }
 ''');
     _createRefactoringForString('Hello Bob');
     // check guesses
     await refactoring.checkInitialConditions();
     expect(refactoring.names, unorderedEquals(['helloBob', 'bob']));
   }
 
-  test_occurrences_differentVariable() {
+  test_occurrences_differentVariable() async {
     indexTestUnit('''
 main() {
   {
     int v = 1;
     print(v + 1); // marker
     print(v + 1);
   }
   {
     int v = 2;
     print(v + 1);
   }
 }
 ''');
     _createRefactoringWithSuffix('v + 1', '); // marker');
     // apply refactoring
-    return _assertSuccessfulRefactoring('''
+    await _assertSuccessfulRefactoring('''
 main() {
   {
     int v = 1;
     var res = v + 1;
     print(res); // marker
     print(res);
   }
   {
     int v = 2;
     print(v + 1);
   }
 }
 ''');
+    _assertSingleLinkedEditGroup(
+        length: 3, offsets: [36, 59, 85], names: ['object', 'i']);
   }
 
   test_occurrences_disableOccurrences() {
     indexTestUnit('''
 int foo() => 42;
 main() {
   int a = 1 + foo();
   int b = 2 + foo(); // marker
 }
 ''');
@@ skipping 204 matching lines @@
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main(p) {
   foo
   var res = p.bar;
   res.baz;
 }
 ''');
   }
 
-  test_singleExpression_inExpressionBody() {
+  test_singleExpression_inExpressionBody() async {
     indexTestUnit('''
 main() {
   print((x) => x.y * x.y + 1);
 }
 ''');
     _createRefactoringForString('x.y');
     // apply refactoring
-    return _assertSuccessfulRefactoring('''
+    await _assertSuccessfulRefactoring('''
 main() {
   print((x) {
     var res = x.y;
     return res * res + 1;
   });
 }
 ''');
+    _assertSingleLinkedEditGroup(
+        length: 3, offsets: [31, 53, 59], names: ['y']);
   }
 
   test_singleExpression_inIfElseIf() {
     indexTestUnit('''
 main(int p) {
   if (p == 1) {
     print(1);
   } else if (p == 2) {
     print(2);
   }
@@ skipping 163 matching lines @@
     _createRefactoringForString('1 + 2 ');
     // apply refactoring
     return _assertSuccessfulRefactoring('''
 main() {
   var res = 1 + 2;
   int a = res ;
 }
 ''');
   }
 
-  test_stringLiteral_part() {
+  test_stringLiteral_part() async {
     indexTestUnit('''
 main() {
   print('abcdefgh');
 }
 ''');
     _createRefactoringForString('cde');
     // apply refactoring
-    return _assertSuccessfulRefactoring(r'''
+    await _assertSuccessfulRefactoring(r'''
 main() {
   var res = 'cde';
   print('ab${res}fgh');
 }
 ''');
+    _assertSingleLinkedEditGroup(length: 3, offsets: [15, 41], names: ['cde']);
   }
 
-  test_stringLiteral_whole() {
+  test_stringLiteral_whole() async {
     indexTestUnit('''
 main() {
   print('abc');
 }
 ''');
     _createRefactoringForString("'abc'");
     // apply refactoring
-    return _assertSuccessfulRefactoring('''
+    await _assertSuccessfulRefactoring('''
 main() {
   var res = 'abc';
   print(res);
 }
 ''');
+    _assertSingleLinkedEditGroup(
+        length: 3, offsets: [15, 36], names: ['object', 's']);
   }
 
-  test_stringLiteralPart() {
+  test_stringLiteralPart() async {
     indexTestUnit(r'''
 main() {
   int x = 1;
   int y = 2;
   print('$x+$y=${x+y}');
 }
 ''');
     _createRefactoringForString(r'$x+$y');
     // apply refactoring
-    return _assertSuccessfulRefactoring(r'''
+    await _assertSuccessfulRefactoring(r'''
 main() {
   int x = 1;
   int y = 2;
   var res = '$x+$y';
   print('${res}=${x+y}');
 }
 ''');
+    _assertSingleLinkedEditGroup(length: 3, offsets: [41, 67], names: ['xy']);
   }
 
   Future _assertInitialConditions_fatal_selection() async {
     RefactoringStatus status = await refactoring.checkInitialConditions();
     assertRefactoringStatus(status, RefactoringProblemSeverity.FATAL,
         expectedMessage:
             'Expression must be selected to activate this refactoring.');
   }
 
+  void _assertSingleLinkedEditGroup(
+      {int length, List<int> offsets, List<String> names}) {
+    String positionsString = offsets
+        .map((offset) => '{"file": "$testFile", "offset": $offset}')
+        .join(',');
+    String suggestionsString =
+        names.map((name) => '{"value": "$name", "kind": "VARIABLE"}').join(',');
+    _assertSingleLinkedEditGroupJson('''
+{
+  "length": $length,
+  "positions": [$positionsString],
+  "suggestions": [$suggestionsString]
+}''');
+  }
+
+  void _assertSingleLinkedEditGroupJson(String expectedJsonString) {
+    List<LinkedEditGroup> editGroups = refactoringChange.linkedEditGroups;
+    expect(editGroups, hasLength(1));
+    expect(editGroups.first.toJson(), JSON.decode(expectedJsonString));
+  }
+
   /**
    * Checks that all conditions are OK and the result of applying the
    * [SourceChange] to [testUnit] is [expectedCode].
    */
   Future _assertSuccessfulRefactoring(String expectedCode) async {
     await assertRefactoringConditionsOK();
     SourceChange refactoringChange = await refactoring.createChange();
     this.refactoringChange = refactoringChange;
     assertTestChangeResult(expectedCode);
   }
@@ skipping 22 matching lines @@
   List<String> _getCoveringExpressions() {
     List<String> subExpressions = <String>[];
     for (int i = 0; i < refactoring.coveringExpressionOffsets.length; i++) {
       int offset = refactoring.coveringExpressionOffsets[i];
       int length = refactoring.coveringExpressionLengths[i];
       subExpressions.add(testCode.substring(offset, offset + length));
     }
     return subExpressions;
   }
 }