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 fail(expected, found, name_opt) {
-  var start;
-  if (name_opt) {
-    // Fix this when we ditch the old test runner.
-    start = "Fail" + "ure (" + name_opt + "): ";
-  } else {
-    start = "Fail" + "ure:";
+function MjsUnitToString(value) {
+  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 + "(" + MjsUnitToString(value.valueOf()) + ")";
+        case "RegExp":
+          return value.toString();
+        case "Array":
+          return "[" + value.map(MjsUnitArrayElementToString).join(",") + "]";
+        case "Object":
+          break;
+        default:
+          return clazz + "()";
+      }
+      // [[Class]] is "Object".
+      var constructor = value.constructor.name;
+      if (name) return name + "()";
+      return "Object()";
+    default:
+      return "-- unknown value --";
   }
-  throw new MjsUnitAssertionError(start + " expected <" + expected + "> found <" + found + ">");
 }
 
 
+function MjsUnitArrayElementToString(value, index, array) {
+  if (value === undefined && !(index in array)) return "";
+  return MjsUnitToString(value);
+}
+
+
+function fail(expected, found, name_opt) {
+  var message = "Fail" + "ure";
+  if (name_opt) {
+    // Fix this when we ditch the old test runner.
+    message += " (" + name_opt + ")";
+  }
+
+  message += ": expected <" + MjsUnitToString(expected) +
+      "> found <" + MjsUnitToString(found) + ">";
+  throw new MjsUnitAssertionError(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);
+    return (a.constructor === b.constructor) && (a.toString() === b.toString());
   }
   if ((typeof a) !== 'object' || (typeof b) !== 'object' ||
       (a === null) || (b === null))
     return false;
   if (a.constructor === Array) {
     if (b.constructor !== Array)
       return false;
     if (a.length != b.length)
       return false;
     for (var i = 0; i < a.length; i++) {
@@ skipping 105 matching lines @@
       eval(code);
     }
   } catch (e) {
     assertTrue(false, "threw an exception: " + (e.message || e));
   }
 }
 
 
 function assertUnreachable(name_opt) {
   // Fix this when we ditch the old test runner.
-  var message = "Fail" + "ure: unreachable"
+  var message = "Fail" + "ure: unreachable";
   if (name_opt) {
     message += " - " + name_opt;
   }
   throw new MjsUnitAssertionError(message);
 }