Merge pull request #1722 from leobalter/curation-20180822

JSC Tests Curation, the stress folder

implementation-contributed/curation_logs/stress.md

@@ -17,4 +17,90 @@
 - set-*.js / map-*.js / weakmap-set-*.js / weakset-*.js:
     - Test static return values for before and after adding an item in an WeakSet.
 - zero-to-string.js:
-    - Number#toString is not checked over literal numbers but number objects only.
+    - Number#toString is not checked over literal numbers but number objects only.
+
+- assign-argument-in-inlined-call.js
+    - No coverage for fn_name.arguments going to inner scopes.
+- assignment-in-function-call-bracket-node.js
+    - Tests obj computer propety names containing expressions that evaluates to `null`.
+- async-arrow-function-in-class-heritage.js
+    - Tests class heritage failing with arrow functions (no constructor). Might have coverage, not found yet.
+- async-arrow-functions-*.js
+    - No tests checking for lexical arguments/new.target/etc in async arrow functions
+    - Async arrow functions needs some refactoring
+- inferred-names.js
+    - Needs to add tests for multiple anonymous fn forms, verify the .name property is properly set
+    - Web Compat fix: https://github.com/Microsoft/ChakraCore/issues/3407
+- builtin-function-is-construct-type-none.js
+    - Add a forEach test with a new.target call
+    - Extend it to other methods
+    - >
+    "Built-in Function Objects
+
+    ...
+    Built-in function objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a particular function. When a built-in constructor is called as part of a new expression the argumentsList parameter of the invoked [[Construct]] internal method provides the values for the built-in constructor's named parameters.
+
+    Built-in functions that are not constructors do not have a prototype property unless otherwise specified in the description of a particular function."
+- builtin-function-length.js
+    - Add length property check for function forms in the language folder
+- computed-accessor.js / computed-accessor-parsing.js
+    - Review the coverage of test/language/computed-property-names
+    - good to use the test generation tool to create cases to be reused for objects and classes, etc
+    - should check type coercion as well, using composed objects too
+- completion-value.js
+    - v8: add tests for completion value resolution in try/catch/finally blocks (anything returning -2)
+        - `eval('99; do { -99; try { 42 } catch (e) { -1 } finally { -2; break; -3 }; } while (false);')`
+        - `eval('99; do { -99; try { [].x.x } catch (e) { 42; } finally { -2; break; -3 }; } while (false);')`
+        - `eval('99; do { -99; try { 42 } catch (e) { -1 } finally { -2; break; -3 }; -77 } while (false);')`
+        - `eval('99; do { -99; try { [].x.x } catch (e) { 42; } finally { -2; break; -3 }; -77 } while (false);')`
+        - `eval('99; do { -99; try { 42 } catch (e) { -1 } finally { -2; continue; -3 }; } while (false);')`
+        - `eval('99; do { -99; try { [].x.x } catch (e) { 42; } finally { -2; continue; -3 }; } while (false);')`
+        - `eval('99; do { -99; try { 42 } catch (e) { -1 } finally { -2; continue; -3 }; -77 } while (false);')`
+        - `eval('99; do { -99; try { [].x.x } catch (e) { 42; } finally { -2; continue; -3 }; -77 } while (false);')`
+        - expected: 42
+        - actual: -2
+    - sm cases are already covered
+- concat-append-one-with-sparse-array.js
+    - Append a small value in a very long array - not any specific part of the specs to check - test is slow but maybe worth considering?
+- create-subclass-structure-may-throw-exception-when-getting-prototype.js
+    - tests are inconsistent in different engines
+    - verify this on the usage for Reflect.construct
+- custom-iterators.js
+    - it would be interesting to create templates and cases for iteration over objects. Using Symbol.iterator (and Symbol.asyncIterator) in for-of loops, for-of-await loops, Array.from, etc etc etc
+    - The examples in that test file would be interesting to create __iterator like__ objects
+    - ChakraCore is apparently reporting of a wrong error constructor
+- custom-prototype-may-be-same-to-original-one.js
+    - Tests that Reflect.constructor can use a custom prototype with the same reference for the original one
+- error-description-on-symbols-should-not-crash.js
+    - Symbols are not callable...
+- exception-in-to-property-key-should-be-handled-early-in-object-methods.js
+    - Review coverage for Object#hasOwnProperty, add coercions for the this value
+- function-caller-*.js
+    - Verify .caller behavior for nested functions, retrieving the function body.
+    - Results are diverging from JSC (abrupt completion) to other engines (no error)
+- global-environment-does-not-trap-unscopables.js
+    - duplicate `language/with/binding-blocked-by-unscopables.js` to assert binding block of the global in inner scopes, deferring references to the local scope.
+- ignore-promise-species.js
+    - add coverage for Promise.all and race handling a local `@@species`
+- modify-set-during-iteration.js
+    - Add coverage for iterating Set/Map/WeakSet/WeakMap objects with values being changed during the iteration. (e.g. for-of loops)
+- module-namespace-access*js
+    - review these tests for import()
+- private-name-as-anonymous-builtin.js
+    - Review name property for the executor functions in Promise.resolve calls
+- regress-187006.js
+    - check if we have coverage for regexp `match` setting array values.
+- regress-179634.js
+    - review coverage for Object.defineProperties
+- regress-170732.js
+    - review coverage for valid and invalid await expressions
+- regress-159883.js
+    - review common forms for invalid dates
+- regress-189317.js
+    - AnnexB defineGetter/Setter being used with built-in functions
+    - cross engine errors
+- string-to-string-error.js / string-value-of-error.js
+    - Needs coverage for the this value in `String#toString` and `String#valueOf`
+    - Also verify with ordinary objects containing toPrimitive methods.
+- reserved-word-with-escape.js
+    - Add coverage for checking reserved names - mostly `var` - as global variables, using escape sequences.

implementation-contributed/javascriptcore/stress/IIFE-es6-default-parameters.js

@@ -1,35 +0,0 @@
-
-function assert(b) {
-    if (!b)
-        throw new Error("Bad assertion");
-}
-
-for (var i = 0; i < 1000; i++) {
-
-    ;(function foo(x = 20) {
-        assert(typeof foo === "function");
-    })();
-
-    ;(function foo(x = 20) {
-        function bar() { return foo; }
-        assert(typeof foo === "function");
-    })();
-
-    ;(function foo(x = foo) {
-        var foo = 20;
-        assert(foo === 20);
-        assert(typeof x === "function");
-    })();
-
-    ;(function foo(capFoo = function() { return foo; }) {
-        var foo = 20;
-        assert(foo === 20);
-        assert(typeof capFoo() === "function");
-    })();
-
-    ;(function foo(x = eval("foo")) {
-        var foo = 20;
-        assert(foo === 20);
-        assert(typeof x === "function");
-    })();
-}

implementation-contributed/javascriptcore/stress/IIFE-function-name-captured.js

@@ -1,38 +0,0 @@
-function assert(b) {
-    if (!b)
-        throw new Error("Bad assertion");
-}
-
-for (var i = 0; i < 1000; i++) {
-    ;(function foo() {
-        foo = 20;
-        assert(foo !== 20);
-        assert(typeof foo === "function");
-    })();
-
-    ;(function foo() {
-        var bar = function() { return foo; }
-        foo = 20;
-        assert(foo !== 20);
-        assert(bar() !== 20);
-        assert(typeof foo === "function");
-        assert(typeof bar() === "function");
-    })();
-
-    ;(function foo() {
-        eval("foo = 20;");
-        assert(foo !== 20);
-        assert(typeof foo === "function");
-    })();
-
-    ;(function foo() {
-        eval("var foo = 20;");
-        assert(foo === 20);
-    })();
-
-    ;(function foo() {
-        "use strict";
-        assert(foo !== 20);
-        assert(typeof foo === "function");
-    })();
-}

implementation-contributed/javascriptcore/stress/JSON-parse-should-cache-array-lengths.js

@@ -1,100 +0,0 @@
-// This test should not hang, and should call the reviver function the expected number of times.
-
-function shouldBe(actualExpr, expectedExpr) {
-    function toString(x) {
-        return "" + x;
-    }
-
-    let actual = eval(actualExpr);
-    let expected = eval(expectedExpr);
-    if (typeof actual != typeof expected)
-        throw Error("expected type " + typeof expected + " actual type " + typeof actual);
-    if (toString(actual) != toString(expected))
-        throw Error("expected: " + expected + " actual: " + actual);
-}
-
-let result;
-let visited;
-
-function test(parseString, clearLength) {
-    visited = [];
-    var result = JSON.parse(parseString, function (key, value) {
-        visited.push('{' + key + ':' + value + '}');
-        if (clearLength)
-            this.length = 0;
-        return; // returning undefined deletes the value.
-    });
-    return result;
-}
-
-result = test('[10]', false);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{:}']");
-shouldBe("visited.length", "2");
-
-result = test('[10]', true);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{:}']");
-shouldBe("visited.length", "2");
-
-result = test('[ [ 10, 11 ], 12, [13, 14, 15], 16, 17]', false);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{1:11}','{0:,}','{1:12}','{0:13}','{1:14}','{2:15}','{2:,,}','{3:16}','{4:17}','{:,,,,}']");
-shouldBe("visited.length", "11");
-
-result = test('[ [ 10, 11 ], 12, [13, 14, 15], 16, 17]', true);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{1:undefined}','{0:}','{1:undefined}','{2:undefined}','{3:undefined}','{4:undefined}','{:}']");
-shouldBe("visited.length", "8");
-
-result = test('[ { "a": [ 10, 11 ], "b": 12 } , [ 13, { "c": 14 }, 15], 16, 17]', false);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{1:11}','{a:,}','{b:12}','{0:[object Object]}','{0:13}','{c:14}','{1:[object Object]}','{2:15}','{1:,,}','{2:16}','{3:17}','{:,,,}']");
-shouldBe("visited.length", "13");
-
-result = test('[ { "a": [ 10, 11 ], "b": 12 } , [ 13, { "c": 14 }, 15], 16, 17]', true);
-shouldBe("result", "undefined");
-shouldBe("visited", "['{0:10}','{1:undefined}','{a:}','{b:12}','{0:[object Object]}','{1:undefined}','{2:undefined}','{3:undefined}','{:}']");
-shouldBe("visited.length", "9");
-
-
-function test2(parseString, clearLength) {
-    visited = [];
-    var result = JSON.parse(parseString, function (key, value) {
-        visited.push('{' + key + ':' + value + '}');
-        if (clearLength)
-            this.length = 0;
-        return (typeof value === "number") ? value * 2 : value;
-    });
-    return result;
-}
-
-result = test2('[10]', false);
-shouldBe("result", "[20]");
-shouldBe("visited", "['{0:10}','{:20}']");
-shouldBe("visited.length", "2");
-
-result = test2('[10]', true);
-shouldBe("result", "[20]");
-shouldBe("visited", "['{0:10}','{:20}']");
-shouldBe("visited.length", "2");
-
-result = test2('[ [ 10, 11 ], 12, [13, 14, 15], 16, 17]', false);
-shouldBe("result", "[20,22,24,26,28,30,32,34]");
-shouldBe("visited", "['{0:10}','{1:11}','{0:20,22}','{1:12}','{0:13}','{1:14}','{2:15}','{2:26,28,30}','{3:16}','{4:17}','{:20,22,24,26,28,30,32,34}']");
-shouldBe("visited.length", "11");
-
-result = test2('[ [ 10, 11 ], 12, [13, 14, 15], 16, 17]', true);
-shouldBe("result", "[]");
-shouldBe("visited", "['{0:10}','{1:undefined}','{0:}','{1:undefined}','{2:undefined}','{3:undefined}','{4:undefined}','{:}']");
-shouldBe("visited.length", "8");
-
-result = test2('[ { "a": [ 10, 11 ], "b": 12 } , [ 13, { "c": 14 }, 15], 16, 17]', false);
-shouldBe("result", "['[object Object]',26,'[object Object]',30,32,34]");
-shouldBe("visited", "['{0:10}','{1:11}','{a:20,22}','{b:12}','{0:[object Object]}','{0:13}','{c:14}','{1:[object Object]}','{2:15}','{1:26,[object Object],30}','{2:16}','{3:17}','{:[object Object],26,[object Object],30,32,34}']");
-shouldBe("visited.length", "13");
-
-result = test2('[ { "a": [ 10, 11 ], "b": 12 } , [ 13, { "c": 14 }, 15], 16, 17]', true);
-shouldBe("result", "[]");
-shouldBe("visited", "['{0:10}','{1:undefined}','{a:}','{b:12}','{0:[object Object]}','{1:undefined}','{2:undefined}','{3:undefined}','{:}']");
-shouldBe("visited.length", "9");

implementation-contributed/javascriptcore/stress/accessors-get-set-prefix.js

@@ -1,34 +0,0 @@
-function tryGetOwnPropertyDescriptorGetName(obj, property, expectedName)
-{
-    let descriptor = Object.getOwnPropertyDescriptor(obj, property);
-    if (!descriptor)
-        throw "Couldn't find property descriptor on object " + obj.toString() + " for property " + property.toString();
-
-    let getter = descriptor.get;
-    if (!getter)
-        throw "Property " + property.toString() + " on object " + obj.toString() + " is not a getter";
-
-    let getterName = getter.name;
-    if (getterName !== expectedName)
-        throw "Wrong getter name for property " + property.toString() + " on object " + obj.toString() + " expected " + expectedName + " got " + getterName;
-}
-
-tryGetOwnPropertyDescriptorGetName(Array, Symbol.species, "get [Symbol.species]");
-tryGetOwnPropertyDescriptorGetName(Map, Symbol.species, "get [Symbol.species]");
-tryGetOwnPropertyDescriptorGetName(Set, Symbol.species, "get [Symbol.species]");
-tryGetOwnPropertyDescriptorGetName(RegExp, Symbol.species, "get [Symbol.species]");
-tryGetOwnPropertyDescriptorGetName(Promise, Symbol.species, "get [Symbol.species]");
-tryGetOwnPropertyDescriptorGetName(Map.prototype, "size", "get size");
-tryGetOwnPropertyDescriptorGetName(Set.prototype, "size", "get size");
-tryGetOwnPropertyDescriptorGetName(RegExp.prototype, "flags", "get flags");
-tryGetOwnPropertyDescriptorGetName(RegExp.prototype, "sticky", "get sticky");
-tryGetOwnPropertyDescriptorGetName(RegExp.prototype, "source", "get source");
-
-if (Object.__lookupGetter__("__proto__").name !== "get __proto__")
-    throw "Expected Object __proto__ getter to be named \"get __proto\"";
-
-if (Object.__lookupSetter__("__proto__").name !== "set __proto__")
-    throw "Expected Object __proto__ setter to be named \"set __proto\"";
-
-if (Int32Array.prototype.__lookupGetter__("byteOffset").name !== "get byteOffset")
-    throw "Expected TypedArray.prototype byteOffset getter to be named \"get byteOffset\"";

implementation-contributed/javascriptcore/stress/addition-order-evaluation.js

@@ -1,3 +1,4 @@
+// Reviewed
 function assert(a, message) {
     if (!a)
         throw new Error(message);

implementation-contributed/javascriptcore/stress/allow-math-ic-b3-code-duplication.js

@@ -1,3 +1,4 @@
+// Reviewed
 function test1() {
     var o1;
     for (let i = 0; i < 1000000; ++i) {

implementation-contributed/javascriptcore/stress/apply-second-argument-must-be-array-like.js

@@ -1,3 +1,4 @@
+// Reviewed
 //@ runDefault
 
 function assert(x) {

implementation-contributed/javascriptcore/stress/arguments-bizarre-behavior.js

@@ -1,25 +0,0 @@
-function foo(x) {
-    Object.defineProperty(arguments, 0, {configurable: true, enumerable: true, writable:true, value:42});
-    return [x, arguments[0], arguments]
-}
-
-var result = foo(1);
-
-if (result[0] !== 42)
-    throw new Error();
-
-if (result[1] !== 42)
-    throw new Error();
-
-if (Array.prototype.join.call(result[2], ",") != "42")
-    throw new Error();
-
-var array = [];
-for (var s in result[2])
-    array.push(s);
-
-if (array.join(",") != "0")
-    throw new Error();
-
-if (Object.keys(result[2]).join(",") != "0")
-    throw new Error();

implementation-contributed/javascriptcore/stress/arguments-bizarre-behaviour-disable-enumerability.js

@@ -1,28 +0,0 @@
-function foo(x) {
-    Object.defineProperty(arguments, 0, {configurable: true, enumerable: false, writable:true, value:42});
-    return [x, arguments[0], arguments]
-}
-
-var result = foo(1);
-
-if (result[0] !== 42)
-    throw new Error();
-
-if (result[1] !== 42)
-    throw new Error();
-
-if (Array.prototype.join.call(result[2], ",") != "42")
-    throw new Error();
-
-var array = [];
-for (var s in result[2])
-    array.push(s);
-
-if (array.join(",") != "0")
-    throw new Error();
-
-if (Object.keys(result[2]).join(",") != "0")
-    throw new Error();
-
-if (Object.getOwnPropertyDescriptor(result[2], 0).enumerable === true)
-    throw new Error();

implementation-contributed/javascriptcore/stress/arith-abs-integer-range-optimization.js

@@ -1,139 +0,0 @@
-function negativeRange(results)
-{
-    for (var i = -1; i > -10; --i) {
-        results[Math.abs(i)] = i;
-    }
-}
-noInline(negativeRange);
-
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    negativeRange(results);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 10; ++j) {
-        if (j < 1) {
-            if (results[j] !== undefined)
-                throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-            continue;
-        }
-        if (results[j] !== -j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-function negativeRangeIncludingZero(results)
-{
-    for (var i = 0; i > -10; --i) {
-        results[Math.abs(i)] = i;
-    }
-}
-noInline(negativeRangeIncludingZero);
-
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    negativeRangeIncludingZero(results);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 10; ++j) {
-        if (results[j] !== -j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-function negativeRangeWithOverflow(results, limit)
-{
-    var i = -2147483648 + 10;
-    do {
-        results.push(Math.abs(i));
-        --i;
-    } while (i !== limit);
-}
-noInline(negativeRangeWithOverflow);
-
-// First, we warm up without overflow.
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    negativeRangeWithOverflow(results, -2147483647);
-    if (results.length != 9)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 9; ++j) {
-        if (results[j] !== 2147483638 + j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-// Then we overflow.
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    negativeRangeWithOverflow(results, -2147483648);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 10; ++j) {
-        if (results[j] !== 2147483638 + j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-function positiveRange(results)
-{
-    for (var i = 1; i < 10; ++i) {
-        results[Math.abs(i)] = i;
-    }
-}
-noInline(positiveRange);
-
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    positiveRange(results);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 10; ++j) {
-        if (j < 1) {
-            if (results[j] !== undefined)
-                throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-            continue;
-        }
-        if (results[j] !== j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-function positiveRangeIncludingZero(results)
-{
-    for (var i = 0; i < 10; ++i) {
-        results[Math.abs(i)] = i;
-    }
-}
-noInline(positiveRangeIncludingZero);
-
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    positiveRangeIncludingZero(results);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = 0; j < 10; ++j) {
-        if (results[j] !== j)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}
-
-function rangeWithoutOverflow(results)
-{
-    for (var i = -10; i < 10; ++i) {
-        results[i] = Math.abs(i);
-    }
-}
-noInline(rangeWithoutOverflow);
-
-for (var i = 0; i < 1e4; ++i) {
-    var results = [];
-    rangeWithoutOverflow(results);
-    if (results.length != 10)
-        throw "Wrong result length: " + results.length;
-    for (var j = -10; j < 10; ++j) {
-        var expected = (j < 0) ? -j : j;
-        if (results[j] !== expected)
-            throw "Wrong result, results[j] = " + results[j] + " at j = " + j;
-    }
-}

implementation-contributed/javascriptcore/stress/arith-abs-on-various-types.js

@@ -1,3 +1,4 @@
+// Reviewed
 //@ skip if not $jitTests
 //@ defaultNoEagerRun
 "use strict";

implementation-contributed/javascriptcore/stress/arith-acos-on-various-types.js

@@ -1,3 +1,4 @@
+// Reviewed
 //@ skip if not $jitTests
 //@ defaultNoEagerRun
 "use strict";

implementation-contributed/javascriptcore/stress/arith-acosh-on-various-types.js

@@ -1,3 +1,4 @@
+// Reviewed
 //@ skip if not $jitTests
 //@ defaultNoEagerRun
 "use strict";

implementation-contributed/javascriptcore/stress/arith-asin-on-various-types.js

@@ -1,237 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let asinOfHalf = Math.asin(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["1", "" + Math.asin(1)],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "" + asinOfHalf],
-    ["Math.PI", "" + Math.asin(Math.PI)],
-    ["Infinity", "NaN"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + asinOfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + asinOfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.asin() without arguments.
-function opaqueASinNoArgument() {
-    return Math.asin();
-}
-noInline(opaqueASinNoArgument);
-noOSRExitFuzzing(opaqueASinNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueASinNoArgument();
-        if (output === output) {
-            throw "Failed opaqueASinNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueASinNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.asin() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesASin(argument) {
-    return Math.asin(argument);
-}
-noInline(opaqueAllTypesASin);
-noOSRExitFuzzing(opaqueAllTypesASin);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesASin(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesASin) > 2)
-        throw "We should have detected asin() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.asin() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueASin(argument) {
-                return Math.asin(argument);
-            }
-            noInline(opaqueASin);
-            noOSRExitFuzzing(opaqueASin);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueASin(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueASin) > 1)
-                throw "We should have compiled a single asin for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.asin() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueASinOnConstant() {
-                return Math.asin(${testCaseInput[0]});
-            }
-            noInline(opaqueASinOnConstant);
-            noOSRExitFuzzing(opaqueASinOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueASinOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueASinOnConstant) > 1)
-                throw "We should have compiled a single asin for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueASinForSideEffects(argument) {
-    return Math.asin(argument);
-}
-noInline(opaqueASinForSideEffects);
-noOSRExitFuzzing(opaqueASinForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let asinResult = Math.asin(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueASinForSideEffects(testObject) !== asinResult)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueASinForSideEffects) > 1)
-        throw "opaqueASinForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify asin() is not subject to CSE if the argument has side effects.
-function opaqueASinForCSE(argument) {
-    return Math.asin(argument) + Math.asin(argument) + Math.asin(argument);
-}
-noInline(opaqueASinForCSE);
-noOSRExitFuzzing(opaqueASinForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let asinResult = Math.asin(0.2);
-    let threeasinResult = asinResult + asinResult + asinResult;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueASinForCSE(testObject) !== threeasinResult)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueASinForCSE) > 1)
-        throw "opaqueASinForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify asin() is not subject to DCE if the argument has side effects.
-function opaqueASinForDCE(argument) {
-    Math.asin(argument);
-}
-noInline(opaqueASinForDCE);
-noOSRExitFuzzing(opaqueASinForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueASinForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueASinForDCE) > 1)
-        throw "opaqueASinForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueASinWithException(argument) {
-        let result = Math.asin(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueASinWithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let asinResult = Math.asin(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueASinWithException(testObject) !== asinResult)
-            throw "Incorrect result in opaqueASinWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueASinWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueASinWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-asinh-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let asinhOfFour = Math.asinh(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + asinhOfFour],
-    ["Math.PI", "" + Math.asinh(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + asinhOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + asinhOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.asinh() without arguments.
-function opaqueASinhNoArgument() {
-    return Math.asinh();
-}
-noInline(opaqueASinhNoArgument);
-noOSRExitFuzzing(opaqueASinhNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueASinhNoArgument();
-        if (output === output) {
-            throw "Failed opaqueASinhNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueASinhNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.asinh() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesASinh(argument) {
-    return Math.asinh(argument);
-}
-noInline(opaqueAllTypesASinh);
-noOSRExitFuzzing(opaqueAllTypesASinh);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesASinh(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesASinh) > 2)
-        throw "We should have detected asinh() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.asinh() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueASinh(argument) {
-                return Math.asinh(argument);
-            }
-            noInline(opaqueASinh);
-            noOSRExitFuzzing(opaqueASinh);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueASinh(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueASinh) > 1)
-                throw "We should have compiled a single asinh for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.asinh() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueASinhOnConstant() {
-                return Math.asinh(${testCaseInput[0]});
-            }
-            noInline(opaqueASinhOnConstant);
-            noOSRExitFuzzing(opaqueASinhOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueASinhOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueASinhOnConstant) > 1)
-                throw "We should have compiled a single asinh for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueASinhForSideEffects(argument) {
-    return Math.asinh(argument);
-}
-noInline(opaqueASinhForSideEffects);
-noOSRExitFuzzing(opaqueASinhForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let asinh16 = Math.asinh(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueASinhForSideEffects(testObject) !== asinh16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueASinhForSideEffects) > 1)
-        throw "opaqueASinhForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify asinh() is not subject to CSE if the argument has side effects.
-function opaqueASinhForCSE(argument) {
-    return Math.asinh(argument) + Math.asinh(argument) + Math.asinh(argument);
-}
-noInline(opaqueASinhForCSE);
-noOSRExitFuzzing(opaqueASinhForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let asinh16 = Math.asinh(16);
-    let threeASinh16 = asinh16 + asinh16 + asinh16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueASinhForCSE(testObject) !== threeASinh16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueASinhForCSE) > 1)
-        throw "opaqueASinhForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify asinh() is not subject to DCE if the argument has side effects.
-function opaqueASinhForDCE(argument) {
-    Math.asinh(argument);
-}
-noInline(opaqueASinhForDCE);
-noOSRExitFuzzing(opaqueASinhForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueASinhForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueASinhForDCE) > 1)
-        throw "opaqueASinhForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueASinhWithException(argument) {
-        let result = Math.asinh(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueASinhWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let asinh64 = Math.asinh(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueASinhWithException(testObject) !== asinh64)
-            throw "Incorrect result in opaqueASinhWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueASinhWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueASinhWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-atan-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let atanOfFour = Math.atan(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + atanOfFour],
-    ["Math.PI", "" + Math.atan(Math.PI)],
-    ["Infinity", "" + Math.atan(Infinity)],
-    ["-Infinity", "-" + Math.atan(Infinity)],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + atanOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + atanOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.atan() without arguments.
-function opaqueATanNoArgument() {
-    return Math.atan();
-}
-noInline(opaqueATanNoArgument);
-noOSRExitFuzzing(opaqueATanNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueATanNoArgument();
-        if (output === output) {
-            throw "Failed opaqueATanNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueATanNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.atan() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesATan(argument) {
-    return Math.atan(argument);
-}
-noInline(opaqueAllTypesATan);
-noOSRExitFuzzing(opaqueAllTypesATan);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesATan(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesATan) > 2)
-        throw "We should have detected atan() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.atan() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueATan(argument) {
-                return Math.atan(argument);
-            }
-            noInline(opaqueATan);
-            noOSRExitFuzzing(opaqueATan);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueATan(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueATan) > 1)
-                throw "We should have compiled a single atan for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.atan() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueATanOnConstant() {
-                return Math.atan(${testCaseInput[0]});
-            }
-            noInline(opaqueATanOnConstant);
-            noOSRExitFuzzing(opaqueATanOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueATanOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueATanOnConstant) > 1)
-                throw "We should have compiled a single atan for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueATanForSideEffects(argument) {
-    return Math.atan(argument);
-}
-noInline(opaqueATanForSideEffects);
-noOSRExitFuzzing(opaqueATanForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let AtanResult = Math.atan(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueATanForSideEffects(testObject) !== AtanResult)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueATanForSideEffects) > 1)
-        throw "opaqueATanForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify atan() is not subject to CSE if the argument has side effects.
-function opaqueATanForCSE(argument) {
-    return Math.atan(argument) + Math.atan(argument) + Math.atan(argument);
-}
-noInline(opaqueATanForCSE);
-noOSRExitFuzzing(opaqueATanForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let AtanResult = Math.atan(16);
-    let threeAtanResult = AtanResult + AtanResult + AtanResult;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueATanForCSE(testObject) !== threeAtanResult)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueATanForCSE) > 1)
-        throw "opaqueATanForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify atan() is not subject to DCE if the argument has side effects.
-function opaqueATanForDCE(argument) {
-    Math.atan(argument);
-}
-noInline(opaqueATanForDCE);
-noOSRExitFuzzing(opaqueATanForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueATanForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueATanForDCE) > 1)
-        throw "opaqueATanForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueATanWithException(argument) {
-        let result = Math.atan(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueATanWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let atanResult = Math.atan(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueATanWithException(testObject) !== atanResult)
-            throw "Incorrect result in opaqueATanWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueATanWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueATanWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-atanh-on-various-types.js

@@ -1,237 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let atanhOfHalf = Math.atanh(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["1", "Infinity"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "" + atanhOfHalf],
-    ["Math.PI", "" + Math.atanh(Math.PI)],
-    ["Infinity", "NaN"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + atanhOfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + atanhOfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.atanh() without arguments.
-function opaqueATanhNoArgument() {
-    return Math.atanh();
-}
-noInline(opaqueATanhNoArgument);
-noOSRExitFuzzing(opaqueATanhNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueATanhNoArgument();
-        if (output === output) {
-            throw "Failed opaqueATanhNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueATanhNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.atanh() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesATanh(argument) {
-    return Math.atanh(argument);
-}
-noInline(opaqueAllTypesATanh);
-noOSRExitFuzzing(opaqueAllTypesATanh);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesATanh(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesATanh) > 2)
-        throw "We should have detected atanh() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.atanh() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueATanh(argument) {
-                return Math.atanh(argument);
-            }
-            noInline(opaqueATanh);
-            noOSRExitFuzzing(opaqueATanh);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueATanh(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueATanh) > 1)
-                throw "We should have compiled a single atanh for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.atanh() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueATanhOnConstant() {
-                return Math.atanh(${testCaseInput[0]});
-            }
-            noInline(opaqueATanhOnConstant);
-            noOSRExitFuzzing(opaqueATanhOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueATanhOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueATanhOnConstant) > 1)
-                throw "We should have compiled a single atanh for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueATanhForSideEffects(argument) {
-    return Math.atanh(argument);
-}
-noInline(opaqueATanhForSideEffects);
-noOSRExitFuzzing(opaqueATanhForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let atanhResult = Math.atanh(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueATanhForSideEffects(testObject) !== atanhResult)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueATanhForSideEffects) > 1)
-        throw "opaqueATanhForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify atanh() is not subject to CSE if the argument has side effects.
-function opaqueATanhForCSE(argument) {
-    return Math.atanh(argument) + Math.atanh(argument) + Math.atanh(argument);
-}
-noInline(opaqueATanhForCSE);
-noOSRExitFuzzing(opaqueATanhForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let atanhResult = Math.atanh(0.2);
-    let threeatanhResult = atanhResult + atanhResult + atanhResult;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueATanhForCSE(testObject) !== threeatanhResult)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueATanhForCSE) > 1)
-        throw "opaqueATanhForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify atanh() is not subject to DCE if the argument has side effects.
-function opaqueATanhForDCE(argument) {
-    Math.atanh(argument);
-}
-noInline(opaqueATanhForDCE);
-noOSRExitFuzzing(opaqueATanhForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueATanhForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueATanhForDCE) > 1)
-        throw "opaqueATanhForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueATanhWithException(argument) {
-        let result = Math.atanh(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueATanhWithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let atanhResult = Math.atanh(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueATanhWithException(testObject) !== atanhResult)
-            throw "Incorrect result in opaqueATanhWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueATanhWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueATanhWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-cbrt-on-various-types.js

@@ -1,238 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let cbrtOfHalf = Math.cbrt(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["1", "1"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["-42.", "" + Math.cbrt(-42)],
-    ["0.5", "" + cbrtOfHalf],
-    ["Math.PI", "" + Math.cbrt(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + cbrtOfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + cbrtOfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.cbrt() without arguments.
-function opaqueCbrtNoArgument() {
-    return Math.cbrt();
-}
-noInline(opaqueCbrtNoArgument);
-noOSRExitFuzzing(opaqueCbrtNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueCbrtNoArgument();
-        if (output === output) {
-            throw "Failed opaqueCbrtNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueCbrtNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.cbrt() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesCbrt(argument) {
-    return Math.cbrt(argument);
-}
-noInline(opaqueAllTypesCbrt);
-noOSRExitFuzzing(opaqueAllTypesCbrt);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesCbrt(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesCbrt) > 2)
-        throw "We should have detected cbrt() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.cbrt() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCbrt(argument) {
-                return Math.cbrt(argument);
-            }
-            noInline(opaqueCbrt);
-            noOSRExitFuzzing(opaqueCbrt);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCbrt(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCbrt) > 1)
-                throw "We should have compiled a single cbrt for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.cbrt() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCbrtOnConstant() {
-                return Math.cbrt(${testCaseInput[0]});
-            }
-            noInline(opaqueCbrtOnConstant);
-            noOSRExitFuzzing(opaqueCbrtOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCbrtOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCbrtOnConstant) > 1)
-                throw "We should have compiled a single cbrt for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueCbrtForSideEffects(argument) {
-    return Math.cbrt(argument);
-}
-noInline(opaqueCbrtForSideEffects);
-noOSRExitFuzzing(opaqueCbrtForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let cbrtResult = Math.cbrt(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCbrtForSideEffects(testObject) !== cbrtResult)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueCbrtForSideEffects) > 1)
-        throw "opaqueCbrtForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify cbrt() is not subject to CSE if the argument has side effects.
-function opaqueCbrtForCSE(argument) {
-    return Math.cbrt(argument) + Math.cbrt(argument) + Math.cbrt(argument);
-}
-noInline(opaqueCbrtForCSE);
-noOSRExitFuzzing(opaqueCbrtForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let cbrtResult = Math.cbrt(0.2);
-    let threecbrtResult = cbrtResult + cbrtResult + cbrtResult;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCbrtForCSE(testObject) !== threecbrtResult)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueCbrtForCSE) > 1)
-        throw "opaqueCbrtForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify cbrt() is not subject to DCE if the argument has side effects.
-function opaqueCbrtForDCE(argument) {
-    Math.cbrt(argument);
-}
-noInline(opaqueCbrtForDCE);
-noOSRExitFuzzing(opaqueCbrtForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueCbrtForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueCbrtForDCE) > 1)
-        throw "opaqueCbrtForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueCbrtWithException(argument) {
-        let result = Math.cbrt(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueCbrtWithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let cbrtResult = Math.cbrt(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueCbrtWithException(testObject) !== cbrtResult)
-            throw "Incorrect result in opaqueCbrtWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueCbrtWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueCbrtWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-ceil-on-various-types.js

@@ -1,308 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "1"],
-    ["-0.5", "-0"],
-    ["4", "4"],
-    ["42.1", "43"],
-    ["42.5", "43"],
-    ["42.9", "43"],
-    ["-42.1", "-42"],
-    ["-42.5", "-42"],
-    ["-42.9", "-42"],
-    ["Math.PI", "4"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "4"],
-    ["\"42.5\"", "43"],
-    ["{ valueOf: () => { return 4; } }", "4"],
-    ["{ valueOf: () => { return 0; } }", "0"],
-    ["{ valueOf: () => { return -0; } }", "-0"],
-    ["{ valueOf: () => { return 0.5; } }", "1"],
-    ["{ valueOf: () => { return -0.5; } }", "-0"],
-    ["{ valueOf: () => { return Number.MIN_SAFE_INTEGER; } }", "-9007199254740991"],
-    ["{ valueOf: () => { return Number.MAX_SAFE_INTEGER; } }", "9007199254740991"],
-    ["{ valueOf: () => { return 0x80000000|0; } }", "-2147483648"],
-    ["{ valueOf: () => { return 0x7fffffff|0; } }", "2147483647"],
-    ["{ valueOf: () => { return (0x80000000|0) - 0.5; } }", "-2147483648"],
-    ["{ valueOf: () => { return (0x7fffffff|0) + 0.5; } }", "2147483648"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && (1 / expected) !== (1 / result))
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.ceil() without arguments.
-function opaqueCeilNoArgument() {
-    return Math.ceil();
-}
-noInline(opaqueCeilNoArgument);
-noOSRExitFuzzing(opaqueCeilNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueCeilNoArgument();
-        if (!isIdentical(output, NaN)) {
-            throw "Failed opaqueCeilNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueCeilNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.ceil() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesCeil(argument) {
-    return Math.ceil(argument);
-}
-noInline(opaqueAllTypesCeil);
-noOSRExitFuzzing(opaqueAllTypesCeil);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesCeil(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesCeil) > 3)
-        throw "We should have detected ceil() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Polymorphic input but negative zero is not observable.
-function opaqueAllTypesCeilWithoutNegativeZero(argument) {
-    return Math.ceil(argument) + 0;
-}
-noInline(opaqueAllTypesCeilWithoutNegativeZero);
-noOSRExitFuzzing(opaqueAllTypesCeilWithoutNegativeZero);
-
-function testAllTypesWithoutNegativeZeroCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesCeilWithoutNegativeZero(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1] + 0))
-                throw "Failed testAllTypesWithoutNegativeZeroCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesCeil) > 3)
-        throw "We should have detected ceil() was polymorphic and generated a generic version.";
-}
-testAllTypesWithoutNegativeZeroCall();
-
-
-// Test Math.ceil() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCeil(argument) {
-                return Math.ceil(argument);
-            }
-            noInline(opaqueCeil);
-            noOSRExitFuzzing(opaqueCeil);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCeil(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCeil) > 1)
-                throw "We should have compiled a single ceil for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-function checkCompileCountForUselessNegativeZero(testFunction)
-{
-    if (jscOptions().useMaximalFlushInsertionPhase) {
-        // If we forced a flush after the operation, the negative zero becomes
-        // observable and we may be overly optimistic.
-        return numberOfDFGCompiles(testFunction) <= 2;
-    }
-    return numberOfDFGCompiles(testFunction) <= 1;
-}
-
-
-// Test Math.ceil() on a completely typed input, but without negative zero.
-function testSingleTypeWithoutNegativeZeroCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCeil(argument) {
-                return Math.ceil(argument) + 0;
-            }
-            noInline(opaqueCeil);
-            noOSRExitFuzzing(opaqueCeil);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCeil(${testCaseInput[0]}), ${testCaseInput[1]} + 0)) {
-                    throw "Failed testSingleTypeWithoutNegativeZeroCall()";
-                }
-            }
-            if (!checkCompileCountForUselessNegativeZero(opaqueCeil))
-                throw "We should have compiled a single ceil for the expected type.";
-        `);
-    }
-}
-testSingleTypeWithoutNegativeZeroCall();
-
-
-// Test Math.ceil() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCeilOnConstant() {
-                return Math.ceil(${testCaseInput[0]});
-            }
-            noInline(opaqueCeilOnConstant);
-            noOSRExitFuzzing(opaqueCeilOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCeilOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCeilOnConstant) > 1)
-                throw "We should have compiled a single ceil for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueCeilForSideEffects(argument) {
-    return Math.ceil(argument);
-}
-noInline(opaqueCeilForSideEffects);
-noOSRExitFuzzing(opaqueCeilForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let ceil16 = Math.ceil(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCeilForSideEffects(testObject) !== ceil16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueCeilForSideEffects) > 1)
-        throw "opaqueCeilForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify ceil() is not subject to CSE if the argument has side effects.
-function opaqueCeilForCSE(argument) {
-    return Math.ceil(argument) + Math.ceil(argument) + Math.ceil(argument);
-}
-noInline(opaqueCeilForCSE);
-noOSRExitFuzzing(opaqueCeilForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let ceil16 = Math.ceil(16);
-    let threeCeil16 = ceil16 + ceil16 + ceil16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCeilForCSE(testObject) !== threeCeil16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueCeilForCSE) > 1)
-        throw "opaqueCeilForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify ceil() is not subject to DCE if the argument has side effects.
-function opaqueCeilForDCE(argument) {
-    Math.ceil(argument);
-}
-noInline(opaqueCeilForDCE);
-noOSRExitFuzzing(opaqueCeilForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueCeilForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueCeilForDCE) > 1)
-        throw "opaqueCeilForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueCeilWithException(argument) {
-        let result = Math.ceil(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueCeilWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let ceil64 = Math.ceil(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueCeilWithException(testObject) !== ceil64)
-            throw "Incorrect result in opaqueCeilWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueCeilWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueCeilWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-clz32-on-various-types.js

@@ -1,234 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "32"],
-    ["null", "32"],
-    ["0", "32"],
-    ["-0.", "32"],
-    ["4", "29"],
-    ["Math.PI", "30"],
-    ["Infinity", "32"],
-    ["-Infinity", "32"],
-    ["NaN", "32"],
-    ["\"WebKit\"", "32"],
-    ["\"4\"", "29"],
-    ["{ valueOf: () => { return 4; } }", "29"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.clz32() without arguments.
-function opaqueClz32NoArgument() {
-    return Math.clz32();
-}
-noInline(opaqueClz32NoArgument);
-noOSRExitFuzzing(opaqueClz32NoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueClz32NoArgument();
-        if (output !== 32) {
-            throw "Failed opaqueClz32NoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueClz32NoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.clz32() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesClz32(argument) {
-    return Math.clz32(argument);
-}
-noInline(opaqueAllTypesClz32);
-noOSRExitFuzzing(opaqueAllTypesClz32);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesClz32(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesClz32) > 2)
-        throw "We should have detected clz32() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.clz32() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueClz32(argument) {
-                return Math.clz32(argument);
-            }
-            noInline(opaqueClz32);
-            noOSRExitFuzzing(opaqueClz32);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueClz32(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueClz32) > 1)
-                throw "We should have compiled a single clz32 for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.clz32() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueClz32OnConstant() {
-                return Math.clz32(${testCaseInput[0]});
-            }
-            noInline(opaqueClz32OnConstant);
-            noOSRExitFuzzing(opaqueClz32OnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueClz32OnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueClz32OnConstant) > 1)
-                throw "We should have compiled a single clz32 for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueClz32ForSideEffects(argument) {
-    return Math.clz32(argument);
-}
-noInline(opaqueClz32ForSideEffects);
-noOSRExitFuzzing(opaqueClz32ForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let clz3216 = Math.clz32(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueClz32ForSideEffects(testObject) !== clz3216)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueClz32ForSideEffects) > 1)
-        throw "opaqueClz32ForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify clz32() is not subject to CSE if the argument has side effects.
-function opaqueClz32ForCSE(argument) {
-    return Math.clz32(argument) + Math.clz32(argument) + Math.clz32(argument);
-}
-noInline(opaqueClz32ForCSE);
-noOSRExitFuzzing(opaqueClz32ForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let clz3216 = Math.clz32(16);
-    let threeClz3216 = clz3216 + clz3216 + clz3216;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueClz32ForCSE(testObject) !== threeClz3216)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueClz32ForCSE) > 1)
-        throw "opaqueClz32ForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify clz32() is not subject to DCE if the argument has side effects.
-function opaqueClz32ForDCE(argument) {
-    Math.clz32(argument);
-}
-noInline(opaqueClz32ForDCE);
-noOSRExitFuzzing(opaqueClz32ForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueClz32ForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueClz32ForDCE) > 1)
-        throw "opaqueClz32ForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueClz32WithException(argument) {
-        let result = Math.clz32(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueClz32WithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let clz3264 = Math.clz32(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueClz32WithException(testObject) !== clz3264)
-            throw "Incorrect result in opaqueClz32WithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueClz32WithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueClz32WithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-cos-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let cosOfFour = Math.cos(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "1"],
-    ["0", "1"],
-    ["-0.", "1"],
-    ["4", "" + cosOfFour],
-    ["Math.PI", "-1"],
-    ["Infinity", "NaN"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + cosOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + cosOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.cos() without arguments.
-function opaqueCosNoArgument() {
-    return Math.cos();
-}
-noInline(opaqueCosNoArgument);
-noOSRExitFuzzing(opaqueCosNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueCosNoArgument();
-        if (output === output) {
-            throw "Failed opaqueCosNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueCosNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.cos() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesCos(argument) {
-    return Math.cos(argument);
-}
-noInline(opaqueAllTypesCos);
-noOSRExitFuzzing(opaqueAllTypesCos);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesCos(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesCos) > 2)
-        throw "We should have detected cos() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.cos() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCos(argument) {
-                return Math.cos(argument);
-            }
-            noInline(opaqueCos);
-            noOSRExitFuzzing(opaqueCos);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCos(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCos) > 1)
-                throw "We should have compiled a single cos for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.cos() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCosOnConstant() {
-                return Math.cos(${testCaseInput[0]});
-            }
-            noInline(opaqueCosOnConstant);
-            noOSRExitFuzzing(opaqueCosOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCosOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCosOnConstant) > 1)
-                throw "We should have compiled a single cos for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueCosForSideEffects(argument) {
-    return Math.cos(argument);
-}
-noInline(opaqueCosForSideEffects);
-noOSRExitFuzzing(opaqueCosForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let cos16 = Math.cos(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCosForSideEffects(testObject) !== cos16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueCosForSideEffects) > 1)
-        throw "opaqueCosForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify cos() is not subject to CSE if the argument has side effects.
-function opaqueCosForCSE(argument) {
-    return Math.cos(argument) + Math.cos(argument) + Math.cos(argument);
-}
-noInline(opaqueCosForCSE);
-noOSRExitFuzzing(opaqueCosForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let cos16 = Math.cos(16);
-    let threeCos16 = cos16 + cos16 + cos16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCosForCSE(testObject) !== threeCos16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueCosForCSE) > 1)
-        throw "opaqueCosForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify cos() is not subject to DCE if the argument has side effects.
-function opaqueCosForDCE(argument) {
-    Math.cos(argument);
-}
-noInline(opaqueCosForDCE);
-noOSRExitFuzzing(opaqueCosForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueCosForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueCosForDCE) > 1)
-        throw "opaqueCosForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueCosWithException(argument) {
-        let result = Math.cos(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueCosWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let cos64 = Math.cos(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueCosWithException(testObject) !== cos64)
-            throw "Incorrect result in opaqueCosWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueCosWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueCosWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-cosh-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let coshOfFour = Math.cosh(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "1"],
-    ["0", "1"],
-    ["-0.", "1"],
-    ["4", "" + coshOfFour],
-    ["Math.PI", "" + Math.cosh(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + coshOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + coshOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.cosh() without arguments.
-function opaqueCoshNoArgument() {
-    return Math.cosh();
-}
-noInline(opaqueCoshNoArgument);
-noOSRExitFuzzing(opaqueCoshNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueCoshNoArgument();
-        if (output === output) {
-            throw "Failed opaqueCoshNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueCoshNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.cosh() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesCosh(argument) {
-    return Math.cosh(argument);
-}
-noInline(opaqueAllTypesCosh);
-noOSRExitFuzzing(opaqueAllTypesCosh);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesCosh(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesCosh) > 2)
-        throw "We should have detected cosh() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.cosh() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCosh(argument) {
-                return Math.cosh(argument);
-            }
-            noInline(opaqueCosh);
-            noOSRExitFuzzing(opaqueCosh);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCosh(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCosh) > 1)
-                throw "We should have compiled a single cosh for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.cosh() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueCoshOnConstant() {
-                return Math.cosh(${testCaseInput[0]});
-            }
-            noInline(opaqueCoshOnConstant);
-            noOSRExitFuzzing(opaqueCoshOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueCoshOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueCoshOnConstant) > 1)
-                throw "We should have compiled a single cosh for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueCoshForSideEffects(argument) {
-    return Math.cosh(argument);
-}
-noInline(opaqueCoshForSideEffects);
-noOSRExitFuzzing(opaqueCoshForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let cosh16 = Math.cosh(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCoshForSideEffects(testObject) !== cosh16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueCoshForSideEffects) > 1)
-        throw "opaqueCoshForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify cosh() is not subject to CSE if the argument has side effects.
-function opaqueCoshForCSE(argument) {
-    return Math.cosh(argument) + Math.cosh(argument) + Math.cosh(argument);
-}
-noInline(opaqueCoshForCSE);
-noOSRExitFuzzing(opaqueCoshForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let cosh16 = Math.cosh(16);
-    let threeCosh16 = cosh16 + cosh16 + cosh16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueCoshForCSE(testObject) !== threeCosh16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueCoshForCSE) > 1)
-        throw "opaqueCoshForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify cosh() is not subject to DCE if the argument has side effects.
-function opaqueCoshForDCE(argument) {
-    Math.cosh(argument);
-}
-noInline(opaqueCoshForDCE);
-noOSRExitFuzzing(opaqueCoshForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueCoshForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueCoshForDCE) > 1)
-        throw "opaqueCoshForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueCoshWithException(argument) {
-        let result = Math.cosh(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueCoshWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let cosh64 = Math.cosh(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueCoshWithException(testObject) !== cosh64)
-            throw "Incorrect result in opaqueCoshWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueCoshWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueCoshWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-expm1-on-various-types.js

@@ -1,237 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let expm1OfHalf = Math.expm1(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["1", "" + Math.expm1(1)],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "" + expm1OfHalf],
-    ["Math.PI", "" + Math.expm1(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-1"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + expm1OfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + expm1OfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.expm1() without arguments.
-function opaqueExpm1NoArgument() {
-    return Math.expm1();
-}
-noInline(opaqueExpm1NoArgument);
-noOSRExitFuzzing(opaqueExpm1NoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueExpm1NoArgument();
-        if (output === output) {
-            throw "Failed opaqueExpm1NoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueExpm1NoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.expm1() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesExpm1(argument) {
-    return Math.expm1(argument);
-}
-noInline(opaqueAllTypesExpm1);
-noOSRExitFuzzing(opaqueAllTypesExpm1);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesExpm1(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesExpm1) > 2)
-        throw "We should have detected expm1() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.expm1() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueExpm1(argument) {
-                return Math.expm1(argument);
-            }
-            noInline(opaqueExpm1);
-            noOSRExitFuzzing(opaqueExpm1);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueExpm1(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueExpm1) > 1)
-                throw "We should have compiled a single expm1 for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.expm1() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueExpm1OnConstant() {
-                return Math.expm1(${testCaseInput[0]});
-            }
-            noInline(opaqueExpm1OnConstant);
-            noOSRExitFuzzing(opaqueExpm1OnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueExpm1OnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueExpm1OnConstant) > 1)
-                throw "We should have compiled a single expm1 for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueExpm1ForSideEffects(argument) {
-    return Math.expm1(argument);
-}
-noInline(opaqueExpm1ForSideEffects);
-noOSRExitFuzzing(opaqueExpm1ForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let expm1Result = Math.expm1(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueExpm1ForSideEffects(testObject) !== expm1Result)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueExpm1ForSideEffects) > 1)
-        throw "opaqueExpm1ForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify expm1() is not subject to CSE if the argument has side effects.
-function opaqueExpm1ForCSE(argument) {
-    return Math.expm1(argument) + Math.expm1(argument) + Math.expm1(argument);
-}
-noInline(opaqueExpm1ForCSE);
-noOSRExitFuzzing(opaqueExpm1ForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let expm1Result = Math.expm1(0.2);
-    let threeexpm1Result = expm1Result + expm1Result + expm1Result;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueExpm1ForCSE(testObject) !== threeexpm1Result)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueExpm1ForCSE) > 1)
-        throw "opaqueExpm1ForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify expm1() is not subject to DCE if the argument has side effects.
-function opaqueExpm1ForDCE(argument) {
-    Math.expm1(argument);
-}
-noInline(opaqueExpm1ForDCE);
-noOSRExitFuzzing(opaqueExpm1ForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueExpm1ForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueExpm1ForDCE) > 1)
-        throw "opaqueExpm1ForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueExpm1WithException(argument) {
-        let result = Math.expm1(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueExpm1WithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let expm1Result = Math.expm1(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueExpm1WithException(testObject) !== expm1Result)
-            throw "Incorrect result in opaqueExpm1WithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueExpm1WithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueExpm1WithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-floor-on-various-types.js

@@ -1,308 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "0"],
-    ["-0.5", "-1"],
-    ["4", "4"],
-    ["42.1", "42"],
-    ["42.5", "42"],
-    ["42.9", "42"],
-    ["-42.1", "-43"],
-    ["-42.5", "-43"],
-    ["-42.9", "-43"],
-    ["Math.PI", "3"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "4"],
-    ["\"42.5\"", "42"],
-    ["{ valueOf: () => { return 4; } }", "4"],
-    ["{ valueOf: () => { return 0; } }", "0"],
-    ["{ valueOf: () => { return -0; } }", "-0"],
-    ["{ valueOf: () => { return 0.5; } }", "0"],
-    ["{ valueOf: () => { return -0.5; } }", "-1"],
-    ["{ valueOf: () => { return Number.MIN_SAFE_INTEGER; } }", "-9007199254740991"],
-    ["{ valueOf: () => { return Number.MAX_SAFE_INTEGER; } }", "9007199254740991"],
-    ["{ valueOf: () => { return 0x80000000|0; } }", "-2147483648"],
-    ["{ valueOf: () => { return 0x7fffffff|0; } }", "2147483647"],
-    ["{ valueOf: () => { return (0x80000000|0) - 0.5; } }", "-2147483649"],
-    ["{ valueOf: () => { return (0x7fffffff|0) + 0.5; } }", "2147483647"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && (1 / expected) !== (1 / result))
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.floor() without arguments.
-function opaqueFloorNoArgument() {
-    return Math.floor();
-}
-noInline(opaqueFloorNoArgument);
-noOSRExitFuzzing(opaqueFloorNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueFloorNoArgument();
-        if (!isIdentical(output, NaN)) {
-            throw "Failed opaqueFloorNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueFloorNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.floor() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesFloor(argument) {
-    return Math.floor(argument);
-}
-noInline(opaqueAllTypesFloor);
-noOSRExitFuzzing(opaqueAllTypesFloor);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesFloor(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesFloor) > 3)
-        throw "We should have detected floor() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Polymorphic input but negative zero is not observable.
-function opaqueAllTypesFloorWithoutNegativeZero(argument) {
-    return Math.floor(argument) + 0;
-}
-noInline(opaqueAllTypesFloorWithoutNegativeZero);
-noOSRExitFuzzing(opaqueAllTypesFloorWithoutNegativeZero);
-
-function testAllTypesWithoutNegativeZeroCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesFloorWithoutNegativeZero(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1] + 0))
-                throw "Failed testAllTypesWithoutNegativeZeroCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesFloor) > 3)
-        throw "We should have detected floor() was polymorphic and generated a generic version.";
-}
-testAllTypesWithoutNegativeZeroCall();
-
-
-// Test Math.floor() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueFloor(argument) {
-                return Math.floor(argument);
-            }
-            noInline(opaqueFloor);
-            noOSRExitFuzzing(opaqueFloor);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueFloor(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueFloor) > 1)
-                throw "We should have compiled a single floor for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-function checkCompileCountForUselessNegativeZero(testFunction)
-{
-    if (jscOptions().useMaximalFlushInsertionPhase) {
-        // If we forced a flush after the operation, the negative zero becomes
-        // observable and we may be overly optimistic.
-        return numberOfDFGCompiles(testFunction) <= 2;
-    }
-    return numberOfDFGCompiles(testFunction) <= 1;
-}
-
-
-// Test Math.floor() on a completely typed input, but without negative zero.
-function testSingleTypeWithoutNegativeZeroCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueFloor(argument) {
-                return Math.floor(argument) + 0;
-            }
-            noInline(opaqueFloor);
-            noOSRExitFuzzing(opaqueFloor);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueFloor(${testCaseInput[0]}), ${testCaseInput[1]} + 0)) {
-                    throw "Failed testSingleTypeWithoutNegativeZeroCall()";
-                }
-            }
-            if (!checkCompileCountForUselessNegativeZero(opaqueFloor))
-                throw "We should have compiled a single floor for the expected type.";
-        `);
-    }
-}
-testSingleTypeWithoutNegativeZeroCall();
-
-
-// Test Math.floor() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueFloorOnConstant() {
-                return Math.floor(${testCaseInput[0]});
-            }
-            noInline(opaqueFloorOnConstant);
-            noOSRExitFuzzing(opaqueFloorOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueFloorOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueFloorOnConstant) > 1)
-                throw "We should have compiled a single floor for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueFloorForSideEffects(argument) {
-    return Math.floor(argument);
-}
-noInline(opaqueFloorForSideEffects);
-noOSRExitFuzzing(opaqueFloorForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let floor16 = Math.floor(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueFloorForSideEffects(testObject) !== floor16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueFloorForSideEffects) > 1)
-        throw "opaqueFloorForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify floor() is not subject to CSE if the argument has side effects.
-function opaqueFloorForCSE(argument) {
-    return Math.floor(argument) + Math.floor(argument) + Math.floor(argument);
-}
-noInline(opaqueFloorForCSE);
-noOSRExitFuzzing(opaqueFloorForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let floor16 = Math.floor(16);
-    let threeFloor16 = floor16 + floor16 + floor16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueFloorForCSE(testObject) !== threeFloor16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueFloorForCSE) > 1)
-        throw "opaqueFloorForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify floor() is not subject to DCE if the argument has side effects.
-function opaqueFloorForDCE(argument) {
-    Math.floor(argument);
-}
-noInline(opaqueFloorForDCE);
-noOSRExitFuzzing(opaqueFloorForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueFloorForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueFloorForDCE) > 1)
-        throw "opaqueFloorForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueFloorWithException(argument) {
-        let result = Math.floor(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueFloorWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let floor64 = Math.floor(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueFloorWithException(testObject) !== floor64)
-            throw "Incorrect result in opaqueFloorWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueFloorWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueFloorWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-fround-on-various-types.js

@@ -1,238 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let froundOfPi = Math.fround(Math.PI);
-let froundOfE = Math.fround(Math.E);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["1.", "1"],
-    ["Math.PI", "" + froundOfPi],
-    ["Math.E", "" + froundOfE],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"" + Math.PI + "\"", "" + froundOfPi],
-    ["{ valueOf: () => { return Math.E; } }", "" + froundOfE],
-    ["{ valueOf: () => { return 1; } }", "1"],
-    ["{ valueOf: () => { return Math.PI; } }", "" + froundOfPi],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-// Test Math.fround() without arguments.
-function opaqueFRoundNoArgument() {
-    return Math.fround();
-}
-noInline(opaqueFRoundNoArgument);
-noOSRExitFuzzing(opaqueFRoundNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueFRoundNoArgument();
-        if (output === output) {
-            throw "Failed opaqueFRoundNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueFRoundNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-// Test Math.fround() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesFround(argument) {
-    return Math.fround(argument);
-}
-noInline(opaqueAllTypesFround);
-noOSRExitFuzzing(opaqueAllTypesFround);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesFround(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesFround) > 2)
-        throw "We should have detected fround() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.fround() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueFround(argument) {
-                return Math.fround(argument);
-            }
-            noInline(opaqueFround);
-            noOSRExitFuzzing(opaqueFround);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueFround(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueFround) > 1)
-                throw "We should have compiled a single fround for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.fround() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueFroundOnConstant() {
-                return Math.fround(${testCaseInput[0]});
-            }
-            noInline(opaqueFroundOnConstant);
-            noOSRExitFuzzing(opaqueFroundOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueFroundOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueFroundOnConstant) > 1)
-                throw "We should have compiled a single fround for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueFroundForSideEffects(argument) {
-    return Math.fround(argument);
-}
-noInline(opaqueFroundForSideEffects);
-noOSRExitFuzzing(opaqueFroundForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let fround16 = Math.fround(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueFroundForSideEffects(testObject) !== fround16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueFroundForSideEffects) > 1)
-        throw "opaqueFroundForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify fround() is not subject to CSE if the argument has side effects.
-function opaqueFroundForCSE(argument) {
-    return Math.fround(argument) + Math.fround(argument) + Math.fround(argument);
-}
-noInline(opaqueFroundForCSE);
-noOSRExitFuzzing(opaqueFroundForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let fround16 = Math.fround(16);
-    let threeFround16 = fround16 + fround16 + fround16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueFroundForCSE(testObject) !== threeFround16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueFroundForCSE) > 1)
-        throw "opaqueFroundForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify fround() is not subject to DCE if the argument has side effects.
-function opaqueFroundForDCE(argument) {
-    Math.fround(argument);
-}
-noInline(opaqueFroundForDCE);
-noOSRExitFuzzing(opaqueFroundForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueFroundForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueFroundForDCE) > 1)
-        throw "opaqueFroundForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueFroundWithException(argument) {
-        let result = Math.fround(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueFroundWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let fround64 = Math.fround(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueFroundWithException(testObject) !== fround64)
-            throw "Incorrect result in opaqueFroundWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueFroundWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueFroundWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-log-on-various-types.js

@@ -1,240 +0,0 @@
-//@ skip if not $jitTests
-//@ runNoCJITValidatePhases
-//@ runFTLNoCJITValidate
-"use strict";
-
-let logOfFour = Math.log(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "-Infinity"],
-    ["0", "-Infinity"],
-    ["-0.", "-Infinity"],
-    ["1.", "0"],
-    ["4", "" + logOfFour],
-    ["Math.E", "1"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + logOfFour],
-    ["{ valueOf: () => { return Math.E; } }", "1"],
-    ["{ valueOf: () => { return 1; } }", "0"],
-    ["{ valueOf: () => { return 4; } }", "" + logOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.log() without arguments.
-function opaqueLogNoArgument() {
-    return Math.log();
-}
-noInline(opaqueLogNoArgument);
-noOSRExitFuzzing(opaqueLogNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueLogNoArgument();
-        if (output === output) {
-            throw "Failed opaqueLogNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueLogNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.log() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesLog(argument) {
-    return Math.log(argument);
-}
-noInline(opaqueAllTypesLog);
-noOSRExitFuzzing(opaqueAllTypesLog);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesLog(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesLog) > 2)
-        throw "We should have detected log() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.log() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLog(argument) {
-                return Math.log(argument);
-            }
-            noInline(opaqueLog);
-            noOSRExitFuzzing(opaqueLog);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLog(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLog) > 1)
-                throw "We should have compiled a single log for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.log() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLogOnConstant() {
-                return Math.log(${testCaseInput[0]});
-            }
-            noInline(opaqueLogOnConstant);
-            noOSRExitFuzzing(opaqueLogOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLogOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLogOnConstant) > 1)
-                throw "We should have compiled a single log for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueLogForSideEffects(argument) {
-    return Math.log(argument);
-}
-noInline(opaqueLogForSideEffects);
-noOSRExitFuzzing(opaqueLogForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let log16 = Math.log(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLogForSideEffects(testObject) !== log16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueLogForSideEffects) > 1)
-        throw "opaqueLogForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify log() is not subject to CSE if the argument has side effects.
-function opaqueLogForCSE(argument) {
-    return Math.log(argument) + Math.log(argument) + Math.log(argument);
-}
-noInline(opaqueLogForCSE);
-noOSRExitFuzzing(opaqueLogForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let log16 = Math.log(16);
-    let threeLog16 = log16 + log16 + log16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLogForCSE(testObject) !== threeLog16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueLogForCSE) > 1)
-        throw "opaqueLogForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify log() is not subject to DCE if the argument has side effects.
-function opaqueLogForDCE(argument) {
-    Math.log(argument);
-}
-noInline(opaqueLogForDCE);
-noOSRExitFuzzing(opaqueLogForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueLogForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueLogForDCE) > 1)
-        throw "opaqueLogForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueLogWithException(argument) {
-        let result = Math.log(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueLogWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let log64 = Math.log(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueLogWithException(testObject) !== log64)
-            throw "Incorrect result in opaqueLogWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueLogWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueLogWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-log10-on-various-types.js

@@ -1,237 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let log10OfHalf = Math.log10(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "-Infinity"],
-    ["1", "0"],
-    ["0", "-Infinity"],
-    ["-0.", "-Infinity"],
-    ["0.5", "" + log10OfHalf],
-    ["Math.PI", "" + Math.log10(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + log10OfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + log10OfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.log10() without arguments.
-function opaqueLog10NoArgument() {
-    return Math.log10();
-}
-noInline(opaqueLog10NoArgument);
-noOSRExitFuzzing(opaqueLog10NoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueLog10NoArgument();
-        if (output === output) {
-            throw "Failed opaqueLog10NoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueLog10NoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.log10() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesLog10(argument) {
-    return Math.log10(argument);
-}
-noInline(opaqueAllTypesLog10);
-noOSRExitFuzzing(opaqueAllTypesLog10);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesLog10(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesLog10) > 2)
-        throw "We should have detected log10() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.log10() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLog10(argument) {
-                return Math.log10(argument);
-            }
-            noInline(opaqueLog10);
-            noOSRExitFuzzing(opaqueLog10);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLog10(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLog10) > 1)
-                throw "We should have compiled a single log10 for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.log10() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLog10OnConstant() {
-                return Math.log10(${testCaseInput[0]});
-            }
-            noInline(opaqueLog10OnConstant);
-            noOSRExitFuzzing(opaqueLog10OnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLog10OnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLog10OnConstant) > 1)
-                throw "We should have compiled a single log10 for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueLog10ForSideEffects(argument) {
-    return Math.log10(argument);
-}
-noInline(opaqueLog10ForSideEffects);
-noOSRExitFuzzing(opaqueLog10ForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let log10Result = Math.log10(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLog10ForSideEffects(testObject) !== log10Result)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueLog10ForSideEffects) > 1)
-        throw "opaqueLog10ForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify log10() is not subject to CSE if the argument has side effects.
-function opaqueLog10ForCSE(argument) {
-    return Math.log10(argument) + Math.log10(argument) + Math.log10(argument);
-}
-noInline(opaqueLog10ForCSE);
-noOSRExitFuzzing(opaqueLog10ForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let log10Result = Math.log10(0.2);
-    let threelog10Result = log10Result + log10Result + log10Result;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLog10ForCSE(testObject) !== threelog10Result)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueLog10ForCSE) > 1)
-        throw "opaqueLog10ForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify log10() is not subject to DCE if the argument has side effects.
-function opaqueLog10ForDCE(argument) {
-    Math.log10(argument);
-}
-noInline(opaqueLog10ForDCE);
-noOSRExitFuzzing(opaqueLog10ForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueLog10ForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueLog10ForDCE) > 1)
-        throw "opaqueLog10ForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueLog10WithException(argument) {
-        let result = Math.log10(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueLog10WithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let log10Result = Math.log10(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueLog10WithException(testObject) !== log10Result)
-            throw "Incorrect result in opaqueLog10WithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueLog10WithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueLog10WithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-log2-on-various-types.js

@@ -1,237 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let log2OfHalf = Math.log2(0.5);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "-Infinity"],
-    ["1", "0"],
-    ["0", "-Infinity"],
-    ["-0.", "-Infinity"],
-    ["0.5", "" + log2OfHalf],
-    ["Math.PI", "" + Math.log2(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"0.5\"", "" + log2OfHalf],
-    ["{ valueOf: () => { return 0.5; } }", "" + log2OfHalf],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.log2() without arguments.
-function opaqueLog2NoArgument() {
-    return Math.log2();
-}
-noInline(opaqueLog2NoArgument);
-noOSRExitFuzzing(opaqueLog2NoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueLog2NoArgument();
-        if (output === output) {
-            throw "Failed opaqueLog2NoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueLog2NoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.log2() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesLog2(argument) {
-    return Math.log2(argument);
-}
-noInline(opaqueAllTypesLog2);
-noOSRExitFuzzing(opaqueAllTypesLog2);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesLog2(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesLog2) > 2)
-        throw "We should have detected log2() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.log2() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLog2(argument) {
-                return Math.log2(argument);
-            }
-            noInline(opaqueLog2);
-            noOSRExitFuzzing(opaqueLog2);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLog2(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLog2) > 1)
-                throw "We should have compiled a single log2 for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.log2() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueLog2OnConstant() {
-                return Math.log2(${testCaseInput[0]});
-            }
-            noInline(opaqueLog2OnConstant);
-            noOSRExitFuzzing(opaqueLog2OnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueLog2OnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueLog2OnConstant) > 1)
-                throw "We should have compiled a single log2 for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueLog2ForSideEffects(argument) {
-    return Math.log2(argument);
-}
-noInline(opaqueLog2ForSideEffects);
-noOSRExitFuzzing(opaqueLog2ForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let log2Result = Math.log2(0.2);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLog2ForSideEffects(testObject) !== log2Result)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueLog2ForSideEffects) > 1)
-        throw "opaqueLog2ForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify log2() is not subject to CSE if the argument has side effects.
-function opaqueLog2ForCSE(argument) {
-    return Math.log2(argument) + Math.log2(argument) + Math.log2(argument);
-}
-noInline(opaqueLog2ForCSE);
-noOSRExitFuzzing(opaqueLog2ForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    let log2Result = Math.log2(0.2);
-    let threelog2Result = log2Result + log2Result + log2Result;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueLog2ForCSE(testObject) !== threelog2Result)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueLog2ForCSE) > 1)
-        throw "opaqueLog2ForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify log2() is not subject to DCE if the argument has side effects.
-function opaqueLog2ForDCE(argument) {
-    Math.log2(argument);
-}
-noInline(opaqueLog2ForDCE);
-noOSRExitFuzzing(opaqueLog2ForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 0.2; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueLog2ForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueLog2ForDCE) > 1)
-        throw "opaqueLog2ForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueLog2WithException(argument) {
-        let result = Math.log2(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueLog2WithException);
-
-    let testObject = { valueOf: () => {  return 0.1; } };
-    let log2Result = Math.log2(0.1);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueLog2WithException(testObject) !== log2Result)
-            throw "Incorrect result in opaqueLog2WithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 0.1; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueLog2WithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueLog2WithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-negate-on-various-types.js

@@ -1,284 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "-0"],
-    ["0", "-0"],
-    ["-0.", "0"],
-    ["0.5", "-0.5"],
-    ["-0.5", "0.5"],
-    ["4", "-4"],
-    ["42.1", "-42.1"],
-    ["42.5", "-42.5"],
-    ["42.9", "-42.9"],
-    ["-42.1", "42.1"],
-    ["-42.5", "42.5"],
-    ["-42.9", "42.9"],
-    ["Math.PI", "-Math.PI"],
-    ["Infinity", "-Infinity"],
-    ["-Infinity", "Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "-4"],
-    ["\"42.5\"", "-42.5"],
-    ["{ valueOf: () => { return 4; } }", "-4"],
-    ["{ valueOf: () => { return 0; } }", "-0"],
-    ["{ valueOf: () => { return -0; } }", "0"],
-    ["{ valueOf: () => { return 0.5; } }", "-0.5"],
-    ["{ valueOf: () => { return -0.5; } }", "0.5"],
-    ["{ valueOf: () => { return Number.MIN_SAFE_INTEGER; } }", "9007199254740991"],
-    ["{ valueOf: () => { return Number.MAX_SAFE_INTEGER; } }", "-9007199254740991"],
-    ["{ valueOf: () => { return 0x80000000|0; } }", "2147483648"],
-    ["{ valueOf: () => { return 0x7fffffff|0; } }", "-2147483647"],
-    ["{ valueOf: () => { return (0x80000000|0) - 0.5; } }", "2147483648.5"],
-    ["{ valueOf: () => { return (0x7fffffff|0) + 0.5; } }", "-2147483647.5"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && (1 / expected) !== (1 / result))
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test negate with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesNegate(argument) {
-    return -(argument);
-}
-noInline(opaqueAllTypesNegate);
-noOSRExitFuzzing(opaqueAllTypesNegate);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesNegate(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesNegate) > 3)
-        throw "We should have detected negate was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Polymorphic input but negative zero is not observable.
-function opaqueAllTypesNegateWithoutNegativeZero(argument) {
-    return -(argument) + 0;
-}
-noInline(opaqueAllTypesNegateWithoutNegativeZero);
-noOSRExitFuzzing(opaqueAllTypesNegateWithoutNegativeZero);
-
-function testAllTypesWithoutNegativeZeroCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesNegateWithoutNegativeZero(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1] + 0))
-                throw "Failed testAllTypesWithoutNegativeZeroCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesNegate) > 3)
-        throw "We should have detected negate was polymorphic and generated a generic version.";
-}
-testAllTypesWithoutNegativeZeroCall();
-
-
-// Test negate on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueNegate(argument) {
-                return -(argument);
-            }
-            noInline(opaqueNegate);
-            noOSRExitFuzzing(opaqueNegate);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueNegate(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueNegate) > 1)
-                throw "Failed testSingleTypeCall(). We should have compiled a single negate for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-function checkCompileCountForUselessNegativeZero(testFunction)
-{
-    if (jscOptions().useMaximalFlushInsertionPhase) {
-        // If we forced a flush after the operation, the negative zero becomes
-        // observable and we may be overly optimistic.
-        return numberOfDFGCompiles(testFunction) <= 2;
-    }
-    return numberOfDFGCompiles(testFunction) <= 1;
-}
-
-
-// Test negate on a completely typed input, but without negative zero.
-function testSingleTypeWithoutNegativeZeroCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueNegate(argument) {
-                return -(argument) + 0;
-            }
-            noInline(opaqueNegate);
-            noOSRExitFuzzing(opaqueNegate);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueNegate(${testCaseInput[0]}), ${testCaseInput[1]} + 0)) {
-                    throw "Failed testSingleTypeWithoutNegativeZeroCall()";
-                }
-            }
-            if (!checkCompileCountForUselessNegativeZero(opaqueNegate))
-                throw "Failed testSingleTypeWithoutNegativeZeroCall(). We should have compiled a single negate for the expected type.";
-        `);
-    }
-}
-testSingleTypeWithoutNegativeZeroCall();
-
-
-// Test negate on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueNegateOnConstant() {
-                return -(${testCaseInput[0]});
-            }
-            noInline(opaqueNegateOnConstant);
-            noOSRExitFuzzing(opaqueNegateOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueNegateOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueNegateOnConstant) > 1)
-                throw "Failed testConstant(). We should have compiled a single negate for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueNegateForSideEffects(argument) {
-    return -(argument);
-}
-noInline(opaqueNegateForSideEffects);
-noOSRExitFuzzing(opaqueNegateForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueNegateForSideEffects(testObject) !== -16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueNegateForSideEffects) > 1)
-        throw "opaqueNegateForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify negate is not subject to CSE if the argument has side effects.
-function opaqueNegateForCSE(argument) {
-    return -(argument) + -(argument) + -(argument);
-}
-noInline(opaqueNegateForCSE);
-noOSRExitFuzzing(opaqueNegateForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueNegateForCSE(testObject) !== -48)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueNegateForCSE) > 1)
-        throw "opaqueNegateForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify negate is not subject to DCE if the argument has side effects.
-function opaqueNegateForDCE(argument) {
-    -(argument);
-}
-noInline(opaqueNegateForDCE);
-noOSRExitFuzzing(opaqueNegateForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueNegateForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueNegateForDCE) > 1)
-        throw "opaqueNegateForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueNegateWithException(argument) {
-        let result = -(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueNegateWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueNegateWithException(testObject) !== -64)
-            throw "Incorrect result in opaqueNegateWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueNegateWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueNegateWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-round-on-various-types.js

@@ -1,308 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "1"],
-    ["-0.5", "-0"],
-    ["4", "4"],
-    ["42.1", "42"],
-    ["42.5", "43"],
-    ["42.9", "43"],
-    ["-42.1", "-42"],
-    ["-42.5", "-42"],
-    ["-42.9", "-43"],
-    ["Math.PI", "3"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "4"],
-    ["\"42.5\"", "43"],
-    ["{ valueOf: () => { return 4; } }", "4"],
-    ["{ valueOf: () => { return 0; } }", "0"],
-    ["{ valueOf: () => { return -0; } }", "-0"],
-    ["{ valueOf: () => { return 0.5; } }", "1"],
-    ["{ valueOf: () => { return -0.5; } }", "-0"],
-    ["{ valueOf: () => { return Number.MIN_SAFE_INTEGER; } }", "-9007199254740991"],
-    ["{ valueOf: () => { return Number.MAX_SAFE_INTEGER; } }", "9007199254740991"],
-    ["{ valueOf: () => { return 0x80000000|0; } }", "-2147483648"],
-    ["{ valueOf: () => { return 0x7fffffff|0; } }", "2147483647"],
-    ["{ valueOf: () => { return (0x80000000|0) - 0.5; } }", "-2147483648"],
-    ["{ valueOf: () => { return (0x7fffffff|0) + 0.5; } }", "2147483648"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && (1 / expected) !== (1 / result))
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.round() without arguments.
-function opaqueRoundNoArgument() {
-    return Math.round();
-}
-noInline(opaqueRoundNoArgument);
-noOSRExitFuzzing(opaqueRoundNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueRoundNoArgument();
-        if (!isIdentical(output, NaN)) {
-            throw "Failed opaqueRoundNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueRoundNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.round() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesRound(argument) {
-    return Math.round(argument);
-}
-noInline(opaqueAllTypesRound);
-noOSRExitFuzzing(opaqueAllTypesRound);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesRound(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesRound) > 3)
-        throw "We should have detected round() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Polymorphic input but negative zero is not observable.
-function opaqueAllTypesRoundWithoutNegativeZero(argument) {
-    return Math.round(argument) + 0;
-}
-noInline(opaqueAllTypesRoundWithoutNegativeZero);
-noOSRExitFuzzing(opaqueAllTypesRoundWithoutNegativeZero);
-
-function testAllTypesWithoutNegativeZeroCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesRoundWithoutNegativeZero(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1] + 0))
-                throw "Failed testAllTypesWithoutNegativeZeroCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesRound) > 3)
-        throw "We should have detected round() was polymorphic and generated a generic version.";
-}
-testAllTypesWithoutNegativeZeroCall();
-
-
-// Test Math.round() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueRound(argument) {
-                return Math.round(argument);
-            }
-            noInline(opaqueRound);
-            noOSRExitFuzzing(opaqueRound);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueRound(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueRound) > 1)
-                throw "We should have compiled a single round for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-function checkCompileCountForUselessNegativeZero(testFunction)
-{
-    if (jscOptions().useMaximalFlushInsertionPhase) {
-        // If we forced a flush after the operation, the negative zero becomes
-        // observable and we may be overly optimistic.
-        return numberOfDFGCompiles(testFunction) <= 2;
-    }
-    return numberOfDFGCompiles(testFunction) <= 1;
-}
-
-
-// Test Math.round() on a completely typed input, but without negative zero.
-function testSingleTypeWithoutNegativeZeroCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueRound(argument) {
-                return Math.round(argument) + 0;
-            }
-            noInline(opaqueRound);
-            noOSRExitFuzzing(opaqueRound);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueRound(${testCaseInput[0]}), ${testCaseInput[1]} + 0)) {
-                    throw "Failed testSingleTypeWithoutNegativeZeroCall()";
-                }
-            }
-            if (!checkCompileCountForUselessNegativeZero(opaqueRound))
-                throw "We should have compiled a single round for the expected type.";
-        `);
-    }
-}
-testSingleTypeWithoutNegativeZeroCall();
-
-
-// Test Math.round() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueRoundOnConstant() {
-                return Math.round(${testCaseInput[0]});
-            }
-            noInline(opaqueRoundOnConstant);
-            noOSRExitFuzzing(opaqueRoundOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueRoundOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueRoundOnConstant) > 1)
-                throw "We should have compiled a single round for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueRoundForSideEffects(argument) {
-    return Math.round(argument);
-}
-noInline(opaqueRoundForSideEffects);
-noOSRExitFuzzing(opaqueRoundForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let round16 = Math.round(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueRoundForSideEffects(testObject) !== round16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueRoundForSideEffects) > 1)
-        throw "opaqueRoundForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify round() is not subject to CSE if the argument has side effects.
-function opaqueRoundForCSE(argument) {
-    return Math.round(argument) + Math.round(argument) + Math.round(argument);
-}
-noInline(opaqueRoundForCSE);
-noOSRExitFuzzing(opaqueRoundForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let round16 = Math.round(16);
-    let threeRound16 = round16 + round16 + round16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueRoundForCSE(testObject) !== threeRound16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueRoundForCSE) > 1)
-        throw "opaqueRoundForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify round() is not subject to DCE if the argument has side effects.
-function opaqueRoundForDCE(argument) {
-    Math.round(argument);
-}
-noInline(opaqueRoundForDCE);
-noOSRExitFuzzing(opaqueRoundForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueRoundForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueRoundForDCE) > 1)
-        throw "opaqueRoundForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueRoundWithException(argument) {
-        let result = Math.round(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueRoundWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let round64 = Math.round(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueRoundWithException(testObject) !== round64)
-            throw "Incorrect result in opaqueRoundWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueRoundWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueRoundWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-sin-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let sinOfFour = Math.sin(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + sinOfFour],
-    ["Math.PI", "" + Math.sin(Math.PI)],
-    ["Infinity", "NaN"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + sinOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + sinOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.sin() without arguments.
-function opaqueSinNoArgument() {
-    return Math.sin();
-}
-noInline(opaqueSinNoArgument);
-noOSRExitFuzzing(opaqueSinNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueSinNoArgument();
-        if (output === output) {
-            throw "Failed opaqueSinNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueSinNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.sin() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesSin(argument) {
-    return Math.sin(argument);
-}
-noInline(opaqueAllTypesSin);
-noOSRExitFuzzing(opaqueAllTypesSin);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesSin(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesSin) > 2)
-        throw "We should have detected sin() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.sin() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSin(argument) {
-                return Math.sin(argument);
-            }
-            noInline(opaqueSin);
-            noOSRExitFuzzing(opaqueSin);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSin(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSin) > 1)
-                throw "We should have compiled a single sin for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.sin() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSinOnConstant() {
-                return Math.sin(${testCaseInput[0]});
-            }
-            noInline(opaqueSinOnConstant);
-            noOSRExitFuzzing(opaqueSinOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSinOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSinOnConstant) > 1)
-                throw "We should have compiled a single sin for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueSinForSideEffects(argument) {
-    return Math.sin(argument);
-}
-noInline(opaqueSinForSideEffects);
-noOSRExitFuzzing(opaqueSinForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let sin16 = Math.sin(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSinForSideEffects(testObject) !== sin16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueSinForSideEffects) > 1)
-        throw "opaqueSinForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify sin() is not subject to CSE if the argument has side effects.
-function opaqueSinForCSE(argument) {
-    return Math.sin(argument) + Math.sin(argument) + Math.sin(argument);
-}
-noInline(opaqueSinForCSE);
-noOSRExitFuzzing(opaqueSinForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let sin16 = Math.sin(16);
-    let threeSin16 = sin16 + sin16 + sin16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSinForCSE(testObject) !== threeSin16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueSinForCSE) > 1)
-        throw "opaqueSinForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify sin() is not subject to DCE if the argument has side effects.
-function opaqueSinForDCE(argument) {
-    Math.sin(argument);
-}
-noInline(opaqueSinForDCE);
-noOSRExitFuzzing(opaqueSinForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueSinForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueSinForDCE) > 1)
-        throw "opaqueSinForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueSinWithException(argument) {
-        let result = Math.sin(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueSinWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let sin64 = Math.sin(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueSinWithException(testObject) !== sin64)
-            throw "Incorrect result in opaqueSinWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueSinWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueSinWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-sinh-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let sinhOfFour = Math.sinh(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + sinhOfFour],
-    ["Math.PI", "" + Math.sinh(Math.PI)],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + sinhOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + sinhOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.sinh() without arguments.
-function opaqueSinhNoArgument() {
-    return Math.sinh();
-}
-noInline(opaqueSinhNoArgument);
-noOSRExitFuzzing(opaqueSinhNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueSinhNoArgument();
-        if (output === output) {
-            throw "Failed opaqueSinhNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueSinhNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.sinh() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesSinh(argument) {
-    return Math.sinh(argument);
-}
-noInline(opaqueAllTypesSinh);
-noOSRExitFuzzing(opaqueAllTypesSinh);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesSinh(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesSinh) > 2)
-        throw "We should have detected sinh() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.sinh() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSinh(argument) {
-                return Math.sinh(argument);
-            }
-            noInline(opaqueSinh);
-            noOSRExitFuzzing(opaqueSinh);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSinh(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSinh) > 1)
-                throw "We should have compiled a single sinh for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.sinh() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSinhOnConstant() {
-                return Math.sinh(${testCaseInput[0]});
-            }
-            noInline(opaqueSinhOnConstant);
-            noOSRExitFuzzing(opaqueSinhOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSinhOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSinhOnConstant) > 1)
-                throw "We should have compiled a single sinh for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueSinhForSideEffects(argument) {
-    return Math.sinh(argument);
-}
-noInline(opaqueSinhForSideEffects);
-noOSRExitFuzzing(opaqueSinhForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let sinh16 = Math.sinh(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSinhForSideEffects(testObject) !== sinh16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueSinhForSideEffects) > 1)
-        throw "opaqueSinhForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify sinh() is not subject to CSE if the argument has side effects.
-function opaqueSinhForCSE(argument) {
-    return Math.sinh(argument) + Math.sinh(argument) + Math.sinh(argument);
-}
-noInline(opaqueSinhForCSE);
-noOSRExitFuzzing(opaqueSinhForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let sinh16 = Math.sinh(16);
-    let threeSinh16 = sinh16 + sinh16 + sinh16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSinhForCSE(testObject) !== threeSinh16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueSinhForCSE) > 1)
-        throw "opaqueSinhForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify sinh() is not subject to DCE if the argument has side effects.
-function opaqueSinhForDCE(argument) {
-    Math.sinh(argument);
-}
-noInline(opaqueSinhForDCE);
-noOSRExitFuzzing(opaqueSinhForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueSinhForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueSinhForDCE) > 1)
-        throw "opaqueSinhForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueSinhWithException(argument) {
-        let result = Math.sinh(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueSinhWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let sinh64 = Math.sinh(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueSinhWithException(testObject) !== sinh64)
-            throw "Incorrect result in opaqueSinhWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueSinhWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueSinhWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-sqrt-on-various-types.js

@@ -1,230 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0."],
-    ["4", "2"],
-    ["42.5", "6.519202405202649"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "2"],
-    ["{ valueOf: () => { return 4; } }", "2"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && 1 / expected === -Infinity && 1 / result !== -Infinity)
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.sqrt() without arguments.
-function opaqueSqrtNoArgument() {
-    return Math.sqrt();
-}
-noInline(opaqueSqrtNoArgument);
-noOSRExitFuzzing(opaqueSqrtNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueSqrtNoArgument();
-        if (output === output) {
-            throw "Failed opaqueSqrtNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueSqrtNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.sqrt() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesSqrt(argument) {
-    return Math.sqrt(argument);
-}
-noInline(opaqueAllTypesSqrt);
-noOSRExitFuzzing(opaqueAllTypesSqrt);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesSqrt(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesSqrt) > 2)
-        throw "We should have detected sqrt() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.sqrt() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSqrt(argument) {
-                return Math.sqrt(argument);
-            }
-            noInline(opaqueSqrt);
-            noOSRExitFuzzing(opaqueSqrt);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSqrt(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSqrt) > 1)
-                throw "We should have compiled a single sqrt for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.sqrt() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueSqrtOnConstant() {
-                return Math.sqrt(${testCaseInput[0]});
-            }
-            noInline(opaqueSqrtOnConstant);
-            noOSRExitFuzzing(opaqueSqrtOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueSqrtOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueSqrtOnConstant) > 1)
-                throw "We should have compiled a single sqrt for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueSqrtForSideEffects(argument) {
-    return Math.sqrt(argument);
-}
-noInline(opaqueSqrtForSideEffects);
-noOSRExitFuzzing(opaqueSqrtForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSqrtForSideEffects(testObject) !== 4)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueSqrtForSideEffects) > 1)
-        throw "opaqueSqrtForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify sqrt() is not subject to CSE if the argument has side effects.
-function opaqueSqrtForCSE(argument) {
-    return Math.sqrt(argument) + Math.sqrt(argument) + Math.sqrt(argument);
-}
-noInline(opaqueSqrtForCSE);
-noOSRExitFuzzing(opaqueSqrtForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueSqrtForCSE(testObject) !== 12)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueSqrtForCSE) > 1)
-        throw "opaqueSqrtForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify sqrt() is not subject to DCE if the argument has side effects.
-function opaqueSqrtForDCE(argument) {
-    Math.sqrt(argument);
-}
-noInline(opaqueSqrtForDCE);
-noOSRExitFuzzing(opaqueSqrtForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueSqrtForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueSqrtForDCE) > 1)
-        throw "opaqueSqrtForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueSqrtWithException(argument) {
-        let result = Math.sqrt(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueSqrtWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueSqrtWithException(testObject) !== 8)
-            throw "Incorrect result in opaqueSqrtWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueSqrtWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueSqrtWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-tan-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let tanOfFour = Math.tan(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + tanOfFour],
-    ["Math.PI", "" + Math.tan(Math.PI)],
-    ["Infinity", "NaN"],
-    ["-Infinity", "NaN"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + tanOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + tanOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.tan() without arguments.
-function opaqueTanNoArgument() {
-    return Math.tan();
-}
-noInline(opaqueTanNoArgument);
-noOSRExitFuzzing(opaqueTanNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueTanNoArgument();
-        if (output === output) {
-            throw "Failed opaqueTanNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueTanNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.tan() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesTan(argument) {
-    return Math.tan(argument);
-}
-noInline(opaqueAllTypesTan);
-noOSRExitFuzzing(opaqueAllTypesTan);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesTan(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesTan) > 2)
-        throw "We should have detected tan() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.tan() on a completely typed input. Every call see only one type.
-function testTangleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTan(argument) {
-                return Math.tan(argument);
-            }
-            noInline(opaqueTan);
-            noOSRExitFuzzing(opaqueTan);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTan(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testTangleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTan) > 1)
-                throw "We should have compiled a tangle tan for the expected type.";
-        `);
-    }
-}
-testTangleTypeCall();
-
-
-// Test Math.tan() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTanOnConstant() {
-                return Math.tan(${testCaseInput[0]});
-            }
-            noInline(opaqueTanOnConstant);
-            noOSRExitFuzzing(opaqueTanOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTanOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTanOnConstant) > 1)
-                throw "We should have compiled a tangle tan for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueTanForSideEffects(argument) {
-    return Math.tan(argument);
-}
-noInline(opaqueTanForSideEffects);
-noOSRExitFuzzing(opaqueTanForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let tan16 = Math.tan(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTanForSideEffects(testObject) !== tan16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueTanForSideEffects) > 1)
-        throw "opaqueTanForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify tan() is not subject to CSE if the argument has side effects.
-function opaqueTanForCSE(argument) {
-    return Math.tan(argument) + Math.tan(argument) + Math.tan(argument);
-}
-noInline(opaqueTanForCSE);
-noOSRExitFuzzing(opaqueTanForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let tan16 = Math.tan(16);
-    let threeTan16 = tan16 + tan16 + tan16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTanForCSE(testObject) !== threeTan16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueTanForCSE) > 1)
-        throw "opaqueTanForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify tan() is not subject to DCE if the argument has side effects.
-function opaqueTanForDCE(argument) {
-    Math.tan(argument);
-}
-noInline(opaqueTanForDCE);
-noOSRExitFuzzing(opaqueTanForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueTanForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueTanForDCE) > 1)
-        throw "opaqueTanForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueTanWithException(argument) {
-        let result = Math.tan(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueTanWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let tan64 = Math.tan(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueTanWithException(testObject) !== tan64)
-            throw "Incorrect result in opaqueTanWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueTanWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueTanWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-tanh-on-various-types.js

@@ -1,236 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let tanhOfFour = Math.tanh(4);
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["4", "" + tanhOfFour],
-    ["Math.PI", "" + Math.tanh(Math.PI)],
-    ["Infinity", "1"],
-    ["-Infinity", "-1"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "" + tanhOfFour],
-    ["{ valueOf: () => { return 4; } }", "" + tanhOfFour],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected)
-            return (1 / expected) === (1 / result);
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.tanh() without arguments.
-function opaqueTanhNoArgument() {
-    return Math.tanh();
-}
-noInline(opaqueTanhNoArgument);
-noOSRExitFuzzing(opaqueTanhNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueTanhNoArgument();
-        if (output === output) {
-            throw "Failed opaqueTanhNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueTanhNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.tanh() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesTanh(argument) {
-    return Math.tanh(argument);
-}
-noInline(opaqueAllTypesTanh);
-noOSRExitFuzzing(opaqueAllTypesTanh);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesTanh(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesTanh) > 2)
-        throw "We should have detected tanh() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Test Math.tanh() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTanh(argument) {
-                return Math.tanh(argument);
-            }
-            noInline(opaqueTanh);
-            noOSRExitFuzzing(opaqueTanh);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTanh(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTanh) > 1)
-                throw "We should have compiled a single tanh for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-// Test Math.tanh() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTanhOnConstant() {
-                return Math.tanh(${testCaseInput[0]});
-            }
-            noInline(opaqueTanhOnConstant);
-            noOSRExitFuzzing(opaqueTanhOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTanhOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTanhOnConstant) > 1)
-                throw "We should have compiled a single tanh for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueTanhForSideEffects(argument) {
-    return Math.tanh(argument);
-}
-noInline(opaqueTanhForSideEffects);
-noOSRExitFuzzing(opaqueTanhForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let tanh16 = Math.tanh(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTanhForSideEffects(testObject) !== tanh16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueTanhForSideEffects) > 1)
-        throw "opaqueTanhForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify tanh() is not subject to CSE if the argument has side effects.
-function opaqueTanhForCSE(argument) {
-    return Math.tanh(argument) + Math.tanh(argument) + Math.tanh(argument);
-}
-noInline(opaqueTanhForCSE);
-noOSRExitFuzzing(opaqueTanhForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let tanh16 = Math.tanh(16);
-    let threeTanh16 = tanh16 + tanh16 + tanh16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTanhForCSE(testObject) !== threeTanh16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueTanhForCSE) > 1)
-        throw "opaqueTanhForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify tanh() is not subject to DCE if the argument has side effects.
-function opaqueTanhForDCE(argument) {
-    Math.tanh(argument);
-}
-noInline(opaqueTanhForDCE);
-noOSRExitFuzzing(opaqueTanhForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueTanhForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueTanhForDCE) > 1)
-        throw "opaqueTanhForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueTanhWithException(argument) {
-        let result = Math.tanh(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueTanhWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let tanh64 = Math.tanh(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueTanhWithException(testObject) !== tanh64)
-            throw "Incorrect result in opaqueTanhWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueTanhWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueTanhWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/arith-trunc-on-various-types.js

@@ -1,308 +0,0 @@
-//@ skip if not $jitTests
-//@ defaultNoEagerRun
-"use strict";
-
-let validInputTestCases = [
-    // input as string, expected result as string.
-    ["undefined", "NaN"],
-    ["null", "0"],
-    ["0", "0"],
-    ["-0.", "-0"],
-    ["0.5", "0"],
-    ["-0.5", "-0"],
-    ["4", "4"],
-    ["42.1", "42"],
-    ["42.5", "42"],
-    ["42.9", "42"],
-    ["-42.1", "-42"],
-    ["-42.5", "-42"],
-    ["-42.9", "-42"],
-    ["Math.PI", "3"],
-    ["Infinity", "Infinity"],
-    ["-Infinity", "-Infinity"],
-    ["NaN", "NaN"],
-    ["\"WebKit\"", "NaN"],
-    ["\"4\"", "4"],
-    ["\"42.5\"", "42"],
-    ["{ valueOf: () => { return 4; } }", "4"],
-    ["{ valueOf: () => { return 0; } }", "0"],
-    ["{ valueOf: () => { return -0; } }", "-0"],
-    ["{ valueOf: () => { return 0.5; } }", "0"],
-    ["{ valueOf: () => { return -0.5; } }", "-0"],
-    ["{ valueOf: () => { return Number.MIN_SAFE_INTEGER; } }", "-9007199254740991"],
-    ["{ valueOf: () => { return Number.MAX_SAFE_INTEGER; } }", "9007199254740991"],
-    ["{ valueOf: () => { return 0x80000000|0; } }", "-2147483648"],
-    ["{ valueOf: () => { return 0x7fffffff|0; } }", "2147483647"],
-    ["{ valueOf: () => { return (0x80000000|0) - 0.5; } }", "-2147483648"],
-    ["{ valueOf: () => { return (0x7fffffff|0) + 0.5; } }", "2147483647"],
-];
-
-let validInputTypedTestCases = validInputTestCases.map((element) => { return [eval("(" + element[0] + ")"), eval(element[1])] });
-
-function isIdentical(result, expected)
-{
-    if (expected === expected) {
-        if (result !== expected)
-            return false;
-        if (!expected && (1 / expected) !== (1 / result))
-            return false;
-
-        return true;
-    }
-    return result !== result;
-}
-
-
-// Test Math.trunc() without arguments.
-function opaqueTruncNoArgument() {
-    return Math.trunc();
-}
-noInline(opaqueTruncNoArgument);
-noOSRExitFuzzing(opaqueTruncNoArgument);
-
-function testNoArgument() {
-    for (let i = 0; i < 1e4; ++i) {
-        let output = opaqueTruncNoArgument();
-        if (!isIdentical(output, NaN)) {
-            throw "Failed opaqueTruncNoArgument";
-        }
-    }
-    if (numberOfDFGCompiles(opaqueTruncNoArgument) > 1)
-        throw "The call without arguments should never exit.";
-}
-testNoArgument();
-
-
-// Test Math.trunc() with a very polymorphic input. All test cases are seen at each iteration.
-function opaqueAllTypesTrunc(argument) {
-    return Math.trunc(argument);
-}
-noInline(opaqueAllTypesTrunc);
-noOSRExitFuzzing(opaqueAllTypesTrunc);
-
-function testAllTypesCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesTrunc(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1]))
-                throw "Failed testAllTypesCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesTrunc) > 3)
-        throw "We should have detected trunc() was polymorphic and generated a generic version.";
-}
-testAllTypesCall();
-
-
-// Polymorphic input but negative zero is not observable.
-function opaqueAllTypesTruncWithoutNegativeZero(argument) {
-    return Math.trunc(argument) + 0;
-}
-noInline(opaqueAllTypesTruncWithoutNegativeZero);
-noOSRExitFuzzing(opaqueAllTypesTruncWithoutNegativeZero);
-
-function testAllTypesWithoutNegativeZeroCall() {
-    for (let i = 0; i < 1e3; ++i) {
-        for (let testCaseInput of validInputTypedTestCases) {
-            let output = opaqueAllTypesTruncWithoutNegativeZero(testCaseInput[0]);
-            if (!isIdentical(output, testCaseInput[1] + 0))
-                throw "Failed testAllTypesWithoutNegativeZeroCall for input " + testCaseInput[0] + " expected " + testCaseInput[1] + " got " + output;
-        }
-    }
-    if (numberOfDFGCompiles(opaqueAllTypesTrunc) > 3)
-        throw "We should have detected trunc() was polymorphic and generated a generic version.";
-}
-testAllTypesWithoutNegativeZeroCall();
-
-
-// Test Math.trunc() on a completely typed input. Every call see only one type.
-function testSingleTypeCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTrunc(argument) {
-                return Math.trunc(argument);
-            }
-            noInline(opaqueTrunc);
-            noOSRExitFuzzing(opaqueTrunc);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTrunc(${testCaseInput[0]}), ${testCaseInput[1]})) {
-                    throw "Failed testSingleTypeCall()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTrunc) > 1)
-                throw "Failed testSingleTypeCall(). We should have compiled a single trunc for the expected type.";
-        `);
-    }
-}
-testSingleTypeCall();
-
-
-function checkCompileCountForUselessNegativeZero(testFunction)
-{
-    if (jscOptions().useMaximalFlushInsertionPhase) {
-        // If we forced a flush after the operation, the negative zero becomes
-        // observable and we may be overly optimistic.
-        return numberOfDFGCompiles(testFunction) <= 2;
-    }
-    return numberOfDFGCompiles(testFunction) <= 1;
-}
-
-
-// Test Math.trunc() on a completely typed input, but without negative zero.
-function testSingleTypeWithoutNegativeZeroCall() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTrunc(argument) {
-                return Math.trunc(argument) + 0;
-            }
-            noInline(opaqueTrunc);
-            noOSRExitFuzzing(opaqueTrunc);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTrunc(${testCaseInput[0]}), ${testCaseInput[1]} + 0)) {
-                    throw "Failed testSingleTypeWithoutNegativeZeroCall()";
-                }
-            }
-            if (!checkCompileCountForUselessNegativeZero(opaqueTrunc))
-                throw "Failed testSingleTypeWithoutNegativeZeroCall(). We should have compiled a single trunc for the expected type.";
-        `);
-    }
-}
-testSingleTypeWithoutNegativeZeroCall();
-
-
-// Test Math.trunc() on constants
-function testConstant() {
-    for (let testCaseInput of validInputTestCases) {
-        eval(`
-            function opaqueTruncOnConstant() {
-                return Math.trunc(${testCaseInput[0]});
-            }
-            noInline(opaqueTruncOnConstant);
-            noOSRExitFuzzing(opaqueTruncOnConstant);
-
-            for (let i = 0; i < 1e4; ++i) {
-                if (!isIdentical(opaqueTruncOnConstant(), ${testCaseInput[1]})) {
-                    throw "Failed testConstant()";
-                }
-            }
-            if (numberOfDFGCompiles(opaqueTruncOnConstant) > 1)
-                throw "Failed testConstant(). We should have compiled a single trunc for the expected type.";
-        `);
-    }
-}
-testConstant();
-
-
-// Verify we call valueOf() exactly once per call.
-function opaqueTruncForSideEffects(argument) {
-    return Math.trunc(argument);
-}
-noInline(opaqueTruncForSideEffects);
-noOSRExitFuzzing(opaqueTruncForSideEffects);
-
-function testSideEffect() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let trunc16 = Math.trunc(16);
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTruncForSideEffects(testObject) !== trunc16)
-            throw "Incorrect result in testSideEffect()";
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testSideEffect()";
-    if (numberOfDFGCompiles(opaqueTruncForSideEffects) > 1)
-        throw "opaqueTruncForSideEffects() is predictable, it should only be compiled once.";
-}
-testSideEffect();
-
-
-// Verify trunc() is not subject to CSE if the argument has side effects.
-function opaqueTruncForCSE(argument) {
-    return Math.trunc(argument) + Math.trunc(argument) + Math.trunc(argument);
-}
-noInline(opaqueTruncForCSE);
-noOSRExitFuzzing(opaqueTruncForCSE);
-
-function testCSE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    let trunc16 = Math.trunc(16);
-    let threeTrunc16 = trunc16 + trunc16 + trunc16;
-    for (let i = 0; i < 1e4; ++i) {
-        if (opaqueTruncForCSE(testObject) !== threeTrunc16)
-            throw "Incorrect result in testCSE()";
-    }
-    if (testObject.counter !== 3e4)
-        throw "Failed testCSE()";
-    if (numberOfDFGCompiles(opaqueTruncForCSE) > 1)
-        throw "opaqueTruncForCSE() is predictable, it should only be compiled once.";
-}
-testCSE();
-
-
-// Verify trunc() is not subject to DCE if the argument has side effects.
-function opaqueTruncForDCE(argument) {
-    Math.trunc(argument);
-}
-noInline(opaqueTruncForDCE);
-noOSRExitFuzzing(opaqueTruncForDCE);
-
-function testDCE() {
-    let testObject = {
-        counter: 0,
-        valueOf: function() { ++this.counter; return 16; }
-    };
-    for (let i = 0; i < 1e4; ++i) {
-        opaqueTruncForDCE(testObject);
-    }
-    if (testObject.counter !== 1e4)
-        throw "Failed testDCE()";
-    if (numberOfDFGCompiles(opaqueTruncForDCE) > 1)
-        throw "opaqueTruncForDCE() is predictable, it should only be compiled once.";
-}
-testDCE();
-
-
-// Test exceptions in the argument.
-function testException() {
-    let counter = 0;
-    function opaqueTruncWithException(argument) {
-        let result = Math.trunc(argument);
-        ++counter;
-        return result;
-    }
-    noInline(opaqueTruncWithException);
-
-    let testObject = { valueOf: () => {  return 64; } };
-    let trunc64 = Math.trunc(64);
-
-    // Warm up without exception.
-    for (let i = 0; i < 1e3; ++i) {
-        if (opaqueTruncWithException(testObject) !== trunc64)
-            throw "Incorrect result in opaqueTruncWithException()";
-    }
-
-    let testThrowObject = { valueOf: () => { throw testObject; return 64; } };
-
-    for (let i = 0; i < 1e2; ++i) {
-        try {
-            if (opaqueTruncWithException(testThrowObject) !== 8)
-                throw "This code should not be reached!!";
-        } catch (e) {
-            if (e !== testObject) {
-                throw "Wrong object thrown from opaqueTruncWithException."
-            }
-        }
-    }
-
-    if (counter !== 1e3) {
-        throw "Invalid count in testException()";
-    }
-}
-testException();

implementation-contributed/javascriptcore/stress/assign-argument-in-inlined-call.js

@@ -1,27 +0,0 @@
-function f1(a) {
-    return a[0];
-}
-
-function getF2Arguments() {
-    return f2.arguments;
-}
-
-noInline(getF2Arguments);
-
-function f2(a) {
-    a = f1(getF2Arguments());
-    return a;
-}
-
-function f3(a) {
-    return f2(a);
-}
-
-noInline(f3);
-
-for (var i = 0; i < 10000; ++i) {
-    var result = f3(42);
-    if (result != 42)
-        throw "Error: bad result: " + result;
-}
-

implementation-contributed/javascriptcore/stress/assign-captured-argument-in-inlined-call.js

@@ -1,21 +0,0 @@
-function f1(a) {
-    return a[0];
-}
-
-function f2(a) {
-    a = f1(arguments);
-    return a;
-}
-
-function f3(a) {
-    return f2(a);
-}
-
-noInline(f3);
-
-for (var i = 0; i < 10000; ++i) {
-    var result = f3(42);
-    if (result != 42)
-        throw "Error: bad result: " + result;
-}
-

implementation-contributed/javascriptcore/stress/assignment-in-function-call-bracket-node.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(actual, expected) {
     if (actual !== expected)
         throw new Error('bad value: ' + actual);

implementation-contributed/javascriptcore/stress/async-arrow-function-in-class-heritage.js

@@ -1,3 +1,9 @@
+// Reviewed
+/**
+ * reviewed
+ * Tests class heritage failing with arrow functions (no constructor). Might have coverage, not found yet.
+ */
+
 function testSyntax(script) {
     try {
         eval(script);

implementation-contributed/javascriptcore/stress/async-arrow-functions-lexical-arguments-binding.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(expected, actual, msg) {
     if (msg === void 0)
         msg = "";

implementation-contributed/javascriptcore/stress/async-arrow-functions-lexical-binding-in-class.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(expected, actual, msg) {
     if (msg === void 0)
         msg = "";

implementation-contributed/javascriptcore/stress/async-arrow-functions-lexical-new.target-binding.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(expected, actual, msg) {
     if (msg === void 0)
         msg = "";

implementation-contributed/javascriptcore/stress/async-arrow-functions-lexical-super-binding.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(expected, actual, msg) {
     if (msg === void 0)
         msg = "";

implementation-contributed/javascriptcore/stress/async-arrow-functions-lexical-this-binding.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(expected, actual, msg) {
     if (msg === void 0)
         msg = "";

implementation-contributed/javascriptcore/stress/async-await-basic.js

@@ -1,348 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function shouldBeAsync(expected, run, msg) {
-    let actual;
-    var hadError = false;
-    run().then(function(value) { actual = value; },
-               function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (hadError)
-        throw actual;
-
-    shouldBe(expected, actual, msg);
-}
-
-function shouldThrow(run, errorType, message) {
-    let actual;
-    var hadError = false;
-
-    try {
-        actual = run();
-    } catch (e) {
-        hadError = true;
-        actual = e;
-    }
-
-    if (!hadError)
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
-    if (!(actual instanceof errorType))
-        throw new Error("Expeced " + run + "() to throw " + errorType.name + " , but threw '" + actual + "'");
-    if (message !== void 0 && actual.message !== message)
-        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
-}
-
-function shouldThrowAsync(run, errorType, message) {
-    let actual;
-    var hadError = false;
-    run().then(function(value) { actual = value; },
-               function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (!hadError)
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
-    if (!(actual instanceof errorType))
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
-    if (message !== void 0 && actual.message !== message)
-        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
-}
-
-function shouldThrowSyntaxError(str, message) {
-    try {
-        eval(str);
-        throw new Error("Expected `" + str + "` to throw a SyntaxError, but did not throw.")
-    } catch (e) {
-        if (e.constructor !== SyntaxError)
-            throw new Error("Expected `" + str + "` to throw a SyntaxError, but threw '" + e + "'");
-        if (message !== void 0 && e.message !== message)
-            throw new Error("Expected `" + str + "` to throw SyntaxError: '" + message + "', but threw '" + e + "'");
-    }
-}
-
-// Do not install `AsyncFunction` constructor on global object
-shouldBe(undefined, this.AsyncFunction);
-let AsyncFunction = (async function() {}).constructor;
-
-// Let functionPrototype be the intrinsic object %AsyncFunctionPrototype%.
-async function asyncFunctionForProto() {}
-shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(asyncFunctionForProto));
-shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(async function() {}));
-shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(async () => {}));
-shouldBe(AsyncFunction.prototype, Object.getPrototypeOf({ async method() {} }.method));
-
-// FIXME: AsyncFunction constructor should build functions with correct prototype.
-// shouldBe(AsyncFunction.prototype, Object.getPrototypeOf(AsyncFunction()));
-
-// AsyncFunctionCreate does not produce an object with a Prototype
-shouldBe(undefined, asyncFunctionForProto.prototype);
-shouldBe(false, asyncFunctionForProto.hasOwnProperty("prototype"));
-shouldBe(undefined, (async function() {}).prototype);
-shouldBe(false, (async function() {}).hasOwnProperty("prototype"));
-shouldBe(undefined, (async() => {}).prototype);
-shouldBe(false, (async() => {}).hasOwnProperty("prototype"));
-shouldBe(undefined, ({ async method() {} }).method.prototype);
-shouldBe(false, ({ async method() {} }).method.hasOwnProperty("prototype"));
-shouldBe(undefined, AsyncFunction().prototype);
-shouldBe(false, AsyncFunction().hasOwnProperty("prototype"));
-
-// AsyncFunction.prototype[ @@toStringTag ]
-var descriptor = Object.getOwnPropertyDescriptor(AsyncFunction.prototype, Symbol.toStringTag);
-shouldBe("AsyncFunction", descriptor.value);
-shouldBe(false, descriptor.enumerable);
-shouldBe(false, descriptor.writable);
-shouldBe(true, descriptor.configurable);
-
-shouldBe(1, AsyncFunction.length);
-
-// Let F be ! FunctionAllocate(functionPrototype, Strict, "non-constructor")
-async function asyncNonConstructorDecl() {}
-shouldThrow(() => new asyncNonConstructorDecl(), TypeError);
-shouldThrow(() => new (async function() {}), TypeError);
-shouldThrow(() => new ({ async nonConstructor() {} }).nonConstructor(), TypeError);
-shouldThrow(() => new (() => "not a constructor!"), TypeError);
-shouldThrow(() => new (AsyncFunction()), TypeError);
-
-// Normal completion
-async function asyncDecl() { return "test"; }
-shouldBeAsync("test", asyncDecl);
-shouldBeAsync("test2", async function() { return "test2"; });
-shouldBeAsync("test3", async () => "test3");
-shouldBeAsync("test4", () => ({ async f() { return "test4"; } }).f());
-
-class MyError extends Error {};
-
-// Throw completion
-async function asyncDeclThrower(e) { throw new MyError(e); }
-shouldThrowAsync(() => asyncDeclThrower("boom!"), MyError, "boom!");
-shouldThrowAsync(() => (async function(e) { throw new MyError(e); })("boom!!!"), MyError, "boom!!!");
-shouldThrowAsync(() => (async e => { throw new MyError(e) })("boom!!"), MyError, "boom!!");
-shouldThrowAsync(() => ({ async thrower(e) { throw new MyError(e); } }).thrower("boom!!!!"), MyError, "boom!!!!");
-
-function resolveLater(value) { return Promise.resolve(value); }
-function rejectLater(error) { return Promise.reject(error); }
-
-// Resume after Normal completion
-var log = [];
-async function resumeAfterNormal(value) {
-    log.push("start:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    return value + 1;
-}
-
-shouldBeAsync(4, () => resumeAfterNormal(1));
-shouldBe("start:1 resume:2 resume:3", log.join(" "));
-
-var O = {
-    async resumeAfterNormal(value) {
-        log.push("start:" + value);
-        value = await resolveLater(value + 1);
-        log.push("resume:" + value);
-        value = await resolveLater(value + 1);
-        log.push("resume:" + value);
-        return value + 1;
-    }
-};
-log = [];
-shouldBeAsync(5, () => O.resumeAfterNormal(2));
-shouldBe("start:2 resume:3 resume:4", log.join(" "));
-
-var resumeAfterNormalArrow = async (value) => {
-    log.push("start:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    return value + 1;
-};
-log = [];
-shouldBeAsync(6, () => resumeAfterNormalArrow(3));
-shouldBe("start:3 resume:4 resume:5", log.join(" "));
-
-var resumeAfterNormalEval = AsyncFunction("value", `
-    log.push("start:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    value = await resolveLater(value + 1);
-    log.push("resume:" + value);
-    return value + 1;
-`);
-log = [];
-shouldBeAsync(7, () => resumeAfterNormalEval(4));
-shouldBe("start:4 resume:5 resume:6", log.join(" "));
-
-// Resume after Throw completion
-async function resumeAfterThrow(value) {
-    log.push("start:" + value);
-    try {
-        value = await rejectLater("throw1");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    try {
-        value = await rejectLater("throw2");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    return value + 1;
-}
-
-log = [];
-shouldBeAsync(2, () => resumeAfterThrow(1));
-shouldBe("start:1 resume:throw1 resume:throw2", log.join(" "));
-
-var O = {
-    async resumeAfterThrow(value) {
-        log.push("start:" + value);
-        try {
-            value = await rejectLater("throw1");
-        } catch (e) {
-            log.push("resume:" + e);
-        }
-        try {
-            value = await rejectLater("throw2");
-        } catch (e) {
-            log.push("resume:" + e);
-        }
-        return value + 1;
-    }
-}
-log = [];
-shouldBeAsync(3, () => O.resumeAfterThrow(2));
-shouldBe("start:2 resume:throw1 resume:throw2", log.join(" "));
-
-var resumeAfterThrowArrow = async (value) => {
-    log.push("start:" + value);
-    try {
-        value = await rejectLater("throw1");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    try {
-        value = await rejectLater("throw2");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    return value + 1;
-};
-log = [];
-shouldBeAsync(4, () => resumeAfterThrowArrow(3));
-shouldBe("start:3 resume:throw1 resume:throw2", log.join(" "));
-
-var resumeAfterThrowEval = AsyncFunction("value", `
-    log.push("start:" + value);
-    try {
-        value = await rejectLater("throw1");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    try {
-        value = await rejectLater("throw2");
-    } catch (e) {
-        log.push("resume:" + e);
-    }
-    return value + 1;
-`);
-log = [];
-shouldBeAsync(5, () => resumeAfterThrowEval(4));
-shouldBe("start:4 resume:throw1 resume:throw2", log.join(" "));
-
-var awaitEpression = async (value) => {
-    log.push("start:" + value);
-    if (!await false)
-        log.push('step 1');
-    var t = ~await true;
-    log.push('step 2 ' + t);
-
-    var t1 = +await Promise.resolve(12345);
-    log.push('step 3 ' + t1);
-
-    var t2 = -await 54321;
-    log.push('step 4 ' + t2);
-
-    var t3 = !!!!!await Promise.resolve(true);
-    log.push('step 5 ' + t3);
-
-    try {
-        var t4 = ++await 1;
-    } catch(e) {
-        if (e instanceof ReferenceError) {
-            log.push('step 6 ');
-        } 
-    }
-
-    try {
-        var t5 = --await 1;
-    } catch(e) {
-        if (e instanceof ReferenceError) {
-            log.push('step 7');
-        } 
-    }
-
-    return void await 'test';
-};
-log = [];
-
-shouldBeAsync(undefined, () => awaitEpression(5));
-shouldBe("start:5 step 1 step 2 -2 step 3 12345 step 4 -54321 step 5 false step 6  step 7", log.join(" "));
-
-// MethoodDefinition SyntaxErrors
-shouldThrowSyntaxError("var obj = { async foo : true };", "Unexpected token ':'. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async foo = true };", "Unexpected token '='. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async foo , bar };", "Unexpected token ','. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async foo }", "Unexpected token '}'. Expected a parenthesis for argument list.");
-
-shouldThrowSyntaxError("var obj = { async 0 : true };", "Unexpected token ':'. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 0 = true };", "Unexpected token '='. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 0 , bar };", "Unexpected token ','. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 0 }", "Unexpected token '}'. Expected a parenthesis for argument list.");
-
-shouldThrowSyntaxError("var obj = { async 'foo' : true };", "Unexpected token ':'. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 'foo' = true };", "Unexpected token '='. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 'foo' , bar };", "Unexpected token ','. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async 'foo' }", "Unexpected token '}'. Expected a parenthesis for argument list.");
-
-shouldThrowSyntaxError("var obj = { async ['foo'] : true };", "Unexpected token ':'. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async ['foo'] = true };", "Unexpected token '='. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async ['foo'] , bar };", "Unexpected token ','. Expected a parenthesis for argument list.");
-shouldThrowSyntaxError("var obj = { async ['foo'] }", "Unexpected token '}'. Expected a parenthesis for argument list.");
-
-shouldThrowSyntaxError("class C { async foo : true };", "Unexpected token ':'. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async foo = true };", "Unexpected token '='. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async foo , bar };", "Unexpected token ','. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async foo }", "Unexpected token '}'. Expected an opening '(' before a async method's parameter list.");
-
-shouldThrowSyntaxError("class C { async 0 : true };", "Unexpected token ':'. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 0 = true };", "Unexpected token '='. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 0 , bar };", "Unexpected token ','. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 0 }", "Unexpected token '}'. Expected an opening '(' before a async method's parameter list.");
-
-shouldThrowSyntaxError("class C { async 'foo' : true };", "Unexpected token ':'. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 'foo' = true };", "Unexpected token '='. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 'foo' , bar };", "Unexpected token ','. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async 'foo' }", "Unexpected token '}'. Expected an opening '(' before a async method's parameter list.");
-
-shouldThrowSyntaxError("class C { async ['foo'] : true };", "Unexpected token ':'. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async ['foo'] = true };", "Unexpected token '='. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async ['foo'] , bar };", "Unexpected token ','. Expected an opening '(' before a async method's parameter list.");
-shouldThrowSyntaxError("class C { async ['foo'] }", "Unexpected token '}'. Expected an opening '(' before a async method's parameter list.");
-
-// Ensure awaited builtin Promise objects are themselves wrapped in a new Promise,
-// per https://tc39.github.io/ecma262/#sec-async-functions-abstract-operations-async-function-await
-log = [];
-async function awaitedPromisesAreWrapped() {
-    log.push("before");
-    await Promise.resolve();
-    log.push("after");
-}
-awaitedPromisesAreWrapped();
-Promise.resolve().then(() => log.push("Promise.resolve()"));
-drainMicrotasks();
-shouldBe("before|Promise.resolve()|after", log.join("|"));

implementation-contributed/javascriptcore/stress/async-await-long-loop.js

@@ -1,26 +0,0 @@
-// Copyright (C) Copyright 2016 the v8 project authors. All rights reserved.
-
-//@ runNoCJIT("--gcMaxHeapSize=2000000")
-
-
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-
-let out;
-
-async function longLoop() {
-    for (let i = 0; i < 10000; i++)
-        await undefined;
-    out = 1;
-}
-
-longLoop();
-
-drainMicrotasks();
-
-shouldBe(out, 1);

implementation-contributed/javascriptcore/stress/async-await-module-reserved-word.js

@@ -1,69 +0,0 @@
-function shouldThrow(func, errorMessage) {
-    var errorThrown = false;
-    var error = null;
-    try {
-        func();
-    } catch (e) {
-        errorThrown = true;
-        error = e;
-    }
-    if (!errorThrown)
-        throw new Error('not thrown');
-    if (String(error) !== errorMessage)
-        throw new Error(`bad error: ${String(error)}`);
-}
-
-function checkModuleSyntaxError(source, errorMessage) {
-    shouldThrow(() => checkModuleSyntax(source), errorMessage);
-}
-
-checkModuleSyntaxError(String.raw`
-var await;
-`, `SyntaxError: Cannot use 'await' as a variable name in a module.:2`);
-checkModuleSyntaxError(`
-export var await;
-`, `SyntaxError: Cannot use 'await' as a variable name in a module.:2`);
-checkModuleSyntaxError(String.raw`
-let await;
-`, `SyntaxError: Cannot use 'await' as a lexical variable name in a module.:2`);
-checkModuleSyntaxError(String.raw`
-export let await;
-`, `SyntaxError: Cannot use 'await' as a lexical variable name in a module.:2`);
-checkModuleSyntaxError(String.raw`
-const await = 1
-`, `SyntaxError: Cannot use 'await' as a lexical variable name in a module.:2`);
-checkModuleSyntaxError(String.raw`
-export const await = 1
-`, `SyntaxError: Cannot use 'await' as a lexical variable name in a module.:2`);
-
-checkModuleSyntaxError(String.raw`
-function await() {}
-`, `SyntaxError: Cannot declare function named 'await' in a module.:2`);
-checkModuleSyntaxError(String.raw`
-function* await() {}
-`, `SyntaxError: Cannot declare function named 'await' in a module.:2`);
-checkModuleSyntaxError(String.raw`
-async function await() {}
-`, `SyntaxError: Cannot declare function named 'await' in a module.:2`);
-
-checkModuleSyntaxError(String.raw`
-import {await} from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import {foo as await} from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import * as await from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import await, {x, y, z} from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import await, {x, y, z,} from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import await from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);
-checkModuleSyntaxError(String.raw`
-import await, * as foo from 'foo';
-`, `SyntaxError: Cannot use 'await' as an imported binding name.:2`);

implementation-contributed/javascriptcore/stress/async-await-mozilla.js

@@ -1,302 +0,0 @@
-/* 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://moz.org/MPL/2.0/. */
-
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function shouldBeAsync(expected, run, msg) {
-    let actual;
-    var hadError = false;
-    run().then(function(value) { actual = value; },
-               function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-    if (hadError)
-        throw actual;
-    shouldBe(expected, actual, msg);
-}
-
-function shouldThrow(run, errorType, message) {
-    let actual;
-    var hadError = false;
-    try {
-        actual = run();
-    } catch (e) {
-        hadError = true;
-        actual = e;
-    }
-    if (!hadError)
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
-    if (!(actual instanceof errorType))
-        throw new Error("Expeced " + run + "() to throw " + errorType.name + " , but threw '" + actual + "'");
-    if (message !== void 0 && actual.message !== message)
-        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
-}
-
-function shouldThrowAsync(run, errorType, message) {
-    let actual;
-    var hadError = false;
-    run().then(function(value) { actual = value; },
-               function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-    if (!hadError)
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but did not throw.");
-    if (!(actual instanceof errorType))
-        throw new Error("Expected " + run + "() to throw " + errorType.name + ", but threw '" + actual + "'");
-    if (message !== void 0 && actual.message !== message)
-        throw new Error("Expected " + run + "() to throw '" + message + "', but threw '" + actual.message + "'");
-}
-
-function assert(cond, msg = "") {
-    if (!cond)
-        throw new Error(msg);
-}
-
-function shouldThrowSyntaxError(str, message) {
-    var hadError = false;
-    try {
-        eval(str);
-    } catch (e) {
-        if (e instanceof SyntaxError) {
-            hadError = true;
-            if (typeof message === "string")
-                assert(e.message === message, "Expected '" + message + "' but threw '" + e.message + "'");
-        }
-    }
-    assert(hadError, "Did not throw syntax error");
-}
-
-// semantics.js
-(function mozSemantics() {
-
-async function empty() {
-}
-
-async function simpleReturn() {
-    return 1;
-}
-
-async function simpleAwait() {
-    var result = await 2;
-    return result;
-}
-
-async function simpleAwaitAsync() {
-    var result = await simpleReturn();
-    return 2 + result;
-}
-
-async function returnOtherAsync() {
-    return 1 + await simpleAwaitAsync();
-}
-
-async function simpleThrower() {
-    throw new Error();
-}
-
-async function delegatedThrower() {
-    var val = await simpleThrower();
-    return val;
-}
-
-async function tryCatch() {
-    try {
-        await delegatedThrower();
-        return 'FAILED';
-    } catch (_) {
-        return 5;
-    }
-}
-
-async function tryCatchThrow() {
-    try {
-        await delegatedThrower();
-        return 'FAILED';
-    } catch (_) {
-        return delegatedThrower();
-    }
-}
-
-async function wellFinally() {
-    try {
-        await delegatedThrower();
-    } catch (_) {
-        return 'FAILED';
-    } finally {
-        return 6;
-    }
-}
-
-async function finallyMayFail() {
-    try {
-        await delegatedThrower();
-    } catch (_) {
-        return 5;
-    } finally {
-        return delegatedThrower();
-    }
-}
-
-async function embedded() {
-    async function inner() {
-        return 7;
-    }
-    return await inner();
-}
-
-// recursion, it works!
-async function fib(n) {
-    return (n == 0 || n == 1) ? n : await fib(n - 1) + await fib(n - 2);
-}
-
-// mutual recursion
-async function isOdd(n) {
-    async function isEven(n) {
-        return n === 0 || await isOdd(n - 1);
-    }
-    return n !== 0 && await isEven(n - 1);
-}
-
-// recursion, take three!
-var hardcoreFib = async function fib2(n) {
-    return (n == 0 || n == 1) ? n : await fib2(n - 1) + await fib2(n - 2);
-}
-
-var asyncExpr = async function() {
-    return 10;
-}
-
-var namedAsyncExpr = async function simple() {
-    return 11;
-}
-
-async function executionOrder() {
-    var value = 0;
-    async function first() {
-        return (value = value === 0 ? 1 : value);
-    }
-    async function second() {
-        return (value = value === 0 ? 2 : value);
-    }
-    async function third() {
-        return (value = value === 0 ? 3 : value);
-    }
-    return await first() + await second() + await third() + 6;
-}
-
-async function miscellaneous() {
-    if (arguments.length === 3 &&
-        arguments.callee.name === "miscellaneous")
-        return 14;
-}
-
-function thrower() {
-    throw 15;
-}
-
-async function defaultArgs(arg = thrower()) {
-}
-
-// Async functions are not constructible
-shouldThrow(() => {
-    async function Person() {
-    }
-    new Person();
-}, TypeError);
-
-shouldBeAsync(undefined, empty);
-shouldBeAsync(1, simpleReturn);
-shouldBeAsync(2, simpleAwait);
-shouldBeAsync(3, simpleAwaitAsync);
-shouldBeAsync(4, returnOtherAsync);
-shouldThrowAsync(simpleThrower, Error);
-shouldBeAsync(5, tryCatch);
-shouldBeAsync(6, wellFinally);
-shouldThrowAsync(finallyMayFail, Error);
-shouldBeAsync(7, embedded);
-shouldBeAsync(8, () => fib(6));
-shouldBeAsync(9, executionOrder);
-shouldBeAsync(10, asyncExpr);
-shouldBeAsync(11, namedAsyncExpr);
-shouldBeAsync(12, () => isOdd(12).then(v => v ? "oops" : 12));
-shouldBeAsync(13, () => hardcoreFib(7));
-shouldBeAsync(14, () => miscellaneous(1, 2, 3));
-shouldBeAsync(15, () => defaultArgs().catch(e => e));
-
-})();
-
-// methods.js
-(function mozMethods() {
-
-class X {
-    constructor() {
-        this.value = 42;
-    }
-    async getValue() {
-        return this.value;
-    }
-    setValue(value) {
-        this.value = value;
-    }
-    async increment() {
-        var value = await this.getValue();
-        this.setValue(value + 1);
-        return this.getValue();
-    }
-    async getBaseClassName() {
-        return 'X';
-    }
-    static async getStaticValue() {
-        return 44;
-    }
-}
-
-class Y extends X {
-    async getBaseClassName() {
-        return super.getBaseClassName();
-    }
-}
-
-var objLiteral = {
-    async get() {
-        return 45;
-    },
-    someStuff: 5
-};
-
-var x = new X();
-var y = new Y();
-
-shouldBeAsync(42, () => x.getValue());
-shouldBeAsync(43, () => x.increment());
-shouldBeAsync(44, () => X.getStaticValue());
-shouldBeAsync(45, () => objLiteral.get());
-shouldBeAsync('X', () => y.getBaseClassName());
-
-})();
-
-(function mozFunctionNameInferrence() {
-
-async function test() { }
-
-var anon = async function() { }
-
-shouldBe("test", test.name);
-shouldBe("anon", anon.name);
-
-})();
-
-(function mozSyntaxErrors() {
-
-shouldThrowSyntaxError("'use strict'; async function eval() {}");
-shouldThrowSyntaxError("'use strict'; async function arguments() {}");
-shouldThrowSyntaxError("async function a(k = super.prop) { }");
-shouldThrowSyntaxError("async function a() { super.prop(); }");
-shouldThrowSyntaxError("async function a() { super(); }");
-shouldThrowSyntaxError("async function a(k = await 3) {}");
-
-})();

implementation-contributed/javascriptcore/stress/async-await-reserved-word.js

@@ -1,163 +0,0 @@
-function assert(cond, msg = "") {
-    if (!cond)
-        throw new Error(msg);
-}
-noInline(assert);
-
-function shouldThrowSyntaxError(str, message) {
-    var hadError = false;
-    try {
-        eval(str);
-    } catch (e) {
-        if (e instanceof SyntaxError) {
-            hadError = true;
-            if (typeof message === "string")
-                assert(e.message === message, "Expected '" + message + "' but threw '" + e.message + "'");
-        }
-    }
-    assert(hadError, "Did not throw syntax error");
-}
-noInline(shouldThrowSyntaxError);
-
-var AsyncFunction = (async function() {}).constructor;
-
-// AsyncFunctionExpression
-shouldThrowSyntaxError("(async function() { var await; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { var [await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { var [...await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { var {await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let await; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let [await] = []; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let [...await] = []; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let {await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let {isAsync: await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { let {isAsync: await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const await; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const [await] = []; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const [...await] = []; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const {await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const {isAsync: await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { const {isAsync: await} = {}; })", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("(async function() { function await() {} })", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("(async function() { async function await() {} })", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("(async function(await) {})", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("(async function f([await]) {})", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("(async function f([...await]) {})", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("(async function f(...await) {})", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("(async function f({await}) {})", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("(async function f({isAsync: await}) {})", "Cannot use 'await' as a parameter name in an async function.");
-
-// AsyncFunctionDeclaration
-shouldThrowSyntaxError("async function f() { var await; }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { var [await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { var [...await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { var {await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let await; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let [await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let [...await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let {await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { let {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const await; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const [await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const [...await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const {await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { const {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("async function f() { function await() {} }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("async function f() { async function await() {} }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("async function f(await) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("async function f([await]) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("async function f([...await]) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("async function f(...await) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("async function f({await}) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("async function f({isAsync: await}) {}", "Cannot use 'await' as a parameter name in an async function.");
-
-// AsyncArrowFunction
-shouldThrowSyntaxError("var f = async () => { var await; }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { var [await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { var [...await] = []; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { var {await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { var {isAsync: await} = {}; })", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let await; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let [await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let [...await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let {await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { let {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const await; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const [await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const [...await] = []; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const {await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { const {isAsync: await} = {}; }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var f = async () => { function await() {} }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("var f = async () => { async function await() {} }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("var f = async (await) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async ([await]) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async ([...await]) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async (...await) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async ({await}) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async ({isAsync: await}) => {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var f = async await => {}", "Cannot use 'await' as a parameter name in an async function.");
-
-// AsyncMethod
-shouldThrowSyntaxError("var O = { async f() { var await; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { var [await] = []; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { var [...await] = []; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { var {await} = {}; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { var {isAsync: await} = {}; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { var {isAsync: await} = {}; } }", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let await; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let [await] = []; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let [...await] = []; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let {await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let {isAsync: await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { let {isAsync: await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const await; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const [await] = []; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const [...await] = []; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const {await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const {isAsync: await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { const {isAsync: await} = {}; } }", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("var O = { async f() { function await() {} }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("var O = { async f() { async function await() {} } }", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("var O = { async f(await) {} } ", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var O = { async f([await]) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var O = { async f([...await]) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var O = { async f(...await) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var O = { async f({await}) {}", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("var O = { async f({isAsync: await}) {}", "Cannot use 'await' as a parameter name in an async function.");
-
-// AsyncFunction constructor
-shouldThrowSyntaxError("AsyncFunction('var await;')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('var [await] = [];')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('var [...await] = [];')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('var {await} = {};')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('var {isAsync: await} = {};')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('var {isAsync: await} = {};')", "Cannot use 'await' as a variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let await;')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let [await] = [];')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let [...await] = [];')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let {await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let {isAsync: await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('let {isAsync: await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const await;')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const [await] = [];')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const [...await] = [];')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const {await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const {isAsync: await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('const {isAsync: await} = {};')", "Cannot use 'await' as a lexical variable name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('function await() {}')", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("AsyncFunction('async function await() {}')", "Cannot declare function named 'await' in an async function.");
-shouldThrowSyntaxError("AsyncFunction('await', '')", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('[await]', '')", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('[...await]', '')", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('...await', '')", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('{await}', '')", "Cannot use 'await' as a parameter name in an async function.");
-shouldThrowSyntaxError("AsyncFunction('{isAsync: await}', '')", "Cannot use 'await' as a parameter name in an async function.");

implementation-contributed/javascriptcore/stress/async-await-syntax.js

@@ -1,582 +0,0 @@
-// Copyright (C) 2016 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function testSyntax(script) {
-    try {
-        eval(script);
-    } catch (error) {
-        if (error instanceof SyntaxError)
-            throw new Error("Bad error: " + String(error) + "\n       evaluating `" + script + "`");
-    }
-}
-
-function testSyntaxError(script, message) {
-    var error = null;
-    try {
-        eval(script);
-    } catch (e) {
-        error = e;
-    }
-    if (!error)
-        throw new Error("Expected syntax error not thrown\n       evaluating `" + script + "`");
-
-    if (typeof message === "string" && String(error) !== message)
-        throw new Error("Bad error: " + String(error) + "\n       evaluating `" + script + "`");
-}
-
-(function testTopLevelAsyncAwaitSyntaxSloppyMode() {
-    testSyntax(`({async: 1})`);
-    testSyntax(`var asyncFn = async function() { await 1; };`);
-
-    testSyntax(`var asyncFn = async function() { var t = !await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = ~await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = typeof await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = void await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = !(await 1); };`);
-    testSyntax(`var asyncFn = async function() { var t = ~(await 1); };`);
-    testSyntax(`var asyncFn = async function() { var t = typeof (await 1); };`);
-    testSyntax(`var asyncFn = async function() { var t = void (await 1); };`);
-
-
-    testSyntax(`var asyncFn = async function() { var t = !!await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = ~~await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = typeof typeof await 1; };`);
-    testSyntax(`var asyncFn = async function() { var t = void void await 1; };`);
-
-    testSyntax(`var asyncFn = async function withName() { await 1; };`);
-    testSyntax(`var asyncFn = async () => await 'test';`);
-
-    testSyntax(`var asyncFn = async () => !await 'test';`);
-    testSyntax(`var asyncFn = async () => ~await 'test';`);
-    testSyntax(`var asyncFn = async () => typeof await 'test';`);
-    testSyntax(`var asyncFn = async () => void await 'test';`);
-    testSyntax(`var asyncFn = async () => - await 'test';`);
-    testSyntax(`var asyncFn = async () => + await 'test';`);
-    testSyntax(`var asyncFn = async () => delete await 'test';`);
-
-    testSyntax(`var asyncFn = async () => !!await 'test';`);
-    testSyntax(`var asyncFn = async () => ~~await 'test';`);
-    testSyntax(`var asyncFn = async () => typeof typeof await 'test';`);
-    testSyntax(`var asyncFn = async () => void void await 'test';`);
-
-    testSyntax(`var asyncFn = async x => await x + 'test';`);
-    testSyntax(`function foo(fn) { fn({ async: true }); }`);
-    testSyntax(`async function asyncFn() { await 1; }`);
-    testSyntax(`var O = { async method() { await 1; } };`);
-    testSyntax(`var O = { async ['meth' + 'od']() { await 1; } };`);
-    testSyntax(`var O = { async 'method'() { await 1; } };`);
-    testSyntax(`var O = { async 0() { await 1; } };`);
-    testSyntax(`var O = { async function() {} };`);
-    testSyntax(`class C { async method() { await 1; } };`);
-    testSyntax(`class C { async ['meth' + 'od']() { await 1; } };`);
-    testSyntax(`class C { async 'method'() { await 1; } };`);
-    testSyntax(`class C { async 0() { await 1; } };`);
-    testSyntax(`var asyncFn = async({ foo = 1 }) => foo;`);
-    testSyntax(`var asyncFn = async({ foo = 1 } = {}) => foo;`);
-    testSyntax(`function* g() { var f = async(yield); }`);
-    testSyntax(`function* g() { var f = async(x = yield); }`);
-    testSyntax(`class C { async ['function']() {} }`);
-    testSyntax(`class C {}; class C2 extends C { async ['function']() {} }`);
-    testSyntax(`class C { static async ['function']() {} }`);
-    testSyntax(`class C {}; class C2 extends C { static async ['function']() {} }`);
-    testSyntax(`class C { async function() {} }`);
-    testSyntax(`class C {}; class C2 extends C { async function() {} }`);
-    testSyntax(`class C { static async function() {} }`);
-    testSyntax(`class C {}; class C2 extends C { static async function() {} }`);
-    testSyntax(`class C { async 'function'() {} }`);
-    testSyntax(`class C {}; class C2 extends C { async 'function'() {} }`);
-    testSyntax(`class C { static async 'function'() {} }`);
-    testSyntax(`class C {}; class C2 extends C { static async 'function'() {} }`);
-})();
-
-(function testTopLevelAsyncAwaitSyntaxStrictMode() {
-    testSyntax(`"use strict"; ({async: 1})`);
-    testSyntax(`"use strict"; var asyncFn = async function() { await 1; };`);
-
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = ~await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = +await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = -await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = typeof await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = void await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !(await 1); };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = ~(await 1); };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = -(await 1); };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = +(await 1); };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = typeof (await 1); };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = void (await 1); };`);
-
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !!await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = ~~await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = typeof typeof await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = void void await 1; };`);
-
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !!await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !~await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !typeof typeof await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async function() { var t = !void void await 1; };`);
-
-
-    testSyntax(`"use strict"; var asyncFn = async function withName() { await 1; };`);
-    testSyntax(`"use strict"; var asyncFn = async () => await 'test';`);
-    testSyntax(`"use strict"; var asyncFn = async x => await x + 'test';`);
-    testSyntax(`"use strict"; function foo(fn) { fn({ async: true }); }`);
-    testSyntax(`"use strict"; async function asyncFn() { await 1; }`);
-    testSyntax(`"use strict"; var O = { async method() { await 1; } };`);
-    testSyntax(`"use strict"; var O = { async ['meth' + 'od']() { await 1; } };`);
-    testSyntax(`"use strict"; var O = { async 'method'() { await 1; } };`);
-    testSyntax(`"use strict"; var O = { async 0() { await 1; } };`);
-    testSyntax(`"use strict"; class C { async method() { await 1; } };`);
-    testSyntax(`"use strict"; class C { async ['meth' + 'od']() { await 1; } };`);
-    testSyntax(`"use strict"; class C { async 'method'() { await 1; } };`);
-    testSyntax(`"use strict"; class C { async 0() { await 1; } };`);
-    testSyntax(`"use strict"; var asyncFn = async({ foo = 1 }) => foo;`);
-    testSyntax(`"use strict"; var asyncFn = async({ foo = 1 } = {}) => foo;`);
-    testSyntax(`"use strict"; function* g() { var f = async(yield); }`);
-    testSyntax(`"use strict"; function* g() { var f = async(x = yield); }`);
-    testSyntax(`"use strict"; class C { async ['function']() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { async ['function']() {} }`);
-    testSyntax(`"use strict"; class C { static async ['function']() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { static async ['function']() {} }`);
-    testSyntax(`"use strict"; class C { async function() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { async function() {} }`);
-    testSyntax(`"use strict"; class C { async function() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { async function() {} }`);
-    testSyntax(`"use strict"; class C { static async function() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { static async function() {} }`);
-    testSyntax(`"use strict"; class C { async 'function'() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { async 'function'() {} }`);
-    testSyntax(`"use strict"; class C { static async 'function'() {} }`);
-    testSyntax(`"use strict"; class C {}; class C2 extends C { static async 'function'() {} }`);
-})();
-
-(function testNestedAsyncAwaitSyntax() {
-    var contextData = [
-        { prefix: "function outerFunction() { ", suffix: " }" },
-        { prefix: "function* outerGenerator() { ", suffix: " }" },
-        { prefix: "var outerFuncExpr = function() { ", suffix: " };" },
-        { prefix: "var outerGenExpr = function*() { ", suffix: " };" },
-        { prefix: "var outerObject = { outerMethod() { ", suffix: " } };" },
-        { prefix: "var outerObject = { *outerGenMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { outerMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { *outerGenMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { static outerStaticMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { static *outerStaticGenMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { outerMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { *outerGenMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { static outerStaticMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { static *outerStaticGenMethod() { ", suffix: " } };" },
-        { prefix: "var outerArrow = () => { ", suffix: " };" },
-        { prefix: "async function outerAsyncFunction() { ", suffix: " }" },
-        { prefix: "var outerAsyncFuncExpr = async function() { ", suffix: " };" },
-        { prefix: "var outerAsyncArrowFunc = async () => { ", suffix: " };" },
-        { prefix: "var outerObject = { async outerAsyncMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { async outerAsyncMethod() { ", suffix: " } };" },
-        { prefix: "var outerClassExpr = class C { static async outerStaticAsyncMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { async outerAsyncMethod() { ", suffix: " } };" },
-        { prefix: "class outerClass { static async outerStaticAsyncMethod() { ", suffix: " } };" },
-    ];
-
-    var testData = [
-        `var async = 1; return async;`,
-        `let async = 1; return async;`,
-        `const async = 1; return async;`,
-        `function async() {} return async();`,
-        `var async = async => async; return async();`,
-        `function foo() { var await = 1; return await; }`,
-        `function foo(await) { return await; }`,
-        `function* foo() { var await = 1; return await; }`,
-        `function* foo(await) { return await; }`,
-        `var f = () => { var await = 1; return await; }`,
-        `var O = { method() { var await = 1; return await; } };`,
-        `var O = { method(await) { return await; } };`,
-        `var O = { *method() { var await = 1; return await; } };`,
-        `var O = { *method(await) { return await; } };`,
-
-        `(function await() {})`,
-    ];
-
-    for (let context of contextData) {
-        for (let test of testData) {
-            let script = context.prefix + test + context.suffix;
-            testSyntax(script);
-            testSyntax(`"use strict"; ${script}`);
-        }
-    }
-})();
-
-
-(function testTopLevelAsyncAwaitSyntaxSloppyMode() {
-    testSyntaxError(`({ async 
-        foo() {} })`);
-    testSyntaxError(`({async =  1})`);
-    testSyntaxError(`var asyncFn = async function await() {}`);
-    testSyntaxError(`var asyncFn = async () => var await = 'test';`);
-    testSyntaxError(`var asyncFn = async () => { var await = 'test'; };`);
-    testSyntaxError(`var asyncFn = async await => await + 'test'`);
-    testSyntaxError(`var asyncFn = async function(await) {}`);
-    testSyntaxError(`var asyncFn = async function withName(await) {}`);
-    testSyntaxError(`var asyncFn = async (await) => 'test';`);
-    testSyntaxError(`async function asyncFunctionDeclaration(await) {}`);
-
-    testSyntaxError(`var outerObject = { async method(a, a) {} }`);
-    testSyntaxError(`var outerObject = { async ['meth' + 'od'](a, a) {} }`);
-    testSyntaxError(`var outerObject = { async 'method'(a, a) {} }`);
-    testSyntaxError(`var outerObject = { async 0(a, a) {} }`);
-
-    testSyntaxError(`var outerObject = { async method(a, {a}) {} }`);
-    testSyntaxError(`var outerObject = { async method({a}, a) {} }`);
-    testSyntaxError(`var outerObject = { async method({a}, {a}) {} }`);
-    testSyntaxError(`var outerObject = { async method(a, ...a) {} }`);
-    testSyntaxError(`var outerObject = { async method({a}, ...a) {} }`);
-    testSyntaxError(`var outerObject = { async method(a, ...a) {} }`);
-    testSyntaxError(`var outerObject = { async method({a, ...a}) {} }`);
-    testSyntaxError(`var outerObject = { func: async function(a, {a}) {} }`);
-    testSyntaxError(`var outerObject = { func: async function({a}, a) {} }`);
-    testSyntaxError(`var outerObject = { func: async function({a}, {a}) {} }`);
-    testSyntaxError(`var outerObject = { func: async function(a, ...a) {} }`);
-    testSyntaxError(`var outerObject = { func: async function({a}, ...a) {} }`);
-    testSyntaxError(`var outerObject = { func: async function(a, ...a) {} }`);
-    testSyntaxError(`var outerObject = { func: async function({a, ...a}) {} }`);
-
-    testSyntaxError(`var asyncArrowFn = async() => await;`);
-
-    testSyntaxError(`var O = { *async asyncGeneratorMethod() {} };`);
-    testSyntaxError(`var O = { async asyncGeneratorMethod*() {} };`);
-
-    testSyntaxError(`var asyncFn = async function(x = await 1) { return x; }`);
-    testSyntaxError(`async function f(x = await 1) { return x; }`);
-    testSyntaxError(`var f = async(x = await 1) => x;`);
-    testSyntaxError(`var O = { async method(x = await 1) { return x; } };`);
-
-    testSyntaxError(`function* outerGenerator() { var asyncArrowFn = async yield => 1; }`);
-    testSyntaxError(`function* outerGenerator() { var asyncArrowFn = async(yield) => 1; }`);
-    testSyntaxError(`function* outerGenerator() { var asyncArrowFn = async(x = yield) => 1; }`);
-    testSyntaxError(`function* outerGenerator() { var asyncArrowFn = async({x = yield}) => 1; }`);
-
-    testSyntaxError(`class C { async constructor() {} }`);
-    testSyntaxError(`class C {}; class C2 extends C { async constructor() {} }`);
-    testSyntaxError(`class C { static async prototype() {} }`);
-    testSyntaxError(`class C {}; class C2 extends C { static async prototype() {} }`);
-
-    testSyntaxError(`var f = async() => ((async(x = await 1) => x)();`);
-
-    // Henrique Ferreiro's bug (tm)
-    testSyntaxError(`(async function foo1() { } foo2 => 1)`);
-    testSyntaxError(`(async function foo3() { } () => 1)`);
-    testSyntaxError(`(async function foo4() { } => 1)`);
-    testSyntaxError(`(async function() { } foo5 => 1)`);
-    testSyntaxError(`(async function() { } () => 1)`);
-    testSyntaxError(`(async function() { } => 1)`);
-    testSyntaxError(`(async.foo6 => 1)`);
-    testSyntaxError(`(async.foo7 foo8 => 1)`);
-    testSyntaxError(`(async.foo9 () => 1)`);
-    testSyntaxError(`(async().foo10 => 1)`);
-    testSyntaxError(`(async().foo11 foo12 => 1)`);
-    testSyntaxError(`(async().foo13 () => 1)`);
-    testSyntaxError(`(async['foo14'] => 1)`);
-    testSyntaxError(`(async['foo15'] foo16 => 1)`);
-    testSyntaxError(`(async['foo17'] () => 1)`);
-    testSyntaxError(`(async()['foo18'] => 1)`);
-    testSyntaxError(`(async()['foo19'] foo20 => 1)`);
-    testSyntaxError(`(async()['foo21'] () => 1`);
-    testSyntaxError("(async`foo22` => 1)");
-    testSyntaxError("(async`foo23` foo24 => 1)");
-    testSyntaxError("(async`foo25` () => 1)");
-    testSyntaxError("(async`foo26`.bar27 => 1)");
-    testSyntaxError("(async`foo28`.bar29 foo30 => 1)");
-    testSyntaxError("(async`foo31`.bar32 () => 1)");
-
-    // assert that errors are still thrown for calls that may have been async functions
-    testSyntaxError(`function async() {}
-                     async({ foo33 = 1 })`);
-})();
-
-(function testTopLevelAsyncAwaitSyntaxStrictMode() {
-    testSyntaxError(`"use strict"; ({ async 
-        foo() {} })`);
-    testSyntaxError(`"use strict"; ({async =  1})`);
-    testSyntaxError(`"use strict"; var asyncFn = async function await() {}`);
-    testSyntaxError(`"use strict"; var asyncFn = async () => var await = 'test';`);
-    testSyntaxError(`"use strict"; var asyncFn = async () => { var await = 'test'; };`);
-    testSyntaxError(`"use strict"; var asyncFn = async await => await + 'test'`);
-    testSyntaxError(`"use strict"; var asyncFn = async function(await) {}`);
-    testSyntaxError(`"use strict"; var asyncFn = async function withName(await) {}`);
-    testSyntaxError(`"use strict"; var asyncFn = async (await) => 'test';`);
-    testSyntaxError(`"use strict"; async function asyncFunctionDeclaration(await) {}`);
-
-    testSyntaxError(`"use strict"; var outerObject = { async method(a, a) {} }`);
-    testSyntaxError(`"use strict"; var outerObject = { async ['meth' + 'od'](a, a) {} }`);
-    testSyntaxError(`"use strict"; var outerObject = { async 'method'(a, a) {} }`);
-    testSyntaxError(`"use strict"; var outerObject = { async 0(a, a) {} }`);
-
-    testSyntaxError(`"use strict"; var asyncArrowFn = async() => await;`);
-
-    testSyntaxError(`"use strict"; var O = { *async asyncGeneratorMethod() {} };`);
-    testSyntaxError(`"use strict"; var O = { async asyncGeneratorMethod*() {} };`);
-
-    testSyntax(`"use strict"; var O = { async function() {} };`);
-
-    testSyntaxError(`"use strict"; var asyncFn = async function(x = await 1) { return x; }`);
-    testSyntaxError(`"use strict"; async function f(x = await 1) { return x; }`);
-    testSyntaxError(`"use strict"; var f = async(x = await 1) => x;`);
-    testSyntaxError(`"use strict"; var O = { async method(x = await 1) { return x; } };`);
-
-    testSyntaxError(`"use strict"; function* outerGenerator() { var asyncArrowFn = async yield => 1; }`);
-    testSyntaxError(`"use strict"; function* outerGenerator() { var asyncArrowFn = async(yield) => 1; }`);
-    testSyntaxError(`"use strict"; function* outerGenerator() { var asyncArrowFn = async(x = yield) => 1; }`);
-    testSyntaxError(`"use strict"; function* outerGenerator() { var asyncArrowFn = async({x = yield}) => 1; }`);
-
-    testSyntaxError(`"use strict"; class C { async constructor() {} }`);
-    testSyntaxError(`"use strict"; class C {}; class C2 extends C { async constructor() {} }`);
-    testSyntaxError(`"use strict"; class C { static async prototype() {} }`);
-    testSyntaxError(`"use strict"; class C {}; class C2 extends C { static async prototype() {} }`);
-
-    testSyntaxError(`"use strict"; var f = async() => ((async(x = await 1) => x)();`);
-
-    // Henrique Ferreiro's bug (tm)
-    testSyntaxError(`"use strict"; (async function foo1() { } foo2 => 1)`);
-    testSyntaxError(`"use strict"; (async function foo3() { } () => 1)`);
-    testSyntaxError(`"use strict"; (async function foo4() { } => 1)`);
-    testSyntaxError(`"use strict"; (async function() { } foo5 => 1)`);
-    testSyntaxError(`"use strict"; (async function() { } () => 1)`);
-    testSyntaxError(`"use strict"; (async function() { } => 1)`);
-    testSyntaxError(`"use strict"; (async.foo6 => 1)`);
-    testSyntaxError(`"use strict"; (async.foo7 foo8 => 1)`);
-    testSyntaxError(`"use strict"; (async.foo9 () => 1)`);
-    testSyntaxError(`"use strict"; (async().foo10 => 1)`);
-    testSyntaxError(`"use strict"; (async().foo11 foo12 => 1)`);
-    testSyntaxError(`"use strict"; (async().foo13 () => 1)`);
-    testSyntaxError(`"use strict"; (async['foo14'] => 1)`);
-    testSyntaxError(`"use strict"; (async['foo15'] foo16 => 1)`);
-    testSyntaxError(`"use strict"; (async['foo17'] () => 1)`);
-    testSyntaxError(`"use strict"; (async()['foo18'] => 1)`);
-    testSyntaxError(`"use strict"; (async()['foo19'] foo20 => 1)`);
-    testSyntaxError(`"use strict"; (async()['foo21'] () => 1)`);
-    testSyntaxError('"use strict"; (async`foo22` => 1)');
-    testSyntaxError('"use strict"; (async`foo23` foo24 => 1)');
-    testSyntaxError('"use strict"; (async`foo25` () => 1)');
-    testSyntaxError('"use strict"; (async`foo26`.bar27 => 1)');
-    testSyntaxError('"use strict"; (async`foo28`.bar29 foo30 => 1)');
-    testSyntaxError('"use strict"; (async`foo31`.bar32 () => 1)');
-
-    // assert that errors are still thrown for calls that may have been async functions
-    testSyntaxError(`"use strict"; function async() {}
-                     async({ foo33 = 1 })`);
-
-    testSyntaxError(`"use strict"; var O = { async method(eval) {} }`);
-    testSyntaxError(`"use strict"; var O = { async ['meth' + 'od'](eval) {} }`);
-    testSyntaxError(`"use strict"; var O = { async 'method'(eval) {} }`);
-    testSyntaxError(`"use strict"; var O = { async 0(eval) {} }`);
-
-    testSyntaxError(`"use strict"; var O = { async method(arguments) {} }`);
-    testSyntaxError(`"use strict"; var O = { async ['meth' + 'od'](arguments) {} }`);
-    testSyntaxError(`"use strict"; var O = { async 'method'(arguments) {} }`);
-    testSyntaxError(`"use strict"; var O = { async 0(arguments) {} }`);
-
-    testSyntaxError(`"use strict"; var O = { async method(dupe, dupe) {} }`);
-})();
-
-(function testAwaitInFormalParameters() {
-    var testData = [
-        `async function f(await) {}`,
-        `async function f(...await) {}`,
-        `async function f(await = 1) {}`,
-        `async function f([await]) {}`,
-        `async function f([await = 1]) {}`,
-        `async function f({ await }) {}`,
-        `async function f({ await = 1 }) {}`,
-        `async function f({ } = await) {}`,
-
-        `(async function(await) {})`,
-        `(async function(...await) {})`,
-        `(async function(await = 1) {})`,
-        `(async function([await]) {})`,
-        `(async function([await = 1]) {})`,
-        `(async function({ await }) {})`,
-        `(async function({ await = 1 }) {})`,
-        `(async function({ } = await) {})`,
-
-        `var asyncArrow = async(await) => 1;`,
-        `var asyncArrow = async(await) => {};`,
-        `var asyncArrow = async(...await) => 1;`,
-        `var asyncArrow = async(...await) => {};`,
-        `var asyncArrow = async(await = 1) => 1;`,
-        `var asyncArrow = async(await = 1) => {};`,
-        `var asyncArrow = async([await]) => 1;`,
-        `var asyncArrow = async([await]) => {};`,
-        `var asyncArrow = async([await = 1]) => 1;`,
-        `var asyncArrow = async([await = 1]) => {};`,
-        `var asyncArrow = async([] = await) => 1;`,
-        `var asyncArrow = async([] = await) => {};`,
-        `var asyncArrow = async({ await }) => 1;`,
-        `var asyncArrow = async({ await } ) => {};`,
-        `var asyncArrow = async({ await = 1}) => 1;`,
-        `var asyncArrow = async({ await = 1}) => {};`,
-        `var asyncArrow = async({ } = await) => 1;`,
-        `var asyncArrow = async({ } = await) => {};`,
-
-        `({ async method(await) {} })`,
-        `({ async method(...await) {} })`,
-        `({ async method(await = 1) {} })`,
-        `({ async method([await]) {} })`,
-        `({ async method([await = 1]) {} })`,
-        `({ async method({ await }) {} })`,
-        `({ async method({ await = 1 }) {} })`,
-        `({ async method({ } = await) {} })`,
-
-        `(class { async method(await) {} })`,
-        `(class { async method(...await) {} })`,
-        `(class { async method(await = 1) {} })`,
-        `(class { async method([await]) {} })`,
-        `(class { async method([await = 1]) {} })`,
-        `(class { async method({ await }) {} })`,
-        `(class { async method({ await = 1 }) {} })`,
-        `(class { async method({ } = await) {} })`,
-
-        `(class { static async method(await) {} })`,
-        `(class { static async method(...await) {} })`,
-        `(class { static async method(await = 1) {} })`,
-        `(class { static async method([await]) {} })`,
-        `(class { static async method([await = 1]) {} })`,
-        `(class { static async method({ await }) {} })`,
-        `(class { static async method({ await = 1 }) {} })`,
-        `(class { static async method({ } = await) {} })`,
-    ];
-
-    for (let script of testData) {
-        testSyntaxError(script);
-        testSyntaxError(`"use strict"; ${script}`);
-
-        var nested = `var await; var f = (async function() { ${script} });`;
-        testSyntaxError(nested);
-        testSyntaxError(`"use strict"; ${nested}`);
-    }
-})();
-
-testSyntaxError(`
-async function fn(arguments) {
-    "use strict";
-}
-`, `SyntaxError: Invalid parameters or function name in strict mode.`);
-
-testSyntaxError(`
-async function fn(eval) {
-    "use strict";
-}
-`, `SyntaxError: Invalid parameters or function name in strict mode.`);
-
-testSyntaxError(`
-async function arguments() {
-    "use strict";
-}
-`, `SyntaxError: 'arguments' is not a valid function name in strict mode.`);
-
-testSyntaxError(`
-async function eval() {
-    "use strict";
-}
-`, `SyntaxError: 'eval' is not a valid function name in strict mode.`);
-
-testSyntaxError(`
-async function fn(a) {
-    let a = 1;
-}
-`, `SyntaxError: Cannot declare a let variable twice: 'a'.`);
-
-testSyntaxError(`
-async function fn(b) {
-    const b = 1;
-}
-`, `SyntaxError: Cannot declare a const variable twice: 'b'.`);
-
-(function testMethodDefinition() {
-    testSyntax("({ async [foo]() {} })");
-    testSyntax("({ async [Symbol.asyncIterator]() {} })");
-    testSyntax("({ async 0() {} })");
-    testSyntax("({ async 'string'() {} })");
-    testSyntax("({ async ident() {} })");
-
-    testSyntax("(class { async [foo]() {} })");
-    testSyntax("(class { async [Symbol.asyncIterator]() {} })");
-    testSyntax("(class { async 0() {} })");
-    testSyntax("(class { async 'string'() {} })");
-    testSyntax("(class { async ident() {} })");
-
-    testSyntax("(class { static async [foo]() {} })");
-    testSyntax("(class { static async [Symbol.asyncIterator]() {} })");
-    testSyntax("(class { static async 0() {} })");
-    testSyntax("(class { static async 'string'() {} })");
-    testSyntax("(class { static async ident() {} })");
-})();
-
-(function testLineTerminator() {
-    let testLineFeedErrors = (prefix, suffix) => {
-        testSyntaxError(`${prefix}// comment
-                         ${suffix}`);
-        testSyntaxError(`${prefix}/* comment
-                         */ ${suffix}`);
-        testSyntaxError(`${prefix}
-                         ${suffix}`);
-        testSyntaxError(`"use strict";${prefix}// comment
-                         ${suffix}`);
-        testSyntaxError(`"use strict";${prefix}/* comment
-                         */ ${suffix}`);
-        testSyntaxError(`"use strict";${prefix}
-                         ${suffix}`);
-    };
-
-    let testLineFeeds = (prefix, suffix) => {
-        testSyntax(`${prefix}// comment
-                    ${suffix}`);
-        testSyntax(`${prefix}/* comment
-                    */${suffix}`);
-        testSyntax(`${prefix}
-                    ${suffix}`);
-        testSyntax(`"use strict";${prefix}// comment
-                    ${suffix}`);
-        testSyntax(`"use strict";${prefix}/* comment
-                    */${suffix}`);
-        testSyntax(`"use strict";${prefix}
-                    ${suffix}`);
-    };
-
-    let tests = [
-        // ObjectLiteral AsyncMethodDefinition
-        { prefix: "({ async", suffix: "method() {} }).method" },
-
-        // ClassLiteral AsyncMethodDefinition
-        { prefix: "(class { async", suffix: "method() {} }).prototype.method" },
-
-        // AsyncArrowFunctions
-        { prefix: "(async", suffix: "param => 1)" },
-        { prefix: "(async", suffix: "(param) => 1)" },
-        { prefix: "(async", suffix: "param => {})" },
-        { prefix: "(async", suffix: "(param) => {})" },
-    ];
-
-    for (let { prefix, suffix } of tests) {
-        testSyntax(`${prefix} ${suffix}`);
-        testSyntax(`"use strict";${prefix} ${suffix}`);
-        shouldBe("function", typeof eval(`${prefix} ${suffix}`));
-        shouldBe("function", typeof eval(`"use strict";${prefix} ${suffix}`));
-        testLineFeedErrors(prefix, suffix);
-    }
-
-    // AsyncFunctionDeclaration
-    testSyntax("async function foo() {}");
-    testLineFeeds("async", "function foo() {}");
-
-    // AsyncFunctionExpression
-    testSyntax("var x = async function foo() {}");
-    testSyntax("'use strict';var x = async function foo() {}");
-    testLineFeeds("var x = async", "function foo() {}");
-    testLineFeedErrors("var x = async", "function() {}");
-})();

implementation-contributed/javascriptcore/stress/async-await-throw-loop.js

@@ -1,32 +0,0 @@
-// Copyright (C) Copyright 2016 the v8 project authors. All rights reserved.
-
-//@ runNoCJIT("--gcMaxHeapSize=2000000")
-
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-
-let out;
-
-async function thrower() { throw undefined; }
-
-async function throwLoop() {
-    for (let i = 0; i < 8000; i++) {
-        try {
-            await thrower();
-        } catch (error) {
-            void 0;
-        }
-    }
-    out = 2;
-}
-
-throwLoop();
-
-drainMicrotasks();
-
-shouldBe(out, 2);

implementation-contributed/javascriptcore/stress/async-function-create-nobaseline.js

@@ -1,13 +0,0 @@
-function test(cond)
-{
-    if (cond) {
-        var func = async function () {};
-        return func;
-    }
-
-    return 42;
-}
-noInline(test);
-
-for (var i = 0; i < 1e4; ++i)
-    test();

implementation-contributed/javascriptcore/stress/async-function-create-optimized.js

@@ -1,44 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + actual);
-}
-
-var AsyncFunctionPrototype = async function() {}.__proto__;
-
-function testAsyncFunctionExpression()
-{
-    return async function()
-    {
-        await 42;
-        return 1;
-    };
-}
-noInline(testAsyncFunctionExpression);
-
-function testAsyncFunctionDeclaration()
-{
-    async function asyncFn()
-    {
-        await 42;
-        return 1;
-    }
-
-    return asyncFn;
-}
-noInline(testAsyncFunctionDeclaration);
-
-function testAsyncArrowFunction()
-{
-    return async() =>
-    {
-        await 42;
-        return 1;
-    };
-}
-noInline(testAsyncArrowFunction);
-
-for (var i = 0; i < 1e4; ++i) {
-    shouldBe(testAsyncFunctionExpression().__proto__, AsyncFunctionPrototype);
-    shouldBe(testAsyncFunctionDeclaration().__proto__, AsyncFunctionPrototype);
-    shouldBe(testAsyncArrowFunction().__proto__, AsyncFunctionPrototype);
-}

implementation-contributed/javascriptcore/stress/async-function-declaration-sinking-no-double-allocate.js

@@ -1,38 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function call(o) { o.x = 3; }
-noInline(call);
-
-function sink (p, q) {
-    async function f() { };
-    if (p) {
-        call(f); // Force allocation of f
-        if (q) {
-            OSRExit();
-        }
-        return f;
-    }
-    return { 'x': 2 };
-}
-noInline(sink);
-
-for (var i = 0; i < 100000; ++i) {
-    var o = sink(true, false);
-    shouldBe(o.__proto__, AsyncFunctionPrototype);
-    if (o.x != 3)
-        throw "Error: expected o.x to be 2 but is " + result;
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Check that the function is properly allocated on OSR exit
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-if (f.x != 3)
-    throw "Error: expected o.x to be 3 but is " + result;

implementation-contributed/javascriptcore/stress/async-function-declaration-sinking-osrexit.js

@@ -1,42 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function shouldBeAsync(expected, promise, msg) {
-    let actual;
-    var hadError = false;
-    promise.then(function(value) { actual = value; },
-                 function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (hadError)
-        throw actual;
-
-    shouldBe(expected, actual, msg);
-}
-
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function sink (p, q) {
-    async function g(x) { return x; };
-    if (p) { if (q) OSRExit(); return g; }
-    async function f(x) { return x; };
-    return f;
-}
-noInline(sink);
-
-for (var i = 0; i < 10000; ++i) {
-    var f = sink(true, false);
-    shouldBe(f.__proto__, AsyncFunctionPrototype);
-    shouldBeAsync(42, f(42));
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Check that the function is properly allocated on OSR exit
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-shouldBeAsync(42, f(42));

implementation-contributed/javascriptcore/stress/async-function-declaration-sinking-put.js

@@ -1,49 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function shouldBeAsync(expected, promise, msg) {
-    let actual;
-    var hadError = false;
-    promise.then(function(value) { actual = value; },
-                 function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (hadError)
-        throw actual;
-
-    shouldBe(expected, actual, msg);
-}
-
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function sink (p, q) {
-    async function g(x) { return x; };
-    if (p) { if (q) g.inner = 42; return g; }
-    async function f(x) { return x; };
-    return f;
-}
-noInline(sink);
-
-for (var i = 0; i < 10000; ++i) {
-    var f = sink(true, true);
-    shouldBe(f.__proto__, AsyncFunctionPrototype);
-    shouldBeAsync(42, f(42));
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Test the allocation on the implicit inner else branch
-var f = sink(true, false);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-shouldBeAsync(12, f(12));
-
-// Check that the allocation did not sink beyond the property assignment
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-var result = f.inner;
-if (result !== 42)
-    throw "Error: inner should be 42 but is " + result;

implementation-contributed/javascriptcore/stress/async-function-expression-sinking-no-double-allocate.js

@@ -1,36 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + actual);
-}
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function call(o) { o.x = 3; }
-noInline(call);
-
-function sink (p, q) {
-    var f = async function() { };
-    if (p) {
-        call(f); // Force allocation of f
-        if (q) {
-            OSRExit();
-        }
-        return f;
-    }
-    return { 'x': 2 };
-}
-noInline(sink);
-
-for (var i = 0; i < 100000; ++i) {
-    var o = sink(true, false);
-    shouldBe(o.__proto__, AsyncFunctionPrototype);
-    if (o.x != 3)
-        throw "Error: expected o.x to be 2 but is " + result;
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Check that the function is properly allocated on OSR exit
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-if (f.x != 3)
-    throw "Error: expected o.x to be 3 but is " + result;

implementation-contributed/javascriptcore/stress/async-function-expression-sinking-osrexit.js

@@ -1,40 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-function shouldBeAsync(expected, promise, msg) {
-    let actual;
-    var hadError = false;
-    promise.then(function(value) { actual = value; },
-                 function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (hadError)
-        throw actual;
-
-    shouldBe(expected, actual, msg);
-}
-
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function sink (p, q) {
-    var g = async function (x) { return x; };
-    if (p) { if (q) OSRExit(); return g; }
-    return async function (x) { return x; };
-}
-noInline(sink);
-
-for (var i = 0; i < 10000; ++i) {
-    var f = sink(true, false);
-    shouldBe(f.__proto__, AsyncFunctionPrototype);
-    shouldBeAsync(42, f(42));
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Check that the function is properly allocated on OSR exit
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-shouldBeAsync(42, f(42));

implementation-contributed/javascriptcore/stress/async-function-expression-sinking-put.js

@@ -1,46 +0,0 @@
-function shouldBe(expected, actual, msg = "") {
-    if (msg)
-        msg = " for " + msg;
-    if (actual !== expected)
-        throw new Error("bad value" + msg + ": " + actual + ". Expected " + expected);
-}
-
-function shouldBeAsync(expected, promise, msg) {
-    let actual;
-    var hadError = false;
-    promise.then(function(value) { actual = value; },
-                 function(error) { hadError = true; actual = error; });
-    drainMicrotasks();
-
-    if (hadError)
-        throw actual;
-
-    shouldBe(expected, actual, msg);
-}
-
-var AsyncFunctionPrototype = async function(){}.__proto__;
-
-function sink (p, q) {
-    var g = async function(x) { return x; };
-    if (p) { if (q) g.inner = 42; return g; }
-    return async function(x) { return x; };
-}
-noInline(sink);
-
-for (var i = 0; i < 10000; ++i) {
-    var f = sink(true, true);
-    shouldBe(f.__proto__, AsyncFunctionPrototype);
-    shouldBeAsync(42, f(42));
-}
-
-// At this point, the function should be compiled down to the FTL
-
-// Test the allocation on the implicit inner else branch
-var f = sink(true, false);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-shouldBeAsync(12, f(12));
-
-// Check that the allocation did not sink beyond the property assignment
-var f = sink(true, true);
-shouldBe(f.__proto__, AsyncFunctionPrototype);
-shouldBe(42, f.inner);

implementation-contributed/javascriptcore/stress/async-generator-assertion.js

@@ -1,36 +0,0 @@
-function assert(b) {
-    if (!b)
-        throw new Error("Bad");
-}
-
-async function* asyncIterator() {
-    yield 42;
-}
-
-function test1() {
-    let p = asyncIterator();
-    p.next().then((x) => {
-        assert(x.value === 42);
-        assert(x.done === false);
-    });
-    p.__proto__ = {};
-    assert(p.next === undefined);
-}
-test1();
-
-let error = null;
-async function test2() {
-    let p2 = asyncIterator();
-    p2.__proto__ = {};
-    try {
-        for await (let x of p2) {
-            throw new Error("Bad!");
-        }
-    } 
-    catch(e) {
-        error = e;
-    }
-}
-test2();
-assert(error instanceof TypeError);
-assert(error.message === "undefined is not a function (near '...x of p2...')");

implementation-contributed/javascriptcore/stress/async-iteration-async-from-sync.js

@@ -1,468 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-const Logger = function () {
-    var log = [];
-
-    this.logEvent = (type, value, done) => {
-        log.push({ type, value, done});
-    };
-    this.logFulfilledEvent = (value, done) => {
-        this.logEvent('fulfilled', value, done);
-    };
-    this.logRejectEvent = error => {
-        this.logEvent('reject', error.toString(), true);
-    };
-    this.logCatchEvent = value => {
-        this.logEvent('catch', value, true);
-    };
-    this.getLogger = () => log;
-
-    this.clear = () => {
-        log = [];
-    }
-};
-
-const fulfillSpy = logger => result => logger.logFulfilledEvent(result.value, result.done);
-const rejectSpy = logger => error => logger.logRejectEvent(error);
-const catchSpy = logger => error => logger.logCatchEvent(error);
-
-const assertLogger = function (loggerObject) {
-    const logger = loggerObject.getLogger();
-
-    var _assertLogger = function () {
-        let index = 0;
-
-        const isNotOutOfLength = () => {
-            assert(index < logger.length, true, `Index is greater then log length`);   
-        }
-
-        this.fullfilled = function (expectedValue, message = 'on fulfill') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.fullfilledDone = function (expectedValue, message = 'on fulfill with done true') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.rejected = function (error, message = 'on reject') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'reject', msg);
-            assert(step.value, error.toString(), msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.catched = function (expectedError, message = 'on catch') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'catch', msg);
-            assert(step.value, expectedError, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.isFinal = function (message = '') {
-            assert(index, logger.length, `expected final step: ${message}`);
-        }; 
-    }; 
-    
-    return new _assertLogger();
-};
-
-const getPromise = promiseHolder => {
-    return new Promise((resolve, reject) => {
-        promiseHolder.resolve = resolve;
-        promiseHolder.reject = reject;
-    });
-};
-
-var logger = new Logger();
-const someValue = 'some-value';
-const errorMessage = 'error-message';
-
-function * foo(value) {
-  let re = yield '1:' + value;
-  re = yield '2:' + re;
-  re = yield '3:' + re;
-  return 'end foo:' + re;
-}
-
-async function * boo(value) {
-  let reply = yield '0:' + value;
-  reply = yield* foo(reply);
-  yield '4:' + reply;
-}
-
-var b = boo('init');
-const errorprint = error => print(error);
-b.next('0').then(fulfillSpy(logger), errorprint);
-b.next('1').then(fulfillSpy(logger), errorprint);
-b.next('2').then(fulfillSpy(logger), errorprint);
-b.next('3').then(fulfillSpy(logger), errorprint);
-b.next('4').then(fulfillSpy(logger), errorprint);
-b.next('5').then(fulfillSpy(logger), errorprint);
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .fullfilled('1:1')
-    .fullfilled('2:2')
-    .fullfilled('3:3')
-    .fullfilled('4:end foo:4')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var b2 = boo(':value');
-
-b2.next(':0').then(fulfillSpy(logger));
-b2.next(':1').then(fulfillSpy(logger), rejectSpy(logger));
-b2.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-b2.next(':2').then(fulfillSpy(logger));
-b2.next(':3').then(fulfillSpy(logger));
-b2.next(':4').then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0::value')
-    .fullfilled('1::1')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var b2 = boo('#value');
-
-b2.next('#0').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#1').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#2').then(fulfillSpy(logger), rejectSpy(logger));
-b2.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#3').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#4').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:#value')
-    .fullfilled('1:#1')
-    .fullfilled('2:#2')
-    .rejected(new Error(errorMessage)) // TODO: Check if this correct
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-function * bar() {
-  yield '1';
-  yield '2';
-  throw new Error(errorMessage);
-  yield '3';
-  return 'end foo';
-}
-
-async function * baz() {
-  yield '0';
-  yield* bar();
-  yield '4';
-}
-
-logger.clear();
-var bz1 = baz();
-
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-let promiseHolder = {};
-
-function *joo() {
-    yield '1';
-    yield getPromise(promiseHolder);
-}
-
-async function *goo () {
-    yield '0';
-    yield* joo();
-    yield '3';
-}
-
-let g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('2')
-    .fullfilled('3')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();

implementation-contributed/javascriptcore/stress/async-iteration-basic.js

@@ -1,955 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-const Logger = function () {
-    var log = [];
-
-    this.logEvent = (type, value, done) => {
-        log.push({ type, value, done});
-    };
-    this.logFulfilledEvent = (value, done) => {
-        this.logEvent('fulfilled', value, done);
-    };
-    this.logRejectEvent = error => {
-        this.logEvent('reject', error.toString(), true);
-    };
-    this.logCatchEvent = value => {
-        this.logEvent('catch', value, true);
-    };
-    this.getLogger = () => log;
-
-    this.clear = () => {
-        log = [];
-    }
-};
-
-const fulfillSpy = logger => result => logger.logFulfilledEvent(result.value, result.done);
-const rejectSpy = logger => error => logger.logRejectEvent(error);
-const catchSpy = logger => error => logger.logCatchEvent(error);
-
-const assertLogger = function (loggerObject) {
-    const logger = loggerObject.getLogger();
-
-    var _assertLogger = function () {
-        let index = 0;
-
-        const isNotOutOfLength = () => {
-            assert(index < logger.length, true, `Index is greater then log length`);   
-        }
-
-        this.fullfilled = function (expectedValue, message = 'on fulfill') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.fullfilledDone = function (expectedValue, message = 'on fulfill with done true') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.rejected = function (error, message = 'on reject') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'reject', msg);
-            assert(step.value, error.toString(), msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.catched = function (expectedError, message = 'on catch') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'catch', msg);
-            assert(step.value, expectedError, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.isFinal = function (message = '') {
-            assert(index, logger.length, `expected final step: ${message}`);
-        }; 
-    }; 
-    
-    return new _assertLogger();
-};
-
-const getPromise = promiseHolder => {
-    return new Promise((resolve, reject) => {
-        promiseHolder.resolve = resolve;
-        promiseHolder.reject = reject;
-    });
-};
-
-async function*generator () {
-    yield 42;
-}
-
-var passed = false;
-var iterator = generator();
-
-iterator.next().then(function(step) {
-    if(iterator[Symbol.asyncIterator]() === iterator && step.done === false && step.value === 42) passed = true;
-});
-
-drainMicrotasks();
-
-assert(passed, true, '');
-
-assert(generator[Symbol.toStringTag], 'AsyncGeneratorFunction');
-assert(Object.prototype.toString.call(generator), '[object AsyncGeneratorFunction]');
-
-
-var holder = {};
-
-var promise = getPromise(holder);
-var logger = new Logger();
-
-async function * baz(value) {
-    var t = await promise;
-    let reply = yield t + ' data-0' + value;
-    let last = yield t + ' data-1' + reply;
-    return 'data-result' + last;
-}
-
-var bz1 = baz(':init');
-
-bz1.next(':0').then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next(':1').then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next(':2').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .isFinal();
-
-holder.resolve('abcd');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-0:init')
-    .fullfilled('abcd data-1:1')
-    .fullfilledDone('data-result:2')
-    .isFinal();
-
-logger.clear();
-
-promise = getPromise(holder);
-
-var bz2 = baz(':init');
-
-bz2.next(':0').then(fulfillSpy(logger), rejectSpy(logger));
-bz2.next(':1').then(fulfillSpy(logger), rejectSpy(logger));
-bz2.next(':2').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .isFinal();
-
-holder.reject('abcd');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected('abcd')
-    .fullfilledDone()
-    .fullfilledDone()
-    .isFinal();
-
-var holder1 = {}; holder2 = {};
-var promise1 = getPromise(holder1);
-var promise2 = getPromise(holder2);
-
-logger.clear();
-
-async function *boo() {
-    var t1 = await promise1;
-    yield t1 + ' data-1';
-    yield t1 + ' data-2';
-    var t2 = await promise2;
-    yield t2 + ' data-3';
-    yield t2 + ' data-4';
-    return 'data-5';
-};
-
-var b = boo();
-
-b.next().then(fulfillSpy(logger));
-b.next().then(fulfillSpy(logger));
-b.next().then(fulfillSpy(logger));
-b.next().then(fulfillSpy(logger));
-b.next().then(fulfillSpy(logger));
-b.next().then(fulfillSpy(logger));
-
-assertLogger(logger)
-    .isFinal('async generator should not resolve any promise until await is no resolved');
-
-holder1.resolve('abcd');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-1')
-    .fullfilled('abcd data-2')
-    .isFinal();
-
-holder2.resolve('efgh');
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-1')
-    .fullfilled('abcd data-2')
-    .fullfilled('efgh data-3')
-    .fullfilled('efgh data-4')
-    .fullfilledDone('data-5')
-    .fullfilledDone(undefined, error => print(error))
-    .isFinal();
-
-holder = {};
-
-promise = getPromise(holder);
-
-async function *foo() {
-    var t = await 'abcd';
-    yield t + ' data-5';
-    var t2 = await promise;
-    yield t2 + ' data-6';
-};
-
-logger.clear();
-
-var f = foo();
-
-f.next().then(fulfillSpy(logger));
-f.next().then(fulfillSpy(logger));
-f.next().then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-5')
-    .isFinal('async generator should not resolve any promise until await is not resolved');
-
-holder.resolve('xyz');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-5')
-    .fullfilled('xyz data-6')
-    .fullfilledDone(undefined)
-    .isFinal('async generator should not resolve any promise until await is not resolved');
-
-holder = {};
-promise = getPromise(holder);
-
-async function *goo() {
-    yield 'data-5';
-    var t = await promise;
-    yield t + ' data-6';
-    yield t + ' data-7';
-};
-
-logger.clear();
-var errorText = 'error-reject';
-var g = goo();
-
-drainMicrotasks();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('data-5')
-    .isFinal('async generator should not resolve any promise until await is not resolved');
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-assertLogger(logger)
-    .fullfilled('data-5')
-    .isFinal('async generator should not resolve any promise until await is not resolved');
-
-holder.reject(errorText);
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('data-5')
-    .rejected(errorText)
-    .fullfilledDone(undefined, 'After reject all resolved value have undefined')
-    .isFinal();
-
-/* Method in class */
-
-const someText = 'foo';
-const resolveText = 'bar';
-
-logger.clear();
-
-holder = {};
-promise = getPromise(holder);
-
-class A { 
-    async * foo() { yield someText; } 
-    async * boo() { var text = await promise; yield text + someText; }
-}
-var a = new A;
-var gf = a.foo();
-
-gf.next().then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(someText)
-    .isFinal();
-
-const gb = a.boo();
-
-gb.next().then(fulfillSpy(logger));
-
-assertLogger(logger)
-    .fullfilled(someText)
-    .isFinal();
-
-holder.resolve(resolveText);
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(someText)
-    .fullfilled(resolveText + someText)
-    .isFinal();
-
-/* Async generator function expression */
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-var asyncGenExp = async function *() { var t = await promise; yield t + someText + someText; };
-
-var gAsyncGenExp = asyncGenExp();
-
-gAsyncGenExp.next().then(fulfillSpy(logger));
-
-holder.resolve(resolveText);
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(resolveText + someText + someText)
-    .isFinal();
-
-logger.clear();
-
-/*Test throw*/
-async function *joo() {
-    yield 'data-1';
-    yield 'data-2';
-    yield 'data-3';
-};
-
-var j = joo();
-var errorTextInFunction = "ErrorInFunction";
-const errorWrongGenerator = "|this| should be an async generator";
-let errorRaised = false;
-
-j.next()
-.then(function(value) {
-    fulfillSpy(logger)(value);
-    return j.throw(new Error(errorTextInFunction));
-})
-.then(function (value) {
-    fulfillSpy(logger)(value);
-}, function (error) {
-    rejectSpy(logger)(error);
-    return j.next();
-})
-.then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('data-1')
-    .rejected((new Error(errorTextInFunction)).toString())
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var j1 = joo();
-
-j1.throw(new Error(errorText)).then(fulfillSpy(logger), rejectSpy(logger));
-j1.next().then(fulfillSpy(logger), rejectSpy(logger));
-j1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var j2 = joo();
-
-const returnValue = 'return-value';
-
-j1.return(returnValue).then(fulfillSpy(logger), rejectSpy(logger));
-j1.throw(new Error(errorText)).then(fulfillSpy(logger), rejectSpy(logger));
-j1.next().then(fulfillSpy(logger), rejectSpy(logger));
-j1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilledDone(returnValue)
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-let j3 = joo();
-
-j3.next.call(undefined).then(fulfillSpy(logger), rejectSpy(logger));
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-    .isFinal();
-
-logger.clear();
-j3 = joo();
-
-j3.next.call(undefined).then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-    .fullfilled('data-1')
-    .fullfilled('data-2')
-    .fullfilled('data-3')
-    .isFinal();
-
-logger.clear();
-j3 = joo();
-
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next.call(undefined).then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-    .fullfilled('data-1')
-    .fullfilled('data-2')
-    .fullfilled('data-3')
-    .isFinal();
-
-logger.clear();
-j3 = joo();
-
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-j3.next.call(undefined).then(fulfillSpy(logger), rejectSpy(logger));
-j3.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-    .fullfilled('data-1')
-    .fullfilled('data-2')
-    .fullfilled('data-3')
-    .isFinal();
-
-logger.clear();
-j3 = joo();
-
-j3.next.call({}).catch(rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-
-logger.clear();
-j3 = joo();
-j3.next.call('string').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new TypeError(errorWrongGenerator))
-    .isFinal();
-
-logger.clear();
-j3 = joo();
-let gen = generator();
-j3.next.call(gen).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(42)
-    .isFinal();
-
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-async function *koo() {
-    var t = await 'abcd';
-    yield t + ' data-first';
-    var t2 = await promise;
-    yield t2 + ' data-second';
-    yield t2 + ' data-third';
-};
-
-const k1 = koo();
-
-k1.next().then(fulfillSpy(logger));
-k1.next().then(fulfillSpy(logger));
-
-k1.throw(new Error(errorText)).then(fulfillSpy(logger), rejectSpy(logger));
-k1.next().then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-first')
-    .isFinal();
-
-holder.resolve('xyz');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-first')
-    .fullfilled('xyz data-second')
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .isFinal();
-
-
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-const k2 = koo();
-
-k2.next().then(fulfillSpy(logger));
-k2.next().then(fulfillSpy(logger));
-
-k2.return(returnValue).then(fulfillSpy(logger));
-
-holder.resolve('xyz');
-
-k2.throw(new Error(errorText)).then(fulfillSpy(logger), rejectSpy(logger));
-k2.next().then(fulfillSpy(logger));
-k2.next().then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abcd data-first')
-    .fullfilled('xyz data-second')
-    .fullfilledDone(returnValue)
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-async function *loo() {
-    var t = await promise;
-    throw new Error(errorText);
-    yield t + 'data-first';
-    yield t + 'data-second';
-};
-
-const l1 = loo();
-
-l1.next().then(fulfillSpy(logger), rejectSpy(logger));
-l1.next().then(fulfillSpy(logger), rejectSpy(logger));
-l1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .isFinal();
-
-holder.resolve('qwe');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-const l2 = loo();
-
-l2.throw(new Error('another error')).then(fulfillSpy(logger), rejectSpy(logger));
-l2.next().then(fulfillSpy(logger), rejectSpy(logger));
-l2.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-holder.resolve('abc');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new Error('another error'))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-holder = {};
-promise = getPromise(holder);
-
-const l3 = loo();
-
-l3.return(someText).then(fulfillSpy(logger), rejectSpy(logger));
-l3.next().then(fulfillSpy(logger), rejectSpy(logger));
-l3.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-holder.resolve(resolveText);
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilledDone(someText)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-async function *moo() {
-    throw new Error(errorText);
-    yield t + 'data-first';
-    yield t + 'data-second';
-};
-
-const m1 = moo();
-
-m1.next().then(fulfillSpy(logger), rejectSpy(logger));
-m1.next().then(fulfillSpy(logger), rejectSpy(logger));
-m1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new Error(errorText))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-const m2 = moo();
-
-m2.throw(new Error('another error')).then(fulfillSpy(logger), rejectSpy(logger));
-m2.next().then(fulfillSpy(logger), rejectSpy(logger));
-m2.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(new Error('another error'))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-const m3 = moo();
-
-m3.return(someText).then(fulfillSpy(logger), rejectSpy(logger));
-m3.next().then(fulfillSpy(logger), rejectSpy(logger));
-m3.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilledDone(someText)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-async function* noo() {
-  const x = Promise.resolve(1);
-  const y = Promise.resolve(2);
-  
-  const fromX = yield x;
-  return y;
-}
-
-const n1 = noo();
-
-let value1 = Promise.resolve("a");
-let value2 = Promise.resolve("b");
-
-n1.next(value1).then(fulfillSpy(logger), rejectSpy(logger));
-n1.next(value2).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone(2)
-    .isFinal();
-
-logger.clear();
-
-const n2 = noo();
-
-value1 = Promise.resolve("a");
-value2 = Promise.resolve("b");
-
-n2.return(value1).then(fulfillSpy(logger), rejectSpy(logger));
-n2.next(value2).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilledDone('a')
-    .fullfilledDone()
-    .isFinal();
-
-logger.clear();
-
-promise = getPromise(holder);
-
-async function *ooo() {
-    yield promise; 
-}
-
-const o1 = ooo();
-
-o1.next(value1).then(fulfillSpy(logger), rejectSpy(logger));
-
-holder.reject("a");
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected('a')
-    .isFinal();
-
-logger.clear();
-
-promise = getPromise(holder);
-
-async function *roo() {
-    try {
-        yield promise; 
-    } catch (e) {
-        yield e;
-    }
-}
-
-const r1 = roo();
-value1 = 'value-1';
-value2 = 'value-2';
-value3 = 'value-3';
-
-r1.next().then(fulfillSpy(logger), rejectSpy(logger));
-r1.next(value1).then(fulfillSpy(logger), rejectSpy(logger));
-r1.next(value1).then(fulfillSpy(logger), rejectSpy(logger));
-
-holder.reject("abc");
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('abc')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-holder1 = {};
-holder2 = {};
-promise1 = getPromise(holder1);
-promise2 = getPromise(holder2);
-
-async function *poo() {
-    try {
-        yield promise1; 
-    } catch (e) {
-        yield promise2;
-    }
-}
-
-const p1 = poo();
-
-p1.next().then(fulfillSpy(logger), rejectSpy(logger));
-p1.next(value3).then(fulfillSpy(logger), rejectSpy(logger));
-p1.next(value3).then(fulfillSpy(logger), rejectSpy(logger));
-
-holder1.reject(value1);
-holder2.reject(value2);
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .rejected(value2)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-async function *soo() {
-    yield 1;
-}
-
-const endValue = 'end-value-1';
-
-logger.clear();
-
-const s1 = soo();
-
-s1.next().then(fulfillSpy(logger), rejectSpy(logger));
-s1.next().then(fulfillSpy(logger), rejectSpy(logger));
-s1.return(Promise.resolve(endValue)).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone()
-    .fullfilledDone(endValue)
-    .isFinal();
-
-logger.clear();
-
-const s2 = soo();
-
-s2.next().then(fulfillSpy(logger), rejectSpy(logger));
-s2.next().then(fulfillSpy(logger), rejectSpy(logger));
-s2.return(Promise.reject(endValue)).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone()
-    .rejected(endValue)
-    .isFinal();
-
-logger.clear();
-const s3 = soo();
-
-s3.next().then(fulfillSpy(logger), rejectSpy(logger));
-s3.next().then(fulfillSpy(logger), rejectSpy(logger));
-s3.return(endValue).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone()
-    .fullfilledDone(endValue)
-    .isFinal();
-
-logger.clear();
-
-const s4 = soo();
-promise1 = Promise.resolve(endValue);
-
-s4.next().then(fulfillSpy(logger), rejectSpy(logger));
-s4.next().then(fulfillSpy(logger), rejectSpy(logger));
-s4.throw(promise1).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone()
-    .rejected(promise1)
-    .isFinal();
-
-logger.clear();
-
-const s5 = soo();
-
-s5.next().then(fulfillSpy(logger), rejectSpy(logger));
-s5.next().then(fulfillSpy(logger), rejectSpy(logger));
-s5.throw(endValue).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilledDone()
-    .rejected(endValue)
-    .isFinal();
-
-async function *too() {
-    return Promise.resolve('abcd');
-}
-
-logger.clear();
-
-const t = too();
-
-t.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilledDone('abcd')
-    .isFinal();

implementation-contributed/javascriptcore/stress/async-iteration-evaluation.js

@@ -1,20 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-let error = false; 
-
-async function * foo(value = obj) {
-    yield '1';
-    return 'end';
-}
-
-try {
-    var f = foo();
-} catch(e) {
-    error = e instanceof ReferenceError;
-}
-
-assert(error, true, 'Error in arguments declaration should to error during evaluation of async generator.');

implementation-contributed/javascriptcore/stress/async-iteration-for-await-of-syntax.js

@@ -1,118 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-function checkSyntax(src) {
-    try {
-        eval(src);
-    } catch (error) {
-        if (error instanceof SyntaxError)
-            throw new Error("Syntax Error: " + String(error) + "\n script: `" + src + "`");
-    }
-}
-
-function checkSyntaxError(src, message) {
-    var bError = false;
-    try {
-        eval(src);
-    } catch (error) {
-        bError = error instanceof SyntaxError && (String(error) === message || typeof message === 'undefined'); 
-    }
-    if (!bError) {
-        throw new Error("Expected syntax Error: " + message + "\n in script: `" + src + "`");
-    }
-}
-
-(function checkSimpleAsyncGeneratorSloppyMode() {
-    checkSyntax('var a1 = async function*asyncGenWithName1(){ for await(const value of foo()) {} }');
-    checkSyntax('var a1 = async function asyncWithName1(){ for await(const value of foo()) {} }');
-    checkSyntax('var a1 = async function*asyncGenWithName1(){ for await(let value of foo()) {} }');
-    checkSyntax('var a1 = async function asyncWithName1(){ for await(let value of foo()) {} }');
-})();
-
-(function checkSimpleAsyncGeneratorStrictMode() {
-    checkSyntax('"use strict"; var a1 = async function*asyncGenWithName1(){ for await(const value of foo()) {}  }');
-    checkSyntax('"use strict"; var a1 = async function asyncWithName1(){ for await(const value of foo()) {} }');
-    checkSyntax('"use strict"; var a1 = async function*asyncGenWithName1(){ for await(let value of foo()) {} }');
-    checkSyntax('"use strict"; var a1 = async function asyncWithName1(){ for await(let value of foo()) {} }');
-})();
-
-
-(function checkNestedAsyncGenerators() { 
-    var wrappers = [
-        {start: 'var a1 = async function*asyncGenWithName1(){', finish: '}'},
-        {start: 'async function*asyncGenWithName2(){ ', finish: '}'},
-        {start: 'async function asyncWithName2(){ ', finish: '}'},
-        {start: 'class A { async * method() { ', finish: ' } }'},
-        {start: 'var a1 = async () => {', finish: '}'},
-        {start: 'var a1 = async () => { try {   ', finish: ' } catch (e) {} }'},
-        {start: 'var a1 = async () => { {   ', finish: ' } }'},
-        {start: 'var a1 = async () => { if (true) {   ', finish: ' } }'},
-        {start: 'var a1 = async () => { if (true) ', finish: ' }'},
-        {start: 'var a1 = async () => { if (true) foo(); else { ', finish: ' } }'},
-        {start: 'var a1 = async () => { while (true) { ', finish: ' } }'},
-        {start: 'var a1 = async () => { for(;;) { ', finish: ' } }'},
-        {start: 'var a1 = async () => { switch(e) { case \'1\' :  ', finish: ' } }'},
-    ];
-
-    expressions = [
-        'for await(const value of foo()) {}',
-        'for await(let value of foo()) {}',
-        'for await(var value of foo()) {}',
-        'for await(var [a, b] of foo()) {}',
-        'for await(let {a, b} of foo()) {}',
-        'for await(const [... b] of foo()) {}',
-        'for await(const [,,, b] of foo()) {}',
-        'for await(const value of boo) {}',
-        'for await(let value of boo) {}',
-        'for await(const value of foo().boo()) {}',
-        'for await(let value of foo.boo()) {}',
-        'for await(let value of foo.boo(value)) {}',
-        'for await(let value of [1,2,3]) {}',
-        'for await(value of [1,2,3]) {}',
-        'for await(value of x + x) {}',
-        'for await(value of f()) {}',
-        'for await(value of (x + x)) {}',
-    ];
-
-    wrappers.forEach(wrapper => {
-        expressions.forEach(exp => {
-            checkSyntax(wrapper.start + exp + wrapper.finish);
-        });
-    })
-})();
-
-
-(function checkSimpleAsyncGeneratorSyntaxErrorInSloppyMode() {
-    checkSyntaxError("var asyncGenFn = function () { for await(const value of foo()) {} }");
-    checkSyntaxError("var asyncGenFn = async function () { var arr = () => { for await(const value of foo()) {} } }");
-    checkSyntaxError("var asyncGenFn = function* () { for await(const value of foo()) {} }");
-    checkSyntaxError("var asyncGenFn = async function* () { var arr = () => { for await(const value of foo()) {} } }");
-    checkSyntaxError('var a1 = async function*asyncGenWithName1(){ for await(const value in foo()) {} }');
-    checkSyntaxError('var a1 = async function asyncWithName1(){ for await(const value in foo()) {} }');
-    checkSyntaxError('var a1 = async function asyncWithName1(){ for await (;;) {} }');
-    checkSyntaxError("var a1 = async function asyncWithName1(){ for await (let v = 4;;) {} }");
-    checkSyntaxError("var a1 = async function asyncWithName1(){ for await (let v of f();;) {} }");
-    checkSyntaxError("var a1 = async function asyncWithName1(){ for await (let v of boo;;) {} }");
-    checkSyntaxError("var a1 = async function asyncWithName1(){ for await (let v of boo of) {} }");
-    checkSyntaxError("async function asyncWithName1(){ for await (let v of boo in) {} }");
-    checkSyntaxError("async function asyncWithName1(){ for await (v in x + x ) {} }");
-})();
-
-(function checkSimpleAsyncGeneratorSyntaxErrorInStrictMode() {
-    checkSyntaxError("'use strict'; var asyncGenFn = function () { for await(const value of foo()) {} }");
-    checkSyntaxError("'use strict'; var asyncGenFn = async function () { var arr = () => { for await(const value of foo()) {} } }");
-    checkSyntaxError("'use strict'; var asyncGenFn = function* () { for await(const value of foo()) {} }");
-    checkSyntaxError("'use strict'; var asyncGenFn = async function* () { var arr = () => { for await(const value of foo()) {} } }");
-    checkSyntaxError("'use strict'; var a1 = async function*asyncGenWithName1(){ for await(const value in foo()) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await(const value in foo()) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await (;;) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await (let v = 4;;) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await (let v of f();;) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await (let v of boo;;) {} }");
-    checkSyntaxError("'use strict'; var a1 = async function asyncWithName1(){ for await (let v of boo of) {} }");
-    checkSyntaxError("'use strict'; async function asyncWithName1(){ for await (let v of boo in) {} }");
-    checkSyntaxError("'use strict'; async function asyncWithName1(){ for await (v in x + x ) {} }");
-})();

implementation-contributed/javascriptcore/stress/async-iteration-for-await-of.js

@@ -1,280 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-var result = 0;
-async function * foo() { yield 1; yield Promise.resolve(2); return 3;};
-
-async function boo () {
-    for await (const value of foo()) {
-        result = result + value;
-    }
-}
-
-boo();
-
-drainMicrotasks();
-
-assert(result, 3);
-
-result =  0;
-
-{
-    const boo =  async function () {
-        for await (const val of foo()) {
-            result = result + val;
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(result, 3);
-}
-
-{
-    result =  0;
-    const boo = async function () {
-        for await (const val of [1, 2, 3]) {
-            result = result + val;
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(result, 6);
-}
-
-{ 
-    let error = false;
-
-    const boo = async function () {
-        for await (const val of 1) {
-            result = result + val;
-        }
-    }
-
-    boo().catch(raisedError => error = raisedError instanceof TypeError);
-
-    drainMicrotasks();
-
-    assert(error, true);
-}
-
-{
-    let conter = 0;
-    const o = {
-        [Symbol.asyncIterator]() {
-            return this
-        },
-        next(args) {
-            return { done: true }
-        }
-    }
-
-    result = -1;
-    const boo = async function () {
-        for await (const val of o) {
-            conter++;
-            result = val;
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(conter, 0);
-    assert(result, -1);
-}
-
-{
-    let conter = 0;
-    const o = {
-        [Symbol.asyncIterator]() {
-            this.index = 0;
-            return this
-        },
-        next(args) {
-            this.index++;
-            if (this.index <= 10)
-                return { done: false, value: this.index };
-            else 
-                return { done: true, value: this.index };
-        }
-    }
-
-    result = 0;
-    const boo = async function () {
-        for await (const val of o) {
-            conter++;
-            result += val;
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(conter, 10);
-    assert(result, 55);
-}
-
-{
-    let conter = 0;
-    let error = false;
-
-    const o = {
-        [Symbol.asyncIterator]() {
-            this.index = 0;
-            return this
-        },
-        next(args) {
-            this.index++;
-            if (this.index <= 10)
-                return { done: false, value: this.index };
-            else 
-                throw new Error('some error');
-        }
-    }
-
-    result = 0;
-    const boo = async function () {
-        for await (const val of o) {
-            conter++;
-            result += val;
-        }
-    }
-
-    boo().catch(e => { error = e instanceof Error && e.message === 'some error'; });
-
-    drainMicrotasks();
-
-    assert(conter, 10);
-    assert(result, 55);
-    assert(error, true);
-}
-
-{
-    let conter = 0;
-    let error = false;
-    let emptyParam = false;
-
-    const o = {
-        [Symbol.asyncIterator]() {
-            this.index = 0;
-            return this
-        },
-        next(args) {
-            emptyParam = args === undefined;
-            this.index++;
-            if (this.index <= 10)
-                return { done: false, value: this.index };
-            else 
-                throw new Error('some error');
-        }
-    }
-
-    result = 0;
-    const boo = async function () {
-        try {
-            for await (const val of o) {
-                conter++;
-                result += val;
-            }
-        } catch (e) {
-            error =  e instanceof Error && e.message === 'some error';
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(conter, 10);
-    assert(result, 55);
-    assert(error, true);
-    assert(emptyParam, true);
-}
-
-{
-    let conter = 0;
-    let error = false;
-
-    const o = {
-        [Symbol.asyncIterator]() {
-            this.index = 0;
-            return this
-        },
-        next(args) {
-            this.index++;
-            if (this.index <= 10)
-                return { done: false, value: this.index };
-            else 
-                return { done: true, value: this.index };
-        }
-    }
-
-    result = 0;
-    const boo = async function () {
-        if (true) {
-            for await (const val of o) {
-                conter++;
-                result += val;
-            }
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(conter, 10);
-    assert(result, 55);
-}
-
-{
-    let conter = 0;
-    let error = false;
-    let emptyParam = false;
-
-    const o = {
-        [Symbol.iterator]() {
-            this.index = 0;
-            return this
-        },
-        next(args) {
-            emptyParam = args === undefined;
-            this.index++;
-            if (this.index <= 10)
-                return { done: false, value: this.index };
-            else 
-                throw new Error('some error');
-        }
-    }
-
-    result = 0;
-    const boo = async function () {
-        try {
-            for await (const val of o) {
-                conter++;
-                result += val;
-            }
-        } catch (e) {
-            error =  e instanceof Error && e.message === 'some error';
-        }
-    }
-
-    boo();
-
-    drainMicrotasks();
-
-    assert(conter, 10);
-    assert(result, 55);
-    assert(error, true);
-    assert(emptyParam, true);
-}

implementation-contributed/javascriptcore/stress/async-iteration-syntax.js

@@ -1,122 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-function checkSyntax(src) {
-    try {
-        eval(src);
-    } catch (error) {
-        if (error instanceof SyntaxError)
-            throw new Error("Syntax Error: " + String(error) + "\n script: `" + src + "`");
-    }
-}
-
-function checkSyntaxError(src, message) {
-    var bError = false;
-    try {
-        eval(src);
-    } catch (error) {
-        bError = error instanceof SyntaxError && (String(error) === message || typeof message === 'undefined'); 
-    }
-    if (!bError) {
-        throw new Error("Expected syntax Error: " + message + "\n in script: `" + src + "`");
-    }
-}
-
-(function checkSimpleAsyncGeneratorSloppyMode() {
-    checkSyntax('var a1 = async function*asyncGenWithName1(){}');
-    checkSyntax('var a2 = async function *asyncGenWithName2(){ yield 11; }');
-    checkSyntax('var a3 = async function * asyncGenWithName2(){ await p; yield 11; }');
-    checkSyntax('var d1 = async function*(){}');
-    checkSyntax('var d2 = async function* (){ yield 11; }');
-    checkSyntax('var d3 = async function * (){ await p; yield 11; }');
-    checkSyntax('async function* withName1(){  }');
-    checkSyntax('async function *withName2(){ yield 11; }');
-    checkSyntax('async function * withName3(){ await p; yield 11; }');
-    checkSyntax('class A { async * method() { } }');
-    checkSyntax('class B { async * method() {yield 11;} }');
-    checkSyntax('class C { async * method() {yield 11; await p;} }');
-    checkSyntax('class D { async * "method"() {yield 11; await p;} }');
-    checkSyntax('class F { async * 0() {yield 11; await p;} }');
-    checkSyntax('var obj = { async * method() {yield 11; await p;} }');
-    checkSyntax('({ async foo() {} })');
-    checkSyntax('({ async : 1 })');
-})();
-
-(function checkSimpleAsyncGeneratorStrictMode() {
-    checkSyntax('"use strict"; var a1 = async function*asyncGenWithName1(){}');
-    checkSyntax('"use strict"; var a2 = async function *asyncGenWithName2(){ yield 11; }');
-    checkSyntax('"use strict"; var a3 = async function * asyncGenWithName2(){ await p; yield 11; }');
-    checkSyntax('"use strict"; var d1 = async function*(){}');
-    checkSyntax('"use strict"; var d2 = async function* (){ yield 11; }');
-    checkSyntax('"use strict"; var d3 = async function * (){ await p; yield 11; }');
-    checkSyntax('"use strict"; async function* withName1(){  }');
-    checkSyntax('"use strict"; async function *withName2(){ yield 11; }');
-    checkSyntax('"use strict"; async function * withName3(){ await p; yield 11; }');
-    checkSyntax('"use strict"; class A { async * method() { } }');
-    checkSyntax('"use strict"; class B { async * method() {yield 11;} }');
-    checkSyntax('"use strict"; class C { async * method() {yield 11; await p;} }');
-    checkSyntax('"use strict"; class D { async * "method"() {yield 11; await p;} }');
-    checkSyntax('"use strict"; class E { async * ["calc" + "ulate"]() {yield 11; await p;} }');
-    checkSyntax('"use strict"; class F { async * 0() {yield 11; await p;} }');
-    checkSyntax('"use strict"; var obj = { async * method() {yield 11; await p;} }');
-    checkSyntax('"use strict"; ({ async foo() {} })');
-    checkSyntax('"use strict"; ({ async : 1 })');
-})();
-
-
-(function checkNestedAsyncGenerators() { 
-    var wrappers = [
-        {start: 'var a1 = async function*asyncGenWithName1(){', finish: '}'},
-        {start: 'async function*asyncGenWithName2(){ ', finish: '}'},
-        {start: 'class A { async * method() { ', finish: ' } }'}
-    ];
-
-    expressions = [
-        'await 10; yield 11; return 12;',
-        'var async = 10; yield async;',
-        'var async = 10; await async;',
-        'var async = 10; return async;',
-        'var async = function() {}; return async;',
-        'var async = function() {}; return async();',
-    ];
-
-    wrappers.forEach(wrapper => {
-        expressions.forEach(exp => {
-            checkSyntax(wrapper.start + exp + wrapper.finish);
-        });
-    })
-})();
-
-
-(function checkSimpleAsyncGeneratorSyntaxErrorInSloppyMode() {
-    checkSyntaxError("var asyncGenFn = async function *await() {}");
-    checkSyntaxError("var asyncGenFn = async function*(await) {}");
-    checkSyntaxError("var asyncGenFn = async function *withName(await) {}");
-    checkSyntaxError("async function *asyncGeneratorFunctionDeclaration(await) {}");
-    checkSyntaxError("var asyncGenFn = *async function () {}");
-    checkSyntaxError("var asyncGenFn = *async function withName() {}");
-    checkSyntaxError("*async function asyncGeneratorFunctionDeclaration(await) {}");
-    checkSyntaxError("var obj = { *async asyncGeneratorMethod() {} };");
-    checkSyntaxError("var obj = { async asyncGeneratorMethod*() {} };");
-    checkSyntaxError("class A { get async* ttt() {} }");
-    checkSyntaxError("class B { get *async ttt() {} }");
-    checkSyntaxError('({ async = 1 })');
-})();
-
-(function checkSimpleAsyncGeneratorSyntaxErrorInStrictMode() {
-    checkSyntaxError("'use strict'; var asyncGenFn = async function *await() {}");
-    checkSyntaxError("'use strict'; var asyncGenFn = async function*(await) {}");
-    checkSyntaxError("'use strict'; var asyncGenFn = async function *withName(await) {}");
-    checkSyntaxError("'use strict'; async function *asyncGeneratorFunctionDeclaration(await) {}");
-    checkSyntaxError("'use strict'; var asyncGenFn = *async function () {}");
-    checkSyntaxError("'use strict'; var asyncGenFn = *async function withName() {}");
-    checkSyntaxError("'use strict'; *async function asyncGeneratorFunctionDeclaration(await) {}");
-    checkSyntaxError("'use strict'; var obj = { *async asyncGeneratorMethod() {} };");
-    checkSyntaxError("'use strict'; var obj = { async asyncGeneratorMethod*() {} };");
-    checkSyntaxError("'use strict'; class A { get async* ttt() {} }");
-    checkSyntaxError("'use strict'; class B { get *async ttt() {} }");
-    checkSyntaxError("'use strict'; ({ async = 1 })");
-})();

implementation-contributed/javascriptcore/stress/async-iteration-yield-promise.js

@@ -1,470 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-const Logger = function () {
-    var log = [];
-
-    this.logEvent = (type, value, done) => {
-        log.push({ type, value, done});
-    };
-    this.logFulfilledEvent = (value, done) => {
-        this.logEvent('fulfilled', value, done);
-    };
-    this.logRejectEvent = error => {
-        this.logEvent('reject', error.toString(), true);
-    };
-    this.logCatchEvent = value => {
-        this.logEvent('catch', value, true);
-    };
-    this.getLogger = () => log;
-
-    this.clear = () => {
-        log = [];
-    }
-};
-
-const fulfillSpy = logger => result => logger.logFulfilledEvent(result.value, result.done);
-const rejectSpy = logger => error => logger.logRejectEvent(error);
-const catchSpy = logger => error => logger.logCatchEvent(error);
-
-const assertLogger = function (loggerObject) {
-    const logger = loggerObject.getLogger();
-
-    var _assertLogger = function () {
-        let index = 0;
-
-        const isNotOutOfLength = () => {
-            assert(index < logger.length, true, `Index is greater then log length`);   
-        }
-
-        this.fullfilled = function (expectedValue, message = 'on fulfill') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.fullfilledDone = function (expectedValue, message = 'on fulfill with done true') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.rejected = function (error, message = 'on reject') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'reject', msg);
-            assert(step.value, error.toString(), msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.catched = function (expectedError, message = 'on catch') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'catch', msg);
-            assert(step.value, expectedError, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.isFinal = function (message = '') {
-            assert(index, logger.length, `expected final step: ${message}`);
-        }; 
-    }; 
-    
-    return new _assertLogger();
-};
-
-const getPromise = promiseHolder => {
-    return new Promise((resolve, reject) => {
-        promiseHolder.resolve = resolve;
-        promiseHolder.reject = reject;
-    });
-};
-
-var logger = new Logger();
-const someValue = 'some-value';
-const errorMessage = 'error-message';
-const promiseHolder = {};
-
-async function * foo(val) {
-    let reply = yield '0:' + val;
-    reply = yield getPromise(promiseHolder);
-    return 'end foo:' + reply;
-}
-
-let f = foo(someValue);
-
-f.next(someValue + ':0').then(fulfillSpy(logger));
-f.next(someValue + ':1').then(fulfillSpy(logger));
-f.next(someValue + ':2').then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:' + someValue)
-    .isFinal();
-
-promiseHolder.resolve('1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:' + someValue)
-    .fullfilled('1')
-    .fullfilledDone('end foo:' +  someValue + ':2')
-    .isFinal();
-
-logger.clear();
-
-f = foo('init');
-
-f.next('0').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('1').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('2').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .isFinal();
-
-promiseHolder.reject('1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .rejected('1')
-    .fullfilledDone()
-    .isFinal();
-
-logger.clear();
-
-f = foo('init');
-
-f.next('0').then(fulfillSpy(logger)).catch(catchSpy(logger));
-f.next('1').then(fulfillSpy(logger)).catch(catchSpy(logger));
-f.next('2').then(fulfillSpy(logger)).catch(catchSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .isFinal();
-
-promiseHolder.reject('1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .fullfilledDone(undefined)
-    .catched('1')
-    .isFinal();
-
-logger.clear();
-
-const promiseHolder1 = {};
-const promiseHolder2 = {};
-
-async function * boo() {
-    const promise1 = getPromise(promiseHolder1);
-    const promise2 = getPromise(promiseHolder2);
-    yield '0';
-    yield promise1;
-    yield '1';
-    yield promise2;
-    return 'end foo';
-}
-
-let b = boo();
-
-b.next().then(fulfillSpy(logger)).catch(catchSpy(logger));
-b.next().then(fulfillSpy(logger)).catch(catchSpy(logger));
-b.next().then(fulfillSpy(logger)).catch(catchSpy(logger));
-b.next().then(fulfillSpy(logger)).catch(catchSpy(logger));
-b.next().then(fulfillSpy(logger)).catch(catchSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.resolve('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('#1')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder2.resolve('#2');
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('#1')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .fullfilledDone('end foo')
-    .isFinal();
-
-
-logger.clear();
-
-b = boo();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.resolve('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('#1')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder2.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('#1')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone()
-    .isFinal();
-
-logger.clear();
-
-b = boo();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.reject('#1');
-promiseHolder2.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .rejected('#1')
-    .fullfilledDone()
-    .fullfilledDone()
-    .fullfilledDone()
-    .isFinal();
-
-logger.clear();
-
-b = boo();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder2.reject('#2');
-promiseHolder1.reject('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .rejected('#1')
-    .fullfilledDone()
-    .fullfilledDone()
-    .fullfilledDone()
-    .isFinal();
-
-async function * bar() {
-  yield '0';
-  yield getPromise(promiseHolder1);
-  throw new Error(errorMessage);
-  yield getPromise(promiseHolder2);
-  return 'end foo';
-}
-
-logger.clear();
-b = bar();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
- 
-
-promiseHolder1.resolve('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('#1')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-b = bar();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.reject('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .rejected('#1')
-    .fullfilledDone()
-    .fullfilledDone()
-    .isFinal();
-
-logger.clear();
-b = bar();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-promiseHolder1.resolve('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-b = bar();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.resolve('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled("#1")
-    .fullfilledDone(someValue)
-    .isFinal();
-
-logger.clear();
-b = bar();
-
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.next().then(fulfillSpy(logger), rejectSpy(logger));
-b.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .isFinal();
-
-promiseHolder1.reject('#1');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .rejected("#1")
-    .fullfilledDone(someValue)
-    .isFinal();

implementation-contributed/javascriptcore/stress/async-iteration-yield-star-interface.js

@@ -1,490 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-const getPromise = promiseHolder => {
-    return new Promise((resolve, reject) => {
-        promiseHolder.resolve = resolve;
-        promiseHolder.reject = reject;
-    });
-};
-
-const Logger = function () {
-    var log = [];
-
-    this.logEvent = (type, value, done) => {
-        log.push({ type, value, done});
-    };
-    this.logFulfilledEvent = (value, done) => {
-        this.logEvent('fulfilled', value, done);
-    };
-    this.logRejectEvent = error => {
-        this.logEvent('reject', error.toString(), true);
-    };
-    this.logCatchEvent = value => {
-        this.logEvent('catch', value, true);
-    };
-    this.logCustomEvent = event => {
-        this.logEvent('custom', event, false);
-    };
-    this.getLogger = () => log;
-
-    this.clear = () => {
-        log = [];
-    }
-};
-
-const fulfillSpy = logger => result => logger.logFulfilledEvent(result.value, result.done);
-const rejectSpy = logger => error => logger.logRejectEvent(error);
-const catchSpy = logger => error => logger.logCatchEvent(error);
-const customSpy = logger => event => logger.logCustomEvent(event);
-
-const assertLogger = function (loggerObject) {
-    const logger = loggerObject.getLogger();
-
-    var _assertLogger = function () {
-        let index = 0;
-
-        const isNotOutOfLength = () => {
-            assert(index < logger.length, true, `Index is greater then log length`);   
-        }
-
-        this.fullfilled = function (expectedValue, message = 'on fulfill') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.fullfilledDone = function (expectedValue, message = 'on fulfill with done true') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.rejected = function (error, message = 'on reject') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'reject', msg);
-            assert(step.value, error.toString(), msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.catched = function (expectedError, message = 'on catch') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'catch', msg);
-            assert(step.value, expectedError, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.custom = function (expectedValue, message = 'on custom event') {
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'custom', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.isFinal = function (message = '') {
-            assert(index, logger.length, `expected final step: ${message}`);
-        }; 
-    }; 
-    
-    return new _assertLogger();
-};
-
-var logger = new Logger();
-const someValue = 'some-value';
-const errorMessage = 'error-message';
-
-let asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    },
-    throw (error) {
-        customSpy(logger)('throw:' + error);
-        return error;
-    },
-    return(value) {
-        customSpy(logger)('return:' + value);
-        return { value: value, done: true };
-    }
-  };
-
-async function *foo () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-let f = foo('Init');
-
-f.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('C').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('next:C')
-    .fullfilled(undefined)
-    .custom('next:D')
-    .fullfilled("C")
-    .custom('next:E')
-    .fullfilled("D")
-    .custom('next:iter:Finish')
-    .fullfilled("E")
-    .fullfilled("3")
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-f = foo('Init');
-
-f.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-f.return('C').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:C')
-    .fullfilled(undefined)
-    .fullfilledDone("C")
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-f = foo('Init');
-
-f.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-f.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-f.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-f.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('throw:' + new Error(errorMessage))
-    .fullfilled(undefined)
-    .custom('next:D')
-    .fullfilled(undefined)
-    .custom('next:E')
-    .fullfilled('D')
-    .custom('next:iter:Finish')
-    .fullfilled('E')
-    .fullfilled('3')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    }
-  };
-
-async function *boo () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-let b = boo('Init');
-
-logger.clear();
-
-b.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('C').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('next:C')
-    .fullfilled(undefined)
-    .custom('next:D')
-    .fullfilled("C")
-    .custom("next:iter:Finish")
-    .fullfilled("D")
-    .fullfilled("3")
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-b = boo('Init');
-
-b.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-b.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-b.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .fullfilled(undefined)
-    .rejected('TypeError: Delegated generator does not have a \'throw\' method.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    },
-    return (value) {
-        customSpy(logger)('return:' + value);
-        return { value: value, done: true };
-    }
-  };
-
-async function *bar () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-b = bar('Init');
-
-logger.clear();
-
-b.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-b.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-b.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .rejected('TypeError: Delegated generator does not have a \'throw\' method.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-let ph = {};
-
-asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    },
-    return (value) {
-        customSpy(logger)('return:' + value);
-        return { value: getPromise(ph), done: true };
-    }
-  };
-
-async function *baz () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-b = baz('Init');
-
-logger.clear();
-
-b.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-b.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-b.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-b.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .rejected('TypeError: Delegated generator does not have a \'throw\' method.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-ph.resolve('accept');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .rejected('TypeError: Delegated generator does not have a \'throw\' method.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-ph = {};
-
-asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    },
-    return (value) {
-        customSpy(logger)('return:' + value);
-        return getPromise(ph);
-    }
-  };
-
-async function *foobar () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-fb = foobar('Init');
-
-logger.clear();
-
-fb.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-fb.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .isFinal();
-
-ph.resolve({ value: 'value', done: true });
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .rejected('TypeError: Delegated generator does not have a \'throw\' method.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-fb = foobar('Init');
-
-logger.clear();
-
-fb.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-fb.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-fb.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .isFinal();
-
-ph.resolve('X');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:undefined')
-    .fullfilled(undefined)
-    .rejected('TypeError: Iterator result interface is not an object.')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();

implementation-contributed/javascriptcore/stress/async-iteration-yield-star.js

@@ -1,684 +0,0 @@
-var assert = function (result, expected, message = "") {
-  if (result !== expected) {
-    throw new Error('Error in assert. Expected "' + expected + '" but was "' + result + '":' + message );
-  }
-};
-
-const Logger = function () {
-    var log = [];
-
-    this.logEvent = (type, value, done) => {
-        log.push({ type, value, done});
-    };
-    this.logFulfilledEvent = (value, done) => {
-        this.logEvent('fulfilled', value, done);
-    };
-    this.logRejectEvent = error => {
-        this.logEvent('reject', error.toString(), true);
-    };
-    this.logCatchEvent = value => {
-        this.logEvent('catch', value, true);
-    };
-    this.logCustomEvent = event => {
-        this.logEvent('custom', event, false);
-    };
-    this.getLogger = () => log;
-
-    this.clear = () => {
-        log = [];
-    }
-};
-
-const fulfillSpy = logger => result => logger.logFulfilledEvent(result.value, result.done);
-const rejectSpy = logger => error => logger.logRejectEvent(error);
-const catchSpy = logger => error => logger.logCatchEvent(error);
-const customSpy = logger => event => logger.logCustomEvent(event);
-
-const assertLogger = function (loggerObject) {
-    const logger = loggerObject.getLogger();
-
-    var _assertLogger = function () {
-        let index = 0;
-
-        const isNotOutOfLength = () => {
-            assert(index < logger.length, true, `Index is greater then log length`);   
-        }
-
-        this.fullfilled = function (expectedValue, message = 'on fulfill') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.fullfilledDone = function (expectedValue, message = 'on fulfill with done true') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'fulfilled', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.rejected = function (error, message = 'on reject') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'reject', msg);
-            assert(step.value, error.toString(), msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.catched = function (expectedError, message = 'on catch') {
-            isNotOutOfLength();
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'catch', msg);
-            assert(step.value, expectedError, msg);
-            assert(step.done, true, msg);
-
-            index++;
-            return this;
-        };
-
-        this.custom = function (expectedValue, message = 'on custom event') {
-
-            const msg = `step: ${index} - ${message}`;
-            let step = logger[index];
-
-            assert(step.type, 'custom', msg);
-            assert(step.value, expectedValue, msg);
-            assert(step.done, false, msg);
-
-            index++;
-            return this;
-        };
-
-        this.isFinal = function (message = '') {
-            assert(index, logger.length, `expected final step: ${message}`);
-        }; 
-    }; 
-    
-    return new _assertLogger();
-};
-
-const getPromise = promiseHolder => {
-    return new Promise((resolve, reject) => {
-        promiseHolder.resolve = resolve;
-        promiseHolder.reject = reject;
-    });
-};
-
-var logger = new Logger();
-const someValue = 'some-value';
-const errorMessage = 'error-message';
-
-async function * foo(value) {
-  let re = yield '1:' + value;
-  re = yield '2:' + re;
-  re = yield '3:' + re;
-  return 'end foo:' + re;
-}
-
-async function * boo(value) {
-  let reply = yield '0:' + value;
-  reply = yield* foo(reply);
-  yield '4:' + reply;
-}
-
-var b = boo('init');
-
-b.next('0').then(fulfillSpy(logger));
-b.next('1').then(fulfillSpy(logger));
-b.next('2').then(fulfillSpy(logger));
-b.next('3').then(fulfillSpy(logger));
-b.next('4').then(fulfillSpy(logger));
-b.next('5').then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:init')
-    .fullfilled('1:1')
-    .fullfilled('2:2')
-    .fullfilled('3:3')
-    .fullfilled('4:end foo:4')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var b2 = boo(':value');
-
-b2.next(':0').then(fulfillSpy(logger));
-b2.next(':1').then(fulfillSpy(logger), rejectSpy(logger));
-b2.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-b2.next(':2').then(fulfillSpy(logger));
-b2.next(':3').then(fulfillSpy(logger));
-b2.next(':4').then(fulfillSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0::value')
-    .fullfilled('1::1')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-var b2 = boo('#value');
-
-b2.next('#0').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#1').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#2').then(fulfillSpy(logger), rejectSpy(logger));
-b2.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#3').then(fulfillSpy(logger), rejectSpy(logger));
-b2.next('#4').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0:#value')
-    .fullfilled('1:#1')
-    .fullfilled('2:#2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-async function * bar() {
-  yield '1';
-  yield '2';
-  throw new Error(errorMessage);
-  yield '3';
-  return 'end foo';
-}
-
-async function * baz() {
-  yield '0';
-  yield* bar();
-  yield '4';
-}
-
-logger.clear();
-var bz1 = baz();
-
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-bz1.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-let promiseHolder = {};
-
-async function *joo() {
-    yield '1';
-    yield getPromise(promiseHolder);
-}
-
-async function *goo () {
-    yield '0';
-    yield* joo();
-    yield '3';
-}
-
-let g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('2')
-    .fullfilled('3')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.return(someValue).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone(someValue)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-g = goo();
-
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-g.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .rejected(new Error(errorMessage))
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-async function *koo() {
-    yield '1';
-    await getPromise(promiseHolder);
-}
-
-async function *loo () {
-    yield '0';
-    yield* joo();
-    yield '3';
-}
-
-let l = loo();
-
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
- assertLogger(logger)
-    .fullfilled("0")
-    .fullfilled("1")
-    .isFinal();
-
-promiseHolder.resolve('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .fullfilled('#2')
-    .fullfilled("3")
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-l = loo();
-
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-l.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled("0")
-    .fullfilled("1")
-    .isFinal();
-
-promiseHolder.reject('#2');
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled('0')
-    .fullfilled('1')
-    .rejected('#2')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-let asyncIter = {
-    [Symbol.asyncIterator]() { return this; },
-    next (value) {
-        customSpy(logger)('next:' + value);
-        return { value: value, done: 'iter:Finish' === value };
-    },
-    throw (error) {
-        customSpy(logger)('throw:' + error);
-        return error;
-    },
-    return(value) {
-        customSpy(logger)('return:' + value);
-        return { value: value, done: true };
-    }
-  };
-
-async function *moo () {
-    yield '0';
-    yield* asyncIter;
-    yield '3';
-}
-
-let m = moo('Init');
-
-m.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('C').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('next:C')
-    .fullfilled(undefined)
-    .custom('next:D')
-    .fullfilled('C')
-    .custom('next:E')
-    .fullfilled('D')
-    .custom('next:iter:Finish')
-    .fullfilled('E')
-    .fullfilled('3')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-m = moo('Init');
-
-m.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-m.return('C').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('return:C')
-    .fullfilled(undefined)
-    .fullfilledDone('C')
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-m = moo('Init');
-
-m.next('A').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('B').then(fulfillSpy(logger), rejectSpy(logger));
-m.throw(new Error(errorMessage)).then(fulfillSpy(logger), rejectSpy(logger));
-m.next('D').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('E').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('iter:Finish').then(fulfillSpy(logger), rejectSpy(logger));
-m.next('Finish').then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .custom('next:undefined')
-    .fullfilled('0')
-    .custom('throw:' + new Error(errorMessage))
-    .fullfilled(undefined)
-    .custom('next:D')
-    .fullfilled(undefined)
-    .custom('next:E')
-    .fullfilled('D')
-    .custom('next:iter:Finish')
-    .fullfilled('E')
-    .fullfilled('3')
-    .fullfilledDone(undefined)
-    .isFinal();
-
-logger.clear();
-
-async function* noo() {
-  try {
-    await Promise.reject("doop");
-  } finally {
-    yield* [1, 2, 3]; // Is this line reachable in this implementation?
-  }
-}
-
-const n = noo();
-
-n.next().then(fulfillSpy(logger), rejectSpy(logger));
-n.next().then(fulfillSpy(logger), rejectSpy(logger));
-n.next().then(fulfillSpy(logger), rejectSpy(logger));
-n.next().then(fulfillSpy(logger), rejectSpy(logger));
-n.next().then(fulfillSpy(logger), rejectSpy(logger));
-
-drainMicrotasks();
-
-assertLogger(logger)
-    .fullfilled(1)
-    .fullfilled(2)
-    .fullfilled(3)
-    .rejected('doop');

implementation-contributed/javascriptcore/stress/bug-131764.js

@@ -1,22 +0,0 @@
-var result = 0;
-function test1(arr) {
-    return Array.of(...arr);
-}
-function test2() {
-    return Array(...arguments);
-}
-
-var result = 0;
-if (this.noInline) {
-    noInline(test1)
-    noInline(test2)
-}
-
-var array = [1,2,3,4,5];
-
-for (var i = 0; i < 10000; i++) {
-     result ^= test2(1,2,3,4,5,6,7).length;
-}
-
-if (result != 0)
-    throw "Error: bad result: " + result;

implementation-contributed/javascriptcore/stress/bug-165091.js

@@ -1,14 +0,0 @@
-function shouldThrowSyntaxError(str, message) {
-    try {
-        eval(str);
-        throw new Error("Expected `" + str + "` to throw a SyntaxError, but did not throw.")
-    } catch (e) {
-        if (e.constructor !== SyntaxError)
-            throw new Error("Expected `" + str + "` to throw a SyntaxError, but threw '" + e + "'");
-        if (message !== void 0 && e.message !== message)
-            throw new Error("Expected `" + str + "` to throw SyntaxError: '" + message + "', but threw '" + e + "'");
-    }
-}
-
-shouldThrowSyntaxError("0/-async J", "Unexpected identifier 'J'")
-

implementation-contributed/javascriptcore/stress/bug-171786.js

@@ -1,15 +0,0 @@
-
-function foo(i, x) {
-    return String.prototype.big.call(x);
-}
-noInline(foo);
-
-for (var i = 0; i < 1000; i++) {
-    try {
-        if (i < 200)
-            foo(i, "hello");
-        else
-            foo(i, undefined);
-    } catch(e) {
-    }
-}

implementation-contributed/javascriptcore/stress/bug-188298.js

@@ -1,12 +0,0 @@
-// This test passes if it does not crash.
-
-function foo() {
-    if (1 < 2);
-    while (true) {
-        if (1 < 2) break;
-    }
-}
-
-for (var i = 0; i < 10000; i++)
-    foo();
-

implementation-contributed/javascriptcore/stress/builtin-function-is-construct-type-none.js

@@ -1,18 +0,0 @@
-function shouldThrow(func, message) {
-    var error = null;
-    try {
-        func();
-    } catch (e) {
-        error = e;
-    }
-    if (!error)
-        throw new Error("not thrown.");
-    if (String(error) !== message)
-        throw new Error("bad error: " + String(error));
-}
-
-for (var i = 0; i < 10000; ++i) {
-    shouldThrow(function () {
-        new Array.prototype.forEach(function () { });
-    }, "TypeError: function is not a constructor (evaluating 'new Array.prototype.forEach(function () { })')");
-}

implementation-contributed/javascriptcore/stress/builtin-function-length.js

@@ -1,3 +1,8 @@
+/**
+ * Reviewed
+ * Add length property check for function forms in the language folder
+ */
+
 function shouldBe(actual, expected) {
     if (actual !== expected)
         throw new Error('bad value: ' + actual);

implementation-contributed/javascriptcore/stress/builtin-function-name.js

@@ -1,45 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + actual);
-}
-
-function shouldThrow(func, errorMessage) {
-    var errorThrown = false;
-    var error = null;
-    try {
-        func();
-    } catch (e) {
-        errorThrown = true;
-        error = e;
-    }
-    if (!errorThrown)
-        throw new Error('not thrown');
-    if (String(error) !== errorMessage)
-        throw new Error(`bad error: ${String(error)}`);
-}
-
-{
-    shouldBe(JSON.stringify(Object.getOwnPropertyNames(Array.prototype.filter).sort()), `["length","name"]`);
-    shouldBe(Array.prototype.filter.name, "filter");
-    shouldBe(JSON.stringify(Object.getOwnPropertyDescriptor(Array.prototype.filter, 'name')), `{"value":"filter","writable":false,"enumerable":false,"configurable":true}`);
-    shouldBe(delete Array.prototype.filter.name, true);
-    shouldBe(JSON.stringify(Object.getOwnPropertyNames(Array.prototype.filter).sort()), `["length"]`);
-}
-
-{
-    shouldThrow(function () {
-        "use strict";
-        Array.prototype.forEach.name = 42;
-    }, `TypeError: Attempted to assign to readonly property.`);
-}
-
-{
-    var resolve = null;
-    var reject = null;
-    new Promise(function (arg0, arg1) {
-        resolve = arg0;
-        reject = arg1;
-    });
-    shouldBe(Object.getOwnPropertyDescriptor(resolve, 'name'), undefined);
-    shouldBe(Object.getOwnPropertyDescriptor(reject, 'name'), undefined);
-}

implementation-contributed/javascriptcore/stress/butterfly-zero-unused-butterfly-properties.js

@@ -1,9 +0,0 @@
-//@ runDefault("--jitPolicyScale=0", "--gcMaxHeapSize=2000")
-
-// This test happened to catch a case where we failed to zero the space in the butterfly before m_lastOffset when reallocating.
-
-var array = Array(1000);
-for (var i = 0; i < 100000; ++i) {
-    array[i - array.length] = '';
-    array[i ^ array.length] = '';
-}

implementation-contributed/javascriptcore/stress/cfa-expected-values-must-set-clobbered-to-false.js

@@ -1,38 +0,0 @@
-//@ runDefault("--useFTLJIT=0", "--useConcurrentJIT=false")
-
-let num = 150;
-
-function foo(comp, o, b) {
-    let sum = o.f;
-    if (b)
-        OSRExit();
-    for (let i = 0; i < comp; ++i) {
-        sum += o.f;
-    }
-    return sum;
-}
-noInline(foo);
-
-let o = {f:25};
-let o2 = {f:25, g:44};
-o2.f = 45;
-o2.f = 45;
-o2.f = 45;
-o2.f = 45;
-let comp = {
-    valueOf() { return num; }
-}
-
-foo(comp, o2, true);
-foo(comp, o2, true);
-for (let i = 0; i < 500; ++i) {
-    foo(comp, o2, false);
-}
-
-let o3 = {g:24, f:73};
-num = 10000000;
-let result = foo(comp, o3, false);
-
-if (result !== (num + 1)*73) {
-    throw new Error("Bad: " + result);
-}

implementation-contributed/javascriptcore/stress/characters-regexp-ignore-case.js

@@ -1,77 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + actual);
-}
-
-function testH(string) {
-    return string.match(/h/i);
-}
-noInline(testH);
-
-function testHe(string) {
-    return string.match(/he/i);
-}
-noInline(testHe);
-
-function testHel(string) {
-    return string.match(/hel/i);
-}
-noInline(testHel);
-
-function testHell(string) {
-    return string.match(/hell/i);
-}
-noInline(testHell);
-
-function testHello(string) {
-    return string.match(/hello/i);
-}
-noInline(testHello);
-
-function testHelloW(string) {
-    return string.match(/hellow/i);
-}
-noInline(testHelloW);
-
-function testHelloWo(string) {
-    return string.match(/hellowo/i);
-}
-noInline(testHelloWo);
-
-function testHelloWor(string) {
-    return string.match(/hellowor/i);
-}
-noInline(testHelloWor);
-
-function testHelloWorl(string) {
-    return string.match(/helloworl/i);
-}
-noInline(testHelloWorl);
-
-function testHelloWorld(string) {
-    return string.match(/helloworld/i);
-}
-noInline(testHelloWorld);
-
-for (var i = 0; i < 1e4; ++i) {
-    shouldBe(testH("HelloWorld")[0], `H`);
-    shouldBe(testHe("HelloWorld")[0], `He`);
-    shouldBe(testHel("HelloWorld")[0], `Hel`);
-    shouldBe(testHell("HelloWorld")[0], `Hell`);
-    shouldBe(testHello("HelloWorld")[0], `Hello`);
-    shouldBe(testHelloW("HelloWorld")[0], `HelloW`);
-    shouldBe(testHelloWo("HelloWorld")[0], `HelloWo`);
-    shouldBe(testHelloWor("HelloWorld")[0], `HelloWor`);
-    shouldBe(testHelloWorl("HelloWorld")[0], `HelloWorl`);
-    shouldBe(testHelloWorld("HelloWorld")[0], `HelloWorld`);
-    shouldBe(testH("HelloWorldこんにちは")[0], `H`);
-    shouldBe(testHe("HelloWorldこんにちは")[0], `He`);
-    shouldBe(testHel("HelloWorldこんにちは")[0], `Hel`);
-    shouldBe(testHell("HelloWorldこんにちは")[0], `Hell`);
-    shouldBe(testHello("HelloWorldこんにちは")[0], `Hello`);
-    shouldBe(testHelloW("HelloWorldこんにちは")[0], `HelloW`);
-    shouldBe(testHelloWo("HelloWorldこんにちは")[0], `HelloWo`);
-    shouldBe(testHelloWor("HelloWorldこんにちは")[0], `HelloWor`);
-    shouldBe(testHelloWorl("HelloWorldこんにちは")[0], `HelloWorl`);
-    shouldBe(testHelloWorld("HelloWorldこんにちは")[0], `HelloWorld`);
-}

implementation-contributed/javascriptcore/stress/characters-regexp.js

@@ -1,77 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + actual);
-}
-
-function testH(string) {
-    return string.match(/H/);
-}
-noInline(testH);
-
-function testHe(string) {
-    return string.match(/He/);
-}
-noInline(testHe);
-
-function testHel(string) {
-    return string.match(/Hel/);
-}
-noInline(testHel);
-
-function testHell(string) {
-    return string.match(/Hell/);
-}
-noInline(testHell);
-
-function testHello(string) {
-    return string.match(/Hello/);
-}
-noInline(testHello);
-
-function testHelloW(string) {
-    return string.match(/HelloW/);
-}
-noInline(testHelloW);
-
-function testHelloWo(string) {
-    return string.match(/HelloWo/);
-}
-noInline(testHelloWo);
-
-function testHelloWor(string) {
-    return string.match(/HelloWor/);
-}
-noInline(testHelloWor);
-
-function testHelloWorl(string) {
-    return string.match(/HelloWorl/);
-}
-noInline(testHelloWorl);
-
-function testHelloWorld(string) {
-    return string.match(/HelloWorld/);
-}
-noInline(testHelloWorld);
-
-for (var i = 0; i < 1e4; ++i) {
-    shouldBe(testH("HelloWorld")[0], `H`);
-    shouldBe(testHe("HelloWorld")[0], `He`);
-    shouldBe(testHel("HelloWorld")[0], `Hel`);
-    shouldBe(testHell("HelloWorld")[0], `Hell`);
-    shouldBe(testHello("HelloWorld")[0], `Hello`);
-    shouldBe(testHelloW("HelloWorld")[0], `HelloW`);
-    shouldBe(testHelloWo("HelloWorld")[0], `HelloWo`);
-    shouldBe(testHelloWor("HelloWorld")[0], `HelloWor`);
-    shouldBe(testHelloWorl("HelloWorld")[0], `HelloWorl`);
-    shouldBe(testHelloWorld("HelloWorld")[0], `HelloWorld`);
-    shouldBe(testH("HelloWorldこんにちは")[0], `H`);
-    shouldBe(testHe("HelloWorldこんにちは")[0], `He`);
-    shouldBe(testHel("HelloWorldこんにちは")[0], `Hel`);
-    shouldBe(testHell("HelloWorldこんにちは")[0], `Hell`);
-    shouldBe(testHello("HelloWorldこんにちは")[0], `Hello`);
-    shouldBe(testHelloW("HelloWorldこんにちは")[0], `HelloW`);
-    shouldBe(testHelloWo("HelloWorldこんにちは")[0], `HelloWo`);
-    shouldBe(testHelloWor("HelloWorldこんにちは")[0], `HelloWor`);
-    shouldBe(testHelloWorl("HelloWorldこんにちは")[0], `HelloWorl`);
-    shouldBe(testHelloWorld("HelloWorldこんにちは")[0], `HelloWorld`);
-}

implementation-contributed/javascriptcore/stress/clobberize-needs-to-model-spread-effects.js

@@ -1,23 +0,0 @@
-function assert(b) {
-    if (!b)
-        throw new Error;
-}
-noInline(assert);
-
-function foo(a, b) {
-    let r1 = b[0];
-    let x = [...a];
-    let r2 = b[0];
-    assert(r1 + r2 === 43);
-}
-noInline(foo);
-
-let b = [42];
-let a = [];
-a[Symbol.iterator] = function* () {
-    b[0] = 1;
-};
-for (let i = 0; i < 10000; ++i) {
-    b[0] = 42;
-    foo(a, b);
-}

implementation-contributed/javascriptcore/stress/closure-call-exit.js

@@ -1,15 +0,0 @@
-function foo(o, i) {
-    return o[i]();
-}
-
-noInline(foo);
-
-for (var i = 0; i < 10000; ++i) {
-    var result = foo([function() { return 42; }], 0);
-    if (result != 42)
-        throw "Error: bad result: " + result;
-}
-
-var result = foo([function() { return 43; }], 0);
-if (result != 43)
-    throw "Error: bad result at end: " + result;

implementation-contributed/javascriptcore/stress/closure-recursive-tail-call-infinite-loop.js

@@ -1,29 +0,0 @@
-"use strict";
-
-function Foo() {}
-
-function second(next, cp) {
-  return 100;
-}
-
-function first(next, cp) {
-  return cp < 60 ? new Foo() : next(cp);
-}
-
-function createClosure(next, strategy) {
-  return function closure(cp) {
-    return strategy(next, cp);
-  };
-}
-
-var tmp = createClosure(null, second);
-var bar = createClosure(tmp, first);
-
-noInline(bar);
-
-for (var i=0; i<50000; i++) {
-  bar(32);
-  bar(32);
-  bar(32);
-  bar(100);
-}

implementation-contributed/javascriptcore/stress/closure-recursive-tail-call.js

@@ -1,21 +0,0 @@
-"use strict";
-
-function makeClosure(x)
-{
-    return (f) => {
-        if (x == 42) {
-            x = 0;
-            return f(f);
-        }
-        else
-            return x;
-    }
-}
-
-for (var i = 0; i < 1000; ++i) {
-    var g = makeClosure(42);
-    var h = makeClosure(41);
-    var value = g(h);
-    if (value != 41)
-        throw "Wrong result, got: " + value;
-}

implementation-contributed/javascriptcore/stress/code-cache-incorrect-caching.js

@@ -1,92 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error(`bad value: ${String(actual)}`);
-}
-
-function shouldThrow(func, errorMessage) {
-    var errorThrown = false;
-    var error = null;
-    try {
-        func();
-    } catch (e) {
-        errorThrown = true;
-        error = e;
-    }
-    if (!errorThrown)
-        throw new Error('not thrown');
-    if (String(error) !== errorMessage)
-        throw new Error(`bad error: ${String(error)}`);
-}
-var globalEval = eval;
-var global = this;
-
-// EvalContextType.
-{
-    function hello()
-    {
-        return eval('new.target');
-    }
-    shouldBe(hello(), undefined);
-    shouldBe(hello(), undefined);
-    shouldBe(hello(), undefined);
-    globalEval(`
-        var thrown = false;
-        try {
-            eval('new.target');
-        } catch (e) {
-            thrown = true;
-            shouldBe(String(e), "SyntaxError: new.target is only valid inside functions.");
-        }
-        shouldBe(thrown, true);
-    `);
-
-    var thrown = false;
-    try {
-        globalEval('new.target');
-    } catch (e) {
-        thrown = true;
-        shouldBe(String(e), "SyntaxError: new.target is only valid inside functions.");
-    }
-    shouldBe(thrown, true);
-}
-
-// DerivedContextType.
-{
-    var object = {
-        hello()
-        {
-            return eval('super.ok');
-        }
-    };
-    object.__proto__ = { ok: 42 };
-    shouldBe(object.hello(), 42);
-
-    var test = {
-        hello: function () {
-            return eval('super.ok');
-        }
-    };
-    test.__proto__ = { ok: 42 };
-    shouldThrow(function () {
-        test.hello();
-    }, `SyntaxError: super is not valid in this context.`);
-}
-
-// isArrowFunctionContext.
-{
-globalEval(`
-    function ok()
-    {
-        return eval('this');
-    }
-    shouldBe(ok(), global)
-    var hello = {
-        hello()
-        {
-            var arrow = () => eval('this');
-            shouldBe(arrow(), hello);
-        }
-    };
-    hello.hello();
-`);
-}

implementation-contributed/javascriptcore/stress/combined-liveness-needs-to-say-arguments-are-live.js

@@ -1,24 +0,0 @@
-//@ runDefault("--jitPolicyScale=0", "--validateFTLOSRExitLiveness=1", "--useConcurrentJIT=0")
-
-// This should not crash in liveness validation.
-
-function baz() { }
-noInline(baz);
-
-function foo() {
-    let i, j;
-    let a0 = [0, 1];
-    let a1 = [];
-    for (i = 0; i < a0.length; i++) {
-        a1.push();
-        for (j = 0; j < 6; j++) {
-        }
-        for (j = 0; j < 4; j++) {
-            baz();
-        }
-    }
-    throw new Error();
-}
-try {
-    new foo();
-} catch { }

implementation-contributed/javascriptcore/stress/comparison-ignore-negative-zero.js

@@ -1,65 +0,0 @@
-function shouldBe(actual, expected) {
-    if (actual !== expected)
-        throw new Error('bad value: ' + String(actual) + ' ' + String(expected));
-}
-noInline(shouldBe);
-
-function zero()
-{
-    return 0;
-}
-noInline(zero);
-
-function negativeZero()
-{
-    return -0;
-}
-noInline(negativeZero);
-
-var object = {
-    valueOf()
-    {
-        return -0;
-    }
-};
-
-function test()
-{
-    shouldBe(0 < zero(), false);
-    shouldBe(0 < (-zero()), false);
-    shouldBe(0 <= zero(), true);
-    shouldBe(0 <= (-zero()), true);
-    shouldBe(0 > zero(), false);
-    shouldBe(0 > (-zero()), false);
-    shouldBe(0 >= zero(), true);
-    shouldBe(0 >= (-zero()), true);
-    shouldBe(0 == zero(), true);
-    shouldBe(0 == (-zero()), true);
-    shouldBe(0 === zero(), true);
-    shouldBe(0 === (-zero()), true);
-    shouldBe(0 != zero(), false);
-    shouldBe(0 != (-zero()), false);
-    shouldBe(0 !== zero(), false);
-    shouldBe(0 !== (-zero()), false);
-
-    shouldBe(0 < object, false);
-    shouldBe(0 < -object, false);
-    shouldBe(0 <= object, true);
-    shouldBe(0 <= -object, true);
-    shouldBe(0 > object, false);
-    shouldBe(0 > -object, false);
-    shouldBe(0 >= object, true);
-    shouldBe(0 >= -object, true);
-    shouldBe(0 == object, true);
-    shouldBe(0 == -object, true);
-    shouldBe(0 === object, false);
-    shouldBe(0 === -object, true);
-    shouldBe(0 != object, false);
-    shouldBe(0 != -object, false);
-    shouldBe(0 !== object, true);
-    shouldBe(0 !== -object, false);
-}
-noInline(test);
-
-for (var i = 0; i < 1e5; ++i)
-    test();

implementation-contributed/javascriptcore/stress/completion-value.js

@@ -1,3 +1,8 @@
+/**
+ * reviewed
+ * v8: add tests for completion value resolution in try/catch/finally blocks (anything returning -2)
+ */
+
 function shouldBe(actual, expected) {
     if (actual !== expected)
         throw new Error('bad value: ' + actual);

implementation-contributed/javascriptcore/stress/computed-accessor.js

@@ -1,3 +1,4 @@
+// Reviewed
 function shouldBe(actual, expected) {
     if (actual !== expected)
         throw new Error(`bad value: ${String(actual)}`);

implementation-contributed/javascriptcore/stress/computed-function-names.js

@@ -1,68 +0,0 @@
-let nullSymbol = Symbol();
-
-let propKeys = [
-     "foo", "", undefined, null, true, false, 0, 10, 1234.567,
-     Symbol("foo"), Symbol(""), nullSymbol,
-];
-
-function toKeyString(x) {
-    if (typeof x === "string")
-        return '"' + x + '"';
-    if (typeof x === "symbol")
-        return x.toString();
-    return "" + x;
-}
-
-function toFuncName(x) {
-    if (typeof x === "symbol") {
-        if (x !== nullSymbol) {
-            let str = x.toString();
-            let key = str.slice(7, str.length - 1);
-            return "[" + key + "]";
-        }
-        return "";
-    }
-    return "" + x;
-}
-
-function shouldBe(title, actual, expected) {
-    if (actual !== expected)
-        throw Error(title + ": actual:" + actual + " expected:" + expected);
-}
-
-function makeObj(propKey, classMethodName) {
-    return {
-        [propKey]: class { static [classMethodName](){} },
-    };
-}
-noInline(makeObj);
-
-for (var i = 0; i < 1000; i++) {
-    for (var k = 0; k < propKeys.length; k++) {
-        let key = propKeys[k];
-        let o = makeObj(key, "prop");
-        shouldBe("typeof o[" + toKeyString(key) + "].name", typeof o[key].name, "string");
-        shouldBe("o[" + toKeyString(key) + "].name", o[key].name, toFuncName(key));
-    }
-
-    for (var k = 0; k < propKeys.length; k++) {
-        let key = propKeys[k];
-        let o = makeObj(key, "name");
-        shouldBe("typeof o[" + toKeyString(key) + "].name", typeof o[key], "function");
-    }
-
-    for (var k = 0; k < propKeys.length; k++) {
-        let key = propKeys[k];
-        let prop = { toString() { return "prop" } };
-        let o = makeObj(key, prop);
-        shouldBe("typeof o[" + toKeyString(key) + "].name", typeof o[key].name, "string");
-        shouldBe("o[" + toKeyString(key) + "].name", o[key].name, toFuncName(key));
-    }
-
-    for (var k = 0; k < propKeys.length; k++) {
-        let key = propKeys[k];
-        let prop = { toString() { return "name" } };
-        let o = makeObj(key, prop);
-        shouldBe("typeof o[" + toKeyString(key) + "].name", typeof o[key], "function");
-    }
-}

implementation-contributed/javascriptcore/stress/concat-append-one-with-sparse-array.js

@@ -1,3 +1,4 @@
+// Reviewed
 //@ skip
 
 let length = 0x10001000;

implementation-contributed/javascriptcore/stress/concat-with-holesMustForwardToPrototype.js

@@ -1,19 +0,0 @@
-Array.prototype[1] = 5;
-
-function arrayEq(a, b) {
-    if (a.length !== b.length)
-        throw new Error([a, "\n\n",  b]);
-
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            throw new Error([a, "\n\n",  b]);
-    }
-}
-
-
-let obj = {};
-arrayEq([1,2,3].concat(4), [1,2,3,4]);
-arrayEq([1,2,3].concat(1.34), [1,2,3,1.34]);
-arrayEq([1.35,2,3].concat(1.34), [1.35,2,3,1.34]);
-arrayEq([1.35,2,3].concat(obj), [1.35,2,3,obj]);
-arrayEq([1,2,3].concat(obj), [1,2,3,obj]);

implementation-contributed/javascriptcore/stress/const-and-with-statement.js

@@ -1,115 +0,0 @@
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-
-function shouldThrowInvalidConstAssignment(f) {
-    var threw = false;
-    try {
-        f();
-    } catch(e) {
-        if (e.name.indexOf("TypeError") !== -1 && e.message.indexOf("readonly") !== -1)
-            threw = true;
-    }
-    assert(threw);
-}
-noInline(shouldThrowInvalidConstAssignment);
-
-
-// Tests
-
-const NUM_LOOPS = 100;
-
-;(function() {
-    function foo() {
-        const x = 40;
-        with ({x : 100}) {
-            assert(x === 100);
-        }
-        with ({y : 100}) {
-            assert(x === 40);
-        }
-    }
-    noInline(foo);
-
-    function bar() {
-        const x = 40;
-        function capX() { return x; }
-        with ({x : 100}) {
-            if (truth()) {
-                const x = 50;
-                const capX = function() { return x; }
-                assert(x === 50);
-                assert(capX() === x);
-            }
-            assert(x === 100);
-            assert(capX() === 40);
-        }
-        with ({y : 100}) {
-            if (truth()) {
-                const x = 50;
-                const capX = function() { return x; }
-                assert(x === 50);
-                assert(capX() === x);
-            }
-            assert(x === 40);
-            assert(capX() === 40);
-        }
-    }
-    noInline(bar);
-
-    function baz() {
-        const x = 40;
-        function capX() { return x; }
-        with ({x : 100}) {
-            if (truth()) {
-                const x = 50;
-                assert(x === 50);
-            }
-            assert(x === 100);
-            assert(capX() === 40);
-        }
-        with ({y : 100}) {
-            if (truth()) {
-                const x = 50;
-                assert(x === 50);
-            }
-            assert(x === 40);
-            assert(capX() === 40);
-        }
-    }
-    noInline(baz);
-
-    for (let i = 0; i < NUM_LOOPS; i++) {
-        foo();
-        bar();
-        baz();
-    }
-})();
-
-
-;(function() {
-    function foo() {
-        const x = 40;
-        with ({x : 100}) {
-            assert(x === 100);
-            x = 20;
-            assert(x === 20);
-        }
-        assert(x === 40);
-        with ({y : 100}) {
-            assert(x === 40);
-            x = 100;
-        }
-    }
-    for (let i = 0; i < NUM_LOOPS; ++i) {
-        shouldThrowInvalidConstAssignment(foo);
-    }
-
-})();

implementation-contributed/javascriptcore/stress/const-exception-handling.js

@@ -1,204 +0,0 @@
-"use strict";
-
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-
-// Tests
-
-
-const NUM_LOOPS = 100;
-
-;(function () {
-function foo() {
-    const x = 20;
-    const y = "y";
-    try {
-        assert(x === 20);
-        assert(y === "y");
-        throw "error";
-    } catch(e) {
-        assert(x === 20);
-    } finally {
-        assert(x === 20);
-        assert(y === "y");
-    }
-
-    for (let i = 0; i < 1; i++) {
-        let numFinally = 0;
-        try {
-            let a = 40;
-            let capA = function() { return a; }
-            assert(capA() === 40);
-            try {
-                const b = 41;
-                const capB = function() { return b; }
-                assert(capB() === 41);
-                assert(capA() === 40);
-                try {
-                    return 20;
-                } catch(e){
-                } finally {
-                    const c = 42;
-                    const capC = function() { return c; }
-                    assert(capC() === 42);
-                    assert(capB() === 41);
-                    assert(capA() === 40);
-                    if (i === 0) {
-                        numFinally++;
-                    }
-                    return 22;
-                }
-            } catch(e) {
-            } finally {
-                if (i === 0) {
-                    numFinally++;
-                }
-                return 23;
-            }
-        } catch(e) {
-        } finally {
-            if (i === 0) {
-                numFinally++;
-            }
-            assert(numFinally === 3);
-            return 24;
-        }
-    }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    assert(foo() === 24);
-}
-
-})();
-
-
-;(function () {
-function foo() {
-    for (let i = 0; i < 1; i++) {
-        let numFinally = 0;
-        let numErrors = 0;
-        try {
-            let a = 40;
-            let capA = function() { return a; }
-            assert(capA() === 40);
-            try {
-                const b = 41;
-                const capB = function() { return b; }
-                assert(capB() === 41);
-                assert(capA() === 40);
-                try {
-                    throw "e";
-                } catch(e) {
-                    assert(i === 0);
-                    assert(capB() === 41);
-                    assert(capA() === 40);
-                    numErrors++;
-                    throw e;
-                } finally {
-                    const c = 42;
-                    const capC = function() { return c; }
-                    const local = "local";
-                    assert(local === "local");
-                    assert(capC() === 42);
-                    assert(capB() === 41);
-                    assert(capA() === 40);
-                    if (i === 0) {
-                        numFinally++;
-                    }
-                }
-            } catch(e) {
-                assert(i === 0);
-                assert(capA() === 40);
-                numErrors++;
-                const local = "local";
-                assert(local === "local");
-            } finally {
-                assert(capA() === 40);
-                if (i === 0) {
-                    numFinally++;
-                }
-                const local = "local";
-                assert(local === "local");
-                return 23;
-            }    
-        } catch(e) {
-            //assert(i === 0);
-        } finally {
-            if (i === 0) {
-                numFinally++;
-            }
-
-            assert(numFinally === 3);
-            assert(numErrors === 2);
-            return 24;
-        }
-    }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    assert(foo() === 24);
-}
-
-})();
-
-
-var d = 100;
-;(function (){
-function foo() {
-    assert(d === 100);
-    for (let i = 0; i < 1; i++) {
-        let numFinally = 0;
-        let numErrors = 0;
-        const c = 44;
-        assert(d === 100);
-        try {
-            const d = 45;
-            if (truth()) {
-                const a = 20;
-                const capA = function() { return a; }
-                assert(capA() === 20);
-                if (truth()) {
-                    const b = 21;
-                    const e = 48;
-                    const capB = function() { return b; }
-                    assert(capB() === 21);
-                    assert(d === 45);
-                    try {
-                        throw "e";
-                    } catch(e) {
-                        assert(capA() === 20);
-                        assert(a === 20);
-                        numErrors++;
-                    } finally {
-                        assert(capA() === 20);
-                        assert(e === 48);
-                        numFinally++;
-                        return 30;
-                    }
-                } 
-            }
-        } finally {
-            assert(c === 44);
-            assert(d === 100);
-            numFinally++;
-            assert(numFinally === 2);
-            assert(numErrors === 1);
-            return 40;
-        }
-    }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    assert(foo() === 40);
-}
-
-})();

implementation-contributed/javascriptcore/stress/const-loop-semantics.js

@@ -1,130 +0,0 @@
-"use strict";
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-function shouldThrowInvalidConstAssignment(f) {
-    var threw = false;
-    try {
-        f();
-    } catch(e) {
-        if (e.name.indexOf("TypeError") !== -1 && e.message.indexOf("readonly") !== -1)
-            threw = true;
-    }
-    assert(threw);
-}
-noInline(shouldThrowInvalidConstAssignment);
-
-
-// ========== tests below ===========
-
-const NUM_LOOPS = 1000;
-
-;(function() {
-    function foo() {
-        const obj = {a: 20, b: 40, c: 50};
-        const props = [];
-        for (const p in obj)
-            props.push(p);
-        assert(props.length === 3);
-        for (const p of props)
-            assert(!!obj[p]);
-        assert(props.indexOf("a") !== -1);
-        assert(props.indexOf("b") !== -1);
-        assert(props.indexOf("c") !== -1);
-    }
-
-    function bar() {
-        const funcs = [];
-        for (const item of [1, 2, 3])
-            funcs.push(function() { return item; });
-        let i = 1;
-        assert(funcs.length === 3);
-        for (const f of funcs) {
-            assert(f() === i);
-            i++;
-        }
-    }
-    function baz() {
-        const funcs = [];
-        const obj = {a:1, b:2, c:3};
-        for (const p in obj)
-            funcs.push(function() { return p; });
-        let i = 1;
-        assert(funcs.length === 3);
-        for (const f of funcs) {
-            assert(obj[f()] === i);
-            i++;
-        }
-    }
-    function taz() {
-        for (const item of [1,2,3]) {
-            const item = 20;
-            assert(item === 20);
-        }
-    }
-    function jaz() {
-        let i = 0;
-        for (const x = 40; i < 10; i++) {
-            assert(x === 40);
-        }
-    }
-    for (var i = 0; i < NUM_LOOPS; i++) {
-        foo();
-        bar();
-        baz();
-        taz();
-        jaz();
-    }
-})();
-
-;(function() {
-    function foo() {
-        for (const item of [1,2,3])
-            item = 20;
-    }
-    function bar() {
-        for (const item of [1,2,3])
-            eval("item = 20")
-    }
-    function baz() {
-        for (const p in {a: 20, b: 40})
-            p = 20;
-    }
-    function taz() {
-        for (const p in {a: 20, b: 40})
-            eval("p = 20")
-    }
-    function jaz() {
-        for (const x = 0; x < 10; x++) { }
-    }
-    function raz() {
-        for (const x = 0; x < 10; ++x) { }
-    }
-    function paz() {
-        for (const x = 0; x < 10; x++) { 
-            let f = function() { return x; }
-        }
-    }
-    function maz() {
-        for (const x = 0; x < 10; ++x) { 
-            let f = function() { return x; } 
-        }
-    }
-    for (var i = 0; i < NUM_LOOPS; i++) {
-        shouldThrowInvalidConstAssignment(foo);
-        shouldThrowInvalidConstAssignment(bar);
-        shouldThrowInvalidConstAssignment(baz);
-        shouldThrowInvalidConstAssignment(taz);
-        shouldThrowInvalidConstAssignment(jaz);
-        shouldThrowInvalidConstAssignment(raz);
-        shouldThrowInvalidConstAssignment(paz);
-        shouldThrowInvalidConstAssignment(maz);
-    }
-})();

implementation-contributed/javascriptcore/stress/const-not-strict-mode.js

@@ -1,147 +0,0 @@
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-
-function shouldThrowTDZ(func) {
-    var hasThrown = false;
-    try {
-        func();
-    } catch(e) {
-        if (e.name.indexOf("ReferenceError") !== -1)
-            hasThrown = true;
-    }
-    assert(hasThrown);
-}
-noInline(shouldThrowTDZ);
-
-
-// Tests
-
-
-const NUM_LOOPS = 1000;
-
-;(function() {
-function foo() {
-    delete x;
-    const x = 20;
-}
-function bar() {
-    delete x;
-    const x = 20;
-    function capX() { return x; }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-}
-
-})();
-
-
-;(function() {
-
-function foo() {
-    var hadError = false;
-    try {
-        x;
-    } catch(e) {
-        hadError = true;
-    }
-    assert(hadError);
-
-    if (truth()) {
-        // This eval is enterpreted as follows:
-        // eval("var x; x = 20");
-        // We first assign undefined to the "var x".
-        // Then, we interperet an assignment expression
-        // into the resolved variable x. x resolves to the lexical "const x;"
-        // Look at ECMA section 13.3.2.4 of the ES6 spec:
-        // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-variable-statement-runtime-semantics-evaluation
-        // And also look at section 8.3.1 ResolveBinding:
-        // http://www.ecma-international.org/ecma-262/6.0/index.html#sec-resolvebinding
-        const x = 40;
-        let threw = false;
-        try {
-            eval("var x = 20;");
-        } catch(e) {
-            if (e.name.indexOf("TypeError") !== -1 && e.message.indexOf("readonly") !== -1)
-                threw = true;
-        }
-        assert(threw);
-        assert(x === 40);
-    }
-    assert(x === undefined);
-}
-
-function bar() {
-    var hadError = false;
-    try {
-        x;
-    } catch(e) {
-        hadError = true;
-    }
-    assert(hadError);
-
-    if (truth()) {
-        const x = 40;
-        function capX() { return x; }
-        let threw = false;
-        try {
-            eval("var x = 20;");
-        } catch(e) {
-            if (e.name.indexOf("TypeError") !== -1 && e.message.indexOf("readonly") !== -1)
-                threw = true;
-        }
-        assert(threw);
-        assert(x === 40);
-    }
-    assert(x === undefined);
-}
-
-function baz() {
-    if (truth()) {
-        const x = 40;
-        eval("const x = 20; assert(x === 20);");
-        assert(x === 40);
-    }
-    if (truth()) {
-        const x = 40;
-        function capX() { return x; }
-        eval("const x = 20; assert(x === 20);");
-        assert(x === 40);
-    }
-}
-
-function baz() {
-    // Test eval() caching.
-    const x = 20;
-    const evalString = "x;";
-
-    assert(eval(evalString) === 20);
-    if (truth()) {
-        const y = 60;
-        assert(eval(evalString) === 20);
-        assert(y === 60);
-        if (truth()) {
-            const y = 50, z = 70, x = 40;
-            assert(eval(evalString) === 40);
-            assert(y === 50 && z === 70);
-        }
-    }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    foo();
-    bar();
-    baz();
-}
-
-})();

implementation-contributed/javascriptcore/stress/const-semantics.js

@@ -1,274 +0,0 @@
-"use strict";
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-function shouldThrowInvalidConstAssignment(f) {
-    var threw = false;
-    try {
-        f();
-    } catch(e) {
-        if (e.name.indexOf("TypeError") !== -1 && e.message.indexOf("readonly") !== -1)
-            threw = true;
-    }
-    assert(threw);
-}
-noInline(shouldThrowInvalidConstAssignment);
-
-
-// ========== tests below ===========
-
-const NUM_LOOPS = 1000;
-
-
-;(function() {
-    function foo() {
-        const x = 40;
-        const {y} = {y: 50}, [z] = [60];
-        assert(x === 40);
-        assert(y === 50);
-        assert(z === 60);
-    }
-    function bar() {
-        const x = 40;
-        const {y} = {y: 50}, [z] = [60];
-        function capture() { return x + y + z; }
-        assert(x === 40);
-        assert(y === 50);
-        assert(z === 60);
-        assert(capture() === 150);
-        if (truth()) {
-            const x = "x";
-            assert(x === "x");
-            if (truth()) {
-                let x = 100;
-                const y = 200;
-                assert(x === 100);
-                assert(y === 200);
-
-                x = 10;
-                assert(x === 10);
-            }
-            assert(x === "x");
-        }
-        assert(x === 40);
-    }
-    function baz() {
-        let y = 10;
-        function sideEffects() {
-            y = 20;
-        }
-
-        const x = 10;
-        try {
-            x = sideEffects();
-        } catch(e) {}
-        assert(y === 20);
-        assert(x === 10);
-
-        try {
-            x = y = 30;
-        } catch(e) {}
-        assert(y === 30);
-        assert(x === 10);
-    }
-    function taz() {
-        let y = 10;
-        let z;
-        function sideEffects() {
-            y = 20;
-            return ["hello", "world"];
-        }
-
-        const x = 10;
-        try {
-            [z, x] = sideEffects();
-        } catch(e) {}
-        assert(y === 20);
-        assert(x === 10);
-        assert(z === "hello");
-    }
-    function jaz() {
-        const x = "x";
-        function capX() { return x; }
-        assert(x === "x");
-        assert(capX() === "x");
-        if (truth()) {
-            let y = 40;
-            let capY = function() { return y; }
-            assert(x === "x");
-            assert(capX() === "x");
-        }
-        assert(x === "x");
-        assert(capX() === "x");
-    }
-    for (var i = 0; i < NUM_LOOPS; i++) {
-        foo();
-        bar();
-        baz();
-        jaz();
-    }
-})();
-
-
-;(function() {
-    function foo() {
-        const x = 40;
-        x = 30;
-    }
-    function bar() {
-        const x = 40;
-        function capX() { return x; }
-        x = 30;
-    }
-    function baz() {
-        const x = 40;
-        assert(x === 40);
-        function bad() { x = 10; }
-        bad();
-    }
-    function jaz() {
-        const x = 40;
-        assert(x === 40);
-        function bad() { eval("x = 10"); }
-        bad();
-    }
-    function faz() {
-        const x = 40;
-        assert(x === 40);
-        eval("x = 10");
-    }
-    function raz() {
-        const x = 40;
-        assert(x === 40);
-        ;({x} = {x: 20});
-    }
-    function taz() {
-        const x = 40;
-        function capX() { return x; }
-        assert(capX() === 40);
-        ;({x} = {x: 20});
-    }
-    function paz() {
-        const x = 20;
-        const y = x = 20;
-    }
-    for (var i = 0; i < NUM_LOOPS; i++) {
-        shouldThrowInvalidConstAssignment(foo);
-        shouldThrowInvalidConstAssignment(bar);
-        shouldThrowInvalidConstAssignment(baz);
-        shouldThrowInvalidConstAssignment(jaz);
-        shouldThrowInvalidConstAssignment(faz);
-        shouldThrowInvalidConstAssignment(raz);
-        shouldThrowInvalidConstAssignment(taz);
-        shouldThrowInvalidConstAssignment(paz);
-    }
-})();
-
-
-;(function() {
-    function foo() {
-        const x = 40;
-        eval("x = 30;");
-    }
-    function bar() {
-        const x = 20;
-        x += 20;
-    }
-    function baz() {
-        const x = 20;
-        x -= 20;
-    }
-    function taz() {
-        const x = 20;
-        shouldThrowInvalidConstAssignment(function() { x = 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x += 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x -= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x *= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x /= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x >>= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x <<= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x ^= 20; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x++; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { x--; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { ++x; });
-        assert(x === 20);
-        shouldThrowInvalidConstAssignment(function() { --x; });
-        assert(x === 20);
-    }
-    function jaz() {
-        const x = 20;
-        let threw = false;
-        try { x = 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x += 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x -= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x *= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x /= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x >>= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x <<= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x ^= 20; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { x++; } catch(e) { threw = true}
-        assert(threw);
-
-
-        threw = false;
-        try { x--; } catch(e) { threw = true}
-        assert(threw);
-
-
-        threw = false;
-        try { ++x; } catch(e) { threw = true}
-        assert(threw);
-
-        threw = false;
-        try { --x; } catch(e) { threw = true};
-        assert(threw);
-    }
-    for (var i = 0; i < NUM_LOOPS; i++) {
-        shouldThrowInvalidConstAssignment(foo);
-        shouldThrowInvalidConstAssignment(bar);
-        shouldThrowInvalidConstAssignment(baz);
-        taz();
-        jaz();
-    }
-})();

implementation-contributed/javascriptcore/stress/const-tdz.js

@@ -1,450 +0,0 @@
-"use strict";
-
-function truth() {
-    return true;
-}
-noInline(truth);
-
-function assert(cond) {
-    if (!cond)
-        throw new Error("broke assertion");
-}
-noInline(assert);
-
-function shouldThrowTDZ(func) {
-    var hasThrown = false;
-    try {
-        func();
-    } catch(e) {
-        if (e.name.indexOf("ReferenceError") !== -1)
-            hasThrown = true;
-    }
-    assert(hasThrown);
-}
-noInline(shouldThrowTDZ);
-
-// Test cases
-
-const NUM_LOOPS = 1000;
-const SHORT_LOOPS = 100;
-
-;(function() {
-function foo() {
-    x;
-    const x = 20;
-}
-function bar() {
-    const x = x;
-}
-function baz() {
-    const {x: prop, y: prop2} = {x: prop};
-}
-function jaz() {
-    const {x: prop, y: prop2} = {x: 20, y: prop};
-}
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-    shouldThrowTDZ(baz);
-    shouldThrowTDZ(jaz);
-}
-})();
-
-
-;(function() {
-function foo() {
-    x;
-    const x = 20;
-    function captureX() { return x; }
-}
-function bar() {
-    captureX();
-    const x = 20;
-    function captureX() { return x; }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-}
-})();
-
-
-;(function() {
-function foo() {
-    if (truth()) {
-        const x = 20;
-        assert(x === 20);
-    }
-    x;
-    const x = 20;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-
-;(function() {
-function foo() {
-    if (truth()) {
-        const y = 20;
-        const captureY = function() { return y; }
-        assert(y === 20);
-        x;
-    }
-    const x = 20;
-    const y = 40;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    if (truth()) {
-        const y = 20;
-        const x = 40;
-        const captureAll = function() { return x + y; }
-        assert(y === 20);
-        assert(x === 40);
-        assert(captureAll() === 60);
-    }
-    tdz;
-    const tdz = 20;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    if (truth()) {
-        const y = 20;
-        const x = 40;
-        const captureAll = function() { return x + y + tdz; }
-        assert(y === 20);
-        assert(x === 40);
-    }
-    tdz;
-    const tdz = 20;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    x = 10;
-    const x = 20;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    x = 10;
-    const x = 20;
-    function cap() { return x; }
-}
-function bar() {
-    captureX();
-    const x = 20;
-    function captureX() { return x; }
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-}
-})();
-
-
-;(function() {
-function foo() {
-    if (!truth()) {
-        y;
-        assert(false);
-    }
-    const y = undefined;
-    assert(y === undefined);
-    if (truth()) {
-        x;
-    }
-    const x = undefined;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    eval("x;");
-    const x = 20;
-}
-function bar() {
-    function captureX() { return x; }
-    eval("captureX();");
-    const x = 20;
-}
-function baz() {
-    function captureX() { return x; }
-    function other() { return captureX; }
-    other()();
-    const x = 20;
-}
-
-for (var i = 0; i < SHORT_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-    shouldThrowTDZ(baz);
-}
-})();
-
-
-;(function() {
-function foo() {
-    const y = 40;
-    eval("y; x;");
-    const x = 20;
-}
-
-for (var i = 0; i < 1; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-;(function() {
-function foo() {
-    const x = 20;
-    const y = 40;
-    assert(eval("x;") === 20);
-    if (truth()) {
-        assert(eval("eval('y');") === 40);
-        eval("eval('x');");
-        const x = 40;
-    }
-}
-
-for (var i = 0; i < SHORT_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-}
-})();
-
-
-// FunctionResolveNode
-;(function() {
-function foo() {
-    function captureX() { return x; }
-    x();
-    const x = function() { return 20; };
-}
-
-function bar() {
-    x();
-    let x = function() { return 20; };
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-}
-})();
-
-
-// TypeofResolveNode
-;(function() {
-function foo() {
-    function captureX() { return x; }
-    typeof x;
-    const x = function() { return 20; };
-}
-
-function bar() {
-    typeof x;
-    const x = function() { return 20; };
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-}
-})();
-
-
-// ReadModifyResolveNode
-;(function() {
-function foo() {
-    function captureX() { return x; }
-    x++;
-    const x = 20;
-}
-
-function bar() {
-    x--;
-    const x = 30;
-}
-
-function baz() {
-    x *= 40;
-    const x = 30;
-}
-
-function kaz() {
-    function captureX() { return x; }
-    x /= 20;
-    const x = 20;
-}
-
-function haz() {
-    function captureX() { return x; }
-    --x;
-    const x = 20;
-}
-
-function jaz() {
-    --x;
-    const x = 30;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(bar);
-    shouldThrowTDZ(baz);
-    shouldThrowTDZ(kaz);
-    shouldThrowTDZ(haz);
-    shouldThrowTDZ(jaz);
-}
-})();
-
-
-;(function() {
-function foo(x) {
-    const y = 50;
-    let result = null;
-    switch(x) {
-        case 10:
-            const y = 40;
-            assert(y === 40);
-        case 20:
-            y += 1;
-            assert(y === 41);
-            result = y;
-            break;
-        default:
-            result = x;
-            break;
-    }
-    assert(y === 50);
-    return result;
-}
-function bar(x) {
-    const y = 50;
-    let result = null;
-    switch(x) {
-        case 10:
-            const y = 40;
-            assert(y === 40);
-        case 20:
-            const capY = function() { return y; }
-            y += 1;
-            assert(y === 41);
-            result = y;
-            break;
-        default:
-            result = x;
-            break;
-    }
-    assert(y === 50);
-    return result;
-}
-function baz(x) {
-    const y = 50;
-    let result = null;
-    switch(x) {
-        case 10:
-            const y = 40;
-            assert(y === 40);
-        case 20:
-            let inc = function() { y += 1; }
-            inc();
-            assert(y === 41);
-            result = y;
-            break;
-        default:
-            result = x;
-            break;
-    }
-    assert(y === 50);
-    return result;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(function() { foo(20); });
-    shouldThrowTDZ(function() { bar(20); });
-    shouldThrowTDZ(function() { baz(20); });
-}
-})();
-
-
-;(function() {
-function foo() {
-    [x] = [1];
-    const x = null;
-}
-
-function boo() {
-    [x] = [1];
-    const x = 20;
-    function capX() { return x; }
-}
-
-function bar() {
-    ({a, p: y} = {a: 100, p: 40});
-    const y = 40;
-}
-
-function zar() {
-    ({a, p: y} = {a: 100, p: 40});
-    const y = 10;
-    function capY() { return y; }
-}
-
-function baz() {
-    ({a, p: {y}} = {a: 100, p: {p: {y: 40}}});
-    const y = 100;
-}
-
-function jaz() {
-    ({y} = {});
-    const y = null;
-}
-
-for (var i = 0; i < NUM_LOOPS; i++) {
-    shouldThrowTDZ(foo);
-    shouldThrowTDZ(boo);
-    shouldThrowTDZ(bar);
-    shouldThrowTDZ(zar);
-    shouldThrowTDZ(baz);
-    shouldThrowTDZ(jaz);
-}
-})();