Stage 1-4: Update tests

8 files changed, 375 insertions, 5 deletions

diff --git a/js/src/tests/ecma_2017/Function/Object-toSource.js b/js/src/tests/ecma_2017/Function/Object-toSource.js
new file mode 100644
index 0000000000..33b9e588ee
--- /dev/null
+++ b/js/src/tests/ecma_2017/Function/Object-toSource.js
@@ -0,0 +1,370 @@
+var BUGNUMBER = 1317400;

+var summary = "Function string representation in Object.prototype.toSource";

+

+print(BUGNUMBER + ": " + summary);

+

+// Methods.

+

+assertEq(({ foo(){} }).toSource(),

+         "({foo(){}})");

+assertEq(({ *foo(){} }).toSource(),

+         "({*foo(){}})");

+assertEq(({ async foo(){} }).toSource(),

+         "({async foo(){}})");

+

+assertEq(({ 1(){} }).toSource(),

+         "({1(){}})");

+

+// Methods with more spacing.

+// Spacing is kept.

+

+assertEq(({ foo (){} }).toSource(),

+         "({foo (){}})");

+assertEq(({ foo () {} }).toSource(),

+         "({foo () {}})");

+

+// Methods with computed name.

+// Method syntax is composed.

+

+let name = "foo";

+assertEq(({ [name](){} }).toSource(),

+         "({foo(){}})");

+assertEq(({ *[name](){} }).toSource(),

+         "({*foo(){}})");

+assertEq(({ async [name](){} }).toSource(),

+         "({async foo(){}})");

+

+assertEq(({ [ Symbol.iterator ](){} }).toSource(),

+         "({[Symbol.iterator](){}})");

+

+// Accessors.

+

+assertEq(({ get foo(){} }).toSource(),

+         "({get foo(){}})");

+assertEq(({ set foo(v){} }).toSource(),

+         "({set foo(v){}})");

+

+// Accessors with computed name.

+// Method syntax is composed.

+

+assertEq(({ get [name](){} }).toSource(),

+         "({get foo(){}})");

+assertEq(({ set [name](v){} }).toSource(),

+         "({set foo(v){}})");

+

+assertEq(({ get [ Symbol.iterator ](){} }).toSource(),

+         "({get [Symbol.iterator](){}})");

+assertEq(({ set [ Symbol.iterator ](v){} }).toSource(),

+         "({set [Symbol.iterator](v){}})");

+

+// Getter and setter with same name.

+// Getter always comes before setter.

+

+assertEq(({ get foo(){}, set foo(v){} }).toSource(),

+         "({get foo(){}, set foo(v){}})");

+assertEq(({ set foo(v){}, get foo(){} }).toSource(),

+         "({get foo(){}, set foo(v){}})");

+

+// Normal properties.

+

+assertEq(({ foo: function(){} }).toSource(),

+         "({foo:(function(){})})");

+assertEq(({ foo: function bar(){} }).toSource(),

+         "({foo:(function bar(){})})");

+assertEq(({ foo: function*(){} }).toSource(),

+         "({foo:(function*(){})})");

+assertEq(({ foo: async function(){} }).toSource(),

+         "({foo:(async function(){})})");

+

+// Normal properties with computed name.

+

+assertEq(({ [ Symbol.iterator ]: function(){} }).toSource(),

+         "({[Symbol.iterator]:(function(){})})");

+

+// Dynamically defined properties with function expression.

+// Never become a method syntax.

+

+let obj = {};

+obj.foo = function() {};

+assertEq(obj.toSource(),

+         "({foo:(function() {})})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: function() {}});

+assertEq(obj.toSource(),

+         "({})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({foo:(function() {})})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: function bar() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({foo:(function bar() {})})");

+

+obj = {};

+Object.defineProperty(obj, Symbol.iterator, {value: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({[Symbol.iterator]:(function() {})})");

+

+// Dynamically defined property with other object's method.

+// Method syntax is composed.

+

+let method = ({foo() {}}).foo;

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: method, enumerable: true});

+assertEq(obj.toSource(),

+         "({foo() {}})");

+

+obj = {};

+Object.defineProperty(obj, "bar", {value: method, enumerable: true});

+assertEq(obj.toSource(),

+         "({bar() {}})");

+

+method = ({*foo() {}}).foo;

+

+obj = {};

+Object.defineProperty(obj, "bar", {value: method, enumerable: true});

+assertEq(obj.toSource(),

+         "({*bar() {}})");

+

+method = ({async foo() {}}).foo;

+

+obj = {};

+Object.defineProperty(obj, "bar", {value: method, enumerable: true});

+assertEq(obj.toSource(),

+         "({async bar() {}})");

+

+// Dynamically defined accessors.

+// Accessor syntax is composed.

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+obj = {};

+Object.defineProperty(obj, Symbol.iterator, {get: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({get [Symbol.iterator]() {}})");

+

+obj = {};

+Object.defineProperty(obj, Symbol.iterator, {set: function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({set [Symbol.iterator]() {}})");

+

+// Dynamically defined accessors with other object's accessors.

+// Accessor syntax is composed.

+

+let accessor = Object.getOwnPropertyDescriptor({ get foo() {} }, "foo").get;

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ get bar() {} }, "bar").get;

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ set foo(v) {} }, "foo").set;

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo(v) {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ set bar(v) {} }, "bar").set;

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo(v) {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ get foo() {} }, "foo").get;

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ get bar() {} }, "bar").get;

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ set foo(v) {} }, "foo").set;

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo(v) {}})");

+

+accessor = Object.getOwnPropertyDescriptor({ set bar(v) {} }, "bar").set;

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo(v) {}})");

+

+// Methods with proxy.

+// Treated as normal property.

+

+method = ({foo() {}}).foo;

+let handler = {

+  get(that, name) {

+    if (name == "toSource") {

+      return function() {

+        return that.toSource();

+      };

+    }

+    return that[name];

+  }

+};

+let proxy = new Proxy(method, handler);

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: proxy, enumerable: true});

+assertEq(obj.toSource(),

+         "({foo:foo() {}})");

+

+// Accessors with proxy.

+// Accessor syntax is composed.

+

+accessor = Object.getOwnPropertyDescriptor({ get foo() {} }, "foo").get;

+proxy = new Proxy(accessor, handler);

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: proxy, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: proxy, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+// Methods from other global.

+// Treated as normal property.

+

+let g = newGlobal();

+

+method = g.eval("({ foo() {} }).foo");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: method, enumerable: true});

+assertEq(obj.toSource(),

+         "({foo:foo() {}})");

+

+// Accessors from other global.

+// Accessor syntax is composed.

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ get foo() {} }, 'foo').get");

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ get bar() {} }, 'bar').get");

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ set foo(v) {} }, 'foo').set");

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo(v) {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ set bar(v) {} }, 'bar').set");

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo(v) {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ get foo() {} }, 'foo').get");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ get bar() {} }, 'bar').get");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ set foo(v) {} }, 'foo').set");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo(v) {}})");

+

+accessor = g.eval("Object.getOwnPropertyDescriptor({ set bar(v) {} }, 'bar').set");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: accessor, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo(v) {}})");

+

+// **** Some weird cases ****

+

+// Accessors with generator or async.

+

+obj = {};

+Object.defineProperty(obj, "foo", {get: function*() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({get foo() {}})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {set: async function() {}, enumerable: true});

+assertEq(obj.toSource(),

+         "({set foo() {}})");

+

+// Modified toSource.

+

+obj = { foo() {} };

+obj.foo.toSource = () => "hello";

+assertEq(obj.toSource(),

+         "({hello})");

+

+obj = { foo() {} };

+obj.foo.toSource = () => "bar() {}";

+assertEq(obj.toSource(),

+         "({bar() {}})");

+

+// Modified toSource with different method name.

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: function bar() {}, enumerable: true});

+obj.foo.toSource = () => "hello";

+assertEq(obj.toSource(),

+         "({foo:hello})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: function* bar() {}, enumerable: true});

+obj.foo.toSource = () => "hello";

+assertEq(obj.toSource(),

+         "({foo:hello})");

+

+obj = {};

+Object.defineProperty(obj, "foo", {value: async function bar() {}, enumerable: true});

+obj.foo.toSource = () => "hello";

+assertEq(obj.toSource(),

+         "({foo:hello})");

+

+if (typeof reportCompare === "function")

+    reportCompare(true, true);

diff --git a/js/src/tests/ecma_2017/Function/browser.js b/js/src/tests/ecma_2017/Function/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/ecma_2017/Function/browser.js
diff --git a/js/src/tests/ecma_2017/Function/shell.js b/js/src/tests/ecma_2017/Function/shell.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/ecma_2017/Function/shell.js
diff --git a/js/src/tests/ecma_6/Generators/runtime.js b/js/src/tests/ecma_6/Generators/runtime.js
index c4d3bb6a66..7146eef9ff 100644
--- a/js/src/tests/ecma_6/Generators/runtime.js
+++ b/js/src/tests/ecma_6/Generators/runtime.js
@@ -109,7 +109,7 @@ function TestGeneratorFunction() {
     // Doesn't matter particularly what string gets serialized, as long
     // as it contains "function*" and "yield 10".
     assertEq(GeneratorFunction('yield 10').toString(),
-             "function* anonymous() {\nyield 10\n}");
+             "function* anonymous(\n) {\nyield 10\n}");
 }
 TestGeneratorFunction();
 
diff --git a/js/src/tests/js1_5/Scope/regress-185485.js b/js/src/tests/js1_5/Scope/regress-185485.js
index 19d190eeaa..a75bf885a9 100644
--- a/js/src/tests/js1_5/Scope/regress-185485.js
+++ b/js/src/tests/js1_5/Scope/regress-185485.js
@@ -94,7 +94,7 @@ with (x)
 }
 status = inSection(5);
 actual = x.g.toString();
-expect = (function () {}).toString();
+expect = (function() {}).toString();
 addThis();
 
 
diff --git a/js/src/tests/js1_7/extensions/regress-354945-01.js b/js/src/tests/js1_7/extensions/regress-354945-01.js
index 76f1a3c82f..1c57db0f7f 100644
--- a/js/src/tests/js1_7/extensions/regress-354945-01.js
+++ b/js/src/tests/js1_7/extensions/regress-354945-01.js
@@ -6,7 +6,7 @@
 //-----------------------------------------------------------------------------
 var BUGNUMBER = 354945;
 var summary = 'Do not crash with new Iterator';
-var expect = 'TypeError: trap __iterator__ for ({__iterator__:(function (){ })}) returned a primitive value';
+var expect = 'TypeError: trap __iterator__ for ({__iterator__:(function(){ })}) returned a primitive value';
 var actual;
 
 
diff --git a/js/src/tests/js1_7/extensions/regress-354945-02.js b/js/src/tests/js1_7/extensions/regress-354945-02.js
index 261bf7de17..abef90f77f 100644
--- a/js/src/tests/js1_7/extensions/regress-354945-02.js
+++ b/js/src/tests/js1_7/extensions/regress-354945-02.js
@@ -20,7 +20,7 @@ function test()
   printBugNumber(BUGNUMBER);
   printStatus (summary);
  
-  expect = 'TypeError: trap __iterator__ for ({__iterator__:(function (){ })}) returned a primitive value';
+  expect = 'TypeError: trap __iterator__ for ({__iterator__:(function(){ })}) returned a primitive value';
   var obj = {};
   obj.__iterator__ = function(){ };
   try
diff --git a/js/src/tests/js1_8_5/regress/regress-584355.js b/js/src/tests/js1_8_5/regress/regress-584355.js
index 4ddfe65d35..7d1b81a2ec 100644
--- a/js/src/tests/js1_8_5/regress/regress-584355.js
+++ b/js/src/tests/js1_8_5/regress/regress-584355.js
@@ -1,5 +1,5 @@
 var actual;
-var expect = "function f() { ff (); }";
+var expect = "function f () { ff (); }";
 function fun() {
     (new Function ("function ff () { actual = '' + ff. caller; } function f () { ff (); } f ();")) ();
 }