Cleanup of mjsunit.js code and make assertEquals more strict.

test/mjsunit/regexp.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 315 matching lines @@
     assertTrue(test, testName);
   } else {
     assertFalse(test, testName);
   }
 }
 
 assertFalse(/f(o)$\1/.test('foo'), "backref detects at_end");
 
 // Check decimal escapes doesn't overflow.
 // (Note: \214 is interpreted as octal).
-assertEquals(/\2147483648/.exec("\x8c7483648"),
-             ["\x8c7483648"],
-             "Overflow decimal escape");
+assertArrayEquals(["\x8c7483648"],
+                  /\2147483648/.exec("\x8c7483648"),
+                  "Overflow decimal escape");
 
 
 // Check numbers in quantifiers doesn't overflow and doesn't throw on
 // too large numbers.
 assertFalse(/a{111111111111111111111111111111111111111111111}/.test('b'),
             "overlarge1");
 assertFalse(/a{999999999999999999999999999999999999999999999}/.test('b'),
             "overlarge2");
 assertFalse(/a{1,111111111111111111111111111111111111111111111}/.test('b'),
             "overlarge3");
@@ skipping 79 matching lines @@
 re.compile("ro+", "gim");
 assertEquals("ro+", re.source);
 assertTrue(re.global);
 assertTrue(re.ignoreCase);
 assertTrue(re.multiline);
 assertEquals(0, re.lastIndex);
 
 re.lastIndex = 42;
 re.someOtherProperty = 42;
 re.someDeletableProperty = 42;
-re[37] = 37;  
-re[42] = 42;  
+re[37] = 37;
+re[42] = 42;
 
 re.compile("ra+", "i");
 assertEquals("ra+", re.source);
 assertFalse(re.global);
 assertTrue(re.ignoreCase);
 assertFalse(re.multiline);
 assertEquals(0, re.lastIndex);
 
 assertEquals(42, re.someOtherProperty);
 assertEquals(42, re.someDeletableProperty);
 assertEquals(37, re[37]);
 assertEquals(42, re[42]);
 
 re.lastIndex = -1;
 re.someOtherProperty = 37;
 re[42] = 37;
 assertTrue(delete re[37]);
 assertTrue(delete re.someDeletableProperty);
 re.compile("ri+", "gm");
 
 assertEquals("ri+", re.source);
 assertTrue(re.global);
 assertFalse(re.ignoreCase);
 assertTrue(re.multiline);
 assertEquals(0, re.lastIndex);
 assertEquals(37, re.someOtherProperty);
 assertEquals(37, re[42]);
 
 // Test boundary-checks.
-function assertRegExpTest(re, input, test) { 
+function assertRegExpTest(re, input, test) {
   assertEquals(test, re.test(input), "test:" + re + ":" + input);
 }
 
 assertRegExpTest(/b\b/, "b", true);
 assertRegExpTest(/b\b$/, "b", true);
 assertRegExpTest(/\bb/, "b", true);
 assertRegExpTest(/^\bb/, "b", true);
 assertRegExpTest(/,\b/, ",", false);
 assertRegExpTest(/,\b$/, ",", false);
 assertRegExpTest(/\b,/, ",", false);
@@ skipping 38 matching lines @@
 for (var i = 0; i < 100; i++) {
   var re = /x(y)z/;
   var res = re.exec("axyzb");
   assertTrue(!!res);
   assertEquals(2, res.length);
   assertEquals("xyz", res[0]);
   assertEquals("y", res[1]);
   assertEquals(1, res.index);
   assertEquals("axyzb", res.input);
   assertEquals(undefined, res.foobar);
-  
+
   res.foobar = "Arglebargle";
   res[3] = "Glopglyf";
   assertEquals("Arglebargle", res.foobar);
 }
 
 // Test that we perform the spec required conversions in the correct order.
 var log;
 var string = "the string";
-var fakeLastIndex = { 
-      valueOf: function() { 
+var fakeLastIndex = {
+      valueOf: function() {
         log.push("li");
         return 0;
-      } 
+      }
     };
-var fakeString = { 
+var fakeString = {
       toString: function() {
         log.push("ts");
         return string;
-      }, 
-      length: 0 
+      },
+      length: 0
     };
 
 var re = /str/;
 log = [];
 re.lastIndex = fakeLastIndex;
 var result = re.exec(fakeString);
 assertEquals(["str"], result);
 assertEquals(["ts", "li"], log);
 
 // Again, to check if caching interferes.
@@ skipping 124 matching lines @@
 // Syntax extension relative to ES5, for matching JSC (and ES3).
 // Shouldn't throw.
 re = RegExp("(?=x)*");
 re = RegExp("(?!x)*");
 
 // Should throw. Shouldn't hit asserts in debug mode.
 assertThrows("RegExp('(*)')");
 assertThrows("RegExp('(?:*)')");
 assertThrows("RegExp('(?=*)')");
 assertThrows("RegExp('(?!*)')");