Add more tests to mul-exhaustive for constant left/right parameters.

test/mjsunit/mjsunit.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 MjsUnitAssertionError.prototype.toString = function () {
   return this.message;
 }
 
 /*
  * This file is included in all mini jsunit test cases.  The test
  * framework expects lines that signal failed tests to start with
  * the f-word and ignore all other lines.
  */
 
+function MJSToString(value) {

[Kevin Millikin (Chromium), 2011/03/21 11:25:39]

You should adopt the same naming convention as the surrounding code or else
change the surrounding code (MjsToString, see MjsUnitAssertionError just above,
and I think it should properly be MjsUnitToString---"mini JSUnit" is the testing
framework, I don't know what "mini JS" is).

[Lasse Reichstein, 2011/03/21 13:17:58]

Renamed to MjsUnitToString.

+  switch (typeof value) {
+  case "string": return JSON.stringify(value);
+  case "number":
+    if (value === 0 && 1/value < 0) return "-0";
+  case "boolean":
+  case "null":
+  case "undefined":
+  case "function":
+    return String(value);
+  case "object":
+    if (value === null) return "null";
+    var clazz = Object.prototype.toString.call(value);
+    clazz = clazz.substring(8, clazz.length - 1);
+    switch (clazz) {
+      case "Number":
+      case "String":
+      case "Boolean":
+      case "Date":
+        return clazz + "(" + MJSToString(value.valueOf()) + ")";
+      case "RegExp":
+        return value.toString();
+      case "Array":
+        return "[" + value.map(MJSToString).join("\n") + "]";
+      case "Object":
+        break;
+      default:
+       return clazz + "()";
+    }
+    // [[Class]] is "Object".
+    var constructor = value.constructor.name;
+    if (name) return name + "()";
+    return "Object()";
+  }
+}
+
+
 function fail(expected, found, name_opt) {
   var start;

[Kevin Millikin (Chromium), 2011/03/21 11:25:39]

I can't figure out why this function is so convoluted.

[Lasse Reichstein, 2011/03/21 13:17:58]

And it doesn't have to be.
I added the second case for message for cases where the type of actual differs
from expected, but with MjsUnitToString, it doesn't matter as much, since it
prints strings with quotes around (so we don't get two different values that
turns to the same string when showing).

I'll try to make it simpler.

[Kevin Millikin (Chromium), 2011/03/21 13:37:36]

Here's where we need printf :)

[Lasse Reichstein, 2011/03/21 14:18:26]

Indeed! :)

   if (name_opt) {
     // Fix this when we ditch the old test runner.
     start = "Fail" + "ure (" + name_opt + "): ";
   } else {
     start = "Fail" + "ure:";
   }
-  throw new MjsUnitAssertionError(start + " expected <" + expected + "> found <" + found + ">");
+  var message;
+  var expected_string = MJSToString(expected);
+  var found_string = MJSToString(found);
+  if (typeof expected === typeof found) {
+    message =
+        " expected <" + expected_string + "> found <" + found_string + ">";
+  } else {
+    message = " expected <" + expected_string + " (" +
+        typeof expected + ")> found <" +
+        found_string + " (" + typeof found + ")>";
+  }
+  throw new MjsUnitAssertionError(start + message);
 }
 
 
 function deepObjectEquals(a, b) {
   var aProps = [];
   for (var key in a)
     aProps.push(key);
   var bProps = [];
   for (var key in b)
     bProps.push(key);
   aProps.sort();
   bProps.sort();
   if (!deepEquals(aProps, bProps))
     return false;
   for (var i = 0; i < aProps.length; i++) {
     if (!deepEquals(a[aProps[i]], b[aProps[i]]))
       return false;
   }
   return true;
 }
 
 
 function deepEquals(a, b) {
-  if (a == b) return true;
+  if (a == b) {
+    // Check for -0.
+    if (a === 0 && b === 0) return (1 / a) === (1 / b);
+    return true;
+  }
   if (typeof a == "number" && typeof b == "number" && isNaN(a) && isNaN(b)) {
     return true;
   }
   if (a == null || b == null) return false;
   if (a.constructor === RegExp || b.constructor === RegExp) {
     return (a.constructor === b.constructor) && (a.toString === b.toString);
   }
   if ((typeof a) !== 'object' || (typeof b) !== 'object' ||
       (a === null) || (b === null))
     return false;
@@ skipping 117 matching lines @@
 
 
 function assertUnreachable(name_opt) {
   // Fix this when we ditch the old test runner.
   var message = "Fail" + "ure: unreachable"
   if (name_opt) {
     message += " - " + name_opt;
   }
   throw new MjsUnitAssertionError(message);
 }