Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

23 files changed, 1872 insertions, 0 deletions

diff --git a/js/src/tests/non262/misc/browser.js b/js/src/tests/non262/misc/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/non262/misc/browser.js
diff --git a/js/src/tests/non262/misc/bug1126318.js b/js/src/tests/non262/misc/bug1126318.js
new file mode 100644
index 0000000000..73ccdc07a7
--- /dev/null
+++ b/js/src/tests/non262/misc/bug1126318.js
@@ -0,0 +1,13 @@
+if (typeof window === "undefined")
+    window = this;
+
+Object.defineProperty(window, "foo", {
+    get: function() { return 5; },
+    configurable: true
+});
+
+for (var i = 0; i < 100; ++i)
+    assertEq(window.foo, 5);
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/misc/builtin-methods-reject-null-undefined-this.js b/js/src/tests/non262/misc/builtin-methods-reject-null-undefined-this.js
new file mode 100644
index 0000000000..c6f0a8f39a
--- /dev/null
+++ b/js/src/tests/non262/misc/builtin-methods-reject-null-undefined-this.js
@@ -0,0 +1,156 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 619283;
+var summary =
+  "ECMAScript built-in methods that immediately throw when |this| is " +
+  "|undefined| or |null| (due to CheckObjectCoercible, ToObject, or ToString)";
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+// We can't just exhaustively loop over everything because 1) method properties
+// might be extensions with special |this| handling, and 2) some methods don't
+// *quite* immediately throw a TypeError, first thing, if |this| is |undefined|
+// or |null|, or their algorithms are very slightly ambiguous about whether they
+// do.  Why?  Ipse-dixitism.  *shrug*
+
+var ClassToMethodMap =
+  {
+    Object:  [/* "toString" has special |this| handling */
+              "toLocaleString", "valueOf", "hasOwnProperty",
+              /*
+               * "isPrototypeOf" has special |this| handling already tested in
+               * non262/Object/isPrototypeOf.js.
+               */
+              /*
+               * "isPrototypeOf" has special |this| handling already tested in
+               * non262/Object/propertyIsEnumerable.js.
+               */
+              "__defineGetter__", "__defineSetter__",
+              "__lookupGetter__", "__lookupSetter__",
+              ],
+    // Function methods often don't ToObject(this) as their very first step,
+    // and they're already stepwise well-tested such that manual tests here
+    // would be redundant.
+    Array:   ["toString", "toLocaleString", "concat", "join", "pop", "push",
+              "reverse", "shift", "slice", "sort", "splice", "unshift",
+              "indexOf", "lastIndexOf", "every", "some", "forEach", "map",
+              "filter", "reduce", "reduceRight"],
+    String:  ["toString", "valueOf", "charAt", "charCodeAt", "concat",
+              "indexOf", "lastIndexOf", "localeCompare", "match", "replace",
+              "search", "slice", "split", "substring", "toLowerCase",
+              "toLocaleLowerCase", "toUpperCase", "toLocaleUpperCase", "trim",
+              "bold", "italics", "fixed", "fontsize",
+              "fontcolor", "link", "anchor", "strike", "small", "big", "blink",
+              "sup", "sub", "substr", "trimLeft", "trimRight",
+              ],
+    Boolean: ["toString", "valueOf"],
+    Number:  ["toString", "toLocaleString", "valueOf",
+              /*
+               * toFixed doesn't *immediately* test |this| for number or
+               * Number-ness, but because the ToInteger(void 0) which arguably
+               * precedes it in the toFixed algorithm won't throw in this test,
+               * we don't need to specially test it.
+               */
+              "toFixed",
+              "toExponential", "toPrecision"],
+    Date:    ["toDateString", "toTimeString", "toLocaleString",
+              "toLocaleDateString", "toLocaleTimeString", "valueOf", "getTime",
+              "getFullYear", "getUTCFullYear", "getMonth", "getUTCMonth",
+              "getDate", "getUTCDate", "getDay", "getUTCDay", "getHours",
+              "getUTCHours", "getMinutes", "getUTCMinutes", "getSeconds",
+              "getUTCSeconds", "getMilliseconds", "getUTCMilliseconds",
+              /*
+               * toFixed doesn't *immediately* test |this| for number or
+               * Number-ness, but because the TimeClip(ToNumber(void 0)) which
+               * arguably precedes it in the setTime algorithm won't throw in
+               * this test, we don't need to specially test it.
+               */
+              "setTime",
+              "getTimezoneOffset", "setMilliseconds", "setUTCMilliseconds",
+              "setSeconds", "setUTCSeconds", "setMinutes", "setUTCMinutes",
+              "setHours", "setUTCHours", "setDate", "setUTCDate",  "setMonth",
+              "setUTCMonth", "setFullYear", "setUTCFullYear", "toUTCString",
+              "toISOString", "toJSON",
+              "getYear", "setYear",  "toGMTString"],
+    RegExp:  ["exec", "test", "toString"],
+    Error:   ["toString"],
+  };
+
+var badThisValues = [null, undefined];
+
+function testMethod(Class, className, method)
+{
+  var expr;
+
+  // Try out explicit this values
+  for (var i = 0, sz = badThisValues.length; i < sz; i++)
+  {
+    var badThis = badThisValues[i];
+
+    expr = className + ".prototype." + method + ".call(" + badThis + ")";
+    try
+    {
+      Class.prototype[method].call(badThis);
+      throw new Error(expr + " didn't throw a TypeError");
+    }
+    catch (e)
+    {
+      assertEq(e instanceof TypeError, true,
+               "wrong error for " + expr + ", instead threw " + e);
+    }
+
+    expr = className + ".prototype." + method + ".apply(" + badThis + ")";
+    try
+    {
+      Class.prototype[method].apply(badThis);
+      throw new Error(expr + " didn't throw a TypeError");
+    }
+    catch (e)
+    {
+      assertEq(e instanceof TypeError, true,
+               "wrong error for " + expr + ", instead threw " + e);
+    }
+  }
+
+  // ..and for good measure..
+
+  expr = "(0, " + className + ".prototype." + method + ")()"
+  try
+  {
+    // comma operator to call GetValue() on the method and de-Reference it
+    (0, Class.prototype[method])();
+    throw new Error(expr + " didn't throw a TypeError");
+  }
+  catch (e)
+  {
+    assertEq(e instanceof TypeError, true,
+             "wrong error for " + expr + ", instead threw " + e);
+  }
+}
+
+for (var className in ClassToMethodMap)
+{
+  var Class = this[className];
+
+  var methodNames = ClassToMethodMap[className];
+  for (var i = 0, sz = methodNames.length; i < sz; i++)
+  {
+    var method = methodNames[i];
+    testMethod(Class, className, method);
+  }
+}
+
+/******************************************************************************/
+
+if (typeof reportCompare === "function")
+  reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/enumerate-undefined.js b/js/src/tests/non262/misc/enumerate-undefined.js
new file mode 100644
index 0000000000..17bc1c4c87
--- /dev/null
+++ b/js/src/tests/non262/misc/enumerate-undefined.js
@@ -0,0 +1,24 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 547087;
+var summary = 'JS_EnumerateStandardClasses uses wrong attributes for undefined';
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+for (var p in this);
+
+assertEq(Object.getOwnPropertyDescriptor(this, "undefined").writable, false);
+
+/******************************************************************************/
+
+reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/error-undefined-message.js b/js/src/tests/non262/misc/error-undefined-message.js
new file mode 100644
index 0000000000..8a9202b8fd
--- /dev/null
+++ b/js/src/tests/non262/misc/error-undefined-message.js
@@ -0,0 +1,7 @@
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/licenses/publicdomain/
+
+assertEq(new Error().hasOwnProperty('message'), false);
+assertEq(new Error(undefined).hasOwnProperty('message'), false);
+
+reportCompare(0, 0, 'ok');
diff --git a/js/src/tests/non262/misc/explicit-undefined-optional-argument.js b/js/src/tests/non262/misc/explicit-undefined-optional-argument.js
new file mode 100644
index 0000000000..f861ccfdb1
--- /dev/null
+++ b/js/src/tests/non262/misc/explicit-undefined-optional-argument.js
@@ -0,0 +1,34 @@
+// Any copyright is dedicated to the Public Domain.
+// http://creativecommons.org/licenses/publicdomain/
+
+var BUGNUMBER = 373118;
+var summary =
+  'Properly handle explicitly-undefined optional arguments to a bunch of ' +
+  'functions';
+
+print(BUGNUMBER + ": " + summary);
+
+//-----------------------------------------------------------------------------
+
+var a;
+
+a = "abc".slice(0, undefined);
+assertEq(a, "abc");
+
+a = "abc".substr(0, undefined);
+assertEq(a, "abc");
+
+a = "abc".substring(0, undefined);
+assertEq(a, "abc");
+
+a = [1, 2, 3].slice(0, undefined);
+assertEq(a.join(), '1,2,3');
+
+a = [1, 2, 3].sort(undefined);
+assertEq(a.join(), '1,2,3');
+
+assertEq((20).toString(undefined), '20');
+
+//-----------------------------------------------------------------------------
+
+reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/function-definition-eval.js b/js/src/tests/non262/misc/function-definition-eval.js
new file mode 100644
index 0000000000..27feae1a69
--- /dev/null
+++ b/js/src/tests/non262/misc/function-definition-eval.js
@@ -0,0 +1,348 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 577325;
+var summary = 'Implement the ES5 algorithm for processing function statements';
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var outer, desc;
+var isInShell = !("Window" in this);
+
+///////////////////////////////////////////////////
+// Function definitions over accessor properties //
+///////////////////////////////////////////////////
+
+var getCalled, setCalled;
+
+// configurable properties get blown away
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc1",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 1"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 1 " + v; },
+                        configurable: true,
+                        enumerable: false
+                      });
+
+// does not throw
+outer = undefined;
+eval("function acc1() { throw 'FAIL redefined 1'; } outer = acc1;");
+assertEq(getCalled, false);
+assertEq(setCalled, false);
+assertEq(typeof acc1, "function");
+assertEq(acc1, outer);
+desc = Object.getOwnPropertyDescriptor(this, "acc1");
+assertEq(desc.value, acc1);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, true);
+
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc2",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 2"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 2 " + v; },
+                        configurable: true,
+                        enumerable: true
+                      });
+
+// does not throw
+outer = undefined;
+eval("function acc2() { throw 'FAIL redefined 2'; } outer = acc2;");
+assertEq(getCalled, false);
+assertEq(setCalled, false);
+assertEq(typeof acc2, "function");
+assertEq(acc2, outer);
+desc = Object.getOwnPropertyDescriptor(this, "acc2");
+assertEq(desc.value, acc2);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, true);
+
+
+// non-configurable properties produce a TypeError.  We only test this in shell,
+// since defining non-configurable properties on Window instances throws.
+if (isInShell) {
+    getCalled = false, setCalled = false;
+    Object.defineProperty(this, "acc3",
+			  {
+                              get: function() { getCalled = true; throw "FAIL get 3"; },
+                              set: function(v) { setCalled = true; throw "FAIL set 3 " + v; },
+                              configurable: false,
+                              enumerable: true
+			  });
+
+    outer = undefined;
+    try
+    {
+	eval("function acc3() { throw 'FAIL redefined 3'; }; outer = acc3");
+	throw new Error("should have thrown trying to redefine global function " +
+			"over a non-configurable, enumerable accessor");
+    }
+    catch (e)
+    {
+	assertEq(e instanceof TypeError, true,
+		 "global function definition, when that function would overwrite " +
+		 "a non-configurable, enumerable accessor, must throw a TypeError " +
+		 "per ES5+errata: " + e);
+	desc = Object.getOwnPropertyDescriptor(this, "acc3");
+	assertEq(typeof desc.get, "function");
+	assertEq(typeof desc.set, "function");
+	assertEq(desc.enumerable, true);
+	assertEq(desc.configurable, false);
+	assertEq(outer, undefined);
+	assertEq(getCalled, false);
+	assertEq(setCalled, false);
+    }
+
+
+    getCalled = false, setCalled = false;
+    Object.defineProperty(this, "acc4",
+			  {
+                              get: function() { getCalled = true; throw "FAIL get 4"; },
+                              set: function(v) { setCalled = true; throw "FAIL set 4 " + v; },
+                              configurable: false,
+                              enumerable: false
+			  });
+
+    outer = undefined;
+    try
+    {
+	eval("function acc4() { throw 'FAIL redefined 4'; }; outer = acc4");
+	throw new Error("should have thrown trying to redefine global function " +
+			"over a non-configurable, non-enumerable accessor");
+    }
+    catch (e)
+    {
+	assertEq(e instanceof TypeError, true,
+		 "global function definition, when that function would overwrite " +
+		 "a non-configurable, non-enumerable accessor, must throw a " +
+		 "TypeError per ES5+errata: " + e);
+	desc = Object.getOwnPropertyDescriptor(this, "acc4");
+	assertEq(typeof desc.get, "function");
+	assertEq(typeof desc.set, "function");
+	assertEq(desc.enumerable, false);
+	assertEq(desc.configurable, false);
+	assertEq(outer, undefined);
+	assertEq(getCalled, false);
+	assertEq(setCalled, false);
+    }
+}
+
+
+///////////////////////////////////////////////
+// Function definitions over data properties //
+///////////////////////////////////////////////
+
+
+// configurable properties, regardless of other attributes, get blown away
+
+Object.defineProperty(this, "data1",
+                      {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: "data1"
+                      });
+
+outer = undefined;
+eval("function data1() { return 'data1 function'; } outer = data1;");
+assertEq(typeof data1, "function");
+assertEq(data1, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data1");
+assertEq(desc.configurable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data1);
+
+
+Object.defineProperty(this, "data2",
+                      {
+                        configurable: true,
+                        enumerable: true,
+                        writable: false,
+                        value: "data2"
+                      });
+
+outer = undefined;
+eval("function data2() { return 'data2 function'; } outer = data2;");
+assertEq(typeof data2, "function");
+assertEq(data2, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data2");
+assertEq(desc.configurable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data2);
+
+
+Object.defineProperty(this, "data3",
+                      {
+                        configurable: true,
+                        enumerable: false,
+                        writable: true,
+                        value: "data3"
+                      });
+
+outer = undefined;
+eval("function data3() { return 'data3 function'; } outer = data3;");
+assertEq(typeof data3, "function");
+assertEq(data3, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data3");
+assertEq(desc.configurable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data3);
+
+
+Object.defineProperty(this, "data4",
+                      {
+                        configurable: true,
+                        enumerable: false,
+                        writable: false,
+                        value: "data4"
+                      });
+
+outer = undefined;
+eval("function data4() { return 'data4 function'; } outer = data4;");
+assertEq(typeof data4, "function");
+assertEq(data4, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data4");
+assertEq(desc.value, data4);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, true);
+
+
+// non-configurable data properties are trickier.  Again, we test these only in shell.
+
+if (isInShell) {
+    Object.defineProperty(this, "data5",
+			  {
+                              configurable: false,
+                              enumerable: true,
+                              writable: true,
+                              value: "data5"
+			  });
+
+    outer = undefined;
+    eval("function data5() { return 'data5 function'; } outer = data5;");
+    assertEq(typeof data5, "function");
+    assertEq(data5, outer);
+    desc = Object.getOwnPropertyDescriptor(this, "data5");
+    assertEq(desc.configurable, false);
+    assertEq(desc.enumerable, true);
+    assertEq(desc.writable, true);
+    assertEq(desc.value, data5);
+
+
+    Object.defineProperty(this, "data6",
+			  {
+                              configurable: false,
+                              enumerable: true,
+                              writable: false,
+                              value: "data6"
+			  });
+
+    outer = undefined;
+    try
+    {
+	eval("function data6() { return 'data6 function'; } outer = data6;");
+	throw new Error("should have thrown trying to redefine global function " +
+			"over a non-configurable, enumerable, non-writable accessor");
+    }
+    catch (e)
+    {
+	assertEq(e instanceof TypeError, true,
+		 "global function definition, when that function would overwrite " +
+		 "a non-configurable, enumerable, non-writable data property, must " +
+		 "throw a TypeError per ES5+errata: " + e);
+	assertEq(data6, "data6");
+	assertEq(outer, undefined);
+	desc = Object.getOwnPropertyDescriptor(this, "data6");
+	assertEq(desc.configurable, false);
+	assertEq(desc.enumerable, true);
+	assertEq(desc.writable, false);
+	assertEq(desc.value, "data6");
+    }
+
+
+    Object.defineProperty(this, "data7",
+			  {
+                              configurable: false,
+                              enumerable: false,
+                              writable: true,
+                              value: "data7"
+			  });
+
+    outer = undefined;
+    try
+    {
+	eval("function data7() { return 'data7 function'; } outer = data7;");
+	throw new Error("should have thrown trying to redefine global function " +
+			"over a non-configurable, non-enumerable, writable data" +
+			"property");
+    }
+    catch (e)
+    {
+	assertEq(e instanceof TypeError, true,
+		 "global function definition, when that function would overwrite " +
+		 "a non-configurable, non-enumerable, writable data property, must " +
+		 "throw a TypeError per ES5+errata: " + e);
+	assertEq(data7, "data7");
+	assertEq(outer, undefined);
+	desc = Object.getOwnPropertyDescriptor(this, "data7");
+	assertEq(desc.configurable, false);
+	assertEq(desc.enumerable, false);
+	assertEq(desc.writable, true);
+	assertEq(desc.value, "data7");
+    }
+
+
+    Object.defineProperty(this, "data8",
+			  {
+                              configurable: false,
+                              enumerable: false,
+                              writable: false,
+                              value: "data8"
+			  });
+
+    outer = undefined;
+    try
+    {
+	eval("function data8() { return 'data8 function'; } outer = data8;");
+	throw new Error("should have thrown trying to redefine global function " +
+			"over a non-configurable, non-enumerable, non-writable data" +
+			"property");
+    }
+    catch (e)
+    {
+	assertEq(e instanceof TypeError, true,
+		 "global function definition, when that function would overwrite " +
+		 "a non-configurable, non-enumerable, non-writable data property, " +
+		 "must throw a TypeError per ES5+errata: " + e);
+	assertEq(data8, "data8");
+	assertEq(outer, undefined);
+	desc = Object.getOwnPropertyDescriptor(this, "data8");
+	assertEq(desc.configurable, false);
+	assertEq(desc.enumerable, false);
+	assertEq(desc.writable, false);
+	assertEq(desc.value, "data8");
+    }
+}
+
+/******************************************************************************/
+
+if (typeof reportCompare === "function")
+  reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/function-definition-evaluate.js b/js/src/tests/non262/misc/function-definition-evaluate.js
new file mode 100644
index 0000000000..4ed156b2a1
--- /dev/null
+++ b/js/src/tests/non262/misc/function-definition-evaluate.js
@@ -0,0 +1,344 @@
+// |reftest| skip-if(!xulRuntime.shell) -- needs evaluate()
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 577325;
+var summary = 'Implement the ES5 algorithm for processing function statements';
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var outer, desc;
+
+///////////////////////////////////////////////////
+// Function definitions over accessor properties //
+///////////////////////////////////////////////////
+
+var getCalled, setCalled;
+
+// configurable properties get blown away
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc1",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 1"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 1 " + v; },
+                        configurable: true,
+                        enumerable: false
+                      });
+
+// does not throw
+outer = undefined;
+evaluate("function acc1() { throw 'FAIL redefined 1'; } outer = acc1;");
+assertEq(getCalled, false);
+assertEq(setCalled, false);
+assertEq(typeof acc1, "function");
+assertEq(acc1, outer);
+desc = Object.getOwnPropertyDescriptor(this, "acc1");
+assertEq(desc.value, acc1);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, false);
+
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc2",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 2"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 2 " + v; },
+                        configurable: true,
+                        enumerable: true
+                      });
+
+// does not throw
+outer = undefined;
+evaluate("function acc2() { throw 'FAIL redefined 2'; } outer = acc2;");
+assertEq(getCalled, false);
+assertEq(setCalled, false);
+assertEq(typeof acc2, "function");
+assertEq(acc2, outer);
+desc = Object.getOwnPropertyDescriptor(this, "acc2");
+assertEq(desc.value, acc2);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, false);
+
+
+// non-configurable properties produce a TypeError
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc3",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 3"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 3 " + v; },
+                        configurable: false,
+                        enumerable: true
+                      });
+
+outer = undefined;
+try
+{
+  evaluate("function acc3() { throw 'FAIL redefined 3'; }; outer = acc3");
+  throw new Error("should have thrown trying to redefine global function " +
+                  "over a non-configurable, enumerable accessor");
+}
+catch (e)
+{
+  assertEq(e instanceof TypeError, true,
+           "global function definition, when that function would overwrite " +
+           "a non-configurable, enumerable accessor, must throw a TypeError " +
+           "per ES5+errata: " + e);
+  desc = Object.getOwnPropertyDescriptor(this, "acc3");
+  assertEq(typeof desc.get, "function");
+  assertEq(typeof desc.set, "function");
+  assertEq(desc.enumerable, true);
+  assertEq(desc.configurable, false);
+  assertEq(outer, undefined);
+  assertEq(getCalled, false);
+  assertEq(setCalled, false);
+}
+
+
+getCalled = false, setCalled = false;
+Object.defineProperty(this, "acc4",
+                      {
+                        get: function() { getCalled = true; throw "FAIL get 4"; },
+                        set: function(v) { setCalled = true; throw "FAIL set 4 " + v; },
+                        configurable: false,
+                        enumerable: false
+                      });
+
+outer = undefined;
+try
+{
+  evaluate("function acc4() { throw 'FAIL redefined 4'; }; outer = acc4");
+  throw new Error("should have thrown trying to redefine global function " +
+                  "over a non-configurable, non-enumerable accessor");
+}
+catch (e)
+{
+  assertEq(e instanceof TypeError, true,
+           "global function definition, when that function would overwrite " +
+           "a non-configurable, non-enumerable accessor, must throw a " +
+           "TypeError per ES5+errata: " + e);
+  desc = Object.getOwnPropertyDescriptor(this, "acc4");
+  assertEq(typeof desc.get, "function");
+  assertEq(typeof desc.set, "function");
+  assertEq(desc.enumerable, false);
+  assertEq(desc.configurable, false);
+  assertEq(outer, undefined);
+  assertEq(getCalled, false);
+  assertEq(setCalled, false);
+}
+
+
+///////////////////////////////////////////////
+// Function definitions over data properties //
+///////////////////////////////////////////////
+
+
+// configurable properties, regardless of other attributes, get blown away
+
+Object.defineProperty(this, "data1",
+                      {
+                        configurable: true,
+                        enumerable: true,
+                        writable: true,
+                        value: "data1"
+                      });
+
+outer = undefined;
+evaluate("function data1() { return 'data1 function'; } outer = data1;");
+assertEq(typeof data1, "function");
+assertEq(data1, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data1");
+assertEq(desc.configurable, false);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data1);
+
+
+Object.defineProperty(this, "data2",
+                      {
+                        configurable: true,
+                        enumerable: true,
+                        writable: false,
+                        value: "data2"
+                      });
+
+outer = undefined;
+evaluate("function data2() { return 'data2 function'; } outer = data2;");
+assertEq(typeof data2, "function");
+assertEq(data2, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data2");
+assertEq(desc.configurable, false);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data2);
+
+
+Object.defineProperty(this, "data3",
+                      {
+                        configurable: true,
+                        enumerable: false,
+                        writable: true,
+                        value: "data3"
+                      });
+
+outer = undefined;
+evaluate("function data3() { return 'data3 function'; } outer = data3;");
+assertEq(typeof data3, "function");
+assertEq(data3, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data3");
+assertEq(desc.configurable, false);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data3);
+
+
+Object.defineProperty(this, "data4",
+                      {
+                        configurable: true,
+                        enumerable: false,
+                        writable: false,
+                        value: "data4"
+                      });
+
+outer = undefined;
+evaluate("function data4() { return 'data4 function'; } outer = data4;");
+assertEq(typeof data4, "function");
+assertEq(data4, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data4");
+assertEq(desc.value, data4);
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, true);
+assertEq(desc.configurable, false);
+
+
+// non-configurable data properties are trickier
+
+Object.defineProperty(this, "data5",
+                      {
+                        configurable: false,
+                        enumerable: true,
+                        writable: true,
+                        value: "data5"
+                      });
+
+outer = undefined;
+evaluate("function data5() { return 'data5 function'; } outer = data5;");
+assertEq(typeof data5, "function");
+assertEq(data5, outer);
+desc = Object.getOwnPropertyDescriptor(this, "data5");
+assertEq(desc.configurable, false);
+assertEq(desc.enumerable, true);
+assertEq(desc.writable, true);
+assertEq(desc.value, data5);
+
+
+Object.defineProperty(this, "data6",
+                      {
+                        configurable: false,
+                        enumerable: true,
+                        writable: false,
+                        value: "data6"
+                      });
+
+outer = undefined;
+try
+{
+  evaluate("function data6() { return 'data6 function'; } outer = data6;");
+  throw new Error("should have thrown trying to redefine global function " +
+                  "over a non-configurable, enumerable, non-writable accessor");
+}
+catch (e)
+{
+  assertEq(e instanceof TypeError, true,
+           "global function definition, when that function would overwrite " +
+           "a non-configurable, enumerable, non-writable data property, must " +
+           "throw a TypeError per ES5+errata: " + e);
+  assertEq(data6, "data6");
+  assertEq(outer, undefined);
+  desc = Object.getOwnPropertyDescriptor(this, "data6");
+  assertEq(desc.configurable, false);
+  assertEq(desc.enumerable, true);
+  assertEq(desc.writable, false);
+  assertEq(desc.value, "data6");
+}
+
+
+Object.defineProperty(this, "data7",
+                      {
+                        configurable: false,
+                        enumerable: false,
+                        writable: true,
+                        value: "data7"
+                      });
+
+outer = undefined;
+try
+{
+  evaluate("function data7() { return 'data7 function'; } outer = data7;");
+  throw new Error("should have thrown trying to redefine global function " +
+                  "over a non-configurable, non-enumerable, writable data" +
+                  "property");
+}
+catch (e)
+{
+  assertEq(e instanceof TypeError, true,
+           "global function definition, when that function would overwrite " +
+           "a non-configurable, non-enumerable, writable data property, must " +
+           "throw a TypeError per ES5+errata: " + e);
+  assertEq(data7, "data7");
+  assertEq(outer, undefined);
+  desc = Object.getOwnPropertyDescriptor(this, "data7");
+  assertEq(desc.configurable, false);
+  assertEq(desc.enumerable, false);
+  assertEq(desc.writable, true);
+  assertEq(desc.value, "data7");
+}
+
+
+Object.defineProperty(this, "data8",
+                      {
+                        configurable: false,
+                        enumerable: false,
+                        writable: false,
+                        value: "data8"
+                      });
+
+outer = undefined;
+try
+{
+  evaluate("function data8() { return 'data8 function'; } outer = data8;");
+  throw new Error("should have thrown trying to redefine global function " +
+                  "over a non-configurable, non-enumerable, non-writable data" +
+                  "property");
+}
+catch (e)
+{
+  assertEq(e instanceof TypeError, true,
+           "global function definition, when that function would overwrite " +
+           "a non-configurable, non-enumerable, non-writable data property, " +
+           "must throw a TypeError per ES5+errata: " + e);
+  assertEq(data8, "data8");
+  assertEq(outer, undefined);
+  desc = Object.getOwnPropertyDescriptor(this, "data8");
+  assertEq(desc.configurable, false);
+  assertEq(desc.enumerable, false);
+  assertEq(desc.writable, false);
+  assertEq(desc.value, "data8");
+}
+
+/******************************************************************************/
+
+if (typeof reportCompare === "function")
+  reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/future-reserved-words.js b/js/src/tests/non262/misc/future-reserved-words.js
new file mode 100644
index 0000000000..43b1b2f607
--- /dev/null
+++ b/js/src/tests/non262/misc/future-reserved-words.js
@@ -0,0 +1,493 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 497869;
+var summary = "Implement FutureReservedWords per-spec";
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var futureReservedWords =
+  [
+   "class",
+   // "const", // Mozilla extension enabled even for versionless code
+   "enum",
+   "export",
+   "extends",
+   "import",
+   "super",
+  ];
+
+var strictFutureReservedWords =
+  [
+   "implements",
+   "interface",
+   "let", // enabled: this file doesn't execute as JS1.7
+   "package",
+   "private",
+   "protected",
+   "public",
+   "static",
+   "yield", // enabled: this file doesn't execute as JS1.7
+  ];
+
+function testWord(word, expectNormal, expectStrict)
+{
+  var actual, status;
+
+  // USE AS LHS FOR ASSIGNMENT
+
+  actual = "";
+  status = summary + ": " + word + ": normal assignment";
+  try
+  {
+    eval(word + " = 'foo';");
+    actual = "no error";
+  }
+  catch(e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict assignment";
+  try
+  {
+    eval("'use strict'; " + word + " = 'foo';");
+    actual = "no error";
+  }
+  catch(e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS DESTRUCTURING SHORTHAND
+
+  actual = "";
+  status = summary + ": " + word + ": destructuring shorthand";
+  try
+  {
+    eval("({ " + word + " } = 'foo');");
+    actual = "no error";
+  }
+  catch(e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict destructuring shorthand";
+  try
+  {
+    eval("'use strict'; ({ " + word + " } = 'foo');");
+    actual = "no error";
+  }
+  catch(e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE IN VARIABLE DECLARATION
+
+  actual = "";
+  status = summary + ": " + word + ": normal var";
+  try
+  {
+    eval("var " + word + ";");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict var";
+  try
+  {
+    eval("'use strict'; var " + word + ";");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE IN FOR-IN VARIABLE DECLARATION
+
+  actual = "";
+  status = summary + ": " + word + ": normal for-in var";
+  try
+  {
+    eval("for (var " + word + " in {});");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict for-in var";
+  try
+  {
+    eval("'use strict'; for (var " + word + " in {});");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS CATCH IDENTIFIER
+
+  actual = "";
+  status = summary + ": " + word + ": normal var";
+  try
+  {
+    eval("try { } catch (" + word + ") { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict var";
+  try
+  {
+    eval("'use strict'; try { } catch (" + word + ") { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS LABEL
+
+  actual = "";
+  status = summary + ": " + word + ": normal label";
+  try
+  {
+    eval(word + ": while (false);");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict label";
+  try
+  {
+    eval("'use strict'; " + word + ": while (false);");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS ARGUMENT NAME IN FUNCTION DECLARATION
+
+  actual = "";
+  status = summary + ": " + word + ": normal function argument";
+  try
+  {
+    eval("function foo(" + word + ") { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict function argument";
+  try
+  {
+    eval("'use strict'; function foo(" + word + ") { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  actual = "";
+  status = summary + ": " + word + ": function argument retroactively strict";
+  try
+  {
+    eval("function foo(" + word + ") { 'use strict'; }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS ARGUMENT NAME IN FUNCTION EXPRESSION
+
+  actual = "";
+  status = summary + ": " + word + ": normal function expression argument";
+  try
+  {
+    eval("var s = (function foo(" + word + ") { });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict function expression argument";
+  try
+  {
+    eval("'use strict'; var s = (function foo(" + word + ") { });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  actual = "";
+  status = summary + ": " + word + ": function expression argument retroactively strict";
+  try
+  {
+    eval("var s = (function foo(" + word + ") { 'use strict'; });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS ARGUMENT NAME WITH FUNCTION CONSTRUCTOR
+
+  actual = "";
+  status = summary + ": " + word + ": argument with normal Function";
+  try
+  {
+    Function(word, "return 17");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": argument with strict Function";
+  try
+  {
+    Function(word, "'use strict'; return 17");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS ARGUMENT NAME IN PROPERTY SETTER
+
+  actual = "";
+  status = summary + ": " + word + ": normal property setter argument";
+  try
+  {
+    eval("var o = { set x(" + word + ") { } };");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict property setter argument";
+  try
+  {
+    eval("'use strict'; var o = { set x(" + word + ") { } };");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  actual = "";
+  status = summary + ": " + word + ": property setter argument retroactively strict";
+  try
+  {
+    eval("var o = { set x(" + word + ") { 'use strict'; } };");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS FUNCTION NAME IN FUNCTION DECLARATION
+
+  actual = "";
+  status = summary + ": " + word + ": normal function name";
+  try
+  {
+    eval("function " + word + "() { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict function name";
+  try
+  {
+    eval("'use strict'; function " + word + "() { }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  actual = "";
+  status = summary + ": " + word + ": function name retroactively strict";
+  try
+  {
+    eval("function " + word + "() { 'use strict'; }");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  // USE AS FUNCTION NAME IN FUNCTION EXPRESSION
+
+  actual = "";
+  status = summary + ": " + word + ": normal function expression name";
+  try
+  {
+    eval("var s = (function " + word + "() { });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectNormal, status);
+
+  actual = "";
+  status = summary + ": " + word + ": strict function expression name";
+  try
+  {
+    eval("'use strict'; var s = (function " + word + "() { });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+
+  actual = "";
+  status = summary + ": " + word + ": function expression name retroactively strict";
+  try
+  {
+    eval("var s = (function " + word + "() { 'use strict'; });");
+    actual = "no error";
+  }
+  catch (e)
+  {
+    actual = e.name;
+    status +=  ", " + e.name + ": " + e.message + " ";
+  }
+  assertEq(actual, expectStrict, status);
+}
+
+function testFutureReservedWord(word)
+{
+  testWord(word, "SyntaxError", "SyntaxError");
+}
+
+function testStrictFutureReservedWord(word)
+{
+  testWord(word, "no error", "SyntaxError");
+}
+
+futureReservedWords.forEach(testFutureReservedWord);
+strictFutureReservedWords.forEach(testStrictFutureReservedWord);
+
+/******************************************************************************/
+
+if (typeof reportCompare === "function")
+  reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/getter-setter-outerize-this.js b/js/src/tests/non262/misc/getter-setter-outerize-this.js
new file mode 100644
index 0000000000..46c61b889a
--- /dev/null
+++ b/js/src/tests/non262/misc/getter-setter-outerize-this.js
@@ -0,0 +1,21 @@
+if (typeof window === "undefined") {
+    // This test is meant to run in the browser, but it's easy to
+    // run it in the shell as well, even though it has no inner/outer
+    // windows.
+    window = this;
+}
+
+var res = false;
+Object.defineProperty(this, "foo", {configurable: true,
+				    get: function() { return this === window; },
+				    set: function(v) { res = this === window; }});
+
+(function() {
+    for (var i = 0; i < 3000; ++i) {
+	window.foo = i;
+	assertEq(res, true, "setter");
+	assertEq(window.foo, true, "getter");
+    }
+})();
+
+reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/global-numeric-properties.js b/js/src/tests/non262/misc/global-numeric-properties.js
new file mode 100644
index 0000000000..352c0d3b75
--- /dev/null
+++ b/js/src/tests/non262/misc/global-numeric-properties.js
@@ -0,0 +1,59 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 537863;
+var summary =
+  'undefined, Infinity, and NaN global properties should not be writable';
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var desc, old, error;
+var global = this;
+
+var names = ["NaN", "Infinity", "undefined"];
+
+for (var i = 0; i < names.length; i++)
+{
+  var name = names[i];
+  desc = Object.getOwnPropertyDescriptor(global, name);
+  assertEq(desc !== undefined, true, name + " should be present");
+  assertEq(desc.enumerable, false, name + " should not be enumerable");
+  assertEq(desc.configurable, false, name + " should not be configurable");
+  assertEq(desc.writable, false, name + " should not be writable");
+
+  old = global[name];
+  global[name] = 17;
+  assertEq(global[name], old, name + " changed on setting?");
+
+  error = "before";
+  try
+  {
+    throw new TypeError("SpiderMonkey doesn't currently implement " +
+                        "strict-mode throwing when setting a readonly " +
+                        "property, not running this bit of test for now; " +
+                        "see bug 537873");
+
+    (function() { "use strict"; global[name] = 42; error = "didn't throw"; })();
+  }
+  catch (e)
+  {
+    if (e instanceof TypeError)
+      error = "typeerror";
+    else
+      error = "bad exception: " + e;
+  }
+  assertEq(error, "typeerror", "wrong strict mode error setting " + name);
+}
+
+/******************************************************************************/
+
+reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/line-paragraph-separator-parse-as-lineterminator.js b/js/src/tests/non262/misc/line-paragraph-separator-parse-as-lineterminator.js
new file mode 100644
index 0000000000..8eef6d6581
--- /dev/null
+++ b/js/src/tests/non262/misc/line-paragraph-separator-parse-as-lineterminator.js
@@ -0,0 +1,51 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 663331;
+var summary =
+  "U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR must match the " +
+  "LineTerminator production when parsing code";
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var hidden = 17;
+var assigned;
+
+assigned = 42;
+assertEq(eval('"use strict"; var hidden\u2028assigned = 5; typeof hidden'),
+         "undefined");
+assertEq(assigned, 5);
+
+assigned = 42;
+function t1()
+{
+  assertEq(eval('var hidden\u2028assigned = 5; typeof hidden'), "undefined");
+  assertEq(assigned, 5);
+}
+t1();
+
+assigned = 42;
+assertEq(eval('"use strict"; var hidden\u2029assigned = 5; typeof hidden'),
+         "undefined");
+assertEq(assigned, 5);
+
+assigned = 42;
+function t2()
+{
+  assertEq(eval('var hidden\u2029assigned = 5; typeof hidden'), "undefined");
+  assertEq(assigned, 5);
+}
+t2();
+
+/******************************************************************************/
+
+reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/new-with-non-constructor.js b/js/src/tests/non262/misc/new-with-non-constructor.js
new file mode 100644
index 0000000000..edec0e31db
--- /dev/null
+++ b/js/src/tests/non262/misc/new-with-non-constructor.js
@@ -0,0 +1,32 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+function checkConstruct(thing) {
+    try {
+        new thing();
+        assertEq(0, 1, "not reached " + thing);
+    } catch (e) {
+        assertEq(e.message.includes(" is not a constructor") ||
+                 e.message === "Function.prototype.toString called on incompatible object", true);
+    }
+}
+
+var re = /aaa/
+checkConstruct(re);
+
+var boundFunctionPrototype = Function.prototype.bind();
+checkConstruct(boundFunctionPrototype);
+
+var boundBuiltin = Math.sin.bind();
+checkConstruct(boundBuiltin);
+
+var proxiedFunctionPrototype = new Proxy(Function.prototype, {});
+checkConstruct(proxiedFunctionPrototype);
+
+var proxiedBuiltin = new Proxy(parseInt, {});
+checkConstruct(proxiedBuiltin);
+
+if (typeof reportCompare == 'function')
+    reportCompare(0, 0, "ok");
diff --git a/js/src/tests/non262/misc/redeclare-var-non-writable-property.js b/js/src/tests/non262/misc/redeclare-var-non-writable-property.js
new file mode 100644
index 0000000000..f21289d853
--- /dev/null
+++ b/js/src/tests/non262/misc/redeclare-var-non-writable-property.js
@@ -0,0 +1,24 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 539488;
+var summary =
+  '|var| statements for existing, read-only/permanent properties should not ' +
+  'be errors';
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+var undefined;
+
+/******************************************************************************/
+
+reportCompare(true, true);
+
+print("All tests passed!");
diff --git a/js/src/tests/non262/misc/regexp-functions-with-undefined.js b/js/src/tests/non262/misc/regexp-functions-with-undefined.js
new file mode 100644
index 0000000000..e55b2acd07
--- /dev/null
+++ b/js/src/tests/non262/misc/regexp-functions-with-undefined.js
@@ -0,0 +1,43 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+var a = /undefined/.exec();
+assertEq(a[0], 'undefined');
+assertEq(a.length, 1);
+
+a = /undefined/.exec(undefined);
+assertEq(a[0], 'undefined');
+assertEq(a.length, 1);
+
+assertEq(/undefined/.test(), true);
+assertEq(/undefined/.test(undefined), true);
+
+assertEq(/aaaa/.exec(), null);
+assertEq(/aaaa/.exec(undefined), null);
+
+assertEq(/aaaa/.test(), false);
+assertEq(/aaaa/.test(undefined), false);
+
+
+assertEq("undefined".search(), 0);
+assertEq("undefined".search(undefined), 0);
+assertEq("aaaa".search(), 0);
+assertEq("aaaa".search(undefined), 0);
+
+a = "undefined".match();
+assertEq(a[0], "");
+assertEq(a.length, 1);
+a = "undefined".match(undefined);
+assertEq(a[0], "");
+assertEq(a.length, 1);
+a = "aaaa".match();
+assertEq(a[0], "");
+assertEq(a.length, 1);
+a = "aaaa".match(undefined);
+assertEq(a[0], "");
+assertEq(a.length, 1);
+
+if (typeof reportCompare === "function")
+    reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/regress-bug632003.js b/js/src/tests/non262/misc/regress-bug632003.js
new file mode 100644
index 0000000000..c299f6dc42
--- /dev/null
+++ b/js/src/tests/non262/misc/regress-bug632003.js
@@ -0,0 +1,63 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ * Contributor: 
+ */
+var BUGNUMBER = 632003;
+var summary = 'The var statement should add the property to the global if it exists on the prototype';
+
+// Define properties on Object.prototype with various attributes and
+// value-getter-setter combinations then check that a var statement
+// can always define a variable with the same name in the global object.
+
+if (typeof evaluate != "undefined") {
+  var global_case = def_all("global_case");
+  evaluate(global_case.source);
+  check_values(this, global_case.var_list);
+}
+
+var eval_case = def_all("eval_case");
+eval(eval_case.source);
+check_values(this, eval_case.var_list);
+
+function def_all(prefix)
+{
+  var builder, index, i, j;
+
+  builder = {source: "", var_list: []};
+  index = 0;
+  for (i = 0; i <= 1; ++i) {
+    for (j = 0; j <= 1; ++j) {
+      def({value: index});
+      def({value: index, writable: true});
+      def({get: Function("return "+index+";")});
+      def({set: function() { }});
+      def({get: Function("return "+index+";"), set: function() { }});
+    }
+  }
+  return builder;
+  
+  function def(descriptor_seed)
+  {
+    var var_name = prefix + index;
+    descriptor_seed.configurable = !!i;
+    descriptor_seed.enumerable = !!j;
+    Object.defineProperty(Object.prototype, var_name, descriptor_seed);
+    var var_value = index + 0.5;
+    builder.source += "var "+var_name+" = "+var_value+";\n";
+    builder.var_list.push({name: var_name, expected_value: var_value});
+    ++index;
+  }
+}
+
+function check_values(obj, var_list)
+{
+  for (i = 0; i != var_list.length; ++i) {
+    var name = var_list[i].name;
+    assertEq(obj.hasOwnProperty(name), true);
+    assertEq(obj[name], var_list[i].expected_value);
+  }
+}
+
+reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/shell.js b/js/src/tests/non262/misc/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/non262/misc/shell.js
diff --git a/js/src/tests/non262/misc/syntax-error-end-of-for-head-part.js b/js/src/tests/non262/misc/syntax-error-end-of-for-head-part.js
new file mode 100644
index 0000000000..f715b3e17e
--- /dev/null
+++ b/js/src/tests/non262/misc/syntax-error-end-of-for-head-part.js
@@ -0,0 +1,51 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 672854;
+var summary =
+  "Syntax errors at the end of |for| statement header parts shouldn't cause " +
+  "crashes";
+
+print(BUGNUMBER + ": " + summary);
+
+/**************
+ * BEGIN TEST *
+ **************/
+
+function checkSyntaxError(str)
+{
+  try
+  {
+    var f = Function("for(w in\\");
+    throw new Error("didn't throw, returned " + f);
+  }
+  catch (e)
+  {
+    assertEq(e instanceof SyntaxError, true,
+             "expected SyntaxError, got " + e);
+  }
+}
+
+checkSyntaxError("for(var w in \\");
+checkSyntaxError("for(w in \\");
+checkSyntaxError("for(var w\\");
+checkSyntaxError("for(w\\");
+checkSyntaxError("for(var w;\\");
+checkSyntaxError("for(w;\\");
+checkSyntaxError("for(var w; w >\\");
+checkSyntaxError("for(w; w >\\");
+checkSyntaxError("for(var w; w > 3;\\");
+checkSyntaxError("for(w; w > 3;\\");
+checkSyntaxError("for(var w; w > 3; 5\\");
+checkSyntaxError("for(w; w > 3; 5\\");
+checkSyntaxError("for(var w; w > 3; 5foo");
+checkSyntaxError("for(w; w > 3; 5foo");
+
+/******************************************************************************/
+
+reportCompare(true, true);
+
+print("Tests complete!");
diff --git a/js/src/tests/non262/misc/unicode-escaped-keyword.js b/js/src/tests/non262/misc/unicode-escaped-keyword.js
new file mode 100644
index 0000000000..e17df168c9
--- /dev/null
+++ b/js/src/tests/non262/misc/unicode-escaped-keyword.js
@@ -0,0 +1,22 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+function throws(code) {
+    var type;
+    try {
+        eval(code);
+    } catch (ex) {
+        type = ex.name;
+    }
+    assertEq(type, 'SyntaxError');
+}
+
+var s = '\\u0073';
+throws('var thi' + s);
+throws('switch (' + s + 'witch) {}')
+throws('var ' + s + 'witch');
+
+if (typeof reportCompare == 'function')
+    reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/unicode-identifier-1d17.js b/js/src/tests/non262/misc/unicode-identifier-1d17.js
new file mode 100644
index 0000000000..ae763fdf27
--- /dev/null
+++ b/js/src/tests/non262/misc/unicode-identifier-1d17.js
@@ -0,0 +1,16 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+var o = {}
+try {
+    eval('o.\\u1d17 = 42;');
+}
+catch (e) {
+    assertEq('should not fail', true);
+}
+assertEq(o['\u1d17'], 42);
+
+if (typeof reportCompare == 'function')
+    reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/unicode-identifier-82f1.js b/js/src/tests/non262/misc/unicode-identifier-82f1.js
new file mode 100644
index 0000000000..313832cc37
--- /dev/null
+++ b/js/src/tests/non262/misc/unicode-identifier-82f1.js
@@ -0,0 +1,16 @@
+/*
+ * Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/
+ */
+
+var o = {}
+try {
+    eval('o.\\u82f1 = 42;');
+}
+catch (e) {
+    assertEq('should not fail', true);
+}
+assertEq(o['\u82f1'], 42);
+
+if (typeof reportCompare == 'function')
+    reportCompare(true, true);
diff --git a/js/src/tests/non262/misc/unnamed-function.js b/js/src/tests/non262/misc/unnamed-function.js
new file mode 100644
index 0000000000..3f9035a684
--- /dev/null
+++ b/js/src/tests/non262/misc/unnamed-function.js
@@ -0,0 +1,42 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//-----------------------------------------------------------------------------
+var BUGNUMBER = 376052;
+var summary = 'Unnamed function expressions are forbidden in statement context';
+
+
+//-----------------------------------------------------------------------------
+test();
+//-----------------------------------------------------------------------------
+
+function test()
+{
+  printBugNumber(BUGNUMBER);
+  printStatus (summary);
+
+  try
+  {
+    eval('(function () {1;})');
+    reportCompare(true, true,
+                  "unnamed function expression not in statement context works");
+  }
+  catch(ex)
+  {
+    reportCompare(true, false, "threw exception: " + ex);
+  }
+
+  try
+  {
+    eval('function () {1;}');
+    reportCompare(true, false, "didn't throw an exception");
+  }
+  catch(ex)
+  {
+    reportCompare(ex instanceof SyntaxError, true,
+                  "unnamed function expression not in statement context " +
+                  "should have been a SyntaxError");
+  }
+}
diff --git a/js/src/tests/non262/misc/unwrapped-no-such-method.js b/js/src/tests/non262/misc/unwrapped-no-such-method.js
new file mode 100644
index 0000000000..d17406e7bb
--- /dev/null
+++ b/js/src/tests/non262/misc/unwrapped-no-such-method.js
@@ -0,0 +1,13 @@
+// Our __noSuchMethod__ handling should only be called when |this| is an object.
+
+var x = "";
+// Reached from interpreter's JSOP_CALLPROP, and js::mjit::ic::CallProp.
+try { x.i(); } catch (ex) { }
+
+// Reached from interpreter's JSOP_CALLELEM, and js::mjit::stubs::CallElem.
+try { x[x](); } catch (ex) { }
+
+// Reached from js::mjit::stubs::CallProp:
+try { true.i(); } catch(ex) { }
+
+reportCompare(true,true);