Replace assertThrowsInstanceOf with assert.throws in sm/String

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, ""]) {

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);

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 = [];

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)));
 }
 

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(), "");

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), "");

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)));
 }
 

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");

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)));
 }
 

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)));
 }
 

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.
 

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)

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}"`));