Serialize NativeBehavior for elements

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/dart_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';
 
 Check currentCheck;
 
 class Check {
   final Check parent;
   final Object object1;
   final Object object2;
   final String property;
   final Object value1;
   final Object value2;
@@ skipping 153 matching lines @@
 
 /// Computes the set difference between [set1] and [set2] using
 /// [elementEquivalence] to determine element equivalence.
 ///
 /// Elements both in [set1] and [set2] are added to [common], elements in [set1]
 /// but not in [set2] are added to [unfound], and the set of elements in [set2]
 /// but not in [set1] are returned.
 Set computeSetDifference(
     Iterable set1,
     Iterable set2,
-    List common,
+    List<List> common,
     List unfound,
     {bool sameElement(a, b): equality,
      void checkElements(a, b)}) {
   // TODO(johnniwinther): Avoid the quadratic cost here. Some ideas:
   // - convert each set to a list and sort it first, then compare by walking
   // both lists in parallel
   // - map each element to a canonical object, create a map containing those
   // mappings, use the mapped sets to compare (then operations like
   // set.difference would work)
   Set remaining = set2.toSet();
   for (var element1 in set1) {
-    bool found = false;
+    var correspondingElement;
     for (var element2 in remaining) {
       if (sameElement(element1, element2)) {
         if (checkElements != null) {
           checkElements(element1, element2);
         }
-        found = true;
+        correspondingElement = element2;
         remaining.remove(element2);
         break;
       }
     }
-    if (found) {
-      common.add(element1);
+    if (correspondingElement != null) {
+      common.add([element1, correspondingElement]);
     } else {
       unfound.add(element1);
     }
   }
   return remaining;
 }
 
 /// Check equivalence of the two iterables, [set1] and [set1], as sets using
 /// [elementEquivalence] to compute the pair-wise equivalence.
 ///
 /// Uses [object1], [object2] and [property] to provide context for failures.
 bool checkSetEquivalence(
     var object1,
     var object2,
     String property,
     Iterable set1,
     Iterable set2,
     bool sameElement(a, b),
     {void onSameElement(a, b)}) {
-  List common = [];
+  List<List> common = <List>[];
   List unfound = [];
   Set remaining =
       computeSetDifference(set1, set2, common, unfound,
           sameElement: sameElement, checkElements: onSameElement);
   if (unfound.isNotEmpty || remaining.isNotEmpty) {
     String message =
         "Set mismatch for `$property` on $object1 vs $object2: \n"
         "Common:\n ${common.join('\n ')}\n"
         "Unfound:\n ${unfound.join('\n ')}\n"
         "Extra: \n ${remaining.join('\n ')}";
@@ skipping 178 matching lines @@
 
   if (impact1 == null) {
     throw 'Missing impact for $member1. $member2 has $impact2';
   }
   if (impact2 == null) {
     throw 'Missing impact for $member2. $member1 has $impact1';
   }
 
   testResolutionImpactEquivalence(impact1, impact2, const CheckStrategy());
 }
+
+void checkSets(
+    Iterable set1,
+    Iterable set2,
+    String messagePrefix,
+    bool sameElement(a, b),
+    {bool failOnUnfound: true,
+    bool verbose: false,
+    void onSameElement(a, b)}) {
+  List<List> common = <List>[];
+  List unfound = [];
+  Set remaining = computeSetDifference(
+      set1, set2, common, unfound,
+      sameElement: sameElement,
+      checkElements: onSameElement);
+  StringBuffer sb = new StringBuffer();
+  sb.write("$messagePrefix:");
+  if (verbose) {
+    sb.write("\n Common:\n  ${common.join('\n  ')}");
+  }
+  if (unfound.isNotEmpty || verbose) {
+    sb.write("\n Unfound:\n  ${unfound.join('\n  ')}");
+  }
+  if (remaining.isNotEmpty || verbose) {
+    sb.write("\n Extra: \n  ${remaining.join('\n  ')}");
+  }
+  String message = sb.toString();
+  if (unfound.isNotEmpty || remaining.isNotEmpty) {
+
+    if (failOnUnfound || remaining.isNotEmpty) {
+      Expect.fail(message);
+    } else {
+      print(message);
+    }
+  } else if (verbose) {
+    print(message);
+  }
+}
+
+String defaultToString(obj) => '$obj';
+
+void checkMaps(
+    Map map1,
+    Map map2,
+    String messagePrefix,
+    bool sameKey(a, b),
+    bool sameValue(a, b),
+    {bool failOnUnfound: true,
+    bool failOnMismatch: true,
+    bool verbose: false,
+    String keyToString(key): defaultToString,
+    String valueToString(key): defaultToString}) {
+  List<List> common = <List>[];
+  List unfound = [];
+  List<List> mismatch = <List>[];
+  Set remaining = computeSetDifference(
+      map1.keys, map2.keys, common, unfound,
+      sameElement: sameKey,
+      checkElements: (k1, k2) {
+        var v1 = map1[k1];
+        var v2 = map2[k2];
+        if (!sameValue(v1, v2)) {
+          mismatch.add([k1, k2]);
+        }
+      });
+  StringBuffer sb = new StringBuffer();
+  sb.write("$messagePrefix:");
+  if (verbose) {
+    sb.write("\n Common: \n");
+    for (List pair in common) {
+      var k1 = pair[0];
+      var k2 = pair[1];
+      var v1 = map1[k1];
+      var v2 = map2[k2];
+      sb.write(" key1   =${keyToString(k1)}\n");
+      sb.write(" key2   =${keyToString(k2)}\n");
+      sb.write("  value1=${valueToString(v1)}\n");
+      sb.write("  value2=${valueToString(v2)}\n");
+    }
+  }
+  if (unfound.isNotEmpty || verbose) {
+    sb.write("\n Unfound: \n");
+    for (var k1 in unfound) {
+      var v1 = map1[k1];
+      sb.write(" key1   =${keyToString(k1)}\n");
+      sb.write("  value1=${valueToString(v1)}\n");
+    }
+  }
+  if (remaining.isNotEmpty || verbose) {
+    sb.write("\n Extra: \n");
+    for (var k2 in remaining) {
+      var v2 = map2[k2];
+      sb.write(" key2   =${keyToString(k2)}\n");
+      sb.write("  value2=${valueToString(v2)}\n");
+    }
+  }
+  if (mismatch.isNotEmpty || verbose) {
+    sb.write("\n Mismatch: \n");
+    for (List pair in mismatch) {
+      var k1 = pair[0];
+      var k2 = pair[1];
+      var v1 = map1[k1];
+      var v2 = map2[k2];
+      sb.write(" key1   =${keyToString(k1)}\n");
+      sb.write(" key2   =${keyToString(k2)}\n");
+      sb.write("  value1=${valueToString(v1)}\n");
+      sb.write("  value2=${valueToString(v2)}\n");
+    }
+  }
+  String message = sb.toString();
+  if (unfound.isNotEmpty || mismatch.isNotEmpty || remaining.isNotEmpty) {
+    if ((unfound.isNotEmpty && failOnUnfound) ||
+        (mismatch.isNotEmpty && failOnMismatch) ||
+        remaining.isNotEmpty) {
+      Expect.fail(message);
+    } else {
+      print(message);
+    }
+  } else if (verbose) {
+    print(message);
+  }
+}