Consider adding/editing a method as a resolvable mismatch.

pkg/analyzer/test/generated/incremental_resolver_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 engine.incremental_resolver_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 17 matching lines @@
 main() {
   groupSep = ' | ';
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(IncrementalResolverTest);
   runReflectiveTests(PoorMansIncrementalResolutionTest);
   runReflectiveTests(ResolutionContextBuilderTest);
 }
 
 
 class DeclarationMatcherTest extends ResolverTestCase {
+  void setUp() {
+    super.setUp();
+    test_resolveApiChanges = true;
+  }
+
   void test_false_class_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 ''', r'''
 class A {}
 class B {}
 class C {}
 ''');
   }
 
   void test_false_class_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 class C {}
 ''', r'''
 class A {}
 class B {}
 ''');
   }
 
   void test_false_class_typeParameters_bounds_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B<T> {
   T f;
 }
 ''', r'''
 class A {}
 class B<T extends A> {
   T f;
 }
 ''');
   }
 
   void test_false_class_typeParameters_bounds_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B<T extends A> {
   T f;
 }
 ''', r'''
 class A {}
 class B<T> {
   T f;
 }
 ''');
   }
 
   void test_false_classMemberAccessor_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   get a => 1;
   get b => 2;
 }
 ''', r'''
 class A {
   get a => 1;
   get b => 2;
   get c => 3;
 }
 ''');
   }
 
   void test_false_classMemberAccessor_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   get a => 1;
   get b => 2;
   get c => 3;
 }
 ''', r'''
 class A {
   get a => 1;
   get b => 2;
 }
 ''');
   }
 
   void test_false_classMemberAccessor_wasGetter() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   get a => 1;
 }
 ''', r'''
 class A {
   set a(x) {}
 }
 ''');
   }
 
   void test_false_classMemberAccessor_wasInstance() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   get a => 1;
 }
 ''', r'''
 class A {
   static get a => 1;
 }
 ''');
   }
 
   void test_false_classMemberAccessor_wasSetter() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   set a(x) {}
 }
 ''', r'''
 class A {
   get a => 1;
 }
 ''');
   }
 
   void test_false_classMemberAccessor_wasStatic() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   static get a => 1;
 }
 ''', r'''
 class A {
   get a => 1;
 }
 ''');
   }
 
   void test_false_classTypeAlias_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class M {}
 class A = Object with M;
 ''', r'''
 class M {}
 class A = Object with M;
 class B = Object with M;
 ''');
   }
 
   void test_false_classTypeAlias_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class M {}
 class A = Object with M;
 class B = Object with M;
 ''', r'''
 class M {}
 class A = Object with M;
 ''');
   }
 
   void test_false_classTypeAlias_typeParameters_bounds_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class M<T> {}
 class A {}
 class B<T> = Object with M<T>;
 ''', r'''
 class M<T> {}
 class A {}
 class B<T extends A> = Object with M<T>;
 ''');
   }
 
   void test_false_classTypeAlias_typeParameters_bounds_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class M<T> {}
 class A {}
 class B<T extends A> = Object with M<T>;
 ''', r'''
 class M<T> {}
 class A {}
 class B<T> = Object with M<T>;
 ''');
   }
 
   void test_false_constructor_parameters_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   A();
 }
 ''', r'''
 class A {
   A(int p);
 }
 ''');
   }
 
   void test_false_constructor_parameters_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   A(int p);
 }
 ''', r'''
 class A {
   A();
 }
 ''');
   }
 
   void test_false_constructor_parameters_type_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   A(int p);
 }
 ''', r'''
 class A {
   A(String p);
 }
 ''');
   }
 
   void test_false_constructor_unnamed_add_hadParameters() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
 }
 ''', r'''
 class A {
   A(int p) {}
 }
 ''');
   }
 
   void test_false_constructor_unnamed_remove_hadParameters() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   A(int p) {}
 }
 ''', r'''
 class A {
 }
 ''');
   }
 
   void test_false_defaultFieldFormalParameterElement_wasSimple() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   int field;
   A(int field);
 }
 ''', r'''
 class A {
   int field;
   A([this.field = 0]);
 }
 ''');
   }
 
   void test_false_enum_constants_add() {
     resetWithEnum();
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 enum E {A, B}
 ''', r'''
 enum E {A, B, C}
 ''');
   }
 
   void test_false_enum_constants_remove() {
     resetWithEnum();
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 enum E {A, B, C}
 ''', r'''
 enum E {A, B}
 ''');
   }
 
   void test_false_export_hide_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async' hide Future;
 ''', r'''
 export 'dart:async' hide Future, Stream;
 ''');
   }
 
   void test_false_export_hide_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async' hide Future, Stream;
 ''', r'''
 export 'dart:async' hide Future;
 ''');
   }
 
   void test_false_export_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async';
 ''', r'''
 export 'dart:async';
 export 'dart:math';
 ''');
   }
 
   void test_false_export_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async';
 export 'dart:math';
 ''', r'''
 export 'dart:async';
 ''');
   }
 
   void test_false_export_show_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async' show Future;
 ''', r'''
 export 'dart:async' show Future, Stream;
 ''');
   }
 
   void test_false_export_show_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 export 'dart:async' show Future, Stream;
 ''', r'''
 export 'dart:async' show Future;
 ''');
   }
 
   void test_false_extendsClause_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 ''', r'''
 class A {}
 class B extends A {}
 ''');
   }
 
   void test_false_extendsClause_different() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 class C extends A {}
 ''', r'''
 class A {}
 class B {}
 class C extends B {}
 ''');
   }
 
   void test_false_extendsClause_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B extends A{}
 ''', r'''
 class A {}
 class B {}
 ''');
   }
 
   void test_false_field_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   int A = 1;
   int C = 3;
 }
 ''', r'''
 class T {
   int A = 1;
   int B = 2;
   int C = 3;
 }
 ''');
   }
 
   void test_false_field_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   int A = 1;
   int B = 2;
   int C = 3;
 }
 ''', r'''
 class T {
   int A = 1;
   int C = 3;
 }
 ''');
   }
 
   void test_false_field_modifier_isConst() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   static final A = 1;
 }
 ''', r'''
 class T {
   static const A = 1;
 }
 ''');
   }
 
   void test_false_field_modifier_isFinal() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   int A = 1;
 }
 ''', r'''
 class T {
   final int A = 1;
 }
 ''');
   }
 
   void test_false_field_modifier_isStatic() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   int A = 1;
 }
 ''', r'''
 class T {
   static int A = 1;
 }
 ''');
   }
 
   void test_false_field_modifier_wasConst() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   static const A = 1;
 }
 ''', r'''
 class T {
   static final A = 1;
 }
 ''');
   }
 
   void test_false_field_modifier_wasFinal() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   final int A = 1;
 }
 ''', r'''
 class T {
   int A = 1;
 }
 ''');
   }
 
   void test_false_field_modifier_wasStatic() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   static int A = 1;
 }
 ''', r'''
 class T {
   int A = 1;
 }
 ''');
   }
 
   void test_false_field_type_differentArgs() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   List<int> A;
 }
 ''', r'''
 class T {
   List<String> A;
 }
 ''');
   }
 
   void test_false_fieldFormalParameterElement_wasSimple() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   int field;
   A(int field);
 }
 ''', r'''
 class A {
   int field;
   A(this.field);
 }
 ''');
   }
 
   void test_false_final_type_different() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class T {
   int A;
 }
 ''', r'''
 class T {
   String A;
 }
 ''');
   }
 
   void test_false_functionTypeAlias_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef A(int pa);
 typedef B(String pb);
 ''', r'''
 typedef A(int pa);
 typedef B(String pb);
 typedef C(pc);
 ''');
   }
 
   void test_false_functionTypeAlias_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef A(int pa);
 typedef B(String pb);
 typedef C(pc);
 ''', r'''
 typedef A(int pa);
 typedef B(String pb);
 ''');
   }
 
   void test_false_functionTypeAlias_parameters_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef A(a);
 ''', r'''
 typedef A(a, b);
 ''');
   }
 
   void test_false_functionTypeAlias_parameters_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef A(a, b);
 ''', r'''
 typedef A(a);
 ''');
   }
 
   void test_false_functionTypeAlias_parameters_type_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef A(int p);
 ''', r'''
 typedef A(String p);
 ''');
   }
 
   void test_false_functionTypeAlias_returnType_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef int A();
 ''', r'''
 typedef String A();
 ''');
   }
 
   void test_false_functionTypeAlias_typeParameters_bounds_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 typedef F<T>();
 ''', r'''
 class A {}
 typedef F<T extends A>();
 ''');
   }
 
   void test_false_functionTypeAlias_typeParameters_bounds_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 typedef F<T extends A>();
 ''', r'''
 class A {}
 typedef F<T extends B>();
 ''');
   }
 
   void test_false_functionTypeAlias_typeParameters_bounds_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 typedef F<T extends A>();
 ''', r'''
 class A {}
 typedef F<T>();
 ''');
   }
 
   void test_false_functionTypeAlias_typeParameters_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef F<A>();
 ''', r'''
 typedef F<A, B>();
 ''');
   }
 
   void test_false_functionTypeAlias_typeParameters_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 typedef F<A, B>();
 ''', r'''
 typedef F<A>();
 ''');
   }
 
   void test_false_FunctionTypedFormalParameter_parameters_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int callback(int a)) {
 }
 ''', r'''
 main(int callback(int a, String b)) {
 }
 ''');
   }
 
   void test_false_FunctionTypedFormalParameter_parameters_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int callback(int a, String b)) {
 }
 ''', r'''
 main(int callback(int a)) {
 }
 ''');
   }
 
   void test_false_FunctionTypedFormalParameter_parameterType() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int callback(int p)) {
 }
 ''', r'''
 main(int callback(String p)) {
 }
 ''');
   }
 
   void test_false_FunctionTypedFormalParameter_returnType() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int callback()) {
 }
 ''', r'''
 main(String callback()) {
 }
 ''');
   }
 
   void test_false_FunctionTypedFormalParameter_wasSimple() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int callback) {
 }
 ''', r'''
 main(int callback(int a, String b)) {
 }
 ''');
   }
 
   void test_false_implementsClause_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 ''', r'''
 class A {}
 class B implements A {}
 ''');
   }
 
   void test_false_implementsClause_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B implements A {}
 ''', r'''
 class A {}
 class B {}
 ''');
   }
 
   void test_false_implementsClause_reorder() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 class C implements A, B {}
 ''', r'''
 class A {}
 class B {}
 class C implements B, A {}
 ''');
   }
 
   void test_false_import_hide_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' hide Future;
 ''', r'''
 import 'dart:async' hide Future, Stream;
 ''');
   }
 
   void test_false_import_hide_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' hide Future, Stream;
 ''', r'''
 import 'dart:async' hide Future;
 ''');
   }
 
   void test_false_import_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async';
 ''', r'''
 import 'dart:async';
 import 'dart:math';
 ''');
   }
 
   void test_false_import_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async';
 import 'dart:math';
 ''', r'''
 import 'dart:async';
 ''');
   }
 
   void test_false_import_prefix_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async';
 ''', r'''
 import 'dart:async' as async;
 ''');
   }
 
   void test_false_import_prefix_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' as oldPrefix;
 ''', r'''
 import 'dart:async' as newPrefix;
 ''');
   }
 
   void test_false_import_prefix_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' as async;
 ''', r'''
 import 'dart:async';
 ''');
   }
 
   void test_false_import_show_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' show Future;
 ''', r'''
 import 'dart:async' show Future, Stream;
 ''');
   }
 
   void test_false_import_show_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 import 'dart:async' show Future, Stream;
 ''', r'''
 import 'dart:async' show Future;
 ''');
   }
 
   void test_false_method_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   a() {}
   b() {}
 }
 ''', r'''
 class A {
   a() {}
   b() {}
   c() {}
 }
 ''');
   }
 
   void test_false_method_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {
   a() {}
   b() {}
   c() {}
 }
 ''', r'''
 class A {
   a() {}
   b() {}
 }
 ''');
   }
 
+  void test_false_method_parameters_type_edit() {
+    // TODO
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
+class A {
+  m(int p) {
+  }
+}
+''', r'''
+class A {
+  m(String p) {
+  }
+}
+''');
+  }
+
   void test_false_method_returnType_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatches(DeclarationMatchKind.MISMATCH_OK, r'''
 class A {
   int m() {}
 }
 ''', r'''
 class A {
   String m() {}
 }
 ''');
   }
 
   void test_false_part_list_add() {
     addNamedSource('/unitA.dart', 'part of lib; class A {}');
     addNamedSource('/unitB.dart', 'part of lib; class B {}');
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 library lib;
 part 'unitA.dart';
 ''', r'''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''');
   }
 
   void test_false_part_list_remove() {
     addNamedSource('/unitA.dart', 'part of lib; class A {}');
     addNamedSource('/unitB.dart', 'part of lib; class B {}');
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''', r'''
 library lib;
 part 'unitA.dart';
 ''');
   }
 
   void test_false_SimpleFormalParameter_named_differentName() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main({int oldName}) {
 }
 ''', r'''
 main({int newName}) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_namedDefault_addValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main({int p}) {
 }
 ''', r'''
 main({int p: 2}) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_namedDefault_differentValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main({int p: 1}) {
 }
 ''', r'''
 main({int p: 2}) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_namedDefault_removeValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main({int p: 1}) {
 }
 ''', r'''
 main({int p}) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_optionalDefault_addValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main([int p]) {
 }
 ''', r'''
 main([int p = 2]) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_optionalDefault_differentValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main([int p = 1]) {
 }
 ''', r'''
 main([int p = 2]) {
 }
 ''');
   }
 
   void test_false_SimpleFormalParameter_optionalDefault_removeValue() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main([int p = 1]) {
 }
 ''', r'''
 main([int p]) {
 }
 ''');
   }
 
   void test_false_topLevelAccessor_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 get a => 1;
 get b => 2;
 ''', r'''
 get a => 1;
 get b => 2;
 get c => 3;
 ''');
   }
 
   void test_false_topLevelAccessor_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 get a => 1;
 get b => 2;
 get c => 3;
 ''', r'''
 get a => 1;
 get b => 2;
 ''');
   }
 
   void test_false_topLevelAccessor_wasGetter() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 get a => 1;
 ''', r'''
 set a(x) {}
 ''');
   }
 
   void test_false_topLevelAccessor_wasSetter() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 set a(x) {}
 ''', r'''
 get a => 1;
 ''');
   }
 
   void test_false_topLevelFunction_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 a() {}
 b() {}
 ''', r'''
 a() {}
 b() {}
 c() {}
 ''');
   }
 
   void test_false_topLevelFunction_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 a() {}
 b() {}
 c() {}
 ''', r'''
 a() {}
 b() {}
 ''');
   }
 
   void test_false_topLevelFunction_parameters_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int a, int b) {
 }
 ''', r'''
 main(int a, int b, int c) {
 }
 ''');
   }
 
   void test_false_topLevelFunction_parameters_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int a, int b, int c) {
 }
 ''', r'''
 main(int a, int b) {
 }
 ''');
   }
 
   void test_false_topLevelFunction_parameters_type_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 main(int a, int b, int c) {
 }
 ''', r'''
 main(int a, String b, int c) {
 }
 ''');
   }
 
   void test_false_topLevelFunction_returnType_edit() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 int a() {}
 ''', r'''
 String a() {}
 ''');
   }
 
   void test_false_topLevelVariable_list_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 const int A = 1;
 const int C = 3;
 ''', r'''
 const int A = 1;
 const int B = 2;
 const int C = 3;
 ''');
   }
 
   void test_false_topLevelVariable_list_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 const int A = 1;
 const int B = 2;
 const int C = 3;
 ''', r'''
 const int A = 1;
 const int C = 3;
 ''');
   }
 
   void test_false_topLevelVariable_modifier_isConst() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 final int A = 1;
 ''', r'''
 const int A = 1;
 ''');
   }
 
   void test_false_topLevelVariable_modifier_isFinal() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 int A = 1;
 ''', r'''
 final int A = 1;
 ''');
   }
 
   void test_false_topLevelVariable_modifier_wasConst() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 const int A = 1;
 ''', r'''
 final int A = 1;
 ''');
   }
 
   void test_false_topLevelVariable_modifier_wasFinal() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 final int A = 1;
 ''', r'''
 int A = 1;
 ''');
   }
 
   void test_false_topLevelVariable_synthetic_wasGetter() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 int get A => 1;
 ''', r'''
 final int A = 1;
 ''');
   }
 
   void test_false_topLevelVariable_type_different() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 int A;
 ''', r'''
 String A;
 ''');
   }
 
   void test_false_topLevelVariable_type_differentArgs() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 List<int> A;
 ''', r'''
 List<String> A;
 ''');
   }
 
   void test_false_type_noTypeArguments_hadTypeArguments() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A<T> {}
 A<int> main() {
 }
 ''', r'''
 class A<T> {}
 A main() {
 }
 ''');
   }
 
   void test_false_withClause_add() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 ''', r'''
 class A {}
 class B extends Object with A {}
 ''');
   }
 
   void test_false_withClause_remove() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B extends Object with A {}
 ''', r'''
 class A {}
 class B {}
 ''');
   }
 
   void test_false_withClause_reorder() {
-    _assertCompilationUnitMatches(false, r'''
+    _assertCompilationUnitMatchesFalse(r'''
 class A {}
 class B {}
 class C extends Object with A, B {}
 ''', r'''
 class A {}
 class B {}
 class C extends Object with B, A {}
 ''');
   }
 
   void test_true_class_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {}
 class B {}
 class C {}
 ''', r'''
 class C {}
 class A {}
 class B {}
 ''');
   }
 
   void test_true_class_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {}
 class B {}
 class C {}
 ''', r'''
 class A {}
 class B {}
 class C {}
 ''');
   }
 
   void test_true_class_typeParameters_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A<T> {}
 ''', r'''
 class A<T> {}
 ''');
   }
 
   void test_true_classMemberAccessor_getterSetter() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   int _test;
   get test => _test;
   set test(v) {
     _test = v;
   }
 }
 ''', r'''
 class A {
   int _test;
   get test => _test;
   set test(v) {
     _test = v;
   }
 }
 ''');
   }
 
   void test_true_classMemberAccessor_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   get a => 1;
   get b => 2;
   get c => 3;
 }
 ''', r'''
 class A {
   get c => 3;
   get a => 1;
   get b => 2;
 }
 ''');
   }
 
   void test_true_classMemberAccessor_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   get a => 1;
   get b => 2;
   get c => 3;
 }
 ''', r'''
 class A {
   get a => 1;
   get b => 2;
   get c => 3;
 }
 ''');
   }
 
   void test_true_classTypeAlias_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class M {}
 class A = Object with M;
 class B = Object with M;
 class C = Object with M;
 ''', r'''
 class M {}
 class C = Object with M;
 class A = Object with M;
 class B = Object with M;
 ''');
   }
 
   void test_true_classTypeAlias_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class M {}
 class A = Object with M;
 class B = Object with M;
 class C = Object with M;
 ''', r'''
 class M {}
 class A = Object with M;
 class B = Object with M;
 class C = Object with M;
 ''');
   }
 
   void test_true_classTypeAlias_typeParameters_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class M<T> {}
 class A<T> {}
 class B<T> = A<T> with M<T>;
 ''', r'''
 class M<T> {}
 class A<T> {}
 class B<T> = A<T> with M<T>;
 ''');
   }
 
   void test_true_constructor_named_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   A.name(int p);
 }
 ''', r'''
 class A {
   A.name(int p);
 }
 ''');
   }
 
   void test_true_constructor_unnamed_add_noParameters() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
 }
 ''', r'''
 class A {
   A() {}
 }
 ''');
   }
 
   void test_true_constructor_unnamed_remove_noParameters() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   A() {}
 }
 ''', r'''
 class A {
 }
 ''');
   }
 
   void test_true_constructor_unnamed_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   A(int p);
 }
 ''', r'''
 class A {
   A(int p);
 }
 ''');
   }
 
   void test_true_defaultFieldFormalParameterElement() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   int field;
   A([this.field = 0]);
 }
 ''', r'''
 class A {
   int field;
   A([this.field = 0]);
 }
 ''');
   }
 
   void test_true_enum_constants_reorder() {
     resetWithEnum();
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 enum E {A, B, C}
 ''', r'''
 enum E {C, A, B}
 ''');
   }
 
   void test_true_enum_list_reorder() {
     resetWithEnum();
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 enum A {A1, A2, A3}
 enum B {B1, B2, B3}
 enum C {C1, C2, C3}
 ''', r'''
 enum C {C1, C2, C3}
 enum A {A1, A2, A3}
 enum B {B1, B2, B3}
 ''');
   }
 
   void test_true_enum_list_same() {
     resetWithEnum();
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 enum A {A1, A2, A3}
 enum B {B1, B2, B3}
 enum C {C1, C2, C3}
 ''', r'''
 enum A {A1, A2, A3}
 enum B {B1, B2, B3}
 enum C {C1, C2, C3}
 ''');
   }
 
   void test_true_executable_same_hasLabel() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main() {
   label: return 42;
 }
 ''', r'''
 main() {
   label: return 42;
 }
 ''');
   }
 
   void test_true_executable_same_hasLocalVariable() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main() {
   int a = 42;
 }
 ''', r'''
 main() {
   int a = 42;
 }
 ''');
   }
 
   void test_true_export_hide_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 export 'dart:async' hide Future, Stream;
 ''', r'''
 export 'dart:async' hide Stream, Future;
 ''');
   }
 
   void test_true_export_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 export 'dart:async';
 export 'dart:math';
 ''', r'''
 export 'dart:math';
 export 'dart:async';
 ''');
   }
 
   void test_true_export_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 export 'dart:async';
 export 'dart:math';
 ''', r'''
 export 'dart:async';
 export 'dart:math';
 ''');
   }
 
   void test_true_export_show_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 export 'dart:async' show Future, Stream;
 ''', r'''
 export 'dart:async' show Stream, Future;
 ''');
   }
 
   void test_true_extendsClause_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {}
 class B extends A {}
 ''', r'''
 class A {}
 class B extends A {}
 ''');
   }
 
   void test_true_field_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class T {
   int A = 1;
   int B = 2;
   int C = 3;
 }
 ''', r'''
 class T {
   int C = 3;
   int A = 1;
   int B = 2;
 }
 ''');
   }
 
   void test_true_field_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class T {
   int A = 1;
   int B = 2;
   int C = 3;
 }
 ''', r'''
 class T {
   int A = 1;
   int B = 2;
   int C = 3;
 }
 ''');
   }
 
   void test_true_fieldFormalParameter() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   int field;
   A(this.field);
 }
 ''', r'''
 class A {
   int field;
   A(this.field);
 }
 ''');
   }
 
   void test_true_functionTypeAlias_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 typedef A(int pa);
 typedef B(String pb);
 typedef C(pc);
 ''', r'''
 typedef C(pc);
 typedef A(int pa);
 typedef B(String pb);
 ''');
   }
 
   void test_true_functionTypeAlias_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 typedef String A(int pa);
 typedef int B(String pb);
 typedef C(pc);
 ''', r'''
 typedef String A(int pa);
 typedef int B(String pb);
 typedef C(pc);
 ''');
   }
 
   void test_true_functionTypeAlias_typeParameters_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 typedef F<A, B, C>();
 ''', r'''
 typedef F<A, B, C>();
 ''');
   }
 
   void test_true_FunctionTypedFormalParameter() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main(int callback(int a, String b)) {
 }
 ''', r'''
 main(int callback(int a, String b)) {
 }
 ''');
   }
 
   void test_true_implementsClause_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {}
 class B implements A {}
 ''', r'''
 class A {}
 class B implements A {}
 ''');
   }
 
   void test_true_import_hide_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async' hide Future, Stream;
 ''', r'''
 import 'dart:async' hide Stream, Future;
 ''');
   }
 
   void test_true_import_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async';
 import 'dart:math';
 ''', r'''
 import 'dart:math';
 import 'dart:async';
 ''');
   }
 
   void test_true_import_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async';
 import 'dart:math';
 ''', r'''
 import 'dart:async';
 import 'dart:math';
 ''');
   }
 
   void test_true_import_prefix() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async' as async;
 ''', r'''
 import 'dart:async' as async;
 ''');
   }
 
   void test_true_import_show_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async' show Future, Stream;
 ''', r'''
 import 'dart:async' show Stream, Future;
 ''');
   }
 
   void test_true_method_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   a() {}
   b() {}
   c() {}
 }
 ''', r'''
 class A {
   c() {}
   a() {}
   b() {}
 }
 ''');
   }
 
   void test_true_method_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   a() {}
   b() {}
   c() {}
 }
 ''', r'''
 class A {
   a() {}
   b() {}
   c() {}
 }
 ''');
   }
 
   void test_true_method_operator_minus() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   operator -(other) {}
 }
 ''', r'''
 class A {
   operator -(other) {}
 }
 ''');
   }
 
   void test_true_method_operator_minusUnary() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   operator -() {}
 }
 ''', r'''
 class A {
   operator -() {}
 }
 ''');
   }
 
   void test_true_method_operator_plus() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {
   operator +(other) {}
 }
 ''', r'''
 class A {
   operator +(other) {}
 }
 ''');
   }
 
   void test_true_part_list_reorder() {
     addNamedSource('/unitA.dart', 'part of lib; class A {}');
     addNamedSource('/unitB.dart', 'part of lib; class B {}');
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''', r'''
 library lib;
 part 'unitB.dart';
 part 'unitA.dart';
 ''');
   }
 
   void test_true_part_list_same() {
     addNamedSource('/unitA.dart', 'part of lib; class A {}');
     addNamedSource('/unitB.dart', 'part of lib; class B {}');
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''', r'''
 library lib;
 part 'unitA.dart';
 part 'unitB.dart';
 ''');
   }
 
   void test_true_SimpleFormalParameter_optional_differentName() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main([int oldName]) {
 }
 ''', r'''
 main([int newName]) {
 }
 ''');
   }
 
   void test_true_SimpleFormalParameter_optionalDefault_differentName() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main([int oldName = 1]) {
 }
 ''', r'''
 main([int newName = 1]) {
 }
 ''');
   }
 
   void test_true_SimpleFormalParameter_required_differentName() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 main(int oldName) {
 }
 ''', r'''
 main(int newName) {
 }
 ''');
   }
 
   void test_true_topLevelAccessor_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 set a(x) {}
 set b(x) {}
 set c(x) {}
 ''', r'''
 set c(x) {}
 set a(x) {}
 set b(x) {}
 ''');
   }
 
   void test_true_topLevelAccessor_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 get a => 1;
 get b => 2;
 get c => 3;
 ''', r'''
 get a => 1;
 get b => 2;
 get c => 3;
 ''');
   }
 
   void test_true_topLevelFunction_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 a() {}
 b() {}
 c() {}
 ''', r'''
 c() {}
 a() {}
 b() {}
 ''');
   }
 
   void test_true_topLevelFunction_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 a() {}
 b() {}
 c() {}
 ''', r'''
 a() {}
 b() {}
 c() {}
 ''');
   }
 
   void test_true_topLevelVariable_list_reorder() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 const int A = 1;
 const int B = 2;
 const int C = 3;
 ''', r'''
 const int C = 3;
 const int A = 1;
 const int B = 2;
 ''');
   }
 
   void test_true_topLevelVariable_list_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 const int A = 1;
 const int B = 2;
 const int C = 3;
 ''', r'''
 const int A = 1;
 const int B = 2;
 const int C = 3;
 ''');
   }
 
   void test_true_topLevelVariable_type_sameArgs() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 Map<int, String> A;
 ''', r'''
 Map<int, String> A;
 ''');
   }
 
   void test_true_type_dynamic() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 dynamic a() {}
 ''', r'''
 dynamic a() {}
 ''');
   }
 
   void test_true_type_hasImportPrefix() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 import 'dart:async' as async;
 async.Future F;
 ''', r'''
 import 'dart:async' as async;
 async.Future F;
 ''');
   }
 
   void test_true_type_noTypeArguments_implyAllDynamic() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A<T> {}
 A main() {
 }
 ''', r'''
 class A<T> {}
 A main() {
 }
 ''');
   }
 
   void test_true_type_void() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 void a() {}
 ''', r'''
 void a() {}
 ''');
   }
 
   void test_true_withClause_same() {
-    _assertCompilationUnitMatches(true, r'''
+    _assertCompilationUnitMatchesTrue(r'''
 class A {}
 class B extends Object with A {}
 ''', r'''
 class A {}
 class B extends Object with A {}
 ''');
   }
 
-  void _assertCompilationUnitMatches(bool expectMatch, String oldContent,
-      String newContent) {
+  void _assertCompilationUnitMatches(DeclarationMatchKind expectMatch,
+      String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
     // parse
     CompilationUnit newUnit = ParserTestCase.parseCompilationUnit(newContent);
     // build elements
     {
       ElementHolder holder = new ElementHolder();
       ElementBuilder builder = new ElementBuilder(holder);
       newUnit.accept(builder);
     }
     // match
     DeclarationMatcher matcher = new DeclarationMatcher();
-    expect(matcher.matches(newUnit, oldUnit.element), expectMatch);
+    DeclarationMatchKind matchKind = matcher.matches(newUnit, oldUnit.element);
+    expect(matchKind, same(expectMatch));
+  }
+
+  void _assertCompilationUnitMatchesFalse(String oldContent,

[Brian Wilkerson, 2014/12/05 19:38:05]

Consider "_assertCompilationUnitDoesNotMatch".

+      String newContent) {
+    _assertCompilationUnitMatches(
+        DeclarationMatchKind.MISMATCH,
+        oldContent,
+        newContent);
+  }
+
+  void _assertCompilationUnitMatchesTrue(String oldContent, String newContent) {

[Brian Wilkerson, 2014/12/05 19:38:05]

Consider "_assertCompilationUnitMatches".

+    _assertCompilationUnitMatches(
+        DeclarationMatchKind.MATCH,
+        oldContent,
+        newContent);
   }
 }
 
 
 class IncrementalResolverTest extends ResolverTestCase {
   Source source;
   String code;
   LibraryElement library;
   CompilationUnit unit;
 
@@ skipping 2177 matching lines @@
     _visitList(node.metadata, other.metadata);
     _visitNode(node.identifier, other.identifier);
   }
 
   static void assertSameResolution(CompilationUnit actual,
       CompilationUnit expected) {
     _SameResolutionValidator validator = new _SameResolutionValidator(expected);
     actual.accept(validator);
   }
 }