diff --git a/test/staging/sm/String/IsRegExp.js b/test/staging/sm/String/IsRegExp.js index 0d9e60c2f7..09c115724c 100644 --- a/test/staging/sm/String/IsRegExp.js +++ b/test/staging/sm/String/IsRegExp.js @@ -16,14 +16,14 @@ print(BUGNUMBER + ": " + summary); for (var method of ["startsWith", "endsWith", "includes"]) { for (var re of [/foo/, new RegExp()]) { - assertThrowsInstanceOf(() => "foo"[method](re), TypeError); + assert.throws(TypeError, () => "foo"[method](re)); re[Symbol.match] = false; "foo"[method](re); } for (var v1 of [true, 1, "bar", [], {}, Symbol.iterator]) { - assertThrowsInstanceOf(() => "foo"[method]({ [Symbol.match]: v1 }), TypeError); + assert.throws(TypeError, () => "foo"[method]({ [Symbol.match]: v1 })); } for (var v2 of [false, 0, undefined, ""]) { diff --git a/test/staging/sm/String/codePointAt.js b/test/staging/sm/String/codePointAt.js index 72ba359a32..04d3b93dae 100644 --- a/test/staging/sm/String/codePointAt.js +++ b/test/staging/sm/String/codePointAt.js @@ -77,17 +77,17 @@ assert.sameValue('\uDF06abc'.codePointAt(null), 0xDF06); assert.sameValue('\uDF06abc'.codePointAt(undefined), 0xDF06); (function() { String.prototype.codePointAt.call(undefined); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.call(undefined, 4); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.call(null); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.call(null, 4); }, TypeError); +assert.throws(TypeError, function() { String.prototype.codePointAt.call(undefined, 4); }); +assert.throws(TypeError, function() { String.prototype.codePointAt.call(null); }); +assert.throws(TypeError, function() { String.prototype.codePointAt.call(null, 4); }); assert.sameValue(String.prototype.codePointAt.call(42, 0), 0x34); assert.sameValue(String.prototype.codePointAt.call(42, 1), 0x32); assert.sameValue(String.prototype.codePointAt.call({ 'toString': function() { return 'abc'; } }, 2), 0x63); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.apply(undefined); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.apply(undefined, [4]); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.apply(null); }, TypeError); -assertThrowsInstanceOf(function() { String.prototype.codePointAt.apply(null, [4]); }, TypeError); +assert.throws(TypeError, function() { String.prototype.codePointAt.apply(undefined); }); +assert.throws(TypeError, function() { String.prototype.codePointAt.apply(undefined, [4]); }); +assert.throws(TypeError, function() { String.prototype.codePointAt.apply(null); }); +assert.throws(TypeError, function() { String.prototype.codePointAt.apply(null, [4]); }); assert.sameValue(String.prototype.codePointAt.apply(42, [0]), 0x34); assert.sameValue(String.prototype.codePointAt.apply(42, [1]), 0x32); assert.sameValue(String.prototype.codePointAt.apply({ 'toString': function() { return 'abc'; } }, [2]), 0x63); diff --git a/test/staging/sm/String/fromCodePoint.js b/test/staging/sm/String/fromCodePoint.js index e5d840f865..4ba934eb4b 100644 --- a/test/staging/sm/String/fromCodePoint.js +++ b/test/staging/sm/String/fromCodePoint.js @@ -31,17 +31,17 @@ assert.sameValue(String.fromCodePoint(0x61, 0x62, 0x1D307), 'ab\uD834\uDF07'); assert.sameValue(String.fromCodePoint(false), '\0'); assert.sameValue(String.fromCodePoint(null), '\0'); -assertThrowsInstanceOf(function() { String.fromCodePoint('_'); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint('+Infinity'); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint('-Infinity'); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(-1); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(0x10FFFF + 1); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(3.14); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(3e-2); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(Infinity); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(NaN); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint(undefined); }, RangeError); -assertThrowsInstanceOf(function() { String.fromCodePoint({}); }, RangeError); +assert.throws(RangeError, function() { String.fromCodePoint('_'); }); +assert.throws(RangeError, function() { String.fromCodePoint('+Infinity'); }); +assert.throws(RangeError, function() { String.fromCodePoint('-Infinity'); }); +assert.throws(RangeError, function() { String.fromCodePoint(-1); }); +assert.throws(RangeError, function() { String.fromCodePoint(0x10FFFF + 1); }); +assert.throws(RangeError, function() { String.fromCodePoint(3.14); }); +assert.throws(RangeError, function() { String.fromCodePoint(3e-2); }); +assert.throws(RangeError, function() { String.fromCodePoint(Infinity); }); +assert.throws(RangeError, function() { String.fromCodePoint(NaN); }); +assert.throws(RangeError, function() { String.fromCodePoint(undefined); }); +assert.throws(RangeError, function() { String.fromCodePoint({}); }); var counter = Math.pow(2, 15) * 3 / 2; var result = []; diff --git a/test/staging/sm/String/match-GetMethod.js b/test/staging/sm/String/match-GetMethod.js index abd491c82a..c4bc62f303 100644 --- a/test/staging/sm/String/match-GetMethod.js +++ b/test/staging/sm/String/match-GetMethod.js @@ -33,6 +33,6 @@ for (let v of [null, undefined]) { } for (let v of [1, true, Symbol.iterator, "", {}, []]) { - assertThrowsInstanceOf(() => "a-a".match(create(v)), TypeError); + assert.throws(TypeError, () => "a-a".match(create(v))); } diff --git a/test/staging/sm/String/normalize-parameter.js b/test/staging/sm/String/normalize-parameter.js index fcc2bb9924..8f0a671fc4 100644 --- a/test/staging/sm/String/normalize-parameter.js +++ b/test/staging/sm/String/normalize-parameter.js @@ -15,7 +15,7 @@ var summary = 'String.prototype.normalize - passing wrong parameter'; print(BUGNUMBER + ": " + summary); function test() { - assertThrowsInstanceOf(() => "abc".normalize("NFE"), RangeError, + assert.throws(RangeError, () => "abc".normalize("NFE"), "String.prototype.normalize should raise RangeError on invalid form"); assert.sameValue("".normalize(), ""); diff --git a/test/staging/sm/String/raw.js b/test/staging/sm/String/raw.js index a09b83ad0d..460f3970c7 100644 --- a/test/staging/sm/String/raw.js +++ b/test/staging/sm/String/raw.js @@ -14,12 +14,12 @@ var summary = 'String.raw'; print(BUGNUMBER + ": " + summary); -assertThrowsInstanceOf(function() { String.raw(); }, TypeError); +assert.throws(TypeError, function() { String.raw(); }); assert.sameValue(String.raw.length, 1); var cooked = []; -assertThrowsInstanceOf(function() { String.raw(cooked); }, TypeError); +assert.throws(TypeError, function() { String.raw(cooked); }); cooked.raw = {}; assert.sameValue(String.raw(cooked), ""); diff --git a/test/staging/sm/String/replace-GetMethod.js b/test/staging/sm/String/replace-GetMethod.js index b527b7b250..70e8da35d9 100644 --- a/test/staging/sm/String/replace-GetMethod.js +++ b/test/staging/sm/String/replace-GetMethod.js @@ -28,6 +28,6 @@ for (let v of [null, undefined]) { } for (let v of [1, true, Symbol.iterator, "", {}, []]) { - assertThrowsInstanceOf(() => "a-a".replace(create(v)), TypeError); + assert.throws(TypeError, () => "a-a".replace(create(v))); } diff --git a/test/staging/sm/String/replaceAll.js b/test/staging/sm/String/replaceAll.js index 6180ba7d52..52ba9650ae 100644 --- a/test/staging/sm/String/replaceAll.js +++ b/test/staging/sm/String/replaceAll.js @@ -20,25 +20,25 @@ assert.sameValue(String.prototype.replaceAll.length, 2); assert.sameValue(String.prototype.replaceAll.name, "replaceAll"); // Throws if called with undefined or null. -assertThrowsInstanceOf(() => String.prototype.replaceAll.call(undefined), TypeError); -assertThrowsInstanceOf(() => String.prototype.replaceAll.call(null), TypeError); +assert.throws(TypeError, () => String.prototype.replaceAll.call(undefined)); +assert.throws(TypeError, () => String.prototype.replaceAll.call(null)); // Throws if called with a non-global RegExp. -assertThrowsInstanceOf(() => "".replaceAll(/a/, ""), TypeError); -assertThrowsInstanceOf(() => "".replaceAll(g.RegExp(""), ""), TypeError); +assert.throws(TypeError, () => "".replaceAll(/a/, "")); +assert.throws(TypeError, () => "".replaceAll(g.RegExp(""), "")); // Also throws with RegExp-like objects. -assertThrowsInstanceOf(() => { +assert.throws(TypeError, () => { "".replaceAll({[Symbol.match]: neverCalled, flags: ""}, ""); -}, TypeError); +}); // |flags| property mustn't be undefined or null. -assertThrowsInstanceOf(() => { +assert.throws(TypeError, () => { "".replaceAll({[Symbol.match]: neverCalled, flags: undefined}, ""); -}, TypeError); -assertThrowsInstanceOf(() => { +}); +assert.throws(TypeError, () => { "".replaceAll({[Symbol.match]: neverCalled, flags: null}, ""); -}, TypeError); +}); // Global RegExp (or RegExp-like) simply redirect to @@replace. assert.sameValue("aba".replace(/a/g, "c"), "cbc"); diff --git a/test/staging/sm/String/search-GetMethod.js b/test/staging/sm/String/search-GetMethod.js index 6cf0d3a5d2..86365c7e1e 100644 --- a/test/staging/sm/String/search-GetMethod.js +++ b/test/staging/sm/String/search-GetMethod.js @@ -28,6 +28,6 @@ for (let v of [null, undefined]) { } for (let v of [1, true, Symbol.iterator, "", {}, []]) { - assertThrowsInstanceOf(() => "a-a".search(create(v)), TypeError); + assert.throws(TypeError, () => "a-a".search(create(v))); } diff --git a/test/staging/sm/String/split-GetMethod.js b/test/staging/sm/String/split-GetMethod.js index 0b8771b597..998e32540e 100644 --- a/test/staging/sm/String/split-GetMethod.js +++ b/test/staging/sm/String/split-GetMethod.js @@ -28,6 +28,6 @@ for (let v of [null, undefined]) { } for (let v of [1, true, Symbol.iterator, "", {}, []]) { - assertThrowsInstanceOf(() => "a-a".split(create(v)), TypeError); + assert.throws(TypeError, () => "a-a".split(create(v))); } diff --git a/test/staging/sm/String/string-pad-start-end.js b/test/staging/sm/String/string-pad-start-end.js index 17bb8d1ed9..d6a4492504 100644 --- a/test/staging/sm/String/string-pad-start-end.js +++ b/test/staging/sm/String/string-pad-start-end.js @@ -14,13 +14,13 @@ esid: pending // `this` must be object coercable. for (let badThis of [null, undefined]) { - assertThrowsInstanceOf(() => { + assert.throws(TypeError, () => { String.prototype.padStart.call(badThis, 42, "oups"); - }, TypeError); + }); - assertThrowsInstanceOf(() => { + assert.throws(TypeError, () => { String.prototype.padEnd.call(badThis, 42, "oups"); - }, TypeError); + }); } let proxy = new Proxy({}, { @@ -49,13 +49,13 @@ assert.sameValue("lame", "lame".padEnd(NaN, "foo")); assert.sameValue("lame", "lame".padEnd(-1, "foo")); assert.sameValue("lame", "lame".padEnd({toString: () => 0}, "foo")); -assertThrowsInstanceOf(() => { +assert.throws(TypeError, () => { "lame".padStart(Symbol("9900"), 0); -}, TypeError); +}); -assertThrowsInstanceOf(() => { +assert.throws(TypeError, () => { "lame".padEnd(Symbol("9900"), 0); -}, TypeError); +}); // The fill argument must be string coercable. diff --git a/test/staging/sm/String/thisv-error.js b/test/staging/sm/String/thisv-error.js index 38e335b8bf..ef7344af10 100644 --- a/test/staging/sm/String/thisv-error.js +++ b/test/staging/sm/String/thisv-error.js @@ -26,7 +26,7 @@ function testName(thisv) { if (key === "constructor") { assert.sameValue(String.prototype[key].call(thisv), ""); } else if (failures.includes(key)) { - assertThrowsInstanceOf(() => String.prototype[key].call(thisv), TypeError, key); + assert.throws(TypeError, () => String.prototype[key].call(thisv), key); } else { var expected = `String.prototype.${key} called on incompatible ${thisv}`; assert.throws(TypeError, () => String.prototype[key].call(thisv), expected) diff --git a/test/staging/sm/String/unicode-braced.js b/test/staging/sm/String/unicode-braced.js index 0220218289..b7f0e4dd7f 100644 --- a/test/staging/sm/String/unicode-braced.js +++ b/test/staging/sm/String/unicode-braced.js @@ -55,19 +55,19 @@ assert.sameValue(eval(`"\\u{${"0".repeat(Math.pow(2, 24)) + "1234"}}"`), String. assert.sameValue("\U{0}", "U{0}"); -assertThrowsInstanceOf(() => eval(`"\\u{-1}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{0.0}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{G}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{{"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{110000}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{00110000}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{100000000000000000000000000000}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{ FFFF}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{FFFF }"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{FF FF}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{F F F F}"`), SyntaxError); -assertThrowsInstanceOf(() => eval(`"\\u{100000001}"`), SyntaxError); +assert.throws(SyntaxError, () => eval(`"\\u{-1}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{0.0}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{G}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{{"`)); +assert.throws(SyntaxError, () => eval(`"\\u{"`)); +assert.throws(SyntaxError, () => eval(`"\\u{110000}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{00110000}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{100000000000000000000000000000}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{ FFFF}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{FFFF }"`)); +assert.throws(SyntaxError, () => eval(`"\\u{FF FF}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{F F F F}"`)); +assert.throws(SyntaxError, () => eval(`"\\u{100000001}"`));