Add more equivalence tests for ElementEnvironment

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';
@@ skipping 632 matching lines @@
   /// We need co-inductive reasoning because mixin applications are compared
   /// structurally and therefore, in the case of generic mixin applications,
   /// meet themselves through the equivalence check of their type variables.
   Set<Pair<ClassEntity, ClassEntity>> assumedMixinApplications =
       new Set<Pair<ClassEntity, ClassEntity>>();
 
   KernelEquivalence(KernelToElementMapImpl builder)
       : testing = new WorldDeconstructionForTesting(builder);
 
   TestStrategy get defaultStrategy => new TestStrategy(
-      elementEquivalence: entityEquivalence, typeEquivalence: typeEquivalence);
+      elementEquivalence: entityEquivalence,
+      typeEquivalence: typeEquivalence,
+      constantEquivalence: constantEquivalence,
+      constantValueEquivalence: constantValueEquivalence);
 
   bool entityEquivalence(Element a, Entity b, {TestStrategy strategy}) {
     if (identical(a, b)) return true;
     if (a == null || b == null) return false;
     strategy ??= defaultStrategy;
     switch (a.kind) {
       case ElementKind.GENERATIVE_CONSTRUCTOR:
         if (b is KGenerativeConstructor) {
           return strategy.test(a, b, 'name', a.name, b.name) &&
               strategy.testElements(
@@ skipping 145 matching lines @@
                   b.namedParameters) &&
               strategy.testTypeLists(a, b, 'namedParameterTypes',
                   aType.namedParameterTypes, b.namedParameterTypes);
         }
         return false;
       default:
         throw new UnsupportedError('Unsupported equivalence: '
             '$a (${a.runtimeType}) vs $b (${b.runtimeType})');
     }
   }
+
+  bool constantEquivalence(ConstantExpression exp1, ConstantExpression exp2,
+      {TestStrategy strategy}) {
+    strategy ??= defaultStrategy;
+    return areConstantsEquivalent(exp1, exp2, strategy: strategy);
+  }
+
+  bool constantValueEquivalence(ConstantValue value1, ConstantValue value2,
+      {TestStrategy strategy}) {
+    strategy ??= defaultStrategy;
+    return areConstantValuesEquivalent(value1, value2, strategy: strategy);
+  }
 }