Replace assertThrowsInstanceOf with assert.throws in sm/RegExp

test/staging/sm/RegExp/RegExpExec-exec.js

@@ -21,7 +21,6 @@ for (var exec of [null, 0, false, undefined, ""]) {
   RegExp.prototype[Symbol.match].call(re, "foo");
 
   // non-RegExp with non-callable exec
-  assertThrowsInstanceOf(() => RegExp.prototype[Symbol.match].call({ exec }, "foo"),
-                         TypeError);
+  assert.throws(TypeError, () => RegExp.prototype[Symbol.match].call({ exec }, "foo"));
 }
 

test/staging/sm/RegExp/RegExpExec-return.js

@@ -26,7 +26,7 @@ for (var ret of [null, {}, [], /a/]) {
 }
 
 for (ret of [undefined, 1, true, false, Symbol.iterator]) {
-  assertThrowsInstanceOf(() => {
+  assert.throws(TypeError, () => {
     RegExp.prototype[Symbol.match].call({
       get global() {
         return false;
@@ -35,6 +35,6 @@ for (ret of [undefined, 1, true, false, Symbol.iterator]) {
         return ret;
       }
     }, "foo");
-  }, TypeError);
+  });
 }
 

test/staging/sm/RegExp/compile-lastIndex.js

@@ -48,7 +48,7 @@ assert.sameValue(regex.test("FOO"), true);
 assert.sameValue(regex.test("bar"), false);
 assert.sameValue(regex.test("BAR"), false);
 
-assertThrowsInstanceOf(() => regex.compile("bar"), TypeError);
+assert.throws(TypeError, () => regex.compile("bar"));
 
 assert.sameValue(regex.global, false);
 assert.sameValue(regex.ignoreCase, false);
@@ -62,7 +62,7 @@ assert.sameValue(regex.test("FOO"), false);
 assert.sameValue(regex.test("bar"), true);
 assert.sameValue(regex.test("BAR"), false);
 
-assertThrowsInstanceOf(() => regex.compile("^baz", "m"), TypeError);
+assert.throws(TypeError, () => regex.compile("^baz", "m"));
 
 assert.sameValue(regex.global, false);
 assert.sameValue(regex.ignoreCase, false);

test/staging/sm/RegExp/constructor-regexp-unicode.js

@@ -14,5 +14,5 @@ var summary = "RegExp constructor should check the pattern syntax again when add
 
 print(BUGNUMBER + ": " + summary);
 
-assertThrowsInstanceOf(() => RegExp(/\-/, "u"), SyntaxError);
+assert.throws(SyntaxError, () => RegExp(/\-/, "u"));
 

test/staging/sm/RegExp/flag-accessors.js

@@ -46,7 +46,7 @@ function test(obj, expects) {
 
 function testThrowsGeneric(obj) {
   for (var prop of props) {
-    assertThrowsInstanceOf(() => genericGet(obj, prop), TypeError);
+    assert.throws(TypeError, () => genericGet(obj, prop));
   }
 }
 

test/staging/sm/RegExp/flags-param-handling.js

@@ -14,14 +14,14 @@ assert.sameValue(RegExp(/foo/, "gi").flags, "gi");
 assert.sameValue(RegExp(/foo/my, "gi").flags, "gi");
 assert.sameValue(RegExp(/foo/my, "").flags, "");
 assert.sameValue(RegExp(/foo/my, undefined).flags, "my");
-assertThrowsInstanceOf(() => RegExp(/foo/my, null), SyntaxError);
-assertThrowsInstanceOf(() => RegExp(/foo/my, "foo"), SyntaxError);
+assert.throws(SyntaxError, () => RegExp(/foo/my, null));
+assert.throws(SyntaxError, () => RegExp(/foo/my, "foo"));
 
 assert.sameValue(/a/.compile("b", "gi").flags, "gi");
 assert.sameValue(/a/.compile(/b/my).flags, "my");
 assert.sameValue(/a/.compile(/b/my, undefined).flags, "my");
-assertThrowsInstanceOf(() => /a/.compile(/b/my, "gi"), TypeError);
-assertThrowsInstanceOf(() => /a/.compile(/b/my, ""), TypeError);
-assertThrowsInstanceOf(() => /a/.compile(/b/my, null), TypeError);
-assertThrowsInstanceOf(() => /a/.compile(/b/my, "foo"), TypeError);
+assert.throws(TypeError, () => /a/.compile(/b/my, "gi"));
+assert.throws(TypeError, () => /a/.compile(/b/my, ""));
+assert.throws(TypeError, () => /a/.compile(/b/my, null));
+assert.throws(TypeError, () => /a/.compile(/b/my, "foo"));
 

test/staging/sm/RegExp/flags.js

@@ -25,9 +25,9 @@ assert.sameValue(genericFlags({sticky:1, unicode:1, global: 0}), "uy");
 assert.sameValue(genericFlags({__proto__: {multiline: true}}), "m");
 assert.sameValue(genericFlags(new Proxy({}, {get(){return true}})), "dgimsuvy");
 
-assertThrowsInstanceOf(() => genericFlags(), TypeError);
-assertThrowsInstanceOf(() => genericFlags(1), TypeError);
-assertThrowsInstanceOf(() => genericFlags(""), TypeError);
+assert.throws(TypeError, () => genericFlags());
+assert.throws(TypeError, () => genericFlags(1));
+assert.throws(TypeError, () => genericFlags(""));
 
 function genericFlags(obj) {
     return Object.getOwnPropertyDescriptor(RegExp.prototype,"flags").get.call(obj);

test/staging/sm/RegExp/lastIndex-exec.js

@@ -59,7 +59,7 @@ for (let {regExp, lastIndex, input} of testCases) {
     let re = new RegExp(regExp);
     Object.defineProperty(re, "lastIndex", { value: lastIndex, writable: false });
     if (re.global || re.sticky) {
-        assertThrowsInstanceOf(() => re.exec(input), TypeError);
+        assert.throws(TypeError, () => re.exec(input));
     } else {
         re.exec(input);
     }
@@ -79,7 +79,7 @@ for (let {regExp, lastIndex, input} of testCases) {
         }
     };
     if (re.global || re.sticky) {
-        assertThrowsInstanceOf(() => re.exec(input), TypeError);
+        assert.throws(TypeError, () => re.exec(input));
     } else {
         re.exec(input);
     }

test/staging/sm/RegExp/lastIndex-match-or-replace.js

@@ -94,7 +94,7 @@ for (let method of [RegExp.prototype[Symbol.match], RegExp.prototype[Symbol.repl
             let re = new Constructor(regExp);
             Object.defineProperty(re, "lastIndex", { value: lastIndex, writable: false });
             if (re.global || re.sticky) {
-                assertThrowsInstanceOf(() => Reflect.apply(method, re, [input]), TypeError);
+                assert.throws(TypeError, () => Reflect.apply(method, re, [input]));
             } else {
                 Reflect.apply(method, re, [input]);
             }
@@ -114,7 +114,7 @@ for (let method of [RegExp.prototype[Symbol.match], RegExp.prototype[Symbol.repl
                 }
             };
             if (re.sticky) {
-                assertThrowsInstanceOf(() => Reflect.apply(method, re, [input]), TypeError);
+                assert.throws(TypeError, () => Reflect.apply(method, re, [input]));
                 assert.sameValue(called, true);
                 assert.sameValue(re.lastIndex, 9000);
             } else if (re.global) {

test/staging/sm/RegExp/lastIndex-nonwritable.js

@@ -22,13 +22,13 @@ var desc = Object.getOwnPropertyDescriptor(regex, "lastIndex");
 assert.sameValue(desc.writable, false);
 assert.sameValue(desc.value, 0);
 
-assertThrowsInstanceOf(() => regex.test(str), TypeError);
+assert.throws(TypeError, () => regex.test(str));
 
 desc = Object.getOwnPropertyDescriptor(regex, "lastIndex");
 assert.sameValue(desc.writable, false);
 assert.sameValue(desc.value, 0);
 
-assertThrowsInstanceOf(() => regex.exec(str), TypeError);
+assert.throws(TypeError, () => regex.exec(str));
 
 desc = Object.getOwnPropertyDescriptor(regex, "lastIndex");
 assert.sameValue(desc.writable, false);

test/staging/sm/RegExp/lastIndex-search.js

@@ -95,7 +95,7 @@ for (let Constructor of [RegExp, DuckRegExp]) {
     for (let {regExp, lastIndex, input} of testCasesNotPositiveZero) {
         let re = new Constructor(regExp);
         Object.defineProperty(re, "lastIndex", { value: lastIndex, writable: false });
-        assertThrowsInstanceOf(() => re[Symbol.search](input), TypeError);
+        assert.throws(TypeError, () => re[Symbol.search](input));
         assert.sameValue(re.lastIndex, lastIndex);
     }
 
@@ -104,7 +104,7 @@ for (let Constructor of [RegExp, DuckRegExp]) {
         let re = new Constructor(regExp);
         Object.defineProperty(re, "lastIndex", { value: lastIndex, writable: false });
         if (re.global || re.sticky) {
-            assertThrowsInstanceOf(() => re[Symbol.search](input), TypeError);
+            assert.throws(TypeError, () => re[Symbol.search](input));
         } else {
             re[Symbol.search](input);
         }

test/staging/sm/RegExp/match-this.js

@@ -15,7 +15,6 @@ var summary = "RegExp.prototype[@@match] should check this value.";
 print(BUGNUMBER + ": " + summary);
 
 for (var v of [null, 1, true, undefined, "", Symbol.iterator]) {
-  assertThrowsInstanceOf(() => RegExp.prototype[Symbol.match].call(v),
-                         TypeError);
+  assert.throws(TypeError, () => RegExp.prototype[Symbol.match].call(v));
 }
 

test/staging/sm/RegExp/prototype.js

@@ -40,7 +40,7 @@ assert.sameValue(getter("unicode"), undefined);
 assert.sameValue(t.toString(), "/(?:)/");
 
 // The methods don't work with the prototype
-assertThrowsInstanceOf(() => t.compile("b", "i"), TypeError);
-assertThrowsInstanceOf(() => t.test("x"), TypeError);
-assertThrowsInstanceOf(() => t.exec("x"), TypeError);
+assert.throws(TypeError, () => t.compile("b", "i"));
+assert.throws(TypeError, () => t.test("x"));
+assert.throws(TypeError, () => t.exec("x"));
 

test/staging/sm/RegExp/replace-this.js

@@ -15,7 +15,6 @@ var summary = "RegExp.prototype[@@replace] should check |this| value.";
 print(BUGNUMBER + ": " + summary);
 
 for (var v of [null, 1, true, undefined, "", Symbol.iterator]) {
-  assertThrowsInstanceOf(() => RegExp.prototype[Symbol.replace].call(v),
-                         TypeError);
+  assert.throws(TypeError, () => RegExp.prototype[Symbol.replace].call(v));
 }
 

test/staging/sm/RegExp/search-this.js

@@ -15,7 +15,6 @@ var summary = "RegExp.prototype[@@search] should check this value.";
 print(BUGNUMBER + ": " + summary);
 
 for (var v of [null, 1, true, undefined, "", Symbol.iterator]) {
-  assertThrowsInstanceOf(() => RegExp.prototype[Symbol.search].call(v),
-                         TypeError);
+  assert.throws(TypeError, () => RegExp.prototype[Symbol.search].call(v));
 }
 

test/staging/sm/RegExp/source.js

@@ -26,11 +26,11 @@ assert.sameValue(RegExp("/").source, "\\/");
 assert.sameValue(RegExp("\n\r").source, "\\n\\r");
 assert.sameValue(RegExp("\u2028\u2029").source, "\\u2028\\u2029");
 
-assertThrowsInstanceOf(() => genericSource(), TypeError);
-assertThrowsInstanceOf(() => genericSource(1), TypeError);
-assertThrowsInstanceOf(() => genericSource(""), TypeError);
-assertThrowsInstanceOf(() => genericSource({}), TypeError);
-assertThrowsInstanceOf(() => genericSource(new Proxy(/foo/, {get(){ return true; }})), TypeError);
+assert.throws(TypeError, () => genericSource());
+assert.throws(TypeError, () => genericSource(1));
+assert.throws(TypeError, () => genericSource(""));
+assert.throws(TypeError, () => genericSource({}));
+assert.throws(TypeError, () => genericSource(new Proxy(/foo/, {get(){ return true; }})));
 
 function genericSource(obj) {
     return Object.getOwnPropertyDescriptor(RegExp.prototype, "source").get.call(obj);

test/staging/sm/RegExp/split-deleted-flags.js

@@ -16,5 +16,5 @@ print(BUGNUMBER + ": " + summary);
 
 delete RegExp.prototype.flags;
 
-assertThrowsInstanceOf(() => "aaaaa".split(/a/), SyntaxError);
+assert.throws(SyntaxError, () => "aaaaa".split(/a/));
 

test/staging/sm/RegExp/split-this.js

@@ -15,7 +15,6 @@ var summary = "RegExp.prototype[@@split] should check this value.";
 print(BUGNUMBER + ": " + summary);
 
 for (var v of [null, 1, true, undefined, "", Symbol.iterator]) {
-  assertThrowsInstanceOf(() => RegExp.prototype[Symbol.split].call(v),
-                         TypeError);
+  assert.throws(TypeError, () => RegExp.prototype[Symbol.split].call(v));
 }
 

test/staging/sm/RegExp/toString.js

@@ -28,9 +28,9 @@ assert.sameValue(RegExp("\n\r").toString(), "/\\n\\r/");
 assert.sameValue(RegExp("\u2028\u2029").toString(), "/\\u2028\\u2029/");
 assert.sameValue(RegExp("/").toString(), "/\\//");
 
-assertThrowsInstanceOf(() => RegExp.prototype.toString.call(), TypeError);
-assertThrowsInstanceOf(() => RegExp.prototype.toString.call(1), TypeError);
-assertThrowsInstanceOf(() => RegExp.prototype.toString.call(""), TypeError);
+assert.throws(TypeError, () => RegExp.prototype.toString.call());
+assert.throws(TypeError, () => RegExp.prototype.toString.call(1));
+assert.throws(TypeError, () => RegExp.prototype.toString.call(""));
 assert.sameValue(RegExp.prototype.toString.call({}), "/undefined/undefined");
 assert.sameValue(RegExp.prototype.toString.call({ source:"foo", flags:"bar" }), "/foo/bar");
 

test/staging/sm/RegExp/unicode-braced.js

@@ -149,21 +149,21 @@ assert.compareArray(/\u{DC38}/u.exec("A\uDC38"),
 
 // ==== wrong patterns ====
 
-assertThrowsInstanceOf(() => eval(`/\\u{-1}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{0.0}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{G}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{{/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{110000}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{00110000}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{100000000000000000000000000000}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{   FFFF}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{FFFF   }/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{FF   FF}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{F F F F}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u{100000001}/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\u{-1}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{0.0}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{G}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{{/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{110000}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{00110000}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{100000000000000000000000000000}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{   FFFF}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{FFFF   }/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{FF   FF}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{F F F F}/u`));
+assert.throws(SyntaxError, () => eval(`/\\u{100000001}/u`));
 
 // surrogate pair with braced
 assert.sameValue(/\u{D83D}\u{DC38}+/u.exec("\uD83D\uDC38\uDC38"),

test/staging/sm/RegExp/unicode-class-braced.js

@@ -227,19 +227,19 @@ assert.sameValue(/[\u{42}-\u{1F438}]/u.exec("A"),
 
 // ==== wrong patterns ====
 
-assertThrowsInstanceOf(() => eval(`/[\\u{-1}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{0.0}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{G}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{{]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{110000}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{00110000}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{100000000000000000000000000000}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{   FFFF}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{FFFF   }]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{FF   FF}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{F F F F}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u{100000001}]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\u{-1}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{0.0}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{G}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{{]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{110000}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{00110000}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{100000000000000000000000000000}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{   FFFF}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{FFFF   }]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{FF   FF}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{F F F F}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u{100000001}]/u`));
 

test/staging/sm/RegExp/unicode-class-lead-trail.js

@@ -136,16 +136,16 @@ assert.compareArray(/[\uD83DA]*/u.exec("\uD83DAA\uD83D"),
 
 // ==== wrong patterns ====
 
-assertThrowsInstanceOf(() => eval(`/[\\u]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u0]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u00]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u000]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u000G]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\u0.00]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u0]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u00]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u000]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u000G]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\u0.00]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\u]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u0]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u00]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u000]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u000G]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\u0.00]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u0]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u00]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u000]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u000G]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\u0.00]/u`));
 

test/staging/sm/RegExp/unicode-class-range.js

@@ -14,24 +14,24 @@ var summary = "Implement RegExp unicode flag -- disallow range with CharacterCla
 
 print(BUGNUMBER + ": " + summary);
 
-assertThrowsInstanceOf(() => eval(`/[\\w-\\uFFFF]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\W-\\uFFFF]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\d-\\uFFFF]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\D-\\uFFFF]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\s-\\uFFFF]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\S-\\uFFFF]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\w-\\uFFFF]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\W-\\uFFFF]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\d-\\uFFFF]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\D-\\uFFFF]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\s-\\uFFFF]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\S-\\uFFFF]/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\w]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\W]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\d]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\D]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\s]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uFFFF-\\S]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\w]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\W]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\d]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\D]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\s]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uFFFF-\\S]/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\w-\\w]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\W-\\W]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\d-\\d]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\D-\\D]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\s-\\s]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\S-\\S]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\w-\\w]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\W-\\W]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\d-\\d]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\D-\\D]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\s-\\s]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\S-\\S]/u`));
 

test/staging/sm/RegExp/unicode-disallow-extended.js

@@ -18,29 +18,29 @@ print(BUGNUMBER + ": " + summary);
 
 assert.compareArray(/\^\$\\\.\*\+\?\(\)\[\]\{\}\|/u.exec("^$\\.*+?()[]{}|"),
               ["^$\\.*+?()[]{}|"]);
-assertThrowsInstanceOf(() => eval(`/\\A/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\-/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\U{10}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\U0000/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\U0000/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\A/u`));
+assert.throws(SyntaxError, () => eval(`/\\-/u`));
+assert.throws(SyntaxError, () => eval(`/\\U{10}/u`));
+assert.throws(SyntaxError, () => eval(`/\\U0000/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\U0000/u`));
 
 assert.compareArray(/[\^\$\\\.\*\+\?\(\)\[\]\{\}\|]+/u.exec("^$\\.*+?()[]{}|"),
               ["^$\\.*+?()[]{}|"]);
-assertThrowsInstanceOf(() => eval(`/[\\A]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\A]/u`));
 assert.compareArray(/[A\-Z]+/u.exec("a-zABC"),
               ["-"]);
-assertThrowsInstanceOf(() => eval(`/[\\U{10}]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\U0000]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\uD83D\\U0000]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\U{10}]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\U0000]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\uD83D\\U0000]/u`));
 
 // PatternCharacter
-assertThrowsInstanceOf(() => eval(`/{}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/{/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/{0}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/{1,}/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/{1,2}/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/{}/u`));
+assert.throws(SyntaxError, () => eval(`/{/u`));
+assert.throws(SyntaxError, () => eval(`/}/u`));
+assert.throws(SyntaxError, () => eval(`/]/u`));
+assert.throws(SyntaxError, () => eval(`/{0}/u`));
+assert.throws(SyntaxError, () => eval(`/{1,}/u`));
+assert.throws(SyntaxError, () => eval(`/{1,2}/u`));
 
 // QuantifiableAssertion
 assert.compareArray(/.B(?=A)/u.exec("cBaCBA"),
@@ -52,8 +52,8 @@ assert.compareArray(/.B(?:A)/u.exec("cBaCBA"),
 assert.compareArray(/.B(A)/u.exec("cBaCBA"),
               ["CBA", "A"]);
 
-assertThrowsInstanceOf(() => eval(`/.B(?=A)+/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/.B(?!A)+/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/.B(?=A)+/u`));
+assert.throws(SyntaxError, () => eval(`/.B(?!A)+/u`));
 assert.compareArray(/.B(?:A)+/u.exec("cBaCBA"),
               ["CBA"]);
 assert.compareArray(/.B(A)+/u.exec("cBaCBA"),
@@ -78,31 +78,31 @@ assert.compareArray(/[\ca]/u.exec("\u0001"),
 assert.compareArray(/[\cz]/u.exec("\u001a"),
               ["\u001a"]);
 
-assertThrowsInstanceOf(() => eval(`/\\c/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\c1/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\c_/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\c/u`));
+assert.throws(SyntaxError, () => eval(`/\\c1/u`));
+assert.throws(SyntaxError, () => eval(`/\\c_/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\c]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\c1]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\c_]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\c]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\c1]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\c_]/u`));
 
 // HexEscapeSequence
-assertThrowsInstanceOf(() => eval(`/\\x/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\x0/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\x1/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\x1G/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\x/u`));
+assert.throws(SyntaxError, () => eval(`/\\x0/u`));
+assert.throws(SyntaxError, () => eval(`/\\x1/u`));
+assert.throws(SyntaxError, () => eval(`/\\x1G/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\x]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\x0]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\x1]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\x1G]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\x]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\x0]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\x1]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\x1G]/u`));
 
 // LegacyOctalEscapeSequence
-assertThrowsInstanceOf(() => eval(`/\\52/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\052/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\52/u`));
+assert.throws(SyntaxError, () => eval(`/\\052/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\52]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\052]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\52]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\052]/u`));
 
 // DecimalEscape
 assert.compareArray(/\0/u.exec("\0"),
@@ -118,31 +118,31 @@ assert.compareArray(/(A.)\1/u.exec("ABACABAB"),
 assert.compareArray(/(A.)(B.)(C.)(D.)(E.)(F.)(G.)(H.)(I.)(J.)(K.)\10/u.exec("A1B2C3D4E5F6G7H8I9JaKbJa"),
               ["A1B2C3D4E5F6G7H8I9JaKbJa", "A1", "B2", "C3", "D4", "E5", "F6", "G7", "H8", "I9", "Ja", "Kb"]);
 
-assertThrowsInstanceOf(() => eval(`/\\00/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\01/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\09/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\1/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\2/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\3/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\4/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\5/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\6/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\7/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\8/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\9/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\10/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\00/u`));
+assert.throws(SyntaxError, () => eval(`/\\01/u`));
+assert.throws(SyntaxError, () => eval(`/\\09/u`));
+assert.throws(SyntaxError, () => eval(`/\\1/u`));
+assert.throws(SyntaxError, () => eval(`/\\2/u`));
+assert.throws(SyntaxError, () => eval(`/\\3/u`));
+assert.throws(SyntaxError, () => eval(`/\\4/u`));
+assert.throws(SyntaxError, () => eval(`/\\5/u`));
+assert.throws(SyntaxError, () => eval(`/\\6/u`));
+assert.throws(SyntaxError, () => eval(`/\\7/u`));
+assert.throws(SyntaxError, () => eval(`/\\8/u`));
+assert.throws(SyntaxError, () => eval(`/\\9/u`));
+assert.throws(SyntaxError, () => eval(`/\\10/u`));
 
-assertThrowsInstanceOf(() => eval(`/[\\00]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\01]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\09]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\1]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\2]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\3]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\4]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\5]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\6]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\7]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\8]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\9]/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/[\\10]/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/[\\00]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\01]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\09]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\1]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\2]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\3]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\4]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\5]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\6]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\7]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\8]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\9]/u`));
+assert.throws(SyntaxError, () => eval(`/[\\10]/u`));
 

test/staging/sm/RegExp/unicode-lead-trail.js

@@ -212,16 +212,16 @@ assert.compareArray(/\uD83DA*/u.exec("\uD83DAA"),
 
 // ==== wrong patterns ====
 
-assertThrowsInstanceOf(() => eval(`/\\u/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u0/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u00/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u000/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u000G/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\u0.00/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u0/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u00/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u000/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u000G/u`), SyntaxError);
-assertThrowsInstanceOf(() => eval(`/\\uD83D\\u0.00/u`), SyntaxError);
+assert.throws(SyntaxError, () => eval(`/\\u/u`));
+assert.throws(SyntaxError, () => eval(`/\\u0/u`));
+assert.throws(SyntaxError, () => eval(`/\\u00/u`));
+assert.throws(SyntaxError, () => eval(`/\\u000/u`));
+assert.throws(SyntaxError, () => eval(`/\\u000G/u`));
+assert.throws(SyntaxError, () => eval(`/\\u0.00/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u0/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u00/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u000/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u000G/u`));
+assert.throws(SyntaxError, () => eval(`/\\uD83D\\u0.00/u`));