From 7249a18ca0844f306708d7898e3d61e4809cce38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20Bargull?= Date: Wed, 30 Apr 2025 14:15:54 +0200 Subject: [PATCH] Replace assertThrowsInstanceOf with assert.throws in staging/sm --- harness/sm/non262-shell.js | 31 +--------------- .../sm/ArrayBuffer/constructorNotCallable.js | 10 +++--- test/staging/sm/ArrayBuffer/slice-species.js | 4 +-- ...eate-function-parse-before-getprototype.js | 4 +-- .../AsyncGenerators/for-await-bad-syntax.js | 6 ++-- test/staging/sm/Atomics/detached-buffers.js | 36 +++++++++---------- .../sm/DataView/detach-after-construction.js | 2 +- .../sm/DataView/get-set-index-range.js | 18 +++++----- test/staging/sm/Date/to-temporal-instant.js | 10 +++--- test/staging/sm/Date/toISOString-01.js | 4 +-- test/staging/sm/Date/toPrimitive.js | 16 ++++----- test/staging/sm/Date/toString-generic.js | 4 +-- test/staging/sm/Error/AggregateError.js | 4 +-- test/staging/sm/JSON/parse-with-source.js | 6 ++-- .../sm/Map/constructor-iterator-close.js | 2 +- .../sm/Map/constructor-iterator-primitive.js | 2 +- .../sm/Number/20.1.3.2-toExponential.js | 2 +- .../staging/sm/Number/20.1.3.2-toPrecision.js | 2 +- test/staging/sm/Number/20.1.3.3-toFixed.js | 8 ++--- test/staging/sm/Number/numericSeparator.js | 6 ++-- test/staging/sm/WeakMap/symbols.js | 2 +- ...ared-arguments-in-param-expression-eval.js | 16 ++++----- .../keyword-unescaped-requirement.js | 3 +- .../newer-type-functions-caller-arguments.js | 8 ++--- test/staging/sm/extensions/shareddataview.js | 12 +++---- test/staging/sm/fields/unimplemented.js | 16 ++++----- .../lexical-environment/unscopables-const.js | 2 +- .../unscopables-getters.js | 4 +-- .../lexical-environment/unscopables-miss.js | 2 +- .../sm/lexical-environment/unscopables-tdz.js | 2 +- .../literals/numeric/idstart-after-numeric.js | 8 ++--- test/staging/sm/regress/regress-640075.js | 6 ++-- .../staging/sm/strict/primitive-assignment.js | 4 +-- 33 files changed, 116 insertions(+), 146 deletions(-) diff --git a/harness/sm/non262-shell.js b/harness/sm/non262-shell.js index 9ad9b49011..a14a3f1645 100644 --- a/harness/sm/non262-shell.js +++ b/harness/sm/non262-shell.js @@ -5,7 +5,7 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /*--- -defines: [assertThrowsValue, assertThrowsInstanceOfWithMessageCheck, assertThrowsInstanceOf] +defines: [assertThrowsValue] allow_unused: True ---*/ @@ -29,33 +29,4 @@ allow_unused: True throw new Error(fullmsg); }; } - - if (typeof globalThis.assertThrowsInstanceOfWithMessageCheck === 'undefined') { - globalThis.assertThrowsInstanceOfWithMessageCheck = function assertThrowsInstanceOfWithMessageCheck(f, ctor, check, msg) { - var fullmsg; - try { - f(); - } catch (exc) { - if (!(exc instanceof ctor)) - fullmsg = `Assertion failed: expected exception ${ctor.name}, got ${exc}`; - else { - // Do not test error messages - return; - } - } - - if (fullmsg === undefined) - fullmsg = `Assertion failed: expected exception ${ctor.name}, no exception thrown`; - if (msg !== undefined) - fullmsg += " - " + msg; - - throw new Error(fullmsg); - }; - } - - if (typeof globalThis.assertThrowsInstanceOf === 'undefined') { - globalThis.assertThrowsInstanceOf = function assertThrowsInstanceOf(f, ctor, msg) { - assertThrowsInstanceOfWithMessageCheck(f, ctor, _ => true, msg); - }; - } })(); diff --git a/test/staging/sm/ArrayBuffer/constructorNotCallable.js b/test/staging/sm/ArrayBuffer/constructorNotCallable.js index 1a42c0f1d2..5a83507928 100644 --- a/test/staging/sm/ArrayBuffer/constructorNotCallable.js +++ b/test/staging/sm/ArrayBuffer/constructorNotCallable.js @@ -9,9 +9,9 @@ description: | pending esid: pending ---*/ -assertThrowsInstanceOf(() => ArrayBuffer(), TypeError); -assertThrowsInstanceOf(() => ArrayBuffer(1), TypeError); -assertThrowsInstanceOf(() => ArrayBuffer.call(null), TypeError); -assertThrowsInstanceOf(() => ArrayBuffer.apply(null, []), TypeError); -assertThrowsInstanceOf(() => Reflect.apply(ArrayBuffer, null, []), TypeError); +assert.throws(TypeError, () => ArrayBuffer()); +assert.throws(TypeError, () => ArrayBuffer(1)); +assert.throws(TypeError, () => ArrayBuffer.call(null)); +assert.throws(TypeError, () => ArrayBuffer.apply(null, [])); +assert.throws(TypeError, () => Reflect.apply(ArrayBuffer, null, [])); diff --git a/test/staging/sm/ArrayBuffer/slice-species.js b/test/staging/sm/ArrayBuffer/slice-species.js index 70be76d1b9..4de0cbf11d 100644 --- a/test/staging/sm/ArrayBuffer/slice-species.js +++ b/test/staging/sm/ArrayBuffer/slice-species.js @@ -105,7 +105,7 @@ for (let [ctor, answer] of tests) { a.constructor = { [Symbol.species]: species }; - assertThrowsInstanceOf(() => a.slice(8, 16), TypeError); + assert.throws(TypeError, () => a.slice(8, 16)); } // undefined constructor @@ -119,7 +119,7 @@ for (let [ctor, answer] of tests) { for (let ctor of [null, 0, 1.1, true, false, "a", Symbol.iterator]) { a = arr.buffer; a.constructor = ctor; - assertThrowsInstanceOf(() => a.slice(8, 16), TypeError); + assert.throws(TypeError, () => a.slice(8, 16)); } // @@species from different global diff --git a/test/staging/sm/AsyncGenerators/create-function-parse-before-getprototype.js b/test/staging/sm/AsyncGenerators/create-function-parse-before-getprototype.js index 957bca48f0..64e6584755 100644 --- a/test/staging/sm/AsyncGenerators/create-function-parse-before-getprototype.js +++ b/test/staging/sm/AsyncGenerators/create-function-parse-before-getprototype.js @@ -20,9 +20,9 @@ var newTarget = Object.defineProperty(function(){}.bind(), "prototype", { var AsyncGenerator = async function*(){}.constructor; -assertThrowsInstanceOf(() => { +assert.throws(SyntaxError, () => { Reflect.construct(AsyncGenerator, ["@error"], newTarget); -}, SyntaxError); +}); assert.sameValue(getProtoCalled, false); diff --git a/test/staging/sm/AsyncGenerators/for-await-bad-syntax.js b/test/staging/sm/AsyncGenerators/for-await-bad-syntax.js index 300c8d8a38..4b2f66f83a 100644 --- a/test/staging/sm/AsyncGenerators/for-await-bad-syntax.js +++ b/test/staging/sm/AsyncGenerators/for-await-bad-syntax.js @@ -13,10 +13,10 @@ var AsyncGenerator = async function*(){}.constructor; function assertSyntaxError(code) { var functionCode = `async function* f() { ${code} }`; - assertThrowsInstanceOf(() => AsyncGenerator(code), SyntaxError, "AsyncGenerator:" + code); - assertThrowsInstanceOf(() => eval(functionCode), SyntaxError, "eval:" + functionCode); + assert.throws(SyntaxError, () => AsyncGenerator(code), "AsyncGenerator:" + code); + assert.throws(SyntaxError, () => eval(functionCode), "eval:" + functionCode); var ieval = eval; - assertThrowsInstanceOf(() => ieval(functionCode), SyntaxError, "indirect eval:" + functionCode); + assert.throws(SyntaxError, () => ieval(functionCode), "indirect eval:" + functionCode); } assertSyntaxError(`for await (;;) ;`); diff --git a/test/staging/sm/Atomics/detached-buffers.js b/test/staging/sm/Atomics/detached-buffers.js index b0de39120d..9bd62b4c62 100644 --- a/test/staging/sm/Atomics/detached-buffers.js +++ b/test/staging/sm/Atomics/detached-buffers.js @@ -32,71 +32,71 @@ function badValue(ta) { for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.load(ta, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.load(ta, badValue(ta))); } // Atomics.store for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.store(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.store(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.store(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.store(ta, 0, badValue(ta))); } // Atomics.compareExchange for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.compareExchange(ta, badValue(ta), 0, 0), TypeError); - assertThrowsInstanceOf(() => Atomics.compareExchange(ta, 0, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.compareExchange(ta, 0, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.compareExchange(ta, badValue(ta), 0, 0)); + assert.throws(TypeError, () => Atomics.compareExchange(ta, 0, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.compareExchange(ta, 0, 0, badValue(ta))); } // Atomics.exchange for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.exchange(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.exchange(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.exchange(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.exchange(ta, 0, badValue(ta))); } // Atomics.add for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.add(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.add(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.add(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.add(ta, 0, badValue(ta))); } // Atomics.sub for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.sub(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.sub(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.sub(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.sub(ta, 0, badValue(ta))); } // Atomics.and for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.and(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.and(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.and(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.and(ta, 0, badValue(ta))); } // Atomics.or for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.or(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.or(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.or(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.or(ta, 0, badValue(ta))); } // Atomics.xor for (let TA of intArrayConstructors) { let ta = new TA(1); - assertThrowsInstanceOf(() => Atomics.xor(ta, badValue(ta), 0), TypeError); - assertThrowsInstanceOf(() => Atomics.xor(ta, 0, badValue(ta)), TypeError); + assert.throws(TypeError, () => Atomics.xor(ta, badValue(ta), 0)); + assert.throws(TypeError, () => Atomics.xor(ta, 0, badValue(ta))); } diff --git a/test/staging/sm/DataView/detach-after-construction.js b/test/staging/sm/DataView/detach-after-construction.js index c7dfbe2296..efb234fc68 100644 --- a/test/staging/sm/DataView/detach-after-construction.js +++ b/test/staging/sm/DataView/detach-after-construction.js @@ -14,5 +14,5 @@ var bufView = new DataView(buf); $262.detachArrayBuffer(buf); -assertThrowsInstanceOf(() => bufView.getInt8(0), TypeError); +assert.throws(TypeError, () => bufView.getInt8(0)); diff --git a/test/staging/sm/DataView/get-set-index-range.js b/test/staging/sm/DataView/get-set-index-range.js index 8ce2707795..3dcfbcf875 100644 --- a/test/staging/sm/DataView/get-set-index-range.js +++ b/test/staging/sm/DataView/get-set-index-range.js @@ -14,12 +14,12 @@ var view = new DataView(buffer); function check(view) { for (let fun of ['getInt8', 'setInt8', 'getInt16', 'setInt16']) { - assertThrowsInstanceOf(() => view[fun](-10), RangeError); - assertThrowsInstanceOf(() => view[fun](-Infinity), RangeError); - assertThrowsInstanceOf(() => view[fun](Infinity), RangeError); + assert.throws(RangeError, () => view[fun](-10)); + assert.throws(RangeError, () => view[fun](-Infinity)); + assert.throws(RangeError, () => view[fun](Infinity)); - assertThrowsInstanceOf(() => view[fun](Math.pow(2, 53)), RangeError); - assertThrowsInstanceOf(() => view[fun](Math.pow(2, 54)), RangeError); + assert.throws(RangeError, () => view[fun](Math.pow(2, 53))); + assert.throws(RangeError, () => view[fun](Math.pow(2, 54))); } } @@ -38,9 +38,9 @@ if ('$262.detachArrayBuffer' in this) { check(view); - assertThrowsInstanceOf(() => view.getInt8(0), TypeError); - assertThrowsInstanceOf(() => view.setInt8(0, 0), TypeError); - assertThrowsInstanceOf(() => view.getInt8(Math.pow(2, 53) - 1), TypeError); - assertThrowsInstanceOf(() => view.setInt8(Math.pow(2, 53) - 1, 0), TypeError); + assert.throws(TypeError, () => view.getInt8(0)); + assert.throws(TypeError, () => view.setInt8(0, 0)); + assert.throws(TypeError, () => view.getInt8(Math.pow(2, 53) - 1)); + assert.throws(TypeError, () => view.setInt8(Math.pow(2, 53) - 1, 0)); } diff --git a/test/staging/sm/Date/to-temporal-instant.js b/test/staging/sm/Date/to-temporal-instant.js index b2960d40ba..45642bc701 100644 --- a/test/staging/sm/Date/to-temporal-instant.js +++ b/test/staging/sm/Date/to-temporal-instant.js @@ -27,7 +27,7 @@ let minusOne = Temporal.Duration.from({nanoseconds: -1}); //Test invalid date { const invalidDate = new Date(NaN); - assertThrowsInstanceOf(() => invalidDate.toTemporalInstant(), RangeError); + assert.throws(RangeError, () => invalidDate.toTemporalInstant()); } //Test Temporal.Instant properties @@ -62,11 +62,11 @@ let minusOne = Temporal.Duration.from({nanoseconds: -1}); assert.sameValue(max.subtract(one).epochNanoseconds, max.epochNanoseconds - 1n); // Subtracting one from the minimum instant. - assertThrowsInstanceOf(() => min.add(minusOne), RangeError); - assertThrowsInstanceOf(() => min.subtract(one), RangeError); + assert.throws(RangeError, () => min.add(minusOne)); + assert.throws(RangeError, () => min.subtract(one)); // Adding one to the maximum instant. - assertThrowsInstanceOf(() => max.add(one), RangeError); - assertThrowsInstanceOf(() => max.subtract(minusOne), RangeError); + assert.throws(RangeError, () => max.add(one)); + assert.throws(RangeError, () => max.subtract(minusOne)); } diff --git a/test/staging/sm/Date/toISOString-01.js b/test/staging/sm/Date/toISOString-01.js index 43988154ce..fa3cc286c0 100644 --- a/test/staging/sm/Date/toISOString-01.js +++ b/test/staging/sm/Date/toISOString-01.js @@ -49,13 +49,13 @@ var maxDateExtended = utc(+275760, 9, 13, 0, 0, 0, 0); assert.sameValue(maxDateExtended, +8.64e15); assert.sameValue(iso(maxDateExtended - 1), "+275760-09-12T23:59:59.999Z"); assert.sameValue(iso(maxDateExtended ), "+275760-09-13T00:00:00.000Z"); -assertThrowsInstanceOf(() => iso(maxDateExtended + 1), RangeError); +assert.throws(RangeError, () => iso(maxDateExtended + 1)); // Values around minimum date for extended iso format. var minDateExtended = utc(-271821, 4, 20, 0, 0, 0, 0); assert.sameValue(minDateExtended, -8.64e15); -assertThrowsInstanceOf(() => iso(minDateExtended - 1), RangeError); +assert.throws(RangeError, () => iso(minDateExtended - 1)); assert.sameValue(iso(minDateExtended ), "-271821-04-20T00:00:00.000Z"); assert.sameValue(iso(minDateExtended + 1), "-271821-04-20T00:00:00.001Z"); diff --git a/test/staging/sm/Date/toPrimitive.js b/test/staging/sm/Date/toPrimitive.js index ba28fc5298..de01398a54 100644 --- a/test/staging/sm/Date/toPrimitive.js +++ b/test/staging/sm/Date/toPrimitive.js @@ -13,8 +13,8 @@ esid: pending // The toPrimitive method throws if the this value isn't an object. var toPrimitive = Date.prototype[Symbol.toPrimitive]; -assertThrowsInstanceOf(() => toPrimitive.call(undefined, "default"), TypeError); -assertThrowsInstanceOf(() => toPrimitive.call(3, "default"), TypeError); +assert.throws(TypeError, () => toPrimitive.call(undefined, "default")); +assert.throws(TypeError, () => toPrimitive.call(3, "default")); // It doesn't have to be a Date object, though. var obj = { @@ -26,11 +26,11 @@ assert.sameValue(toPrimitive.call(obj, "string"), "str"); assert.sameValue(toPrimitive.call(obj, "default"), "str"); // It throws if the hint argument is missing or not one of the three allowed values. -assertThrowsInstanceOf(() => toPrimitive.call(obj), TypeError); -assertThrowsInstanceOf(() => toPrimitive.call(obj, undefined), TypeError); -assertThrowsInstanceOf(() => toPrimitive.call(obj, "boolean"), TypeError); -assertThrowsInstanceOf(() => toPrimitive.call(obj, ["number"]), TypeError); -assertThrowsInstanceOf(() => toPrimitive.call(obj, {toString() { throw "FAIL"; }}), TypeError); +assert.throws(TypeError, () => toPrimitive.call(obj)); +assert.throws(TypeError, () => toPrimitive.call(obj, undefined)); +assert.throws(TypeError, () => toPrimitive.call(obj, "boolean")); +assert.throws(TypeError, () => toPrimitive.call(obj, ["number"])); +assert.throws(TypeError, () => toPrimitive.call(obj, {toString() { throw "FAIL"; }})); // The next few tests cover the OrdinaryToPrimitive algorithm, specified in // ES6 7.1.1 ToPrimitive(input [, PreferredType]). @@ -61,7 +61,7 @@ assert.sameValue(dateobj[Symbol.toPrimitive]("number"), 15); // If neither is callable, it throws a TypeError. Date.prototype.toString = "ponies"; -assertThrowsInstanceOf(() => dateobj[Symbol.toPrimitive]("default"), TypeError); +assert.throws(TypeError, () => dateobj[Symbol.toPrimitive]("default")); // Surface features. assert.sameValue(toPrimitive.name, "[Symbol.toPrimitive]"); diff --git a/test/staging/sm/Date/toString-generic.js b/test/staging/sm/Date/toString-generic.js index b7d67f9acf..5da7e1cfdd 100644 --- a/test/staging/sm/Date/toString-generic.js +++ b/test/staging/sm/Date/toString-generic.js @@ -17,8 +17,8 @@ var summary = 'Date.prototype.toString is a generic function'; print(BUGNUMBER + ": " + summary); for (var thisValue of [{}, [], /foo/, Date.prototype, new Proxy(new Date(), {})]) - assertThrowsInstanceOf(() => Date.prototype.toString.call(thisValue), TypeError); + assert.throws(TypeError, () => Date.prototype.toString.call(thisValue)); for (var prim of [null, undefined, 0, 1.2, true, false, "foo", Symbol.iterator]) - assertThrowsInstanceOf(() => Date.prototype.toString.call(prim), TypeError); + assert.throws(TypeError, () => Date.prototype.toString.call(prim)); diff --git a/test/staging/sm/Error/AggregateError.js b/test/staging/sm/Error/AggregateError.js index 8defe9194d..8e86516e2b 100644 --- a/test/staging/sm/Error/AggregateError.js +++ b/test/staging/sm/Error/AggregateError.js @@ -19,8 +19,8 @@ assert.sameValue(AggregateError.prototype.name, "AggregateError"); assert.sameValue(AggregateError.prototype.message, ""); // The |errors| argument is mandatory. -assertThrowsInstanceOf(() => new AggregateError(), TypeError); -assertThrowsInstanceOf(() => AggregateError(), TypeError); +assert.throws(TypeError, () => new AggregateError()); +assert.throws(TypeError, () => AggregateError()); // The .errors data property is an array object. { diff --git a/test/staging/sm/JSON/parse-with-source.js b/test/staging/sm/JSON/parse-with-source.js index 354f3fa9be..a26d76a62d 100644 --- a/test/staging/sm/JSON/parse-with-source.js +++ b/test/staging/sm/JSON/parse-with-source.js @@ -102,7 +102,7 @@ esid: pending } assert.sameValue(true, Object.isFrozen(JSON.rawJSON('"shouldBeFrozen"'))); - assertThrowsInstanceOf(() => JSON.rawJSON(), SyntaxError); + assert.throws(SyntaxError, () => JSON.rawJSON()); assertIsRawJson(JSON.rawJSON(1, 2), '1'); })(); @@ -125,9 +125,9 @@ esid: pending assert.sameValue(TypeError !== otherGlobal.TypeError, true); assertErrorComesFromCorrectRealm = (fun, thisRealmType) => { - assertThrowsInstanceOf(() => fun(this), thisRealmType, + assert.throws(thisRealmType, () => fun(this), `${thisRealmType.name} should come from this realm.`); - assertThrowsInstanceOf(() => fun(otherGlobal), otherGlobal[thisRealmType.name], + assert.throws(otherGlobal[thisRealmType.name], () => fun(otherGlobal), `${thisRealmType.name} should come from the other realm.`); } diff --git a/test/staging/sm/Map/constructor-iterator-close.js b/test/staging/sm/Map/constructor-iterator-close.js index 4f83891d50..0ce0d5db73 100644 --- a/test/staging/sm/Map/constructor-iterator-close.js +++ b/test/staging/sm/Map/constructor-iterator-close.js @@ -61,7 +61,7 @@ function test(ctors, { nextVal=undefined, } assert.sameValue(caught, true); } else if (exceptionType) { - assertThrowsInstanceOf(() => new ctor(iterable), exceptionType); + assert.throws(exceptionType, () => new ctor(iterable)); } else { new ctor(iterable); } diff --git a/test/staging/sm/Map/constructor-iterator-primitive.js b/test/staging/sm/Map/constructor-iterator-primitive.js index dbadaf28f8..b123abf265 100644 --- a/test/staging/sm/Map/constructor-iterator-primitive.js +++ b/test/staging/sm/Map/constructor-iterator-primitive.js @@ -37,7 +37,7 @@ for (let ctor of ctors) { return primitive; } }; - assertThrowsInstanceOf(() => new ctor(arg), TypeError); + assert.throws(TypeError, () => new ctor(arg)); } } diff --git a/test/staging/sm/Number/20.1.3.2-toExponential.js b/test/staging/sm/Number/20.1.3.2-toExponential.js index ef2d420a22..1a42e0012a 100644 --- a/test/staging/sm/Number/20.1.3.2-toExponential.js +++ b/test/staging/sm/Number/20.1.3.2-toExponential.js @@ -51,7 +51,7 @@ assertThrowsValue( "hello"); // Not a number throws TypeError -assertThrowsInstanceOf(() => Number.prototype.toExponential.call("Hello"), TypeError); +assert.throws(TypeError, () => Number.prototype.toExponential.call("Hello")); if (typeof assert.sameValue === "function") { } diff --git a/test/staging/sm/Number/20.1.3.2-toPrecision.js b/test/staging/sm/Number/20.1.3.2-toPrecision.js index 4b7cb74238..ec012c560d 100644 --- a/test/staging/sm/Number/20.1.3.2-toPrecision.js +++ b/test/staging/sm/Number/20.1.3.2-toPrecision.js @@ -51,7 +51,7 @@ assertThrowsValue( "hello"); // Not a number throws TypeError -assertThrowsInstanceOf(() => Number.prototype.toPrecision.call("Hello"), TypeError); +assert.throws(TypeError, () => Number.prototype.toPrecision.call("Hello")); if (typeof assert.sameValue === "function") { } diff --git a/test/staging/sm/Number/20.1.3.3-toFixed.js b/test/staging/sm/Number/20.1.3.3-toFixed.js index 017670ec91..98f0da3929 100644 --- a/test/staging/sm/Number/20.1.3.3-toFixed.js +++ b/test/staging/sm/Number/20.1.3.3-toFixed.js @@ -15,9 +15,9 @@ assert.sameValue(Number.prototype.toFixed.call(-Infinity), "-Infinity"); assert.sameValue(Number.prototype.toFixed.call(Infinity), "Infinity"); assert.sameValue(Number.prototype.toFixed.call(NaN), "NaN"); -assertThrowsInstanceOf(() => Number.prototype.toFixed.call(-Infinity, 555), RangeError); -assertThrowsInstanceOf(() => Number.prototype.toFixed.call(Infinity, 555), RangeError); -assertThrowsInstanceOf(() => Number.prototype.toFixed.call(NaN, 555), RangeError); +assert.throws(RangeError, () => Number.prototype.toFixed.call(-Infinity, 555)); +assert.throws(RangeError, () => Number.prototype.toFixed.call(Infinity, 555)); +assert.throws(RangeError, () => Number.prototype.toFixed.call(NaN, 555)); -assertThrowsInstanceOf(() => Number.prototype.toFixed.call("Hello"), TypeError); +assert.throws(TypeError, () => Number.prototype.toFixed.call("Hello")); diff --git a/test/staging/sm/Number/numericSeparator.js b/test/staging/sm/Number/numericSeparator.js index 7f7b8ebfdd..6e3533c9ea 100644 --- a/test/staging/sm/Number/numericSeparator.js +++ b/test/staging/sm/Number/numericSeparator.js @@ -11,7 +11,7 @@ description: | pending esid: pending ---*/ -assertThrowsInstanceOf(function() { eval('let a = 100_00_;'); }, SyntaxError); -assertThrowsInstanceOf(() => eval("let b = 10__;"), SyntaxError); -assertThrowsInstanceOf(() => eval("let b = 1._2;"), SyntaxError); +assert.throws(SyntaxError, function() { eval('let a = 100_00_;'); }); +assert.throws(SyntaxError, () => eval("let b = 10__;")); +assert.throws(SyntaxError, () => eval("let b = 1._2;")); diff --git a/test/staging/sm/WeakMap/symbols.js b/test/staging/sm/WeakMap/symbols.js index 1559d8de93..1b89c050e8 100644 --- a/test/staging/sm/WeakMap/symbols.js +++ b/test/staging/sm/WeakMap/symbols.js @@ -21,7 +21,7 @@ assert.sameValue(m.get(sym), 0); // sym1 will be registered in global Symbol registry hence cannot be used as a // key in WeakMap. var sym1 = Symbol.for("testKey"); -assertThrowsInstanceOf(() => m.set(sym1, 1), TypeError); +assert.throws(TypeError, () => m.set(sym1, 1)); // Well-known symbols can be used as weakmap keys. var sym2 = Symbol.hasInstance; diff --git a/test/staging/sm/eval/redeclared-arguments-in-param-expression-eval.js b/test/staging/sm/eval/redeclared-arguments-in-param-expression-eval.js index c376c5b63c..b40a70ba39 100644 --- a/test/staging/sm/eval/redeclared-arguments-in-param-expression-eval.js +++ b/test/staging/sm/eval/redeclared-arguments-in-param-expression-eval.js @@ -14,13 +14,13 @@ assert.sameValue("arguments" in this, false); // Declare |arguments| when no pre-existing (and explicit) |arguments| bindings are present. function f1(p = eval("var arguments")) {} -assertThrowsInstanceOf(f1, SyntaxError); +assert.throws(SyntaxError, f1); // Declare |arguments| when the function body contains an |arguments| var-binding. function f2(p = eval("var arguments")) { var arguments; } -assertThrowsInstanceOf(f2, SyntaxError); +assert.throws(SyntaxError, f2); // Declare |arguments| when the function body contains an |arguments| function declaration. // @@ -30,7 +30,7 @@ assertThrowsInstanceOf(f2, SyntaxError); function f3(p = eval("var arguments")) { function arguments() {} } -assertThrowsInstanceOf(f3, SyntaxError); +assert.throws(SyntaxError, f3); // Declare |arguments| when the function body contains an |arguments| lexical binding. // @@ -40,15 +40,15 @@ assertThrowsInstanceOf(f3, SyntaxError); function f4(p = eval("var arguments")) { let arguments; } -assertThrowsInstanceOf(f4, SyntaxError); +assert.throws(SyntaxError, f4); // Declare |arguments| when a following parameter is named |arguments|. function f5(p = eval("var arguments"), arguments) {} -assertThrowsInstanceOf(f5, SyntaxError); +assert.throws(SyntaxError, f5); // Declare |arguments| when a preceding parameter is named |arguments|. function f6(arguments, p = eval("var arguments")) {} -assertThrowsInstanceOf(f6, SyntaxError); +assert.throws(SyntaxError, f6); // Repeat the same kind of tests for arrow function. @@ -85,11 +85,11 @@ a4(); // Declare |arguments| when a following parameter is named |arguments|. var a5 = (p = eval("var arguments"), arguments) => {}; -assertThrowsInstanceOf(a5, SyntaxError); +assert.throws(SyntaxError, a5); // Declare |arguments| when a preceding parameter is named |arguments|. var a6 = (arguments, p = eval("var arguments")) => {}; -assertThrowsInstanceOf(a6, SyntaxError); +assert.throws(SyntaxError, a6); // None of the direct eval calls introduced a global |arguments| binding. assert.sameValue("arguments" in this, false); diff --git a/test/staging/sm/extensions/keyword-unescaped-requirement.js b/test/staging/sm/extensions/keyword-unescaped-requirement.js index 0407b5b7e4..97746d53bc 100644 --- a/test/staging/sm/extensions/keyword-unescaped-requirement.js +++ b/test/staging/sm/extensions/keyword-unescaped-requirement.js @@ -39,8 +39,7 @@ var randomExtensions = for (var extension of randomExtensions) { - assertThrowsInstanceOf(() => Function(extension), SyntaxError, - "bad behavior for: " + extension); + assert.throws(SyntaxError, () => Function(extension), "bad behavior for: " + extension); } /******************************************************************************/ diff --git a/test/staging/sm/extensions/newer-type-functions-caller-arguments.js b/test/staging/sm/extensions/newer-type-functions-caller-arguments.js index 7f27ff67a0..3833eb9b97 100644 --- a/test/staging/sm/extensions/newer-type-functions-caller-arguments.js +++ b/test/staging/sm/extensions/newer-type-functions-caller-arguments.js @@ -92,12 +92,12 @@ functions.forEach(f => { }); function checkArgumentsAccess(f) { - assertThrowsInstanceOf(() => f.arguments, TypeError, - `Expected 'arguments' property access to throw on ${f}`); + assert.throws(TypeError, () => f.arguments, + `Expected 'arguments' property access to throw on ${f}`); } function checkCallerAccess(f) { - assertThrowsInstanceOf(() => f.caller, TypeError, - `Expected 'caller' property access to throw on ${f}`); + assert.throws(TypeError, () => f.caller, + `Expected 'caller' property access to throw on ${f}`); } diff --git a/test/staging/sm/extensions/shareddataview.js b/test/staging/sm/extensions/shareddataview.js index a7f53d96dd..a84e80b9bd 100644 --- a/test/staging/sm/extensions/shareddataview.js +++ b/test/staging/sm/extensions/shareddataview.js @@ -36,13 +36,13 @@ assert.sameValue(dv2.getInt8(0), 37); // Test that range checking works -assertThrowsInstanceOf(() => dv.setInt32(4098, -1), RangeError); -assertThrowsInstanceOf(() => dv.setInt32(4094, -1), RangeError); -assertThrowsInstanceOf(() => dv.setInt32(-1, -1), RangeError); +assert.throws(RangeError, () => dv.setInt32(4098, -1)); +assert.throws(RangeError, () => dv.setInt32(4094, -1)); +assert.throws(RangeError, () => dv.setInt32(-1, -1)); -assertThrowsInstanceOf(() => dv2.setInt32(2080, -1), RangeError); -assertThrowsInstanceOf(() => dv2.setInt32(2046, -1), RangeError); -assertThrowsInstanceOf(() => dv2.setInt32(-1, -1), RangeError); +assert.throws(RangeError, () => dv2.setInt32(2080, -1)); +assert.throws(RangeError, () => dv2.setInt32(2046, -1)); +assert.throws(RangeError, () => dv2.setInt32(-1, -1)); } diff --git a/test/staging/sm/fields/unimplemented.js b/test/staging/sm/fields/unimplemented.js index 7d31241b91..607aafbff6 100644 --- a/test/staging/sm/fields/unimplemented.js +++ b/test/staging/sm/fields/unimplemented.js @@ -26,41 +26,41 @@ if (!fieldsEnabled) { let source = `class C { x }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { x = 0; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { 0 = 0; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { [0] = 0; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { "hi" = 0; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { "hi" = 0; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { d = function(){}; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); source = `class C { d = class D { x = 0; }; }`; - assertThrowsInstanceOf(() => Function(source), SyntaxError); + assert.throws(SyntaxError, () => Function(source)); } diff --git a/test/staging/sm/lexical-environment/unscopables-const.js b/test/staging/sm/lexical-environment/unscopables-const.js index 51059d9102..bef8693ea2 100644 --- a/test/staging/sm/lexical-environment/unscopables-const.js +++ b/test/staging/sm/lexical-environment/unscopables-const.js @@ -14,5 +14,5 @@ esid: pending const x = 1; with ({x: 1, [Symbol.unscopables]: {x: true}}) - assertThrowsInstanceOf(() => {x = 2;}, TypeError); + assert.throws(TypeError, () => {x = 2;}); diff --git a/test/staging/sm/lexical-environment/unscopables-getters.js b/test/staging/sm/lexical-environment/unscopables-getters.js index e2d081ca45..184157f0e9 100644 --- a/test/staging/sm/lexical-environment/unscopables-getters.js +++ b/test/staging/sm/lexical-environment/unscopables-getters.js @@ -28,7 +28,7 @@ assert.sameValue(hit1, 1); // It can throw; the exception is propagated out. function Fit() {} with ({x: 0, get [Symbol.unscopables]() { throw new Fit; }}) - assertThrowsInstanceOf(() => x, Fit); + assert.throws(Fit, () => x); // Individual properties on the @@unscopables object can have getters. let hit2 = 0; @@ -47,5 +47,5 @@ assert.sameValue(hit2, 1); // And they can throw. with ({x: 0, [Symbol.unscopables]: {get x() { throw new Fit; }}}) - assertThrowsInstanceOf(() => x, Fit); + assert.throws(Fit, () => x); diff --git a/test/staging/sm/lexical-environment/unscopables-miss.js b/test/staging/sm/lexical-environment/unscopables-miss.js index b02baf9bb3..a8d72fe0bf 100644 --- a/test/staging/sm/lexical-environment/unscopables-miss.js +++ b/test/staging/sm/lexical-environment/unscopables-miss.js @@ -13,5 +13,5 @@ esid: pending // is a ReferenceError. with ({x: 1, [Symbol.unscopables]: {x: true}}) - assertThrowsInstanceOf(() => x, ReferenceError); + assert.throws(ReferenceError, () => x); diff --git a/test/staging/sm/lexical-environment/unscopables-tdz.js b/test/staging/sm/lexical-environment/unscopables-tdz.js index bc11500af4..0cd5bea2f2 100644 --- a/test/staging/sm/lexical-environment/unscopables-tdz.js +++ b/test/staging/sm/lexical-environment/unscopables-tdz.js @@ -12,7 +12,7 @@ esid: pending // Accessing an uninitialized variable due to @@unscopables is still a ReferenceError. with ({x: 1, [Symbol.unscopables]: {x: true}}) - assertThrowsInstanceOf(() => x, ReferenceError); + assert.throws(ReferenceError, () => x); let x; diff --git a/test/staging/sm/literals/numeric/idstart-after-numeric.js b/test/staging/sm/literals/numeric/idstart-after-numeric.js index d18952d0f0..3a16d9a6fa 100644 --- a/test/staging/sm/literals/numeric/idstart-after-numeric.js +++ b/test/staging/sm/literals/numeric/idstart-after-numeric.js @@ -15,9 +15,9 @@ var BUGNUMBER = '523401'; var summary = 'numeric literal followed by an identifier'; var array = new Array(); -assertThrowsInstanceOf(() => eval("array[0for]"), SyntaxError); -assertThrowsInstanceOf(() => eval("array[1yield]"), SyntaxError); -assertThrowsInstanceOf(() => eval("array[2in []]"), SyntaxError); // "2 in []" is valid. +assert.throws(SyntaxError, () => eval("array[0for]")); +assert.throws(SyntaxError, () => eval("array[1yield]")); +assert.throws(SyntaxError, () => eval("array[2in []]")); // "2 in []" is valid. assert.sameValue(array[2 in []], undefined); assert.sameValue(2 in [], false); -assertThrowsInstanceOf(() => eval("array[3in]"), SyntaxError); +assert.throws(SyntaxError, () => eval("array[3in]")); diff --git a/test/staging/sm/regress/regress-640075.js b/test/staging/sm/regress/regress-640075.js index 129f119abd..75a99acc8c 100644 --- a/test/staging/sm/regress/regress-640075.js +++ b/test/staging/sm/regress/regress-640075.js @@ -12,8 +12,8 @@ description: | esid: pending ---*/ "use strict"; -assertThrowsInstanceOf( - () => eval("(function() { eval(); function eval() {} })"), - SyntaxError +assert.throws( + SyntaxError, + () => eval("(function() { eval(); function eval() {} })") ) diff --git a/test/staging/sm/strict/primitive-assignment.js b/test/staging/sm/strict/primitive-assignment.js index 941c9016fc..052328d854 100644 --- a/test/staging/sm/strict/primitive-assignment.js +++ b/test/staging/sm/strict/primitive-assignment.js @@ -23,8 +23,8 @@ for (let value of primitives) { assert.sameValue(value.x = 5, 5); assert.sameValue(value[key] = 6, 6); - assertThrowsInstanceOf(function() { "use strict"; value.x = 5; }, TypeError); - assertThrowsInstanceOf(function() { "use strict"; value[key] = 6; }, TypeError); + assert.throws(TypeError, function() { "use strict"; value.x = 5; }); + assert.throws(TypeError, function() { "use strict"; value[key] = 6; }); let target = {}; assert.sameValue(Reflect.set(target, key, 5, value), false);