Expect.equals and Expect.identical escape more strings

pkg/expect/lib/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;
 
 /**
  * Expect is used for tests that do not want to make use of the
  * Dart unit test library - for example, the core language tests.
  * Third parties are discouraged from using this, and should use
  * the expect() function in the unit test library instead for
  * test assertions.
  */
 class Expect {
   /**
    * Return a slice of a string.
    *
    * The slice will contain at least the substring from [start] to the lower of
    * [end] and `start + length`.
    * If the result is no more than `length - 10` characters long,
    * context may be added by extending the range of the slice, by decreasing
    * [start] and increasing [end], up to at most length characters.
    * If the start or end of the slice are not matching the start or end of
    * the string, ellipses are added before or after the slice.
-   * Control characters may be encoded as "\xhh" codes.
+   * Characters other than printable ASCII are escaped.
    */
   static String _truncateString(String string, int start, int end, int length) {
     if (end - start > length) {
       end = start + length;
     } else if (end - start < length) {
       int overflow = length - (end - start);
       if (overflow > 10) overflow = 10;
       // Add context.
       start = start - ((overflow + 1) ~/ 2);
       end = end + (overflow ~/ 2);
       if (start < 0) start = 0;
       if (end > string.length) end = string.length;
     }
-    if (start == 0 && end == string.length) return string;
     StringBuffer buf = new StringBuffer();
     if (start > 0) buf.write("...");
-    for (int i = start; i < end; i++) {
-      int code = string.codeUnitAt(i);
-      if (code < 0x20) {
-        buf.write(r"\x");
-        buf.write("0123456789abcdef"[code ~/ 16]);
-        buf.write("0123456789abcdef"[code % 16]);
-      } else {
-        buf.writeCharCode(string.codeUnitAt(i));
-      }
-    }
+    _escapeSubstring(buf, string, 0, string.length);
     if (end < string.length) buf.write("...");
     return buf.toString();
   }
 
+  /// Return the string with characters that are not printable ASCII characters
+  /// escaped as either "\xXX" codes or "\uXXXX" codes.
+  static String _escapeString(String string) {
+    StringBuffer buf = new StringBuffer();
+    _escapeSubstring(buf, string, 0, string.length);
+    return buf.toString();
+  }
+
+  static _escapeSubstring(StringBuffer buf, String string, int start, int end) {
+    const hexDigits = "0123456789ABCDEF";
+    for (int i = start; i < end; i++) {
+      int code = string.codeUnitAt(i);
+      if (0x20 <= code && code < 0x7F) {
+        if (code == 0x5C) {
+          buf.write(r"\\");
+        } else {
+          buf.writeCharCode(code);
+        }
+      } else if (code < 0x100) {
+        buf.write(r"\x");
+        buf.write(hexDigits[code >> 4]);
+        buf.write(hexDigits[code & 15]);
+      } else {
+        buf.write(r"\u{");
+        buf.write(code.toRadixString(16).toUpperCase());
+        buf.write(r"}");
+      }
+    }
+  }
+
   /**
    * Find the difference between two strings.
    *
    * This finds the first point where two strings differ, and returns
    * a text describing the difference.
    *
    * For small strings (length less than 20) nothing is done, and null is
    * returned. Small strings can be compared visually, but for longer strings
    * only a slice containing the first difference will be shown.
    */
@@ skipping 21 matching lines @@
    * Checks whether the expected and actual values are equal (using `==`).
    */
   static void equals(var expected, var actual, [String reason = null]) {
     if (expected == actual) return;
     String msg = _getMessage(reason);
     if (expected is String && actual is String) {
       String stringDifference = _stringDifference(expected, actual);
       if (stringDifference != null) {
         _fail("Expect.equals($stringDifference$msg) fails.");
       }
+      _fail("Expect.equals(expected: <${_escapeString(expected)}>"
+          ", actual: <${_escapeString(actual)}>$msg) fails.");
     }
     _fail("Expect.equals(expected: <$expected>, actual: <$actual>$msg) fails.");
   }
 
   /**
    * Checks whether the actual value is a bool and its value is true.
    */
   static void isTrue(var actual, [String reason = null]) {
     if (_identical(actual, true)) return;
     String msg = _getMessage(reason);
@@ skipping 27 matching lines @@
     _fail("Expect.isNotNull(actual: <$actual>$msg) fails.");
   }
 
   /**
    * 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);
+    if (expected is String && actual is String) {
+      String note =
+          (expected == actual) ? ' Strings equal but not identical.' : '';
+      _fail("Expect.identical(expected: <${_escapeString(expected)}>"
+          ", actual: <${_escapeString(actual)}>$msg) "
+          "fails.$note");
+    }
     _fail("Expect.identical(expected: <$expected>, actual: <$actual>$msg) "
         "fails.");
   }
 
   // Unconditional failure.
   static void fail(String msg) {
     _fail("Expect.fail('$msg')");
   }
 
   /**
@@ skipping 309 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();
 }