johnson 2.0.0.pre0 → 2.0.0.pre1

data/vendor/tracemonkey/tests/js1_8_1/trace/shell.js

@@ -0,0 +1 @@
+gTestsubsuite='trace';

data/vendor/tracemonkey/{trace-test.js → tests/js1_8_1/trace/trace-test.js}

@@ -1,4 +1,58 @@
 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is JavaScript Engine testing utilities.
+ *
+ * The Initial Developer of the Original Code is
+ * Mozilla Foundation.
+ * Portions created by the Initial Developer are Copyright (C) 2008
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s): Mike Shaver
+ *                 Brendan Eich
+ *                 Andreas Gal
+ *                 David Anderson
+ *                 Boris Zbarsky
+ *                 Brian Crowder
+ *                 Blake Kaplan
+ *                 Robert Sayre
+ *                 Vladimir Vukicevic
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+var gTestfile = 'trace-test.js';
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 'none';
+var summary = 'trace-capability mini-testsuite';
+
+printBugNumber(BUGNUMBER);
+printStatus (summary);
+
+jit(true);
+
 /**
  * A number of the tests in this file depend on the setting of
  * HOTLOOP.  Define some constants up front, so they're easy to grep
@@ -7,7 +61,7 @@
 // The HOTLOOP constant we depend on; only readable from our stats
 // object in debug builds.
 const haveTracemonkey = !!(this.tracemonkey)
-const HOTLOOP = haveTracemonkey ? tracemonkey.HOTLOOP : 2;
+  const HOTLOOP = haveTracemonkey ? tracemonkey.HOTLOOP : 2;
 // The loop count at which we trace
 const RECORDLOOP = HOTLOOP;
 // The loop count at which we run the trace
@@ -32,27 +86,27 @@ var fails = [], passes=[];
 
 function jitstatHandler(f)
 {
-    if (!haveTracemonkey)
-        return;
-
-    // XXXbz this is a nasty hack, but I can't figure out a way to
-    // just use jitstats.tbl here
-    f("recorderStarted");
-    f("recorderAborted");
-    f("traceCompleted");
-    f("sideExitIntoInterpreter");
-    f("timeoutIntoInterpreter");
-    f("typeMapMismatchAtEntry");
-    f("returnToDifferentLoopHeader");
-    f("traceTriggered");
-    f("globalShapeMismatchAtEntry");
-    f("treesTrashed");
-    f("slotPromoted");
-    f("unstableLoopVariable");
-    f("breakLoopExits");
-    f("returnLoopExits");
-    f("mergedLoopExits")
-    f("noCompatInnerTrees");
+  if (!haveTracemonkey) 
+    return;
+
+  // XXXbz this is a nasty hack, but I can't figure out a way to
+  // just use jitstats.tbl here
+  f("recorderStarted");
+  f("recorderAborted");
+  f("traceCompleted");
+  f("sideExitIntoInterpreter");
+  f("timeoutIntoInterpreter");
+  f("typeMapMismatchAtEntry");
+  f("returnToDifferentLoopHeader");
+  f("traceTriggered");
+  f("globalShapeMismatchAtEntry");
+  f("treesTrashed");
+  f("slotPromoted");
+  f("unstableLoopVariable");
+  f("breakLoopExits");
+  f("returnLoopExits");
+  f("mergedLoopExits");
+  f("noCompatInnerTrees");
 }
 
 var jitProps = {};
@@ -93,43 +147,107 @@ function test(f)
   }
 }
 
+function map_test(t, cases)
+{
+  for (var i = 0; i < cases.length; i++) {
+    function c() { return t(cases[i].input); }
+    c.expected = cases[i].expected;
+    c.name = t.name + "(" + uneval(cases[i].input) + ")";
+    test(c);
+  }
+}
+
+// Use this function to compare expected and actual test results.
+// Types must match.
+// For numbers, treat NaN as matching NaN, distinguish 0 and -0, and
+// tolerate a certain degree of error for other values.
+//
+// These are the same criteria used by the tests in js/tests, except that
+// we distinguish 0 and -0.
+function close_enough(expected, actual)
+{
+  if (typeof expected != typeof actual)
+    return false;
+  if (typeof expected != 'number')
+    return actual == expected;
+
+  // Distinguish NaN from other values.  Using x != x comparisons here
+  // works even if tests redefine isNaN.
+  if (actual != actual)
+    return expected != expected
+      if (expected != expected)
+        return false;
+
+  // Tolerate a certain degree of error.
+  if (actual != expected)
+    return Math.abs(actual - expected) <= 1E-10;
+
+  // Distinguish 0 and -0.
+  if (actual == 0)
+    return (1 / actual > 0) == (1 / expected > 0);
+
+  return true;
+}
+
 function check(desc, actual, expected, oldJITstats, expectedJITstats)
 {
-  if (expected == actual) {
-    var pass = true;
+  var pass = false;
+  if (close_enough(expected, actual)) {
+    pass = true;
     jitstatHandler(function(prop) {
-                     if (expectedJITstats && prop in expectedJITstats &&
-                         expectedJITstats[prop] !=
-                           tracemonkey[prop] - oldJITstats[prop]) {
-                       pass = false;
-                     }
-                   });
+        if (expectedJITstats && prop in expectedJITstats &&
+            expectedJITstats[prop] !=
+            tracemonkey[prop] - oldJITstats[prop]) {
+          pass = false;
+        }
+      });
     if (pass) {
+      reportCompare(expected, actual, desc);
       passes.push(desc);
       return print("TEST-PASS | trace-test.js |", desc);
     }
   }
+
+  if (expected instanceof RegExp) {
+    pass = reportMatch(expected, actual + '', desc);
+    if (pass) {
+      jitstatHandler(function(prop) {
+          if (expectedJITstats && prop in expectedJITstats &&
+              expectedJITstats[prop] !=
+              tracemonkey[prop] - oldJITstats[prop]) {
+            pass = false;
+          }
+        });
+    }
+    if (pass) {
+      passes.push(desc);
+      return print(desc, ": passed");
+    }
+  }
+
+  reportCompare(expected, actual, desc);
+
   fails.push(desc);
   var expectedStats = "";
   if (expectedJITstats) {
-      jitstatHandler(function(prop) {
-                       if (prop in expectedJITstats) {
-                         if (expectedStats)
-                           expectedStats += " ";
-                         expectedStats +=
-                           prop + ": " + expectedJITstats[prop];
-                       }
-                     });
+    jitstatHandler(function(prop) {
+        if (prop in expectedJITstats) {
+          if (expectedStats)
+            expectedStats += " ";
+          expectedStats +=
+            prop + ": " + expectedJITstats[prop];
+        }
+      });
   }
   var actualStats = "";
   if (expectedJITstats) {
-      jitstatHandler(function(prop) {
-                       if (prop in expectedJITstats) {
-                         if (actualStats)
-                           actualStats += " ";
-                         actualStats += prop + ": " + (tracemonkey[prop]-oldJITstats[prop]);
-                       }
-                     });
+    jitstatHandler(function(prop) {
+        if (prop in expectedJITstats) {
+          if (actualStats)
+            actualStats += " ";
+          actualStats += prop + ": " + (tracemonkey[prop]-oldJITstats[prop]);
+        }
+      });
   }
   print("TEST-UNEXPECTED-FAIL | trace-test.js |", desc, ": expected", typeof(expected),
         "(", uneval(expected), ")",
@@ -276,12 +394,12 @@ function lsh_inner(n)
     r = 0x1 << n;
   return r;
 }
-function lsh()
-{
-  return [lsh_inner(15),lsh_inner(55),lsh_inner(1),lsh_inner(0)];
-}
-lsh.expected = "32768,8388608,2,1";
-test(lsh);
+
+map_test (lsh_inner,
+          [{input: 15, expected: 32768},
+           {input: 55, expected: 8388608},
+           {input: 1,  expected: 2},
+           {input: 0,  expected: 1}]);
 
 function rsh_inner(n)
 {
@@ -290,12 +408,11 @@ function rsh_inner(n)
     r = 0x11010101 >> n;
   return r;
 }
-function rsh()
-{
-  return [rsh_inner(8),rsh_inner(5),rsh_inner(35),rsh_inner(-1)];
-}
-rsh.expected = "1114369,8914952,35659808,0";
-test(rsh);
+map_test (rsh_inner,
+          [{input: 8,  expected: 1114369},
+           {input: 5,  expected: 8914952},
+           {input: 35, expected: 35659808},
+           {input: -1, expected: 0}]);
 
 function ursh_inner(n)
 {
@@ -304,19 +421,19 @@ function ursh_inner(n)
     r = -55 >>> n;
   return r;
 }
-function ursh() {
-  return [ursh_inner(8),ursh_inner(33),ursh_inner(0),ursh_inner(1)];
-}
-ursh.expected = "16777215,2147483620,4294967241,2147483620";
-test(ursh);
+map_test (ursh_inner,
+          [{input: 8,  expected: 16777215},
+           {input: 33, expected: 2147483620},
+           {input: 0,  expected: 4294967241},
+           {input: 1,  expected: 2147483620}]);
 
 function doMath_inner(cos)
 {
-    var s = 0;
-    var sin = Math.sin;
-    for (var i = 0; i < 200; i++)
-        s = -Math.pow(sin(i) + cos(i * 0.75), 4);
-    return s;
+  var s = 0;
+  var sin = Math.sin;
+  for (var i = 0; i < 200; i++)
+    s = -Math.pow(sin(i) + cos(i * 0.75), 4);
+  return s;
 }
 function doMath() {
   return doMath_inner(Math.cos);
@@ -325,20 +442,20 @@ doMath.expected = -0.5405549555611059;
 test(doMath);
 
 function fannkuch() {
-   var count = Array(8);
-   var r = 8;
-   var done = 0;
-   while (done < 40) {
-      // write-out the first 30 permutations
-      done += r;
-      while (r != 1) { count[r - 1] = r; r--; }
-      while (true) {
-         count[r] = count[r] - 1;
-         if (count[r] > 0) break;
-         r++;
-      }
-   }
-   return done;
+  var count = Array(8);
+  var r = 8;
+  var done = 0;
+  while (done < 40) {
+    // write-out the first 30 permutations
+    done += r;
+    while (r != 1) { count[r - 1] = r; r--; }
+    while (true) {
+      count[r] = count[r] - 1;
+      if (count[r] > 0) break;
+      r++;
+    }
+  }
+  return done;
 }
 fannkuch.expected = 41;
 test(fannkuch);
@@ -398,20 +515,20 @@ function call()
   var q1 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0;
   var o = {};
   function f1() {
-      return 1;
+    return 1;
   }
   function f2(f) {
-      return f();
+    return f();
   }
   o.f = f1;
   for (var i = 0; i < 100; ++i) {
-      q1 += f1();
-      q2 += f2(f1);
-      q3 += glob_f1();
-      q4 += o.f();
-      q5 += glob_f2();
+    q1 += f1();
+    q2 += f2(f1);
+    q3 += glob_f1();
+    q4 += o.f();
+    q5 += glob_f2();
   }
-  var ret = [q1, q2, q3, q4, q5];
+  var ret = String([q1, q2, q3, q4, q5]);
   return ret;
 }
 call.expected =  "100,100,100,100,100";
@@ -430,16 +547,16 @@ setprop.expected =  "19,-1,19";
 test(setprop);
 
 function testif() {
-    var q = 0;
-    for (var i = 0; i < 100; i++) {
-        if ((i & 1) == 0)
-            q++;
-        else
-            q--;
-    }
-    return q;
+	var q = 0;
+	for (var i = 0; i < 100; i++) {
+		if ((i & 1) == 0)
+			q++;
+		else
+			q--;
+	}
+  return q;
 }
-testif.expected = "0";
+testif.expected = 0;
 test(testif);
 
 var globalinc = 0;
@@ -475,19 +592,19 @@ function trees() {
     else if ((i & 2) == 0) o[1]++;
     else o[2]++;
   }
-  return o;
+  return String(o);
 }
 trees.expected = "50,25,25";
 test(trees);
 
 function unboxint() {
-    var q = 0;
-    var o = [4];
-    for (var i = 0; i < 100; ++i)
-        q = o[0] << 1;
-    return q;
+  var q = 0;
+  var o = [4];
+  for (var i = 0; i < 100; ++i)
+    q = o[0] << 1;
+  return q;
 }
-unboxint.expected = "8";
+unboxint.expected = 8;
 test(unboxint);
 
 function strings()
@@ -560,10 +677,10 @@ var orNaNTest1, orNaNTest2;
 
 orNaNTest1 = new Function("return orTestHelper(NaN, NaN, 10);");
 orNaNTest1.name = 'orNaNTest1';
-orNaNTest1.expected = '0';
+orNaNTest1.expected = 0;
 orNaNTest2 = new Function("return orTestHelper(NaN, 1, 10);");
 orNaNTest2.name = 'orNaNTest2';
-orNaNTest2.expected = '45';
+orNaNTest2.expected = 45;
 test(orNaNTest1);
 test(orNaNTest2);
 
@@ -579,44 +696,44 @@ function andTestHelper(a, b, n)
 
 if (!testName || testName == "truthies") {
   (function () {
-     var opsies   = ["||", "&&"];
-     var falsies  = [null, undefined, false, NaN, 0, ""];
-     var truthies = [{}, true, 1, 42, 1/0, -1/0, "blah"];
-     var boolies  = [falsies, truthies];
-
-     // The for each here should abort tracing, so that this test framework
-     // relies only on the interpreter while the orTestHelper and andTestHelper
-     //  functions get trace-JITed.
-     for each (var op in opsies) {
-       for (var i in boolies) {
-         for (var j in boolies[i]) {
-           var x = uneval(boolies[i][j]);
-           for (var k in boolies) {
-             for (var l in boolies[k]) {
-               var y = uneval(boolies[k][l]);
-               var prefix = (op == "||") ? "or" : "and";
-               var f = new Function("return " + prefix + "TestHelper(" + x + "," + y + ",10)");
-               f.name = prefix + "Test(" + x + "," + y + ")";
-               f.expected = eval(x + op + y) ? 45 : 0;
-               test(f);
-             }
-           }
-         }
-       }
-     }
-   })();
+    var opsies   = ["||", "&&"];
+    var falsies  = [null, undefined, false, NaN, 0, ""];
+    var truthies = [{}, true, 1, 42, 1/0, -1/0, "blah"];
+    var boolies  = [falsies, truthies];
+
+    // The for each here should abort tracing, so that this test framework
+    // relies only on the interpreter while the orTestHelper and andTestHelper
+    //  functions get trace-JITed.
+    for each (var op in opsies) {
+        for (var i in boolies) {
+          for (var j in boolies[i]) {
+            var x = uneval(boolies[i][j]);
+            for (var k in boolies) {
+              for (var l in boolies[k]) {
+                var y = uneval(boolies[k][l]);
+                var prefix = (op == "||") ? "or" : "and";
+                var f = new Function("return " + prefix + "TestHelper(" + x + "," + y + ",10)");
+                f.name = prefix + "Test(" + x + "," + y + ")";
+                f.expected = eval(x + op + y) ? 45 : 0;
+                test(f);
+              }
+            }
+          }
+        }
+      }
+  })();
 }
 
 function nonEmptyStack1Helper(o, farble) {
-    var a = [];
-    var j = 0;
-    for (var i in o)
-        a[j++] = i;
-    return a.join("");
+  var a = [];
+  var j = 0;
+  for (var i in o)
+    a[j++] = i;
+  return a.join("");
 }
 
 function nonEmptyStack1() {
-    return nonEmptyStack1Helper({a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8}, "hi");
+  return nonEmptyStack1Helper({a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8}, "hi");
 }
 
 nonEmptyStack1.expected = "abcdefgh";
@@ -774,18 +891,18 @@ function missingArgTest() {
   }
   return q;
 }
-missingArgTest.expected = "1"
+missingArgTest.expected = 1;
 test(missingArgTest);
 
 JSON = function () {
-    return {
-        stringify: function stringify(value, whitelist) {
-            switch (typeof(value)) {
-              case "object":
-                return value.constructor.name;
-            }
-        }
-    };
+  return {
+  stringify: function stringify(value, whitelist) {
+      switch (typeof(value)) {
+      case "object":
+      return value.constructor.name;
+      }
+    }
+  };
 }();
 
 function missingArgTest2() {
@@ -793,16 +910,16 @@ function missingArgTest2() {
     ["{}", {}],
     ["[]", []],
     ['{"foo":"bar"}', {"foo":"bar"}],
-  ]
+    ]
 
-  var a = [];
+    var a = [];
   for (var i=0; i < testPairs.length; i++) {
     var s = JSON.stringify(testPairs[i][1])
-    a[i] = s;
+      a[i] = s;
   }
   return a.join(",");
 }
-missingArgTest2.expected = "Object,Array,Object";
+missingArgTest2.expected = /(Object,Array,Object|{},\[\],{"foo":"bar"})/;
 test(missingArgTest2);
 
 function deepForInLoop() {
@@ -820,71 +937,71 @@ deepForInLoop.expected = "pqrst";
 test(deepForInLoop);
 
 function nestedExit(x) {
-    var q = 0;
-    for (var i = 0; i < 10; ++i)
-    {
-        if (x)
-            ++q;
-    }
+  var q = 0;
+  for (var i = 0; i < 10; ++i)
+  {
+    if (x)
+	    ++q;
+  }
 }
 function nestedExitLoop() {
-    for (var j = 0; j < 10; ++j)
-        nestedExit(j < 7);
-    return "ok";
+  for (var j = 0; j < 10; ++j)
+    nestedExit(j < 7);
+  return "ok";
 }
 nestedExitLoop.expected = "ok";
 test(nestedExitLoop);
 
 function bitsinbyte(b) {
-    var m = 1, c = 0;
-    while(m<0x100) {
-        if(b & m) c++;
-        m <<= 1;
-    }
-    return 1;
+  var m = 1, c = 0;
+  while(m<0x100) {
+    if(b & m) c++;
+    m <<= 1;
+  }
+  return 1;
 }
 function TimeFunc(func) {
-    var x,y;
-    for(var y=0; y<256; y++) func(y);
+  var x,y;
+  for(var y=0; y<256; y++) func(y);
 }
 function nestedExit2() {
-    TimeFunc(bitsinbyte);
-    return "ok";
+  TimeFunc(bitsinbyte);
+  return "ok";
 }
 nestedExit2.expected = "ok";
 test(nestedExit2);
 
 function parsingNumbers() {
-    var s1 = "123";
-    var s1z = "123zzz";
-    var s2 = "123.456";
-    var s2z = "123.456zzz";
+  var s1 = "123";
+  var s1z = "123zzz";
+  var s2 = "123.456";
+  var s2z = "123.456zzz";
 
-    var e1 = 123;
-    var e2 = 123.456;
+  var e1 = 123;
+  var e2 = 123.456;
 
-    var r1, r1z, r2, r2z;
+  var r1, r1z, r2, r2z;
 
-    for (var i = 0; i < 10; i++) {
-        r1 = parseInt(s1);
-        r1z = parseInt(s1z);
-        r2 = parseFloat(s2);
-        r2z = parseFloat(s2z);
-    }
+  for (var i = 0; i < 10; i++) {
+    r1 = parseInt(s1);
+    r1z = parseInt(s1z);
+    r2 = parseFloat(s2);
+    r2z = parseFloat(s2z);
+  }
 
-    if (r1 == e1 && r1z == e1 && r2 == e2 && r2z == e2)
-        return "ok";
-    return "fail";
+  if (r1 == e1 && r1z == e1 && r2 == e2 && r2z == e2)
+    return "ok";
+  return "fail";
 }
 parsingNumbers.expected = "ok";
 test(parsingNumbers);
 
 function matchInLoop() {
-    var k = "hi";
-    for (var i = 0; i < 10; i++) {
-        var result = k.match(/hi/) != null;
-    }
-    return result;
+  var k = "hi";
+  for (var i = 0; i < 10; i++) {
+    var result = k.match(/hi/) != null;
+  }
+  return result;
 }
 matchInLoop.expected = true;
 test(matchInLoop);
@@ -899,14 +1016,14 @@ function testMatchAsCondition() {
 test(testMatchAsCondition);
 
 function deep1(x) {
-    if (x > 90)
-       return 1;
-    return 2;
+  if (x > 90)
+    return 1;
+  return 2;
 }
 function deep2() {
-    for (var i = 0; i < 100; ++i)
-        deep1(i);
-    return "ok";
+  for (var i = 0; i < 100; ++i)
+    deep1(i);
+  return "ok";
 }
 deep2.expected = "ok";
 test(deep2);
@@ -937,24 +1054,24 @@ test(testHeavy2);
 
 var merge_type_maps_x = 0, merge_type_maps_y = 0;
 function merge_type_maps() {
-    for (merge_type_maps_x = 0; merge_type_maps_x < 50; ++merge_type_maps_x)
-        if ((merge_type_maps_x & 1) == 1)
-            ++merge_type_maps_y;
-    return [merge_type_maps_x,merge_type_maps_y].join(",");
+  for (merge_type_maps_x = 0; merge_type_maps_x < 50; ++merge_type_maps_x)
+    if ((merge_type_maps_x & 1) == 1)
+	    ++merge_type_maps_y;
+  return [merge_type_maps_x,merge_type_maps_y].join(",");
 }
 merge_type_maps.expected = "50,25";
 test(merge_type_maps)
 
 function inner_double_outer_int() {
-    function f(i) {
-        for (var m = 0; m < 20; ++m)
-            for (var n = 0; n < 100; n += i)
-                ;
-        return n;
-    }
-    return f(.5);
+  function f(i) {
+    for (var m = 0; m < 20; ++m)
+	    for (var n = 0; n < 100; n += i)
+        ;
+    return n;
+  }
+  return f(.5);
 }
-inner_double_outer_int.expected = "100";
+inner_double_outer_int.expected = 100;
 test(inner_double_outer_int);
 
 function newArrayTest()
@@ -970,7 +1087,7 @@ test(newArrayTest);
 function stringSplitTest()
 {
   var s = "a,b"
-  var a = null;
+    var a = null;
   for (var i = 0; i < 10; ++i)
     a = s.split(",");
   return a.join();
@@ -981,7 +1098,7 @@ test(stringSplitTest);
 function stringSplitIntoArrayTest()
 {
   var s = "a,b"
-  var a = [];
+    var a = [];
   for (var i = 0; i < 10; ++i)
     a[i] = s.split(",");
   return a.join();
@@ -990,71 +1107,71 @@ stringSplitIntoArrayTest.expected="a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b,a,b";
 test(stringSplitIntoArrayTest);
 
 function forVarInWith() {
-    function foo() ({notk:42});
-    function bar() ({p:1, q:2, r:3, s:4, t:5});
-    var o = foo();
-    var a = [];
-    with (o) {
-        for (var k in bar())
-            a[a.length] = k;
-    }
-    return a.join("");
+  function foo() ({notk:42});
+  function bar() ({p:1, q:2, r:3, s:4, t:5});
+  var o = foo();
+  var a = [];
+  with (o) {
+    for (var k in bar())
+      a[a.length] = k;
+  }
+  return a.join("");
 }
 forVarInWith.expected = "pqrst";
 test(forVarInWith);
 
 function inObjectTest() {
-    var o = {p: 1, q: 2, r: 3, s: 4, t: 5};
-    var r = 0;
-    for (var i in o) {
-        if (!(i in o))
-            break;
-        if ((i + i) in o)
-            break;
-        ++r;
-    }
-    return r;
+  var o = {p: 1, q: 2, r: 3, s: 4, t: 5};
+  var r = 0;
+  for (var i in o) {
+    if (!(i in o))
+      break;
+    if ((i + i) in o)
+      break;
+    ++r;
+  }
+  return r;
 }
 inObjectTest.expected = 5;
 test(inObjectTest);
 
 function inArrayTest() {
-    var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-    for (var i = 0; i < a.length; i++) {
-        if (!(i in a))
-            break;
-    }
-    return i;
+  var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+  for (var i = 0; i < a.length; i++) {
+    if (!(i in a))
+      break;
+  }
+  return i;
 }
 inArrayTest.expected = 10;
 test(inArrayTest);
 
 function innerLoopIntOuterDouble() {
-    var n = 10000, i=0, j=0, count=0, limit=0;
-    for (i = 1; i <= n; ++i) {
-        limit = i * 1;
-        for (j = 0; j < limit; ++j) {
-            ++count;
-        }
+  var n = 10000, i=0, j=0, count=0, limit=0;
+  for (i = 1; i <= n; ++i) {
+    limit = i * 1;
+    for (j = 0; j < limit; ++j) {
+	    ++count;
     }
-    return "" + count;
+  }
+  return "" + count;
 }
 innerLoopIntOuterDouble.expected="50005000";
 test(innerLoopIntOuterDouble);
 
 function outerline(){
-    var i=0;
-    var j=0;
+  var i=0;
+  var j=0;
 
-    for (i = 3; i<= 100000; i+=2)
+  for (i = 3; i<= 100000; i+=2)
+  {
+    for (j = 3; j < 1000; j+=2)
     {
-        for (j = 3; j < 1000; j+=2)
-        {
-            if ((i & 1) == 1)
-                break;
-        }
+	    if ((i & 1) == 1)
+        break;
     }
-    return "ok";
+  }
+  return "ok";
 }
 outerline.expected="ok";
 test(outerline);
@@ -1076,8 +1193,8 @@ function loopingAccumulator() {
 }
 
 function testLoopingAccumulator() {
-    var x = addAccumulations(loopingAccumulator);
-    return x;
+	var x = addAccumulations(loopingAccumulator);
+	return x;
 }
 testLoopingAccumulator.expected = 20;
 test(testLoopingAccumulator);
@@ -1126,11 +1243,11 @@ function testBranchingUnstableObject() {
   var x = {s: "a"};
   var t = "";
   for (var i=0; i < 100; ++i) {
-      if (i == 51)
-      {
-        x.s = 5;
-      }
-      t += x.s;
+    if (i == 51)
+    {
+      x.s = 5;
+    }
+    t += x.s;
   }
   return t.length;
 }
@@ -1144,12 +1261,12 @@ function testArrayDensityChange() {
     x[i] = "asdf";
   }
   for (var i=0; i < x.length; ++i) {
-      if (i == 51)
-      {
-        x[199] = "asdf";
-      }
-      if (x[i])
-        count += x[i].length;
+    if (i == 51)
+    {
+      x[199] = "asdf";
+    }
+    if (x[i])
+      count += x[i].length;
   }
   return count;
 }
@@ -1157,218 +1274,218 @@ testArrayDensityChange.expected = 404;
 test(testArrayDensityChange);
 
 function testDoubleToStr() {
-    var x = 0.0;
-    var y = 5.5;
-    for (var i = 0; i < 200; i++) {
-       x += parseFloat(y.toString());
-    }
-    return x;
+  var x = 0.0;
+  var y = 5.5;
+  for (var i = 0; i < 200; i++) {
+    x += parseFloat(y.toString());
+  }
+  return x;
 }
 testDoubleToStr.expected = 5.5*200;
 test(testDoubleToStr);
 
 function testNumberToString() {
-    var x = new Number(0);
-    for (var i = 0; i < 4; i++)
-        x.toString();
+  var x = new Number(0);
+  for (var i = 0; i < 4; i++)
+    x.toString();
 }
 test(testNumberToString);
 
 function testDecayingInnerLoop() {
-    var i, j, k = 10;
-    for (i = 0; i < 5000; ++i) {
-        for (j = 0; j < k; ++j);
-            --k;
-    }
-    return i;
+  var i, j, k = 10;
+  for (i = 0; i < 5000; ++i) {
+    for (j = 0; j < k; ++j);
+    --k;
+  }
+  return i;
 }
 testDecayingInnerLoop.expected = 5000;
 test(testDecayingInnerLoop);
 
 function testContinue() {
-    var i;
-    var total = 0;
-    for (i = 0; i < 20; ++i) {
-        if (i == 11)
-            continue;
-        total++;
-    }
-    return total;
+  var i;
+  var total = 0;
+  for (i = 0; i < 20; ++i) {
+    if (i == 11)
+	    continue;
+    total++;
+  }
+  return total;
 }
 testContinue.expected = 19;
 test(testContinue);
 
 function testContinueWithLabel() {
-    var i = 0;
-    var j = 20;
-    checkiandj :
-    while (i < 10) {
-        i += 1;
-        checkj :
-        while (j > 10) {
-            j -= 1;
-            if ((j % 2) == 0)
-            continue checkj;
-        }
+  var i = 0;
+  var j = 20;
+checkiandj :
+  while (i<10) {
+    i+=1;
+	checkj :
+    while (j>10) {
+	    j-=1;
+	    if ((j%2)==0)
+        continue checkj;
     }
-    return i + j;
+  }
+  return i + j;
 }
 testContinueWithLabel.expected = 20;
 test(testContinueWithLabel);
 
 function testDivision() {
-    var a = 32768;
-    var b;
-    while (b !== 1) {
-        b = a / 2;
-        a = b;
-    }
-    return a;
+  var a = 32768;
+  var b;
+  while (b !== 1) {
+    b = a / 2;
+    a = b;
+  }
+  return a;
 }
 testDivision.expected = 1;
 test(testDivision);
 
 function testDivisionFloat() {
-    var a = 32768.0;
-    var b;
-    while (b !== 1) {
-        b = a / 2.0;
-        a = b;
-    }
-    return a === 1.0;
+  var a = 32768.0;
+  var b;
+  while (b !== 1) {
+    b = a / 2.0;
+    a = b;
+  }
+  return a === 1.0;
 }
 testDivisionFloat.expected = true;
 test(testDivisionFloat);
 
 function testToUpperToLower() {
-    var s = "Hello", s1, s2;
-    for (i = 0; i < 100; ++i) {
-        s1 = s.toLowerCase();
-        s2 = s.toUpperCase();
-    }
-    return s1 + s2;
+  var s = "Hello", s1, s2;
+  for (i = 0; i < 100; ++i) {
+    s1 = s.toLowerCase();
+    s2 = s.toUpperCase();
+  }
+  return s1 + s2;
 }
 testToUpperToLower.expected = "helloHELLO";
 test(testToUpperToLower);
 
 function testReplace2() {
-    var s = "H e l l o", s1;
-    for (i = 0; i < 100; ++i)
-        s1 = s.replace(" ", "");
-    return s1;
+  var s = "H e l l o", s1;
+  for (i = 0; i < 100; ++i)
+    s1 = s.replace(" ", "");
+  return s1;
 }
 testReplace2.expected = "He l l o";
 test(testReplace2);
 
 function testBitwise() {
-    var x = 10000;
-    var y = 123456;
-    var z = 987234;
-    for (var i = 0; i < 50; i++) {
-        x = x ^ y;
-        y = y | z;
-        z = ~x;
-    }
-    return x + y + z;
+  var x = 10000;
+  var y = 123456;
+  var z = 987234;
+  for (var i = 0; i < 50; i++) {
+    x = x ^ y;
+    y = y | z;
+    z = ~x;
+  }
+  return x + y + z;
 }
 testBitwise.expected = -1298;
 test(testBitwise);
 
 function testSwitch() {
-    var x = 0;
-    var ret = 0;
-    for (var i = 0; i < 100; ++i) {
-        switch (x) {
-            case 0:
-                ret += 1;
-                break;
-            case 1:
-                ret += 2;
-                break;
-            case 2:
-                ret += 3;
-                break;
-            case 3:
-                ret += 4;
-                break;
-            default:
-                x = 0;
-        }
-        x++;
+  var x = 0;
+  var ret = 0;
+  for (var i = 0; i < 100; ++i) {
+    switch (x) {
+    case 0:
+      ret += 1;
+      break;
+    case 1:
+      ret += 2;
+      break;
+    case 2:
+      ret += 3;
+      break;
+    case 3:
+      ret += 4;
+      break;
+    default:
+      x = 0;
     }
-    return ret;
+    x++;
+  }
+  return ret;
 }
 testSwitch.expected = 226;
 test(testSwitch);
 
 function testSwitchString() {
-    var x = "asdf";
-    var ret = 0;
-    for (var i = 0; i < 100; ++i) {
-        switch (x) {
-        case "asdf":
-            x = "asd";
-            ret += 1;
-            break;
-        case "asd":
-            x = "as";
-            ret += 2;
-            break;
-        case "as":
-            x = "a";
-            ret += 3;
-            break;
-        case "a":
-            x = "foo";
-            ret += 4;
-            break;
-        default:
-            x = "asdf";
-        }
+  var x = "asdf";
+  var ret = 0;
+  for (var i = 0; i < 100; ++i) {
+    switch (x) {
+    case "asdf":
+      x = "asd";
+      ret += 1;
+      break;
+    case "asd":
+      x = "as";
+      ret += 2;
+      break;
+    case "as":
+      x = "a";
+      ret += 3;
+      break;
+    case "a":
+      x = "foo";
+      ret += 4;
+      break;
+    default:
+      x = "asdf";
     }
-    return ret;
+  }
+  return ret;
 }
 testSwitchString.expected = 200;
 test(testSwitchString);
 
 function testNegZero1Helper(z) {
-    for (let j = 0; j < 5; ++j) { z = -z; }
-    return Math.atan2(0, -0) == Math.atan2(0, z);
+  for (let j = 0; j < 5; ++j) { z = -z; }
+  return Math.atan2(0, -0) == Math.atan2(0, z);
 }
 
 var testNegZero1 = function() { return testNegZero1Helper(0); }
-testNegZero1.expected = true;
+  testNegZero1.expected = true;
 testNegZero1.name = 'testNegZero1';
 testNegZero1Helper(1);
 test(testNegZero1);
 
 // No test case, just make sure this doesn't assert.
 function testNegZero2() {
-    var z = 0;
-    for (let j = 0; j < 5; ++j) { ({p: (-z)}); }
+  var z = 0;
+  for (let j = 0; j < 5; ++j) { ({p: (-z)}); }
 }
 testNegZero2();
 
 function testConstSwitch() {
-    var x;
-    for (var j=0;j<5;++j) { switch(1.1) { case NaN: case 2: } x = 2; }
-    return x;
+  var x;
+  for (var j=0;j<5;++j) { switch(1.1) { case NaN: case 2: } x = 2; }
+  return x;
 }
 testConstSwitch.expected = 2;
 test(testConstSwitch);
 
 function testConstSwitch2() {
-    var x;
-    for (var j = 0; j < 4; ++j) { switch(0/0) { } }
-    return "ok";
+  var x;
+  for (var j = 0; j < 4; ++j) { switch(0/0) { } }
+  return "ok";
 }
 testConstSwitch2.expected = "ok";
 test(testConstSwitch2);
 
 function testConstIf() {
-    var x;
-    for (var j=0;j<5;++j) { if (1.1 || 5) { } x = 2;}
-    return x;
+  var x;
+  for (var j=0;j<5;++j) { if (1.1 || 5) { } x = 2;}
+  return x;
 }
 testConstIf.expected = 2;
 test(testConstIf);
@@ -1381,7 +1498,7 @@ function testTypeofHole() {
   return a.join(",");
 }
 testTypeofHole.expected = "undefined,undefined,undefined,undefined,undefined,number"
-test(testTypeofHole);
+  test(testTypeofHole);
 
 function testNativeLog() {
   var a = new Array(5);
@@ -1394,206 +1511,206 @@ testNativeLog.expected = "10,10,10,10,10";
 test(testNativeLog);
 
 function test_JSOP_ARGSUB() {
-    function f0() { return arguments[0]; }
-    function f1() { return arguments[1]; }
-    function f2() { return arguments[2]; }
-    function f3() { return arguments[3]; }
-    function f4() { return arguments[4]; }
-    function f5() { return arguments[5]; }
-    function f6() { return arguments[6]; }
-    function f7() { return arguments[7]; }
-    function f8() { return arguments[8]; }
-    function f9() { return arguments[9]; }
-    var a = [];
-    for (var i = 0; i < 10; i++) {
-        a[0] = f0('a');
-        a[1] = f1('a','b');
-        a[2] = f2('a','b','c');
-        a[3] = f3('a','b','c','d');
-        a[4] = f4('a','b','c','d','e');
-        a[5] = f5('a','b','c','d','e','f');
-        a[6] = f6('a','b','c','d','e','f','g');
-        a[7] = f7('a','b','c','d','e','f','g','h');
-        a[8] = f8('a','b','c','d','e','f','g','h','i');
-        a[9] = f9('a','b','c','d','e','f','g','h','i','j');
-    }
-    return a.join("");
+  function f0() { return arguments[0]; }
+  function f1() { return arguments[1]; }
+  function f2() { return arguments[2]; }
+  function f3() { return arguments[3]; }
+  function f4() { return arguments[4]; }
+  function f5() { return arguments[5]; }
+  function f6() { return arguments[6]; }
+  function f7() { return arguments[7]; }
+  function f8() { return arguments[8]; }
+  function f9() { return arguments[9]; }
+  var a = [];
+  for (var i = 0; i < 10; i++) {
+    a[0] = f0('a');
+    a[1] = f1('a','b');
+    a[2] = f2('a','b','c');
+    a[3] = f3('a','b','c','d');
+    a[4] = f4('a','b','c','d','e');
+    a[5] = f5('a','b','c','d','e','f');
+    a[6] = f6('a','b','c','d','e','f','g');
+    a[7] = f7('a','b','c','d','e','f','g','h');
+    a[8] = f8('a','b','c','d','e','f','g','h','i');
+    a[9] = f9('a','b','c','d','e','f','g','h','i','j');
+  }
+  return a.join("");
 }
 test_JSOP_ARGSUB.expected = "abcdefghij";
 test(test_JSOP_ARGSUB);
 
 function test_JSOP_ARGCNT() {
-    function f0() { return arguments.length; }
-    function f1() { return arguments.length; }
-    function f2() { return arguments.length; }
-    function f3() { return arguments.length; }
-    function f4() { return arguments.length; }
-    function f5() { return arguments.length; }
-    function f6() { return arguments.length; }
-    function f7() { return arguments.length; }
-    function f8() { return arguments.length; }
-    function f9() { return arguments.length; }
-    var a = [];
-    for (var i = 0; i < 10; i++) {
-        a[0] = f0('a');
-        a[1] = f1('a','b');
-        a[2] = f2('a','b','c');
-        a[3] = f3('a','b','c','d');
-        a[4] = f4('a','b','c','d','e');
-        a[5] = f5('a','b','c','d','e','f');
-        a[6] = f6('a','b','c','d','e','f','g');
-        a[7] = f7('a','b','c','d','e','f','g','h');
-        a[8] = f8('a','b','c','d','e','f','g','h','i');
-        a[9] = f9('a','b','c','d','e','f','g','h','i','j');
-    }
-    return a.join(",");
+  function f0() { return arguments.length; }
+  function f1() { return arguments.length; }
+  function f2() { return arguments.length; }
+  function f3() { return arguments.length; }
+  function f4() { return arguments.length; }
+  function f5() { return arguments.length; }
+  function f6() { return arguments.length; }
+  function f7() { return arguments.length; }
+  function f8() { return arguments.length; }
+  function f9() { return arguments.length; }
+  var a = [];
+  for (var i = 0; i < 10; i++) {
+    a[0] = f0('a');
+    a[1] = f1('a','b');
+    a[2] = f2('a','b','c');
+    a[3] = f3('a','b','c','d');
+    a[4] = f4('a','b','c','d','e');
+    a[5] = f5('a','b','c','d','e','f');
+    a[6] = f6('a','b','c','d','e','f','g');
+    a[7] = f7('a','b','c','d','e','f','g','h');
+    a[8] = f8('a','b','c','d','e','f','g','h','i');
+    a[9] = f9('a','b','c','d','e','f','g','h','i','j');
+  }
+  return a.join(",");
 }
 test_JSOP_ARGCNT.expected = "1,2,3,4,5,6,7,8,9,10";
 test(test_JSOP_ARGCNT);
 
 function testNativeMax() {
-    var out = [], k;
-    for (var i = 0; i < 5; ++i) {
-        k = Math.max(k, i);
-    }
-    out.push(k);
+  var out = [], k;
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(k, i);
+  }
+  out.push(k);
 
-    k = 0;
-    for (var i = 0; i < 5; ++i) {
-        k = Math.max(k, i);
-    }
-    out.push(k);
+  k = 0;
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(k, i);
+  }
+  out.push(k);
 
-    for (var i = 0; i < 5; ++i) {
-        k = Math.max(0, -0);
-    }
-    out.push((1 / k) < 0);
-    return out.join(",");
+  for (var i = 0; i < 5; ++i) {
+    k = Math.max(0, -0);
+  }
+  out.push((1 / k) < 0);
+  return out.join(",");
 }
 testNativeMax.expected = "NaN,4,false";
 test(testNativeMax);
 
 function testFloatArrayIndex() {
-    var a = [];
-    for (var i = 0; i < 10; ++i) {
-        a[3] = 5;
-        a[3.5] = 7;
-    }
-    return a[3] + "," + a[3.5];
+  var a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[3] = 5;
+    a[3.5] = 7;
+  }
+  return a[3] + "," + a[3.5];
 }
 testFloatArrayIndex.expected = "5,7";
 test(testFloatArrayIndex);
 
 function testStrict() {
-    var n = 10, a = [];
-    for (var i = 0; i < 10; ++i) {
-        a[0] = (n === 10);
-        a[1] = (n !== 10);
-        a[2] = (n === null);
-        a[3] = (n == null);
-    }
-    return a.join(",");
+  var n = 10, a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[0] = (n === 10);
+    a[1] = (n !== 10);
+    a[2] = (n === null);
+    a[3] = (n == null);
+  }
+  return a.join(",");
 }
 testStrict.expected = "true,false,false,false";
 test(testStrict);
 
 function testSetPropNeitherMissNorHit() {
-    for (var j = 0; j < 5; ++j) { if (({}).__proto__ = 1) { } }
-    return "ok";
+  for (var j = 0; j < 5; ++j) { if (({}).__proto__ = 1) { } }
+  return "ok";
 }
 testSetPropNeitherMissNorHit.expected = "ok";
 test(testSetPropNeitherMissNorHit);
 
 function testPrimitiveConstructorPrototype() {
-    var f = function(){};
-    f.prototype = false;
-    for (let j=0;j<5;++j) { new f; }
-    return "ok";
+  var f = function(){};
+  f.prototype = false;
+  for (let j=0;j<5;++j) { new f; }
+  return "ok";
 }
 testPrimitiveConstructorPrototype.expected = "ok";
 test(testPrimitiveConstructorPrototype);
 
 function testSideExitInConstructor() {
-    var FCKConfig = {};
-    FCKConfig.CoreStyles =
+  var FCKConfig = {};
+  FCKConfig.CoreStyles =
     {
-        'Bold': { },
-        'Italic': { },
-        'FontFace': { },
-        'Size' :
-        {
-        Overrides: [ ]
-        },
+	    'Bold': { },
+	    'Italic': { },
+	    'FontFace': { },
+	    'Size' :
+	    {
+      Overrides: [ ]
+	    },
+
+	    'Color' :
+	    {
+      Element: '',
+      Styles: {  },
+      Overrides: [  ]
+	    },
+	    'BackColor': {
+      Element : '',
+      Styles : { 'background-color' : '' }
+	    },
 
-        'Color' :
-        {
-        Element: '',
-        Styles: {  },
-        Overrides: [  ]
-        },
-        'BackColor': {
-        Element : '',
-        Styles : { 'background-color' : '' }
-        },
-
-    };
-    var FCKStyle = function(A) {
-        A.Element;
     };
+  var FCKStyle = function(A) {
+    A.Element;
+  };
 
-    var pass = true;
-    for (var s in FCKConfig.CoreStyles) {
-        var x = new FCKStyle(FCKConfig.CoreStyles[s]);
-        if (!x)
-            pass = false;
-    }
-    return pass;
+  var pass = true;
+  for (var s in FCKConfig.CoreStyles) {
+    var x = new FCKStyle(FCKConfig.CoreStyles[s]);
+    if (!x)
+      pass = false;
+  }
+  return pass;
 }
 testSideExitInConstructor.expected = true;
 test(testSideExitInConstructor);
 
 function testNot() {
-    var a = new Object(), b = null, c = "foo", d = "", e = 5, f = 0, g = 5.5, h = -0, i = true, j = false, k = undefined;
-    var r;
-    for (var i = 0; i < 10; ++i)
-        r = [!a, !b, !c, !d, !e, !f, !g, !h, !i, !j, !k];
-    return r.join(",");
+  var a = new Object(), b = null, c = "foo", d = "", e = 5, f = 0, g = 5.5, h = -0, i = true, j = false, k = undefined;
+  var r;
+  for (var i = 0; i < 10; ++i)
+    r = [!a, !b, !c, !d, !e, !f, !g, !h, !i, !j, !k];
+  return r.join(",");
 }
 testNot.expected = "false,true,false,true,false,true,false,true,false,true,true";
 test(testNot);
 
 function doTestDifferingArgc(a, b)
 {
-    var k = 0;
-    for (var i = 0; i < 10; i++)
-    {
-        k += i;
-    }
-    return k;
+  var k = 0;
+  for (var i = 0; i < 10; i++)
+  {
+    k += i;
+  }
+  return k;
 }
 function testDifferingArgc()
 {
-    var x = 0;
-    x += doTestDifferingArgc(1, 2);
-    x += doTestDifferingArgc(1);
-    x += doTestDifferingArgc(1, 2, 3);
-    return x;
+  var x = 0;
+  x += doTestDifferingArgc(1, 2);
+  x += doTestDifferingArgc(1);
+  x += doTestDifferingArgc(1, 2, 3);
+  return x;
 }
 testDifferingArgc.expected = 45*3;
 test(testDifferingArgc);
 
 function doTestMoreArgcThanNargs()
 {
-    var x = 0;
-    for (var i = 0; i < 10; i++)
-    {
-        x = x + arguments[3];
-    }
-    return x;
+  var x = 0;
+  for (var i = 0; i < 10; i++)
+  {
+    x = x + arguments[3];
+  }
+  return x;
 }
 function testMoreArgcThanNargs()
 {
-    return doTestMoreArgcThanNargs(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+  return doTestMoreArgcThanNargs(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
 }
 testMoreArgcThanNargs.expected = 4*10;
 test(testMoreArgcThanNargs);
@@ -1630,372 +1747,372 @@ testNestedExitStackOuter.expected = 81;
 test(testNestedExitStackOuter);
 
 function testHOTLOOPSize() {
-    return HOTLOOP > 1;
+  return HOTLOOP > 1;
 }
 testHOTLOOPSize.expected = true;
 test(testHOTLOOPSize);
 
 function testMatchStringObject() {
-    var a = new String("foo");
-    var b;
-    for (i = 0; i < 300; i++)
-        b = a.match(/bar/);
-    return b;
+  var a = new String("foo");
+  var b;
+  for (i = 0; i < 300; i++)
+    b = a.match(/bar/);
+  return b;
 }
 testMatchStringObject.expected = null;
 test(testMatchStringObject);
 
 function innerSwitch(k)
 {
-    var m = 0;
+  var m = 0;
 
-    switch (k)
-    {
-    case 0:
-        m = 1;
-        break;
-    }
+  switch (k)
+  {
+  case 0:
+    m = 1;
+    break;
+  }
 
-    return m;
+  return m;
 }
 function testInnerSwitchBreak()
 {
-    var r = new Array(5);
-    for (var i = 0; i < 5; i++)
-    {
-        r[i] = innerSwitch(0);
-    }
+  var r = new Array(5);
+  for (var i = 0; i < 5; i++)
+  {
+    r[i] = innerSwitch(0);
+  }
 
-    return r.join(",");
+  return r.join(",");
 }
 testInnerSwitchBreak.expected = "1,1,1,1,1";
 test(testInnerSwitchBreak);
 
 function testArrayNaNIndex()
 {
-    for (var j = 0; j < 4; ++j) { [this[NaN]]; }
-    for (var j = 0; j < 5; ++j) { if([1][-0]) { } }
-    return "ok";
+  for (var j = 0; j < 4; ++j) { [this[NaN]]; }
+  for (var j = 0; j < 5; ++j) { if([1][-0]) { } }
+  return "ok";
 }
 testArrayNaNIndex.expected = "ok";
 test(testArrayNaNIndex);
 
 function innerTestInnerMissingArgs(a,b,c,d)
 {
-        if (a) {
-        } else {
-        }
+  if (a) {
+  } else {
+  }
 }
 function doTestInnerMissingArgs(k)
 {
-    for (i = 0; i < 10; i++) {
-        innerTestInnerMissingArgs(k);
-    }
+  for (i = 0; i < 10; i++) {
+    innerTestInnerMissingArgs(k);
+  }
 }
 function testInnerMissingArgs()
 {
-    doTestInnerMissingArgs(1);
-    doTestInnerMissingArgs(0);
-    return 1;
+  doTestInnerMissingArgs(1);
+  doTestInnerMissingArgs(0);
+  return 1;
 }
 testInnerMissingArgs.expected = 1;  //Expected: that we don't crash.
 test(testInnerMissingArgs);
 
 function regexpLastIndex()
 {
-    var n = 0;
-    var re = /hi/g;
-    var ss = " hi hi hi hi hi hi hi hi hi hi";
-    for (var i = 0; i < 10; i++) {
-        // re.exec(ss);
-        n += (re.lastIndex > 0) ? 3 : 0;
-        re.lastIndex = 0;
-    }
-    return n;
+  var n = 0;
+  var re = /hi/g;
+  var ss = " hi hi hi hi hi hi hi hi hi hi";
+  for (var i = 0; i < 10; i++) {
+    // re.exec(ss);
+    n += (re.lastIndex > 0) ? 3 : 0;
+    re.lastIndex = 0;
+  }
+  return n;
 }
 regexpLastIndex.expected = 0; // 30;
 test(regexpLastIndex);
 
 function testHOTLOOPCorrectness() {
-    var b = 0;
-    for (var i = 0; i < HOTLOOP; ++i)
-        ++b;
-    return b;
+  var b = 0;
+  for (var i = 0; i < HOTLOOP; ++i)
+    ++b;
+  return b;
 }
 testHOTLOOPCorrectness.expected = HOTLOOP;
 testHOTLOOPCorrectness.jitstats = {
-    recorderStarted: 1,
-    recorderAborted: 0,
-    traceTriggered: 0
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 0
 };
 // Change the global shape right before doing the test
 this.testHOTLOOPCorrectnessVar = 1;
 test(testHOTLOOPCorrectness);
 
 function testRUNLOOPCorrectness() {
-    var b = 0;
-    for (var i = 0; i < RUNLOOP; ++i) {
+  var b = 0;
+  for (var i = 0; i < RUNLOOP; ++i) {
     ++b;
-    }
-    return b;
+  }
+  return b;
 }
 testRUNLOOPCorrectness.expected = RUNLOOP;
 testRUNLOOPCorrectness.jitstats = {
-    recorderStarted: 1,
-    recorderAborted: 0,
-    traceTriggered: 1
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
 };
 // Change the global shape right before doing the test
 this.testRUNLOOPCorrectnessVar = 1;
 test(testRUNLOOPCorrectness);
 
 function testDateNow() {
-    // Accessing global.Date for the first time will change the global shape,
-    // so do it before the loop starts; otherwise we have to loop an extra time
-    // to pick things up.
-    var time = Date.now();
-    for (var j = 0; j < RUNLOOP; ++j)
-        time = Date.now();
-    return "ok";
+  // Accessing global.Date for the first time will change the global shape,
+  // so do it before the loop starts; otherwise we have to loop an extra time
+  // to pick things up.
+  var time = Date.now();
+  for (var j = 0; j < RUNLOOP; ++j)
+    time = Date.now();
+  return "ok";
 }
 testDateNow.expected = "ok";
 testDateNow.jitstats = {
-    recorderStarted: 1,
-    recorderAborted: 0,
-    traceTriggered: 1
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
 };
 test(testDateNow);
 
 function testINITELEM()
 {
-    var x;
-    for (var i = 0; i < 10; ++i)
-        x = { 0: 5, 1: 5 };
-    return x[0] + x[1];
+  var x;
+  for (var i = 0; i < 10; ++i)
+    x = { 0: 5, 1: 5 };
+  return x[0] + x[1];
 }
 testINITELEM.expected = 10;
 test(testINITELEM);
 
 function testUndefinedBooleanCmp()
 {
-    var t = true, f = false, x = [];
-    for (var i = 0; i < 10; ++i) {
-        x[0] = t == undefined;
-        x[1] = t != undefined;
-        x[2] = t === undefined;
-        x[3] = t !== undefined;
-        x[4] = t < undefined;
-        x[5] = t > undefined;
-        x[6] = t <= undefined;
-        x[7] = t >= undefined;
-        x[8] = f == undefined;
-        x[9] = f != undefined;
-        x[10] = f === undefined;
-        x[11] = f !== undefined;
-        x[12] = f < undefined;
-        x[13] = f > undefined;
-        x[14] = f <= undefined;
-        x[15] = f >= undefined;
-    }
-    return x.join(",");
+  var t = true, f = false, x = [];
+  for (var i = 0; i < 10; ++i) {
+    x[0] = t == undefined;
+    x[1] = t != undefined;
+    x[2] = t === undefined;
+    x[3] = t !== undefined;
+    x[4] = t < undefined;
+    x[5] = t > undefined;
+    x[6] = t <= undefined;
+    x[7] = t >= undefined;
+    x[8] = f == undefined;
+    x[9] = f != undefined;
+    x[10] = f === undefined;
+    x[11] = f !== undefined;
+    x[12] = f < undefined;
+    x[13] = f > undefined;
+    x[14] = f <= undefined;
+    x[15] = f >= undefined;
+  }
+  return x.join(",");
 }
 testUndefinedBooleanCmp.expected = "false,true,false,true,false,false,false,false,false,true,false,true,false,false,false,false";
 test(testUndefinedBooleanCmp);
 
 function testConstantBooleanExpr()
 {
-    for (var j = 0; j < 3; ++j) { if(true <= true) { } }
-    return "ok";
+  for (var j = 0; j < 3; ++j) { if(true <= true) { } }
+  return "ok";
 }
 testConstantBooleanExpr.expected = "ok";
 test(testConstantBooleanExpr);
 
 function testNegativeGETELEMIndex()
 {
-    for (let i=0;i<3;++i) /x/[-4];
-    return "ok";
+  for (let i=0;i<3;++i) /x/[-4];
+  return "ok";
 }
 testNegativeGETELEMIndex.expected = "ok";
 test(testNegativeGETELEMIndex);
 
 function doTestInvalidCharCodeAt(input)
 {
-    var q = "";
-    for (var i = 0; i < 10; i++)
-       q += input.charCodeAt(i);
-    return q;
+  var q = "";
+  for (var i = 0; i < 10; i++)
+    q += input.charCodeAt(i);
+  return q;
 }
 function testInvalidCharCodeAt()
 {
-    return doTestInvalidCharCodeAt("");
+  return doTestInvalidCharCodeAt("");
 }
 testInvalidCharCodeAt.expected = "NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN";
 test(testInvalidCharCodeAt);
 
 function FPQuadCmp()
 {
-    for (let j = 0; j < 3; ++j) { true == 0; }
-    return "ok";
+  for (let j = 0; j < 3; ++j) { true == 0; }
+  return "ok";
 }
 FPQuadCmp.expected = "ok";
 test(FPQuadCmp);
 
 function testDestructuring() {
-    var t = 0;
-    for (var i = 0; i < HOTLOOP + 1; ++i) {
-        var [r, g, b] = [1, 1, 1];
-        t += r + g + b;
+  var t = 0;
+  for (var i = 0; i < HOTLOOP + 1; ++i) {
+    var [r, g, b] = [1, 1, 1];
+    t += r + g + b;
+  }
+  return t
     }
-    return t
-}
 testDestructuring.expected = (HOTLOOP + 1) * 3;
 test(testDestructuring);
 
 function loopWithUndefined1(t, val) {
-    var a = new Array(6);
-    for (var i = 0; i < 6; i++)
-        a[i] = (t > val);
-    return a;
+  var a = new Array(6);
+  for (var i = 0; i < 6; i++)
+    a[i] = (t > val);
+  return a;
 }
 loopWithUndefined1(5.0, 2);     //compile version with val=int
 
 function testLoopWithUndefined1() {
-    return loopWithUndefined1(5.0).join(",");  //val=undefined
+  return loopWithUndefined1(5.0).join(",");  //val=undefined
 };
 testLoopWithUndefined1.expected = "false,false,false,false,false,false";
 test(testLoopWithUndefined1);
 
 function loopWithUndefined2(t, dostuff, val) {
-    var a = new Array(6);
-    for (var i = 0; i < 6; i++) {
-        if (dostuff) {
-            val = 1;
-            a[i] = (t > val);
-        } else {
-            a[i] = (val == undefined);
-        }
+  var a = new Array(6);
+  for (var i = 0; i < 6; i++) {
+    if (dostuff) {
+      val = 1; 
+      a[i] = (t > val);
+    } else {
+      a[i] = (val == undefined);
     }
-    return a;
+  }
+  return a;
 }
 function testLoopWithUndefined2() {
-    var a = loopWithUndefined2(5.0, true, 2);
-    var b = loopWithUndefined2(5.0, true);
-    var c = loopWithUndefined2(5.0, false, 8);
-    var d = loopWithUndefined2(5.0, false);
-    return [a[0], b[0], c[0], d[0]].join(",");
+  var a = loopWithUndefined2(5.0, true, 2);
+  var b = loopWithUndefined2(5.0, true);
+  var c = loopWithUndefined2(5.0, false, 8);
+  var d = loopWithUndefined2(5.0, false);
+  return [a[0], b[0], c[0], d[0]].join(",");
 }
 testLoopWithUndefined2.expected = "true,true,false,true";
 test(testLoopWithUndefined2);
 
 //test no multitrees assert
 function testBug462388() {
-    var c = 0, v; for each (let x in ["",v,v,v]) { for (c=0;c<4;++c) { } }
-    return true;
+  var c = 0, v; for each (let x in ["",v,v,v]) { for (c=0;c<4;++c) { } }
+  return true;
 }
 testBug462388.expected = true;
 test(testBug462388);
 
 //test no multitrees assert
 function testBug462407() {
-    for each (let i in [0, {}, 0, 1.5, {}, 0, 1.5, 0, 0]) { }
-    return true;
+  for each (let i in [0, {}, 0, 1.5, {}, 0, 1.5, 0, 0]) { }
+  return true;
 }
 testBug462407.expected = true;
 test(testBug462407);
 
 //test no multitrees assert
 function testBug463490() {
-    function f(a, b, d) {
-        for (var i = 0; i < 10; i++) {
-            if (d)
-                b /= 2;
-        }
-        return a + b;
+  function f(a, b, d) {
+    for (var i = 0; i < 10; i++) {
+      if (d)
+        b /= 2;
     }
-    //integer stable loop
-    f(2, 2, false);
-    //double stable loop
-    f(3, 4.5, false);
-    //integer unstable branch
-    f(2, 2, true);
-    return true;
+    return a + b;
+  }
+  //integer stable loop
+  f(2, 2, false);
+  //double stable loop
+  f(3, 4.5, false);
+  //integer unstable branch
+  f(2, 2, true);
+  return true;
 };
 testBug463490.expected = true;
 test(testBug463490);
 
 // Test no assert (bug 464089)
 function shortRecursiveLoop(b, c) {
-    for (var i = 0; i < c; i++) {
-        if (b)
-            shortRecursiveLoop(c - 1);
-    }
+  for (var i = 0; i < c; i++) {
+    if (b)
+      shortRecursiveLoop(c - 1);
+  }
 }
 function testClosingRecursion() {
-    shortRecursiveLoop(false, 1);
-    shortRecursiveLoop(true, 3);
-    return true;
+  shortRecursiveLoop(false, 1);
+  shortRecursiveLoop(true, 3);
+  return true;
 }
 testClosingRecursion.expected = true;
 test(testClosingRecursion);
 
 // Test no assert or crash from outer recorders (bug 465145)
 function testBug465145() {
-    this.__defineSetter__("x", function(){});
-    this.watch("x", function(){});
-    y = this;
-    for (var z = 0; z < 2; ++z) { x = y };
-    this.__defineSetter__("x", function(){});
-    for (var z = 0; z < 2; ++z) { x = y };
+	this.__defineSetter__("x", function(){});
+	this.watch("x", function(){});
+	y = this;
+	for (var z = 0; z < 2; ++z) { x = y };
+	this.__defineSetter__("x", function(){});
+	for (var z = 0; z < 2; ++z) { x = y };
 }
 
 function testTrueShiftTrue() {
-    var a = new Array(5);
-    for (var i=0;i<5;++i) a[i] = "" + (true << true);
-    return a.join(",");
+  var a = new Array(5);
+  for (var i=0;i<5;++i) a[i] = "" + (true << true);
+  return a.join(",");
 }
 testTrueShiftTrue.expected = "2,2,2,2,2";
 test(testTrueShiftTrue);
 
 // Test no assert or crash
 function testBug465261() {
-    for (let z = 0; z < 2; ++z) { for each (let x in [0, true, (void 0), 0, (void
-    0)]) { if(x){} } };
-    return true;
+  for (let z = 0; z < 2; ++z) { for each (let x in [0, true, (void 0), 0, (void
+                                                                           0)]) { if(x){} } };
+  return true;
 }
 testBug465261.expected = true;
 test(testBug465261);
 
 function testBug465272() {
-    var a = new Array(5);
-    for (j=0;j<5;++j) a[j] = "" + ((5) - 2);
-    return a.join(",");
+  var a = new Array(5);
+  for (j=0;j<5;++j) a[j] = "" + ((5) - 2);
+  return a.join(",");
 }
 testBug465272.expected = "3,3,3,3,3"
-test(testBug465272);
+  test(testBug465272);
 
 function testBug465483() {
-    var a = new Array(4);
-    var c = 0;
-    for each (i in [4, 'a', 'b', (void 0)]) a[c++] = '' + (i + i);
-    return a.join(',');
+	var a = new Array(4);
+	var c = 0;
+	for each (i in [4, 'a', 'b', (void 0)]) a[c++] = '' + (i + i);
+	return a.join(',');
 }
 testBug465483.expected = '8,aa,bb,NaN';
 test(testBug465483);
 
 function testNullCallee() {
-    try {
-        function f() {
-            var x = new Array(5);
-            for (var i = 0; i < 5; i++)
-                x[i] = a[i].toString();
-            return x.join(',');
-        }
-        f([[1],[2],[3],[4],[5]]);
-        f([null, null, null, null, null]);
-    } catch (e) {
-        return true;
+  try {
+    function f() {
+      var x = new Array(5);
+      for (var i = 0; i < 5; i++)
+        x[i] = a[i].toString();
+      return x.join(',');
     }
-    return false;
+    f([[1],[2],[3],[4],[5]]);
+    f([null, null, null, null, null]);
+  } catch (e) {
+    return true;
+  }
+  return false;
 }
 testNullCallee.expected = true;
 test(testNullCallee);
@@ -2034,32 +2151,32 @@ test(testBug466262);
 
 function testNewDate()
 {
-    // Accessing global.Date for the first time will change the global shape,
-    // so do it before the loop starts; otherwise we have to loop an extra time
-    // to pick things up.
-    var start = new Date();
-    var time = new Date();
-    for (var j = 0; j < RUNLOOP; ++j)
-        time = new Date();
-    return time > 0 && time >= start;
+  // Accessing global.Date for the first time will change the global shape,
+  // so do it before the loop starts; otherwise we have to loop an extra time
+  // to pick things up.
+  var start = new Date();
+  var time = new Date();
+  for (var j = 0; j < RUNLOOP; ++j)
+    time = new Date();
+  return time > 0 && time >= start;
 }
 testNewDate.expected = true;
 testNewDate.jitstats = {
-    recorderStarted: 1,
-    recorderAborted: 0,
-    traceTriggered: 1
+recorderStarted: 1,
+recorderAborted: 0,
+traceTriggered: 1
 };
 test(testNewDate);
 
 function testArrayPushPop() {
-    var a = [], sum1 = 0, sum2 = 0;
-    for (var i = 0; i < 10; ++i)
-        sum1 += a.push(i);
-    for (var i = 0; i < 10; ++i)
-        sum2 += a.pop();
-    a.push(sum1);
-    a.push(sum2);
-    return a.join(",");
+  var a = [], sum1 = 0, sum2 = 0;
+  for (var i = 0; i < 10; ++i)
+    sum1 += a.push(i);
+  for (var i = 0; i < 10; ++i)
+    sum2 += a.pop();
+  a.push(sum1);
+  a.push(sum2);
+  return a.join(",");
 }
 testArrayPushPop.expected = "55,45";
 test(testArrayPushPop);
@@ -2143,89 +2260,89 @@ testSlowArrayPopNestedTrees.expected = 3.14159;
 test(testSlowArrayPopNestedTrees);
 
 function testResumeOp() {
-    var a = [1,"2",3,"4",5,"6",7,"8",9,"10",11,"12",13,"14",15,"16"];
-    var x = "";
-    while (a.length > 0)
-        x += a.pop();
-    return x;
+  var a = [1,"2",3,"4",5,"6",7,"8",9,"10",11,"12",13,"14",15,"16"];
+  var x = "";
+  while (a.length > 0)
+    x += a.pop();
+  return x;
 }
 testResumeOp.expected = "16151413121110987654321";
 test(testResumeOp);
 
 function testUndefinedCmp() {
-    var a = false;
-    for (var j = 0; j < 4; ++j) { if (undefined < false) { a = true; } }
-    return a;
+  var a = false;
+  for (var j = 0; j < 4; ++j) { if (undefined < false) { a = true; } }
+  return a;
 }
 testUndefinedCmp.expected = false;
 test(testUndefinedCmp);
 
 function reallyDeepNestedExit(schedule)
 {
-    var c = 0, j = 0;
-    for (var i = 0; i < 5; i++) {
-        for (j = 0; j < 4; j++) {
-            c += (schedule[i*4 + j] == 1) ? 1 : 2;
-        }
+  var c = 0, j = 0;
+  for (var i = 0; i < 5; i++) {
+    for (j = 0; j < 4; j++) {
+      c += (schedule[i*4 + j] == 1) ? 1 : 2;
     }
-    return c;
+  }
+  return c;
 }
 function testReallyDeepNestedExit()
 {
-    var c = 0;
-    var schedule1 = new Array(5*4);
-    var schedule2 = new Array(5*4);
-    for (var i = 0; i < 5*4; i++) {
-        schedule1[i] = 0;
-        schedule2[i] = 0;
-    }
-    /**
-     * First innermost compile: true branch runs through.
-     * Second '': false branch compiles new loop edge.
-     * First outer compile: expect true branch.
-     * Second '': hit false branch.
-     */
-    schedule1[0*4 + 3] = 1;
-    var schedules = [schedule1,
-                     schedule2,
-                     schedule1,
-                     schedule2,
-                     schedule2];
-
-    for (var i = 0; i < 5; i++) {
-        c += reallyDeepNestedExit(schedules[i]);
-    }
-    return c;
+  var c = 0;
+  var schedule1 = new Array(5*4);
+  var schedule2 = new Array(5*4);
+  for (var i = 0; i < 5*4; i++) {
+    schedule1[i] = 0;
+    schedule2[i] = 0;
+  }
+  /**
+   * First innermost compile: true branch runs through.
+   * Second '': false branch compiles new loop edge.
+   * First outer compile: expect true branch.
+   * Second '': hit false branch.
+   */
+  schedule1[0*4 + 3] = 1;
+  var schedules = [schedule1,
+                   schedule2,
+                   schedule1,
+                   schedule2,
+                   schedule2];
+
+  for (var i = 0; i < 5; i++) {
+    c += reallyDeepNestedExit(schedules[i]);
+  }
+  return c;
 }
 testReallyDeepNestedExit.expected = 198;
 test(testReallyDeepNestedExit);
 
 function testRegExpTest() {
-    var r = /abc/;
-    var flag = false;
-    for (var i = 0; i < 10; ++i)
-        flag = r.test("abc");
-    return flag;
+  var r = /abc/;
+  var flag = false;
+  for (var i = 0; i < 10; ++i)
+    flag = r.test("abc");
+  return flag;
 }
 testRegExpTest.expected = true;
 test(testRegExpTest);
 
 function testNumToString() {
-    var r = [];
-    var d = 123456789;
-    for (var i = 0; i < 10; ++i) {
-        r = [
-             d.toString(),
-             (-d).toString(),
-             d.toString(10),
-             (-d).toString(10),
-             d.toString(16),
-             (-d).toString(16),
-             d.toString(36),
-             (-d).toString(36)
-            ];
-    }
-    return r.join(",");
+  var r = [];
+  var d = 123456789;
+  for (var i = 0; i < 10; ++i) {
+    r = [
+      d.toString(),
+      (-d).toString(),
+      d.toString(10),
+      (-d).toString(10),
+      d.toString(16),
+      (-d).toString(16),
+      d.toString(36),
+      (-d).toString(36)
+      ];
+  }
+  return r.join(",");
 }
 testNumToString.expected = "123456789,-123456789,123456789,-123456789,75bcd15,-75bcd15,21i3v9,-21i3v9";
 test(testNumToString);
@@ -2240,145 +2357,145 @@ testLongNumToString.expected = '1000000000000000000000000000';
 test(testLongNumToString);
 
 function testSubstring() {
-    for (var i = 0; i < 5; ++i) {
-        actual = "".substring(5);
-    }
-    return actual;
+  for (var i = 0; i < 5; ++i) {
+    actual = "".substring(5);
+  }
+  return actual;
 }
 testSubstring.expected = "";
 test(testSubstring);
 
 function testForInLoopChangeIteratorType() {
-    for(y in [0,1,2]) y = NaN;
-    (function(){
-        [].__proto__.u = void 0;
-        for (let y in [5,6,7,8])
-            y = NaN;
-        delete [].__proto__.u;
-    })()
+  for(y in [0,1,2]) y = NaN;
+  (function(){
+    [].__proto__.u = void 0;
+    for (let y in [5,6,7,8])
+      y = NaN;
+    delete [].__proto__.u;
+  })()
     return "ok";
 }
 testForInLoopChangeIteratorType.expected = "ok";
 test(testForInLoopChangeIteratorType);
 
 function testGrowDenseArray() {
-    var a = new Array();
-    for (var i = 0; i < 10; ++i)
-        a[i] |= 5;
-    return a.join(",");
+  var a = new Array();
+  for (var i = 0; i < 10; ++i)
+    a[i] |= 5;
+  return a.join(",");
 }
 testGrowDenseArray.expected = "5,5,5,5,5,5,5,5,5,5";
 test(testGrowDenseArray);
 
 function testCallProtoMethod() {
-    function X() { this.x = 1; }
-    X.prototype.getName = function () { return "X"; }
+  function X() { this.x = 1; }
+  X.prototype.getName = function () { return "X"; }
 
-    function Y() { this.x = 2; }
-    Y.prototype.getName = function() "Y";
+  function Y() { this.x = 2; }
+  Y.prototype.getName = function() "Y";
 
-    var a = [new X, new X, new X, new X, new Y];
-    var s = '';
-    for (var i = 0; i < a.length; i++)
-        s += a[i].getName();
-    return s;
+  var a = [new X, new X, new X, new X, new Y];
+  var s = '';
+  for (var i = 0; i < a.length; i++)
+    s += a[i].getName();
+  return s;
 }
 testCallProtoMethod.expected = 'XXXXY';
 test(testCallProtoMethod);
 
 function testTypeUnstableForIn() {
-    var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
-    var x = 0;
-    for (var i in a) {
-        i = parseInt(i);
-        x++;
-    }
-    return x;
+  var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
+  var x = 0;
+  for (var i in a) {
+    i = parseInt(i);
+    x++;
+  }
+  return x;
 }
 testTypeUnstableForIn.expected = 16;
 test(testTypeUnstableForIn);
 
 function testAddUndefined() {
-    for (var j = 0; j < 3; ++j)
-        (0 + void 0) && 0;
+  for (var j = 0; j < 3; ++j)
+    (0 + void 0) && 0;
 }
 test(testAddUndefined);
 
 function testStringify() {
-    var t = true, f = false, u = undefined, n = 5, d = 5.5, s = "x";
-    var a = [];
-    for (var i = 0; i < 10; ++i) {
-        a[0] = "" + t;
-        a[1] = t + "";
-        a[2] = "" + f;
-        a[3] = f + "";
-        a[4] = "" + u;
-        a[5] = u + "";
-        a[6] = "" + n;
-        a[7] = n + "";
-        a[8] = "" + d;
-        a[9] = d + "";
-        a[10] = "" + s;
-        a[11] = s + "";
-    }
-    return a.join(",");
+  var t = true, f = false, u = undefined, n = 5, d = 5.5, s = "x";
+  var a = [];
+  for (var i = 0; i < 10; ++i) {
+    a[0] = "" + t;
+    a[1] = t + "";
+    a[2] = "" + f;
+    a[3] = f + "";
+    a[4] = "" + u;
+    a[5] = u + "";
+    a[6] = "" + n;
+    a[7] = n + "";
+    a[8] = "" + d;
+    a[9] = d + "";
+    a[10] = "" + s;
+    a[11] = s + "";
+  }
+  return a.join(",");
 }
 testStringify.expected = "true,true,false,false,undefined,undefined,5,5,5.5,5.5,x,x";
 test(testStringify);
 
 function testObjectToString() {
-    var o = {toString: function()"foo"};
-    var s = "";
-    for (var i = 0; i < 10; i++)
-        s += o;
-    return s;
+  var o = {toString: function()"foo"};
+  var s = "";
+  for (var i = 0; i < 10; i++)
+    s += o;
+  return s;
 }
 testObjectToString.expected = "foofoofoofoofoofoofoofoofoofoo";
 test(testObjectToString);
 
 function testObjectToNumber() {
-    var o = {valueOf: function()-3};
-    var x = 0;
-    for (var i = 0; i < 10; i++)
-        x -= o;
-    return x;
+  var o = {valueOf: function()-3};
+  var x = 0;
+  for (var i = 0; i < 10; i++)
+    x -= o;
+  return x;
 }
 testObjectToNumber.expected = 30;
 test(testObjectToNumber);
 
 function my_iterator_next() {
-    if (this.i == 10) {
-        this.i = 0;
-        throw this.StopIteration;
-    }
-    return this.i++;
+  if (this.i == 10) {
+    this.i = 0;
+    throw this.StopIteration;
+  }
+  return this.i++;
 }
-function testCustomIterator() {
-    var o = {
-        __iterator__: function () {
-            return {
-                i: 0,
-                next: my_iterator_next,
-                StopIteration: StopIteration
-            };
-        }
-    };
-    var a=[];
-    for (var k = 0; k < 100; k += 10) {
-        for(var j in o) {
-            a[k + (j >> 0)] = j*k;
-        }
+function testCustomIterator() {
+  var o = {
+  __iterator__: function () {
+      return {
+      i: 0,
+      next: my_iterator_next,
+      StopIteration: StopIteration
+      };
+    }
+  };
+  var a=[];
+  for (var k = 0; k < 100; k += 10) {
+    for(var j in o) {
+      a[k + (j >> 0)] = j*k;
     }
-    return a.join();
+  }
+  return a.join();
 }
 testCustomIterator.expected = "0,0,0,0,0,0,0,0,0,0,0,10,20,30,40,50,60,70,80,90,0,20,40,60,80,100,120,140,160,180,0,30,60,90,120,150,180,210,240,270,0,40,80,120,160,200,240,280,320,360,0,50,100,150,200,250,300,350,400,450,0,60,120,180,240,300,360,420,480,540,0,70,140,210,280,350,420,490,560,630,0,80,160,240,320,400,480,560,640,720,0,90,180,270,360,450,540,630,720,810";
 test(testCustomIterator);
 
 function bug464403() {
-    print(8);
-    var u = [print, print, function(){}]
+  print(8);
+  var u = [print, print, function(){}]
     for each (x in u) for (u.e in [1,1,1,1]);
-    return "ok";
+  return "ok";
 }
 bug464403.expected = "ok";
 test(bug464403);
@@ -2414,172 +2531,172 @@ testObjectOrderedCmp2.expected = "true,true,true,true,true";
 test(testObjectOrderedCmp2);
 
 function testLogicalNotNaN() {
-    var i = 0;
-    var a = new Array(5);
-    while (i < a.length)
-        a[i++] = !NaN;
-    return a.join();
+  var i = 0;
+  var a = new Array(5);
+  while (i < a.length)
+    a[i++] = !NaN;
+  return a.join();
 }
 testLogicalNotNaN.expected = "true,true,true,true,true";
 test(testLogicalNotNaN);
 
 function testStringToInt32() {
-    var s = "";
-    for (let j = 0; j < 5; ++j) s += ("1e+81" ^  3);
-    return s;
+  var s = "";
+  for (let j = 0; j < 5; ++j) s += ("1e+81" ^  3);
+  return s;
 }
 testStringToInt32.expected = "33333";
 test(testStringToInt32);
 
 function testIn() {
-    var array = [3];
-    var obj = { "-1": 5, "1.7": 3, "foo": 5, "1": 7 };
-    var a = [];
-    for (let j = 0; j < 5; ++j) {
-        a.push("0" in array);
-        a.push(-1 in obj);
-        a.push(1.7 in obj);
-        a.push("foo" in obj);
-        a.push(1 in obj);
-        a.push("1" in array);
-        a.push(-2 in obj);
-        a.push(2.7 in obj);
-        a.push("bar" in obj);
-        a.push(2 in obj);
-    }
-    return a.join(",");
+  var array = [3];
+  var obj = { "-1": 5, "1.7": 3, "foo": 5, "1": 7 };
+  var a = [];
+  for (let j = 0; j < 5; ++j) {
+    a.push("0" in array);
+    a.push(-1 in obj);
+    a.push(1.7 in obj);
+    a.push("foo" in obj);
+    a.push(1 in obj);
+    a.push("1" in array);  
+    a.push(-2 in obj);
+    a.push(2.7 in obj);
+    a.push("bar" in obj);
+    a.push(2 in obj);    
+  }
+  return a.join(",");
 }
 testIn.expected = "true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false,true,true,true,true,true,false,false,false,false,false";
 test(testIn);
 
 function testBranchCse() {
-    empty = [];
-    out = [];
-    for (var j=0;j<10;++j) { empty[42]; out.push((1 * (1)) | ""); }
-    return out.join(",");
+  empty = [];
+  out = [];
+  for (var j=0;j<10;++j) { empty[42]; out.push((1 * (1)) | ""); }
+  return out.join(",");
 }
 testBranchCse.expected = "1,1,1,1,1,1,1,1,1,1";
 test(testBranchCse);
 
 function testMulOverflow() {
-    var a = [];
-    for (let j=0;j<5;++j) a.push(0 | ((0x60000009) * 0x60000009));
-    return a.join(",");
+  var a = [];
+  for (let j=0;j<5;++j) a.push(0 | ((0x60000009) * 0x60000009));
+  return a.join(",");
 }
 testMulOverflow.expected = "-1073741824,-1073741824,-1073741824,-1073741824,-1073741824";
 test(testMulOverflow);
 
 function testThinLoopDemote() {
-    function f()
-    {
-        var k = 1;
-        for (var n = 0; n < 4; n++) {
-            k = (k * 10);
-        }
-        return k;
+  function f()
+  {
+    var k = 1;
+    for (var n = 0; n < 4; n++) {
+      k = (k * 10);
     }
-    f();
-    return f();
+    return k;
+  }
+  f();
+  return f();
 }
 testThinLoopDemote.expected = 10000;
 testThinLoopDemote.jitstats = {
-    recorderStarted: 2,
-    recorderAborted: 0,
-    traceCompleted: 2,
-    traceTriggered: 2,
-    unstableLoopVariable: 1
+recorderStarted: 2,
+recorderAborted: 0,
+traceCompleted: 2,
+traceTriggered: 2,
+unstableLoopVariable: 1
 };
 test(testThinLoopDemote);
 
 var global = this;
 function testWeirdDateParseOuter()
 {
-    var vDateParts = ["11", "17", "2008"];
-    var out = [];
-    for (var vI = 0; vI < vDateParts.length; vI++)
-        out.push(testWeirdDateParseInner(vDateParts[vI]));
-    /* Mutate the global shape so we fall off trace; this causes
-     * additional oddity */
-    global.x = Math.random();
-    return out;
-}
+  var vDateParts = ["11", "17", "2008"];
+  var out = [];
+  for (var vI = 0; vI < vDateParts.length; vI++)
+    out.push(testWeirdDateParseInner(vDateParts[vI]));
+  /* Mutate the global shape so we fall off trace; this causes
+   * additional oddity */
+  global.x = Math.random();
+  return out;
+} 
 function testWeirdDateParseInner(pVal)
 {
-    var vR = 0;
-    for (var vI = 0; vI < pVal.length; vI++) {
-        var vC = pVal.charAt(vI);
-        if ((vC >= '0') && (vC <= '9'))
-            vR = (vR * 10) + parseInt(vC);
-    }
-    return vR;
+  var vR = 0;
+  for (var vI = 0; vI < pVal.length; vI++) {
+    var vC = pVal.charAt(vI);
+    if ((vC >= '0') && (vC <= '9'))
+	    vR = (vR * 10) + parseInt(vC);
+  }
+  return vR;
 }
 function testWeirdDateParse() {
-    var result = [];
-    result.push(testWeirdDateParseInner("11"));
-    result.push(testWeirdDateParseInner("17"));
-    result.push(testWeirdDateParseInner("2008"));
-    result.push(testWeirdDateParseInner("11"));
-    result.push(testWeirdDateParseInner("17"));
-    result.push(testWeirdDateParseInner("2008"));
-    result = result.concat(testWeirdDateParseOuter());
-    result = result.concat(testWeirdDateParseOuter());
-    result.push(testWeirdDateParseInner("11"));
-    result.push(testWeirdDateParseInner("17"));
-    result.push(testWeirdDateParseInner("2008"));
-    return result.join(",");
+  var result = [];
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  result = result.concat(testWeirdDateParseOuter());
+  result = result.concat(testWeirdDateParseOuter());
+  result.push(testWeirdDateParseInner("11"));
+  result.push(testWeirdDateParseInner("17"));
+  result.push(testWeirdDateParseInner("2008"));
+  return result.join(",");
 }
 testWeirdDateParse.expected = "11,17,2008,11,17,2008,11,17,2008,11,17,2008,11,17,2008";
 testWeirdDateParse.jitstats = {
-    recorderStarted: 8,
-    recorderAborted: 1,
-    traceCompleted: 7,
-    traceTriggered: 14,
-    unstableLoopVariable: 3,
-    noCompatInnerTrees: 1
+recorderStarted: 8,
+recorderAborted: 1,
+traceCompleted: 7,
+traceTriggered: 14,
+unstableLoopVariable: 3,
+noCompatInnerTrees: 1
 };
 test(testWeirdDateParse);
 
 function testUndemotableBinaryOp() {
-    var out = [];
-    for (let j = 0; j < 5; ++j) { out.push(6 - ((void 0) ^ 0x80000005)); }
-    return out.join(",");
+  var out = [];
+  for (let j = 0; j < 5; ++j) { out.push(6 - ((void 0) ^ 0x80000005)); }
+  return out.join(",");
 }
 testUndemotableBinaryOp.expected = "2147483649,2147483649,2147483649,2147483649,2147483649";
 test(testUndemotableBinaryOp);
 
 function testNullRelCmp() {
-    var out = [];
-    for(j=0;j<3;++j) { out.push(3 > null); out.push(3 < null); out.push(0 == null); out.push(3 == null); }
-    return out.join(",");
+  var out = [];
+  for(j=0;j<3;++j) { out.push(3 > null); out.push(3 < null); out.push(0 == null); out.push(3 == null); }
+  return out.join(",");
 }
 testNullRelCmp.expected = "true,false,false,false,true,false,false,false,true,false,false,false";
 test(testNullRelCmp);
 
 function testEqFalseEmptyString() {
-    var x = [];
-    for (var i=0;i<5;++i) x.push(false == "");
-    return x.join(",");
+  var x = [];
+  for (var i=0;i<5;++i) x.push(false == "");
+  return x.join(",");
 }
 testEqFalseEmptyString.expected = "true,true,true,true,true";
 test(testEqFalseEmptyString);
 
 function testIncDec2(ii) {
-    var x = [];
-    for (let j=0;j<5;++j) {
-        ii=j;
-        jj=j;
-        var kk=j;
-        x.push(ii--);
-        x.push(jj--);
-        x.push(kk--);
-        x.push(++ii);
-        x.push(++jj);
-        x.push(++kk);
-    }
-    return x.join(",");
+  var x = [];
+  for (let j=0;j<5;++j) { 
+    ii=j;
+    jj=j; 
+    var kk=j; 
+    x.push(ii--);
+    x.push(jj--); 
+    x.push(kk--); 
+    x.push(++ii);
+    x.push(++jj); 
+    x.push(++kk); 
+  }
+  return x.join(",");
 }
 function testIncDec() {
-    return testIncDec2(0);
+  return testIncDec2(0);
 }
 testIncDec.expected = "0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,4,4";
 test(testIncDec);
@@ -3619,18 +3736,6 @@ function testComparisons()
 testComparisons.expected = "no failures reported!";
 test(testComparisons);
 
-function testBug504520() {
-    // A bug involving comparisons.
-    var arr = [1/0, 1/0, 1/0, 1/0, 1/0, 0];
-    assertEq(arr.length > RUNLOOP, true);
-
-    var x = 0;
-    for (var i = 0; i < arr.length; i++)
-        arr[i] >= 1/0 ? null : ++x;
-    assertEq(x, 1);
-}
-test(testBug504520);
-
 function testCaseAbort()
 {
   var four = "4";
@@ -3806,12 +3911,12 @@ test(testAddAnyInconvertibleObject);
 function testAddInconvertibleObjectAny()
 {
   var count = 0;
-  function toString()
-  {
-    ++count;
-    if (count == 95)
-      return {};
-    return "" + count;
+  function toString() 
+  { 
+      ++count; 
+      if (count == 95) 
+          return {}; 
+      return "" + count;
   }
 
   var threw = false;
@@ -3943,7 +4048,7 @@ function testBitOrInconvertibleObjectAny()
   {
     threw = true;
     if (i !== 94)
-      return "expected i === 4, got " + i;
+      return "expected i === 94, got " + i;
     if (q !== 95)
       return "expected q === 95, got " + q;
     if (count !== 95)
@@ -4130,6 +4235,33 @@ function testBug474769() {
 testBug474769.expected = 1;
 test(testBug474769);
 
+function testReverseArgTypes() {
+    for (var j = 0; j < 4; ++j) ''.replace('', /x/);
+    return 1;
+}
+testReverseArgTypes.expected = 1;
+test(testReverseArgTypes);
+
+function testBug458838() {
+    var a = 1;
+    function g() {
+        var b = 0
+            for (var i = 0; i < 10; ++i) {
+                b += a;
+            }
+        return b;
+    }
+
+    return g();
+}
+testBug458838.expected = 10;
+testBug458838.jitstats = {
+  recorderStarted: 1,
+  recorderAborted: 0,
+  traceCompleted: 1
+};
+test(testBug458838);
+
 function testInterpreterReentry() {
     this.__defineSetter__('x', function(){})
     for (var j = 0; j < 5; ++j) { x = 3; }
@@ -4160,13 +4292,6 @@ function testInterpreterReentry3() {
 testInterpreterReentry3.expected = 1;
 test(testInterpreterReentry3);
 
-function testReverseArgTypes() {
-    for (var j = 0; j < 4; ++j) ''.replace('', /x/);
-    return 1;
-}
-testReverseArgTypes.expected = 1;
-test(testReverseArgTypes);
-
 function testInterpreterReentry4() {
     var obj = {a:1, b:1, c:1, d:1, get e() 1000 };
     for (var p in obj)
@@ -4393,22 +4518,6 @@ delete h;
 delete a;
 delete f;
 
-function testRebranding2() {
-    // Same as testRebranding, but the object to be rebranded isn't the global.
-    var x = "FAIL";
-    function g(){}
-    function h(){ x = "ok"; }
-    var obj = {m: g};
-    var arr = [g, g, g, g, h];
-    for (var i = 0; i < 5; i++) {
-        obj.m = arr[i];
-        obj.m();
-    }
-    return x;
-}
-testRebranding2.expected = "ok";
-test(testRebranding2);
-
 function testLambdaCtor() {
     var a = [];
     for (var x = 0; x < RUNLOOP; ++x) {
@@ -4422,6 +4531,7 @@ function testLambdaCtor() {
     // Assert that the last f was properly constructed.
     return a[RUNLOOP-1].__proto__ === f.prototype;
 }
+
 testLambdaCtor.expected = true;
 test(testLambdaCtor);
 
@@ -4456,36 +4566,36 @@ test(testString);
 
 function testToStringBeforeValueOf()
 {
-    var o = {toString: function() { return "s"; }, valueOf: function() { return "v"; } };
-    var a = [];
-    for (var i = 0; i < 10; i++)
-        a.push(String(o));
-    return a.join(",");
+  var o = {toString: function() { return "s"; }, valueOf: function() { return "v"; } };
+  var a = [];
+  for (var i = 0; i < 10; i++)
+    a.push(String(o));
+  return a.join(",");
 }
 testToStringBeforeValueOf.expected = "s,s,s,s,s,s,s,s,s,s";
 testToStringBeforeValueOf.jitstats = {
-    recorderStarted: 1,
-    sideExitIntoInterpreter: 1
+  recorderStarted: 1,
+  sideExitIntoInterpreter: 1
 };
 test(testToStringBeforeValueOf);
 
 function testNullToString()
 {
-    var a = [];
-    for (var i = 0; i < 10; i++)
-        a.push(String(null));
-    for (i = 0; i < 10; i++) {
-        var t = typeof a[i];
-        if (t != "string")
-           a.push(t);
-    }
-    return a.join(",");
+  var a = [];
+  for (var i = 0; i < 10; i++)
+    a.push(String(null));
+  for (i = 0; i < 10; i++) {
+    var t = typeof a[i];
+    if (t != "string")
+      a.push(t);
+  }
+  return a.join(",");
 }
 testNullToString.expected = "null,null,null,null,null,null,null,null,null,null";
 testNullToString.jitstats = {
-    recorderStarted: 2,
-    sideExitIntoInterpreter: 2,
-    recorderAborted: 0
+  recorderStarted: 2,
+  sideExitIntoInterpreter: 2,
+  recorderAborted: 0
 };
 test(testNullToString);
 
@@ -4498,9 +4608,9 @@ function testAddNull()
 }
 testAddNull.expected = "null,";
 testAddNull.jitstats = {
-    recorderStarted: 1,
-    sideExitIntoInterpreter: 1,
-    recorderAborted: 0
+  recorderStarted: 1,
+  sideExitIntoInterpreter: 1,
+  recorderAborted: 0
 };
 test(testAddNull);
 
@@ -4790,26 +4900,6 @@ function testNEWINIT_DOUBLE()
 testNEWINIT_DOUBLE.expected = "ok";
 test(testNEWINIT_DOUBLE);
 
-function testBug458838() {
-    var a = 1;
-    function g() {
-        var b = 0
-            for (var i = 0; i < 10; ++i) {
-                b += a;
-            }
-        return b;
-    }
-
-    return g();
-}
-testBug458838.expected = 10;
-testBug458838.jitstats = {
-  recorderStarted: 1,
-  recorderAborted: 0,
-  traceCompleted: 1
-};
-test(testBug458838);
-
 function testIntOverflow() {
     // int32_max - 7
     var ival = 2147483647 - 7;
@@ -5070,6 +5160,111 @@ function testSlowNativeBail() {
 }
 test(testSlowNativeBail);
 
+/* Test the proper operation of the left shift operator. This is especially
+ * important on ARM as an explicit mask is required at the native instruction
+ * level. */
+function testShiftLeft()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = 1 << (shifts[i] + 256);
+
+    return r.join(",");
+}
+testShiftLeft.expected =
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648,"+
+    "1,2,128,256,32768,65536,8388608,16777216,-2147483648";
+test(testShiftLeft);
+
+/* Test the proper operation of the logical right shift operator. This is
+ * especially important on ARM as an explicit mask is required at the native
+ * instruction level. */
+function testShiftRightLogical()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >>> (shifts[i] + 256);
+
+    return r.join(",");
+}
+/* Note: Arguments to the ">>>" operator are converted to unsigned 32-bit
+ * integers during evaluation. As a result, -2147483648 >>> 0 evaluates to the
+ * unsigned interpretation of the same value, which is 2147483648. */
+testShiftRightLogical.expected =
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1,"+
+    "2147483648,1073741824,16777216,8388608,65536,32768,256,128,1";
+test(testShiftRightLogical);
+
+/* Test the proper operation of the arithmetic right shift operator. This is
+ * especially important on ARM as an explicit mask is required at the native
+ * instruction level. */
+function testShiftRightArithmetic()
+{
+    var r = [];
+    var i = 0;
+    var j = 0;
+
+    var shifts = [0,1,7,8,15,16,23,24,31];
+
+    /* Samples from the simple shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> shifts[i];
+
+    /* Samples outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 32);
+
+    /* Samples far outside the normal shift range. */
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 224);
+    for (i = 0; i < shifts.length; i++)
+        r[j++] = -2147483648 >> (shifts[i] + 256);
+
+    return r.join(",");
+}
+testShiftRightArithmetic.expected =
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1,"+
+    "-2147483648,-1073741824,-16777216,-8388608,-65536,-32768,-256,-128,-1";
+test(testShiftRightArithmetic);
+
 function testStringConstructorWithExtraArg() {
     for (let i = 0; i < 5; ++i)
         new String(new String(), 2);
@@ -5104,151 +5299,6 @@ function testNewArrayCount2() {
 testNewArrayCount2.expected = 3;
 test(testNewArrayCount2);
 
-function testGetCallObjInlined(i) {
-    if (i > 7) eval("1");
-    return 1;
-}
-
-function testGetCallObj() {
-    for (var i = 0; i < 10; ++i)
-        testGetCallObjInlined(i);
-    return "ok";
-}
-testGetCallObj.expected = "ok";
-test(testGetCallObj);
-
-function testGetThis() {
-    for (var i = 0; i < 3; ++i) {
-        (function() { return this; })();
-    }
-    return "ok";
-}
-testGetThis.expected = "ok";
-test(testGetThis);
-
-function testArrayNamedProp() {
-    for (var x = 0; x < 10; ++x) { [4].sort-- }
-    return "ok";
-}
-testArrayNamedProp.expected = "ok";
-test(testArrayNamedProp);
-
-function testUndemoteLateGlobalSlots() {
-    for each (aaa in ["", "", 0/0, ""]) {
-        ++aaa;
-        for each (bbb in [0, "", aaa, "", 0, "", 0/0]) {
-        }
-    }
-    delete aaa;
-    delete bbb;
-    return "ok";
-}
-testUndemoteLateGlobalSlots.expected = "ok";
-test(testUndemoteLateGlobalSlots);
-
-function testSetProtoRegeneratesObjectShape()
-{
-  var f = function() {};
-  var g = function() {};
-  g.prototype.__proto__ = {};
-
-  function iq(obj)
-  {
-    for (var i = 0; i < 10; ++i)
-      "" + obj.prototype;
-  }
-
-  iq(f);
-  iq(f);
-  iq(f);
-  iq(f);
-  iq(g);
-
-  if (shapeOf(f.prototype) === shapeOf(g.prototype))
-    return "object shapes same after proto of one is changed";
-
-  return true;
-}
-testSetProtoRegeneratesObjectShape.expected = true;
-test(testSetProtoRegeneratesObjectShape);
-
-function testFewerGlobalsInInnerTree() {
-    for each (a in [new Number(1), new Number(1), {}, {}, new Number(1)]) {
-        for each (b in [2, "", 2, "", "", ""]) {
-		    for each (c in [{}, {}, 3, 3, 3, 3, {}, {}]) {
-                4 + a;
-			}
-		}
-	}
-    delete a;
-    delete b;
-    delete c;
-    return "ok";
-}
-testFewerGlobalsInInnerTree.expected = "ok";
-test(testFewerGlobalsInInnerTree);
-
-function testEliminatedGuardWithinAnchor() {
-    for (let i = 0; i < 5; ++i) { i / (i * i); }
-    return "ok";
-}
-testEliminatedGuardWithinAnchor.expected = "ok";
-test(testEliminatedGuardWithinAnchor);
-
-function testInt32ToId()
-{
-  // Ensure that a property which is a negative integer that does not fit in a
-  // jsval is properly detected by the 'in' operator.
-  var obj = { "-1073741828": 17 };
-  var index = -1073741819;
-  var a = [];
-  for (var i = 0; i < 10; i++)
-  {
-    a.push(index in obj);
-    index--;
-  }
-
-  // Ensure that a property which is a negative integer that does not fit in a
-  // jsval is properly *not* detected by the 'in' operator.  In this case
-  // wrongly applying INT_TO_JSID to -2147483648 will shift off the sign bit
-  // (the only bit set in that number) and bitwise-or that value with 1,
-  // producing jsid(1) -- which actually represents "0", not "-2147483648".
-  // Thus 'in' will report a "-2147483648" property when none exists, because
-  // it thinks the request was really whether the object had property "0".
-  var obj2 = { 0: 17 };
-  var b = [];
-  var index = -(1 << 28);
-  for (var i = 0; i < 10; i++)
-  {
-    b.push(index in obj2);
-    index = index - (1 << 28);
-  }
-
-  return a.join(",") + b.join(",");
-}
-testInt32ToId.expected =
-  "false,false,false,false,false,false,false,false,false,true" +
-  "false,false,false,false,false,false,false,false,false,false";
-testInt32ToId.jitstats = {
-  sideExitIntoInterpreter: 2
-};
-test(testInt32ToId);
-
-function testOwnPropertyWithInOperator()
-{
-  var o = { 0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6 };
-  var a = [];
-  for (var i = 0; i < 7; i++)
-    a.push(i in o);
-  return a.join(",");
-}
-testOwnPropertyWithInOperator.expected = "true,true,true,true,true,true,true";
-testOwnPropertyWithInOperator.jitstats = {
-  sideExitIntoInterpreter: 1
-};
-test(testOwnPropertyWithInOperator);
-
-
 /*****************************************************************************
  *                                                                           *
  *  _____ _   _  _____ ______ _____ _______                                  *
@@ -5276,254 +5326,9 @@ test(testOwnPropertyWithInOperator);
  *                                                                           *
  *****************************************************************************/
 
-load(gSrcdir + "/math-trace-tests.js");
-
-// BEGIN MANDELBROT STUFF
-// XXXbz I would dearly like to wrap it up into a function to avoid polluting
-// the global scope, but the function ends up heavyweight, and then we lose on
-// the jit.
-if (gDoMandelbrotTest) {
-load(gSrcdir + "/mandelbrot-results.js");
-//function testMandelbrotAll() {
-  // Configuration options that affect which codepaths we follow.
-  var doImageData = true;
-  var avoidSparseArray = true;
-
-  // Control of iteration numbers and sizing.  We'll do
-  // scaler * colorNames.length iterations or so before deciding that we
-  // don't escape.
-  const scaler = 5;
-  const numRows = 600;
-  const numCols = 600;
-
-  const colorNames = [
-    "black",
-    "green",
-    "blue",
-    "red",
-    "purple",
-    "orange",
-    "cyan",
-    "yellow",
-    "magenta",
-    "brown",
-    "pink",
-    "chartreuse",
-    "darkorange",
-    "crimson",
-    "gray",
-    "deeppink",
-    "firebrick",
-    "lavender",
-    "lawngreen",
-    "lightsalmon",
-    "lime",
-    "goldenrod"
-  ];
-  const threshold = (colorNames.length - 1) * scaler;
-
-  // Now set up our colors
-  var colors = [];
-  // 3-part for loop (iterators buggy, we will add a separate test for them)
-  for (var colorNameIdx = 0; colorNameIdx < colorNames.length; ++colorNameIdx) {
-  //for (var colorNameIdx in colorNames) {
-    colorNameIdx = parseInt(colorNameIdx);
-    colors.push([colorNameIdx, colorNameIdx, colorNameIdx, 0]);
-  }
-
-  // Storage for our point data
-  var points;
-
-  var scratch = {};
-  var scratchZ = {};
-  function complexMult(a, b) {
-    var newr = a.r * b.r - a.i * b.i;
-    var newi = a.r * b.i + a.i * b.r;
-    scratch.r = newr;
-    scratch.i = newi;
-    return scratch;
-  }
-  function complexAdd(a, b) {
-    scratch.r = a.r + b.r;
-    scratch.i = a.i + b.i;
-    return scratch;
-  }
-  function abs(a) {
-    return Math.sqrt(a.r * a.r + a.i * a.i);
-  }
-
-  function escapeAbsDiff(normZ, absC) {
-    var absZ = Math.sqrt(normZ);
-    return normZ > absZ + absC;
-  }
-
-  function escapeNorm2(normZ) {
-    return normZ > 4;
-  }
-
-  function fuzzyColors(i) {
-    return Math.floor(i / scaler) + 1;
-  }
-
-  function moddedColors(i) {
-    return (i % (colorNames.length - 1)) + 1;
-  }
-
-  function computeEscapeSpeedObjects(real, imag) {
-    var c = { r: real, i: imag }
-    scratchZ.r = scratchZ.i = 0;
-    var absC = abs(c);
-    for (var i = 0; i < threshold; ++i) {
-      scratchZ = complexAdd(c, complexMult(scratchZ, scratchZ));
-      if (escape(scratchZ.r * scratchZ.r + scratchZ.i * scratchZ.i,
-                 absC)) {
-        return colorMap(i);
-      }
-    }
-    return 0;
-  }
-
-  function computeEscapeSpeedOneObject(real, imag) {
-    // fold in the fact that we start with 0
-    var r = real;
-    var i = imag;
-    var absC = abs({r: real, i: imag});
-    for (var j = 0; j < threshold; ++j) {
-      var r2 = r * r;
-      var i2 = i * i;
-      if (escape(r2 + i2, absC)) {
-        return colorMap(j);
-      }
-      i = 2 * r * i + imag;
-      r = r2 - i2 + real;
-    }
-    return 0;
-  }
-
-  function computeEscapeSpeedDoubles(real, imag) {
-    // fold in the fact that we start with 0
-    var r = real;
-    var i = imag;
-    var absC = Math.sqrt(real * real + imag * imag);
-    for (var j = 0; j < threshold; ++j) {
-      var r2 = r * r;
-      var i2 = i * i;
-      if (escape(r2 + i2, absC)) {
-        return colorMap(j);
-      }
-      i = 2 * r * i + imag;
-      r = r2 - i2 + real;
-    }
-    return 0;
-  }
-
-  var computeEscapeSpeed = computeEscapeSpeedDoubles;
-  var escape = escapeNorm2;
-  var colorMap = fuzzyColors;
-
-  function addPointOrig(pointArray, n, i, j) {
-    if (!points[n]) {
-      points[n] = [];
-      points[n].push([i, j, 1, 1]);
-    } else {
-      var point = points[n][points[n].length-1];
-      if (point[0] == i && point[1] == j - point[3]) {
-        ++point[3];
-      } else {
-        points[n].push([i, j, 1, 1]);
-      }
-    }
-  }
-
-  function addPointImagedata(pointArray, n, col, row) {
-    var slotIdx = ((row * numCols) + col) * 4;
-    pointArray[slotIdx] = colors[n][0];
-    pointArray[slotIdx+1] = colors[n][1];
-    pointArray[slotIdx+2] = colors[n][2];
-    pointArray[slotIdx+3] = colors[n][3];
-  }
-
-  function createMandelSet() {
-    var realRange = { min: -2.1, max: 1 };
-    var imagRange = { min: -1.5, max: 1.5 };
-
-    var addPoint;
-    if (doImageData) {
-      addPoint = addPointImagedata;
-      points = new Array(4*numCols*numRows);
-      if (avoidSparseArray) {
-        for (var idx = 0; idx < 4*numCols*numRows; ++idx) {
-          points[idx] = 0;
-        }
-      }
-    } else {
-      addPoint = addPointOrig;
-      points = [];
-    }
-    var realStep = (realRange.max - realRange.min)/numCols;
-    var imagStep = (imagRange.min - imagRange.max)/numRows;
-    for (var i = 0, curReal = realRange.min;
-         i < numCols;
-         ++i, curReal += realStep) {
-      for (var j = 0, curImag = imagRange.max;
-           j < numRows;
-           ++j, curImag += imagStep) {
-        var n = computeEscapeSpeed(curReal, curImag);
-        addPoint(points, n, i, j)
-      }
-    }
-    var result;
-    if (doImageData) {
-      if (colorMap == fuzzyColors) {
-        result = mandelbrotImageDataFuzzyResult;
-      } else {
-        result = mandelbrotImageDataModdedResult;
-      }
-    } else {
-      result = mandelbrotNoImageDataResult;
-    }
-    return points.toSource() == result;
-  }
-
-  createMandelSet.expected = true;
-
-  const escapeTests = [ escapeAbsDiff ];
-  const colorMaps = [ fuzzyColors, moddedColors ];
-  const escapeComputations = [ computeEscapeSpeedObjects,
-                               computeEscapeSpeedOneObject,
-                               computeEscapeSpeedDoubles ];
-  // Test all possible escape-speed generation codepaths, using the
-  // imageData + sparse array avoidance storage.
-  doImageData = true;
-  avoidSparseArray = true;
-  for (var escapeIdx in escapeTests) {
-    escape = escapeTests[escapeIdx];
-    for (var colorMapIdx in colorMaps) {
-      colorMap = colorMaps[colorMapIdx];
-      for (var escapeComputationIdx in escapeComputations) {
-        computeEscapeSpeed = escapeComputations[escapeComputationIdx];
-        test(createMandelSet);
-      }
-    }
-  }
+// math-trace-tests.js is a separate file here.
 
-  // Test all possible storage strategies. Note that we already tested
-  // doImageData == true with avoidSparseArray == true.
-  escape = escapeAbsDiff;
-  colorMap = fuzzyColors; // This part doesn't really matter too much here
-  computeEscapeSpeed = computeEscapeSpeedDoubles;
-
-  doImageData = true;
-  avoidSparseArray = false;
-  test(createMandelSet);
-
-  escape = escapeNorm2;
-  doImageData = false;  // avoidSparseArray doesn't matter here
-  test(createMandelSet);
-//}
-//testMandelbrotAll();
-} /* if (gDoMandelbrotTest) */
-// END MANDELBROT STUFF
+// MANDELBROT STUFF deleted
 
 /*****************************************************************************
  *  _   _  ____     _   __  ____  _____  ______                              *
@@ -5551,14 +5356,16 @@ load(gSrcdir + "/mandelbrot-results.js");
 
 /* NOTE: Keep this test last, since it screws up all for...in loops after it. */
 function testGlobalProtoAccess() {
-    return "ok";
+  return "ok";
 }
 this.__proto__.a = 3; for (var j = 0; j < 4; ++j) { [a]; }
 testGlobalProtoAccess.expected = "ok";
 test(testGlobalProtoAccess);
 
+jit(false);
+
 /* Keep these at the end so that we can see the summary after the trace-debug spew. */
 if (gReportSummary) {
-    print("\npassed:", passes.length && passes.join(","));
-    print("\nFAILED:", fails.length && fails.join(","));
+  print("\npassed:", passes.length && passes.join(","));
+  print("\nFAILED:", fails.length && fails.join(","));
 }