Don't use LinkedEditGroup.id.

pkg/analysis_server/test/services/correction/fix_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.correction.fix;
 
 import 'package:analysis_server/src/services/correction/change.dart';
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_memory_index.dart';
@@ skipping 28 matching lines @@
     fix = _assertHasFix(kind, error);
     change = fix.change;
     // apply to "file"
     List<FileEdit> fileEdits = change.fileEdits;
     expect(fileEdits, hasLength(1));
     resultCode = applySequence(testCode, change.fileEdits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
-  void assertHasPositionGroup(String id, List<Position> expectedPositions) {
-    List<LinkedEditGroup> linkedPositionGroups = change.linkedEditGroups;
-    for (LinkedEditGroup group in linkedPositionGroups) {
-      if (group.id == id) {
-        expect(group.positions, unorderedEquals(expectedPositions));
-        return;
-      }
-    }
-    fail('No PositionGroup with id=$id found in $linkedPositionGroups');
-  }
-
   void assertNoFix(FixKind kind) {
     AnalysisError error = _findErrorToFix();
     List<Fix> fixes = computeFixes(searchEngine, testUnit, error);
     for (Fix fix in fixes) {
       if (fix.kind == kind) {
         throw fail('Unexpected fix $kind in\n${fixes.join('\n')}');
       }
     }
   }
 
@@ skipping 22 matching lines @@
   }
 
   List<Position> expectedPositions(List<String> patterns) {
     List<Position> positions = <Position>[];
     patterns.forEach((String search) {
       positions.add(expectedPosition(search));
     });
     return positions;
   }
 
+  List<LinkedEditSuggestion> expectedSuggestions(LinkedEditSuggestionKind kind,
+      List<String> values) {
+    return values.map((value) {
+      return new LinkedEditSuggestion(kind, value);
+    }).toList();
+  }
+
   void setUp() {
     super.setUp();
     index = createLocalMemoryIndex();
     searchEngine = new SearchEngineImpl(index);
     verifyNoTestUnitErrors = false;
   }
 
   void test_boolean() {
     _indexTestUnit('''
 main() {
@@ skipping 67 matching lines @@
 }
 ''');
     assertHasFix(FixKind.CREATE_CLASS, '''
 main() {
   Test v = null;
 }
 
 class Test {
 }
 ''');
-    assertHasPositionGroup('NAME', expectedPositions(['Test v =', 'Test {']));
+    _assertLinkedGroup(change.linkedEditGroups[0], ['Test v =', 'Test {']);
   }
 
   void test_createConstructorSuperExplicit() {
     _indexTestUnit('''
 class A {
   A(bool p1, int p2, double p3, String p4, {p5});
 }
 class B extends A {
   B() {}
 }
@@ skipping 1386 matching lines @@
 class A {
   main() {
     myUndefinedMethod(0, 1.0, '3');
   }
 
   void myUndefinedMethod(int i, double d, String s) {
   }
 }
 ''');
     // linked positions
-    _assertHasLinkedPositions(
-        'NAME',
+    int index = 0;
+    _assertLinkedGroup(
+        change.linkedEditGroups[index++],
+        ['void myUndefinedMethod(']);
+    _assertLinkedGroup(
+        change.linkedEditGroups[index++],
         ['myUndefinedMethod(0', 'myUndefinedMethod(int']);
-    _assertHasLinkedPositions('RETURN_TYPE', ['void myUndefinedMethod(']);
-    _assertHasLinkedPositions('TYPE0', ['int i']);
-    _assertHasLinkedPositions('TYPE1', ['double d']);
-    _assertHasLinkedPositions('TYPE2', ['String s']);
-    _assertHasLinkedPositions('ARG0', ['i,']);
-    _assertHasLinkedPositions('ARG1', ['d,']);
-    _assertHasLinkedPositions('ARG2', ['s)']);
-    // linked proposals
-    _assertHasLinkedSuggestions(
-        'TYPE0',
+    _assertLinkedGroup(
+        change.linkedEditGroups[index++],
+        ['int i'],
         expectedSuggestions(
             LinkedEditSuggestionKind.TYPE,
             ['int', 'num', 'Object', 'Comparable']));
-    _assertHasLinkedSuggestions(
-        'TYPE1',
+    _assertLinkedGroup(change.linkedEditGroups[index++], ['i,']);
+    _assertLinkedGroup(
+        change.linkedEditGroups[index++],
+        ['double d'],
         expectedSuggestions(
             LinkedEditSuggestionKind.TYPE,
             ['double', 'num', 'Object', 'Comparable']));
-    _assertHasLinkedSuggestions(
-        'TYPE2',
+    _assertLinkedGroup(change.linkedEditGroups[index++], ['d,']);
+    _assertLinkedGroup(
+        change.linkedEditGroups[index++],
+        ['String s'],
         expectedSuggestions(
             LinkedEditSuggestionKind.TYPE,
             ['String', 'Object', 'Comparable']));
-  }
-
-  List<LinkedEditSuggestion> expectedSuggestions(LinkedEditSuggestionKind kind,
-      List<String> values) {
-    return values.map((value) {
-      return new LinkedEditSuggestion(kind, value);
-    }).toList();
+    _assertLinkedGroup(change.linkedEditGroups[index++], ['s)']);
   }
 
   void test_undefinedMethod_createUnqualified_returnType() {
     _indexTestUnit('''
 class A {
   main() {
     int v = myUndefinedMethod();
   }
 }
 ''');
     assertHasFix(FixKind.CREATE_METHOD, '''
 class A {
   main() {
     int v = myUndefinedMethod();
   }
 
   int myUndefinedMethod() {
   }
 }
 ''');
     // linked positions
-    _assertHasLinkedPositions(
-        'NAME',
+    _assertLinkedGroup(change.linkedEditGroups[0], ['int myUndefinedMethod(']);
+    _assertLinkedGroup(
+        change.linkedEditGroups[1],
         ['myUndefinedMethod();', 'myUndefinedMethod() {']);
-    _assertHasLinkedPositions('RETURN_TYPE', ['int myUndefinedMethod(']);
   }
 
   void test_undefinedMethod_createUnqualified_staticFromField() {
     _indexTestUnit('''
 class A {
   static var f = myUndefinedMethod();
 }
 ''');
     assertHasFix(FixKind.CREATE_METHOD, '''
 class A {
@@ skipping 141 matching lines @@
   Fix _assertHasFix(FixKind kind, AnalysisError error) {
     List<Fix> fixes = computeFixes(searchEngine, testUnit, error);
     for (Fix fix in fixes) {
       if (fix.kind == kind) {
         return fix;
       }
     }
     throw fail('Expected to find fix $kind in\n${fixes.join('\n')}');
   }
 
-  void _assertHasLinkedPositions(String groupId, List<String> expectedStrings) {
+  void _assertLinkedGroup(LinkedEditGroup group, List<String> expectedStrings,
+      [List<LinkedEditSuggestion> expectedSuggestions]) {
     List<Position> expectedPositions = _findResultPositions(expectedStrings);
-    List<LinkedEditGroup> groups = change.linkedEditGroups;
-    for (LinkedEditGroup group in groups) {
-      if (group.id == groupId) {
-        List<Position> actualPositions = group.positions;
-        expect(actualPositions, unorderedEquals(expectedPositions));
-        return;
-      }
+    expect(group.positions, unorderedEquals(expectedPositions));
+    if (expectedSuggestions != null) {
+      expect(group.suggestions, unorderedEquals(expectedSuggestions));
     }
-    fail('No group with ID=$groupId foind in\n${groups.join('\n')}');
-  }
-
-  void _assertHasLinkedSuggestions(String groupId,
-      List<LinkedEditSuggestion> expected) {
-    List<LinkedEditGroup> groups = change.linkedEditGroups;
-    for (LinkedEditGroup group in groups) {
-      if (group.id == groupId) {
-        expect(group.suggestions, expected);
-        return;
-      }
-    }
-    fail('No group with ID=$groupId foind in\n${groups.join('\n')}');
   }
 
   /**
    * We search for elements only already resolved lbiraries, and we use
    * `dart:async` elements in tests.
    */
   void _ensureSdkAsyncLibraryResolved() {
     resolveLibraryUnit(addSource('/other.dart', 'import "dart:async";'));
   }
 
@@ skipping 23 matching lines @@
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _indexTestUnit(String code) {
     resolveTestUnit(code);
     index.indexUnit(context, testUnit);
   }
 }