Start cleaning up the HTML tests.

pkg/dev_compiler/test/codegen/expect.dart

 // Copyright (c) 2012, 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.
 
 /**
  * This library contains an Expect class with static methods that can be used
  * for simple unit-tests.
  */
 library expect;
 
@@ skipping 332 matching lines @@
 
     for (final val in extraSet) {
       sb.write('$val ');
     }
     _fail(sb.toString());
   }
 
   /**
    * Checks that [expected] is equivalent to [actual].
    *
-   * If the objects are lists or maps, recurses into them.
+   * 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 List && actual is List) {
-      int n =
-          (expected.length < actual.length) ? expected.length : actual.length;
-      for (int i = 0; i < n; i++) {
-        deepEquals(expected[i], actual[i]);
+    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 (expected.length != actual.length) {
+      if (expectedLength != actualLength) {
+        var nextElement =
+            (expectedLength > length ? expected : actual).elementAt(length);
         _fail('Expect.deepEquals(list length, '
-            'expected: <${expected.length}>, actual: <${actual.length}>) '
-            'fails: Next element <'
-            '${expected.length > n ? expected[n] : actual[n]}>');
+            '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 if (expected is String && actual is String) {
-      String stringDifference = _stringDifference(expected, actual);
-      // If we get here, they should not be equal.
-      assert(stringDifference != null);
-      _fail("Expect.deepEquals($stringDifference) 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
@@ skipping 61 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();
 }