Start cleaning up the HTML tests.

pkg/expect/lib/expect.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file

[Bob Nystrom, 2016/10/12 22:14:37]

The changes in this file just make it bitwise identical to
pkg/dev_compiler/test/expect.dart.

 // 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.
 
 /**
  * This library contains an Expect class with static methods that can be used
  * for simple unit-tests.
  */
 library expect;
 
 /**
@@ skipping 62 matching lines @@
         int start = i;
         i++;
         while (i < expected.length && i < actual.length) {
           if (expected.codeUnitAt(i) == actual.codeUnitAt(i)) break;
           i++;
         }
         int end = i;
         var truncExpected = _truncateString(expected, start, end, 20);
         var truncActual = _truncateString(actual, start, end, 20);
         return "at index $start: Expected <$truncExpected>, "
-                                "Found: <$truncActual>";
+            "Found: <$truncActual>";
       }
     }
     return null;
   }
 
   /**
    * Checks whether the expected and actual values are equal (using `==`).
    */
   static void equals(var expected, var actual, [String reason = null]) {
     if (expected == actual) return;
@@ skipping 44 matching lines @@
   }
 
   /**
    * Checks whether the expected and actual values are identical
    * (using `identical`).
    */
   static void identical(var expected, var actual, [String reason = null]) {
     if (_identical(expected, actual)) return;
     String msg = _getMessage(reason);
     _fail("Expect.identical(expected: <$expected>, actual: <$actual>$msg) "
-          "fails.");
+        "fails.");
   }
 
   // Unconditional failure.
   static void fail(String msg) {
     _fail("Expect.fail('$msg')");
   }
 
   /**
    * Failure if the difference between expected and actual is greater than the
    * given tolerance. If no tolerance is given, tolerance is assumed to be the
    * value 4 significant digits smaller than the value given for expected.
    */
-  static void approxEquals(num expected,
-                           num actual,
-                           [num tolerance = null,
-                            String reason = null]) {
+  static void approxEquals(num expected, num actual,
+      [num tolerance = null, String reason = null]) {
     if (tolerance == null) {
       tolerance = (expected / 1e4).abs();
     }
     // Note: use !( <= ) rather than > so we fail on NaNs
     if ((expected - actual).abs() <= tolerance) return;
 
     String msg = _getMessage(reason);
     _fail('Expect.approxEquals(expected:<$expected>, actual:<$actual>, '
-          'tolerance:<$tolerance>$msg) fails');
+        'tolerance:<$tolerance>$msg) fails');
   }
 
   static void notEquals(unexpected, actual, [String reason = null]) {
     if (unexpected != actual) return;
     String msg = _getMessage(reason);
     _fail("Expect.notEquals(unexpected: <$unexpected>, actual:<$actual>$msg) "
-          "fails.");
+        "fails.");
   }
 
   /**
    * Checks that all elements in [expected] and [actual] are equal `==`.
    * This is different than the typical check for identity equality `identical`
    * used by the standard list implementation.  It should also produce nicer
    * error messages than just calling `Expect.equals(expected, actual)`.
    */
   static void listEquals(List expected, List actual, [String reason = null]) {
     String msg = _getMessage(reason);
     int n = (expected.length < actual.length) ? expected.length : actual.length;
     for (int i = 0; i < n; i++) {
       if (expected[i] != actual[i]) {
         _fail('Expect.listEquals(at index $i, '
-              'expected: <${expected[i]}>, actual: <${actual[i]}>$msg) fails');
+            'expected: <${expected[i]}>, actual: <${actual[i]}>$msg) fails');
       }
     }
     // We check on length at the end in order to provide better error
     // messages when an unexpected item is inserted in a list.
     if (expected.length != actual.length) {
       _fail('Expect.listEquals(list length, '
-        'expected: <${expected.length}>, actual: <${actual.length}>$msg) '
-        'fails: Next element <'
-        '${expected.length > n ? expected[n] : actual[n]}>');
+          'expected: <${expected.length}>, actual: <${actual.length}>$msg) '
+          'fails: Next element <'
+          '${expected.length > n ? expected[n] : actual[n]}>');
     }
   }
 
   /**
    * Checks that all [expected] and [actual] have the same set of keys (using
    * the semantics of [Map.containsKey] to determine what "same" means. For
    * each key, checks that the values in both maps are equal using `==`.
    */
   static void mapEquals(Map expected, Map actual, [String reason = null]) {
     String msg = _getMessage(reason);
@@ skipping 12 matching lines @@
       if (!expected.containsKey(key)) {
         _fail('Expect.mapEquals(unexpected key: <$key>$msg) fails');
       }
     }
   }
 
   /**
    * Specialized equality test for strings. When the strings don't match,
    * this method shows where the mismatch starts and ends.
    */
-  static void stringEquals(String expected,
-                           String actual,
-                           [String reason = null]) {
+  static void stringEquals(String expected, String actual,
+      [String reason = null]) {
     if (expected == actual) return;
 
     String msg = _getMessage(reason);
     String defaultMessage =
         'Expect.stringEquals(expected: <$expected>", <$actual>$msg) fails';
 
     if ((expected == null) || (actual == null)) {
       _fail('$defaultMessage');
     }
 
     // Scan from the left until we find the mismatch.
     int left = 0;
     int right = 0;
     int eLen = expected.length;
     int aLen = actual.length;
 
     while (true) {
       if (left == eLen || left == aLen || expected[left] != actual[left]) {
         break;
       }
       left++;
     }
 
     // Scan from the right until we find the mismatch.
-    int eRem = eLen - left;  // Remaining length ignoring left match.
+    int eRem = eLen - left; // Remaining length ignoring left match.
     int aRem = aLen - left;
     while (true) {
-      if (right == eRem || right == aRem ||
+      if (right == eRem ||
+          right == aRem ||
           expected[eLen - right - 1] != actual[aLen - right - 1]) {
         break;
       }
       right++;
     }
 
     // First difference is at index `left`, last at `length - right - 1`
     // Make useful difference message.
     // Example:
     // Diff (1209..1209/1246):
     // ...,{"name":"[  ]FallThroug...
     // ...,{"name":"[ IndexError","kind":"class"},{"name":" ]FallThroug...
     // (colors would be great!)
 
     // Make snippets of up to ten characters before and after differences.
 
     String leftSnippet = expected.substring(left < 10 ? 0 : left - 10, left);
     int rightSnippetLength = right < 10 ? right : 10;
     String rightSnippet =
         expected.substring(eLen - right, eLen - right + rightSnippetLength);
 
     // Make snippets of the differences.
     String eSnippet = expected.substring(left, eLen - right);
     String aSnippet = actual.substring(left, aLen - right);
 
     // If snippets are long, elide the middle.
     if (eSnippet.length > 43) {
-      eSnippet = eSnippet.substring(0, 20) + "..." +
-                 eSnippet.substring(eSnippet.length - 20);
+      eSnippet = eSnippet.substring(0, 20) +
+          "..." +
+          eSnippet.substring(eSnippet.length - 20);
     }
     if (aSnippet.length > 43) {
-      aSnippet = aSnippet.substring(0, 20) + "..." +
-                 aSnippet.substring(aSnippet.length - 20);
+      aSnippet = aSnippet.substring(0, 20) +
+          "..." +
+          aSnippet.substring(aSnippet.length - 20);
     }
     // Add "..." before and after, unless the snippets reach the end.
     String leftLead = "...";
     String rightTail = "...";
     if (left <= 10) leftLead = "";
     if (right <= 10) rightTail = "";
 
     String diff = '\nDiff ($left..${eLen - right}/${aLen - right}):\n'
-                  '$leftLead$leftSnippet[ $eSnippet ]$rightSnippet$rightTail\n'
-                  '$leftLead$leftSnippet[ $aSnippet ]$rightSnippet$rightTail';
+        '$leftLead$leftSnippet[ $eSnippet ]$rightSnippet$rightTail\n'
+        '$leftLead$leftSnippet[ $aSnippet ]$rightSnippet$rightTail';
     _fail("$defaultMessage$diff");
   }
 
   /**
    * Checks that every element of [expected] is also in [actual], and that
    * every element of [actual] is also in [expected].
    */
-  static void setEquals(Iterable expected,
-                        Iterable actual,
-                        [String reason = null]) {
+  static void setEquals(Iterable expected, Iterable actual,
+      [String reason = null]) {
     final missingSet = new Set.from(expected);
     missingSet.removeAll(actual);
     final extraSet = new Set.from(actual);
     extraSet.removeAll(expected);
 
     if (extraSet.isEmpty && missingSet.isEmpty) return;
     String msg = _getMessage(reason);
 
     StringBuffer sb = new StringBuffer("Expect.setEquals($msg) fails");
     // Report any missing items.
@@ skipping 10 matching lines @@
       sb.write('\nExpected collection should not contain: ');
     }
 
     for (final val in extraSet) {
       sb.write('$val ');
     }
     _fail(sb.toString());
   }
 
   /**
+   * Checks that [expected] is equivalent to [actual].
+   *
+   * If the objects are iterables or maps, recurses into them.
+   */
+  static void deepEquals(Object expected, Object actual) {
+    // Early exit check for equality.
+    if (expected == actual) return;
+
+    if (expected is String && actual is String) {
+      stringEquals(expected, actual);
+    } else if (expected is Iterable && actual is Iterable) {
+      var expectedLength = expected.length;
+      var actualLength = actual.length;
+
+      var length =
+          expectedLength < actualLength ? expectedLength : actualLength;
+      for (var i = 0; i < length; i++) {
+        deepEquals(expected.elementAt(i), actual.elementAt(i));
+      }
+
+      // We check on length at the end in order to provide better error
+      // messages when an unexpected item is inserted in a list.
+      if (expectedLength != actualLength) {
+        var nextElement =
+            (expectedLength > length ? expected : actual).elementAt(length);
+        _fail('Expect.deepEquals(list length, '
+            'expected: <$expectedLength>, actual: <$actualLength>) '
+            'fails: Next element <$nextElement>');
+      }
+    } else if (expected is Map && actual is Map) {
+      // Make sure all of the values are present in both and match.
+      for (final key in expected.keys) {
+        if (!actual.containsKey(key)) {
+          _fail('Expect.deepEquals(missing expected key: <$key>) fails');
+        }
+
+        Expect.deepEquals(expected[key], actual[key]);
+      }
+
+      // Make sure the actual map doesn't have any extra keys.
+      for (final key in actual.keys) {
+        if (!expected.containsKey(key)) {
+          _fail('Expect.deepEquals(unexpected key: <$key>) fails');
+        }
+      }
+    } else {
+      _fail("Expect.deepEquals(expected: <$expected>, actual: <$actual>) "
+          "fails.");
+    }
+  }
+
+  /**
    * Calls the function [f] and verifies that it throws an exception.
    * The optional [check] function can provide additional validation
    * that the correct exception is being thrown.  For example, to check
    * the type of the exception you could write this:
    *
    *     Expect.throws(myThrowingFunction, (e) => e is MyException);
    */
   static void throws(void f(),
-                     [bool check(exception) = null,
-                      String reason = null]) {
+      [_CheckExceptionFn check = null, String reason = null]) {
     String msg = reason == null ? "" : "($reason)";
     if (f is! _Nullary) {
       // Only throws from executing the funtion body should count as throwing.
       // The failure to even call `f` should throw outside the try/catch.
       _fail("Expect.throws$msg: Function f not callable with zero arguments");
     }
     try {
       f();
     } catch (e, s) {
       if (check != null) {
         if (!check(e)) {
           _fail("Expect.throws$msg: Unexpected '$e'\n$s");
         }
       }
       return;
     }
     _fail('Expect.throws$msg fails: Did not throw');
   }
 
-  static String _getMessage(String reason)
-      => (reason == null) ? "" : ", '$reason'";
+  static String _getMessage(String reason) =>
+      (reason == null) ? "" : ", '$reason'";
 
   static void _fail(String message) {
     throw new ExpectException(message);
   }
 }
 
 bool _identical(a, b) => identical(a, b);
 
-typedef _Nullary();  // Expect.throws argument must be this type.
+typedef bool _CheckExceptionFn(exception);
+typedef _Nullary(); // Expect.throws argument must be this type.
 
 class ExpectException implements Exception {
   ExpectException(this.message);
   String toString() => message;
   String message;
 }
 
 /// Annotation class for testing of dart2js. Use this as metadata on method
 /// declarations to disable inlining of the annotated method.
 class NoInline {
@@ skipping 14 matching lines @@
   const TrustTypeAnnotations();
 }
 
 /// Annotation class for testing of dart2js. Use this as metadata on method
 /// declarations to disable closed world assumptions on parameters, effectively
 /// assuming that the runtime arguments could be any value. Note that the
 /// constraints due to [TrustTypeAnnotations] still apply.
 class AssumeDynamic {
   const AssumeDynamic();
 }