Prepare equivalence strategies for testing entities.

tests/compiler/dart2js/serialization/test_helper.dart

 // Copyright (c) 2016, 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 dart2js.serialization_test_helper;
 
 import 'dart:collection';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/constants/values.dart';
+import 'package:compiler/src/elements/entities.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
+import 'package:compiler/src/elements/types.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/serialization/equivalence.dart';
 import 'package:compiler/src/tree/nodes.dart';
 import 'package:expect/expect.dart';
 import 'test_data.dart';
 
 Check currentCheck;
 
 class Check {
@@ skipping 26 matching lines @@
     StringBuffer sb = new StringBuffer();
     printOn(sb, '');
     return sb.toString();
   }
 }
 
 /// Strategy for checking equivalence.
 ///
 /// Use this strategy to fail early with contextual information in the event of
 /// inequivalence.
-class CheckStrategy implements TestStrategy {
-  const CheckStrategy();
+class CheckStrategy extends TestStrategy {
+  const CheckStrategy(
+      {Equivalence<Entity> elementEquivalence: areElementsEquivalent,
+      Equivalence<DartType> typeEquivalence: areTypesEquivalent,
+      Equivalence<ConstantExpression> constantEquivalence:
+          areConstantsEquivalent,
+      Equivalence<ConstantValue> constantValueEquivalence:
+          areConstantValuesEquivalent})
+      : super(
+            elementEquivalence: elementEquivalence,
+            typeEquivalence: typeEquivalence,
+            constantEquivalence: constantEquivalence,
+            constantValueEquivalence: constantValueEquivalence);
+
+  TestStrategy get testOnly => new TestStrategy(
+      elementEquivalence: elementEquivalence,
+      typeEquivalence: typeEquivalence,
+      constantEquivalence: constantEquivalence,
+      constantValueEquivalence: constantValueEquivalence);
 
   @override
   bool test(var object1, var object2, String property, var value1, var value2,
       [bool equivalence(a, b) = equality]) {
     return check(object1, object2, property, value1, value2, equivalence);
   }
 
   @override
   bool testLists(
       Object object1, Object object2, String property, List list1, List list2,
@@ skipping 16 matching lines @@
         object1, object2, property, set1, set2, elementEquivalence);
   }
 
   @override
   bool testMaps(var object1, var object2, String property, Map map1, Map map2,
       [bool keyEquivalence(a, b) = equality,
       bool valueEquivalence(a, b) = equality]) {
     return checkMapEquivalence(object1, object2, property, map1, map2,
         keyEquivalence, valueEquivalence);
   }
-
-  @override
-  bool testElements(Object object1, Object object2, String property,
-      Element element1, Element element2) {
-    return checkElementIdentities(
-        object1, object2, property, element1, element2);
-  }
-
-  @override
-  bool testTypes(Object object1, Object object2, String property,
-      ResolutionDartType type1, ResolutionDartType type2) {
-    return checkTypes(object1, object2, property, type1, type2);
-  }
-
-  @override
-  bool testConstants(Object object1, Object object2, String property,
-      ConstantExpression exp1, ConstantExpression exp2) {
-    return checkConstants(object1, object2, property, exp1, exp2);
-  }
-
-  @override
-  bool testConstantValues(Object object1, Object object2, String property,
-      ConstantValue value1, ConstantValue value2) {
-    return areConstantValuesEquivalent(value1, value2);
-  }
-
-  @override
-  bool testTypeLists(Object object1, Object object2, String property,
-      List<ResolutionDartType> list1, List<ResolutionDartType> list2) {
-    return checkTypeLists(object1, object2, property, list1, list2);
-  }
-
-  @override
-  bool testConstantLists(Object object1, Object object2, String property,
-      List<ConstantExpression> list1, List<ConstantExpression> list2) {
-    return checkConstantLists(object1, object2, property, list1, list2);
-  }
-
-  @override
-  bool testConstantValueLists(Object object1, Object object2, String property,
-      List<ConstantValue> list1, List<ConstantValue> list2) {
-    return checkConstantValueLists(object1, object2, property, list1, list2);
-  }
-
-  @override
-  bool testNodes(
-      Object object1, Object object2, String property, Node node1, Node node2) {
-    return new NodeEquivalenceVisitor(this)
-        .testNodes(object1, object2, property, node1, node2);
-  }
 }
 
 /// Check that the values [property] of [object1] and [object2], [value1] and
 /// [value2] respectively, are equal and throw otherwise.
 bool check(var object1, var object2, String property, var value1, var value2,
     [bool equivalence(a, b) = equality]) {
   currentCheck =
       new Check(currentCheck, object1, object2, property, value1, value2);
   if (!equivalence(value1, value2)) {
     throw currentCheck;
@@ skipping 498 matching lines @@
   }
 
   if (index == 1 && skip != 0) {
     return ['${skip}', segmentNumber(index)];
   } else if (index == count) {
     return [segmentNumber(index - 1)];
   } else {
     return [segmentNumber(index - 1), segmentNumber(index)];
   }
 }