From 4ecc2dc1d8740af4909d4e4ea83bd969b095d6a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9=20Bargull?= Date: Wed, 30 Apr 2025 14:15:50 +0200 Subject: [PATCH] Replace assertThrowsInstanceOf with assert.throws in sm/PrivateName --- .../sm/PrivateName/error-outside-class.js | 7 ++- .../PrivateName/illegal-in-class-context.js | 5 +- .../illegal-in-identifier-context.js | 48 +++++++++---------- .../PrivateName/illegal-in-object-context.js | 16 +++---- .../sm/PrivateName/lexical-presence.js | 8 ++-- 5 files changed, 41 insertions(+), 43 deletions(-) diff --git a/test/staging/sm/PrivateName/error-outside-class.js b/test/staging/sm/PrivateName/error-outside-class.js index 3bee61c815..156dbefdd8 100644 --- a/test/staging/sm/PrivateName/error-outside-class.js +++ b/test/staging/sm/PrivateName/error-outside-class.js @@ -11,13 +11,12 @@ esid: pending ---*/ // Can't reference a private field without an object -assertThrowsInstanceOf(() => eval('#x'), SyntaxError); +assert.throws(SyntaxError, () => eval('#x')); // Can't reference a private field without an enclosing class -assertThrowsInstanceOf(() => eval('this.#x'), SyntaxError); +assert.throws(SyntaxError, () => eval('this.#x')); // Can't reference a private field in a random function outside a class context -assertThrowsInstanceOf( - () => eval('function foo() { return this.#x'), SyntaxError); +assert.throws(SyntaxError, () => eval('function foo() { return this.#x')); diff --git a/test/staging/sm/PrivateName/illegal-in-class-context.js b/test/staging/sm/PrivateName/illegal-in-class-context.js index 65a26b4466..066fc3544d 100644 --- a/test/staging/sm/PrivateName/illegal-in-class-context.js +++ b/test/staging/sm/PrivateName/illegal-in-class-context.js @@ -10,11 +10,10 @@ description: | esid: pending ---*/ -assertThrowsInstanceOf(() => eval(`class A { #x; #x; }`), SyntaxError); +assert.throws(SyntaxError, () => eval(`class A { #x; #x; }`)); // No computed private fields -assertThrowsInstanceOf( - () => eval(`var x = "foo"; class A { #[x] = 20; }`), SyntaxError); +assert.throws(SyntaxError, () => eval(`var x = "foo"; class A { #[x] = 20; }`)); assert.throws( SyntaxError, diff --git a/test/staging/sm/PrivateName/illegal-in-identifier-context.js b/test/staging/sm/PrivateName/illegal-in-identifier-context.js index f27c7cb82c..33fcccac5d 100644 --- a/test/staging/sm/PrivateName/illegal-in-identifier-context.js +++ b/test/staging/sm/PrivateName/illegal-in-identifier-context.js @@ -13,41 +13,41 @@ esid: pending // Private names can't appear in contexts where plain identifiers are expected. // Private names as binding identifiers. -assertThrowsInstanceOf(() => eval(`var #a;`), SyntaxError); -assertThrowsInstanceOf(() => eval(`let #a;`), SyntaxError); -assertThrowsInstanceOf(() => eval(`const #a = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(`function #a(){}`), SyntaxError); -assertThrowsInstanceOf(() => eval(`function f(#a){}`), SyntaxError); +assert.throws(SyntaxError, () => eval(`var #a;`)); +assert.throws(SyntaxError, () => eval(`let #a;`)); +assert.throws(SyntaxError, () => eval(`const #a = 0;`)); +assert.throws(SyntaxError, () => eval(`function #a(){}`)); +assert.throws(SyntaxError, () => eval(`function f(#a){}`)); // With escape sequences (leading and non-leading case). -assertThrowsInstanceOf(() => eval(String.raw`var #\u0061;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`var #a\u0061;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`let #\u0061;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`let #a\u0061;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`const #\u0061 = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`const #a\u0061 = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`function #\u0061(){}`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`function #a\u0061(){}`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`function f(#\u0061){}`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`function f(#a\u0061){}`), SyntaxError); +assert.throws(SyntaxError, () => eval(String.raw`var #\u0061;`)); +assert.throws(SyntaxError, () => eval(String.raw`var #a\u0061;`)); +assert.throws(SyntaxError, () => eval(String.raw`let #\u0061;`)); +assert.throws(SyntaxError, () => eval(String.raw`let #a\u0061;`)); +assert.throws(SyntaxError, () => eval(String.raw`const #\u0061 = 0;`)); +assert.throws(SyntaxError, () => eval(String.raw`const #a\u0061 = 0;`)); +assert.throws(SyntaxError, () => eval(String.raw`function #\u0061(){}`)); +assert.throws(SyntaxError, () => eval(String.raw`function #a\u0061(){}`)); +assert.throws(SyntaxError, () => eval(String.raw`function f(#\u0061){}`)); +assert.throws(SyntaxError, () => eval(String.raw`function f(#a\u0061){}`)); // Private names as label identifiers. -assertThrowsInstanceOf(() => eval(`#a: ;`), SyntaxError); +assert.throws(SyntaxError, () => eval(`#a: ;`)); // With escape sequences (leading and non-leading case). -assertThrowsInstanceOf(() => eval(String.raw`#\u0061: ;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`#a\u0061: ;`), SyntaxError); +assert.throws(SyntaxError, () => eval(String.raw`#\u0061: ;`)); +assert.throws(SyntaxError, () => eval(String.raw`#a\u0061: ;`)); // Private names as identifier references. -assertThrowsInstanceOf(() => eval(`#a = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(`typeof #a;`), SyntaxError); +assert.throws(SyntaxError, () => eval(`#a = 0;`)); +assert.throws(SyntaxError, () => eval(`typeof #a;`)); // With escape sequences (leading and non-leading case). -assertThrowsInstanceOf(() => eval(String.raw`#\u0061 = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`#a\u0061 = 0;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`typeof #\u0061;`), SyntaxError); -assertThrowsInstanceOf(() => eval(String.raw`typeof #a\u0061;`), SyntaxError); +assert.throws(SyntaxError, () => eval(String.raw`#\u0061 = 0;`)); +assert.throws(SyntaxError, () => eval(String.raw`#a\u0061 = 0;`)); +assert.throws(SyntaxError, () => eval(String.raw`typeof #\u0061;`)); +assert.throws(SyntaxError, () => eval(String.raw`typeof #a\u0061;`)); diff --git a/test/staging/sm/PrivateName/illegal-in-object-context.js b/test/staging/sm/PrivateName/illegal-in-object-context.js index 9082ef33e7..e20ed639eb 100644 --- a/test/staging/sm/PrivateName/illegal-in-object-context.js +++ b/test/staging/sm/PrivateName/illegal-in-object-context.js @@ -12,12 +12,12 @@ esid: pending // Private names aren't valid in object literals. -assertThrowsInstanceOf(() => eval(`var o = {#a: 0};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {#a};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {#a(){}};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {get #a(){}};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {set #a(v){}};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {*#a(v){}};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {async #a(v){}};`), SyntaxError); -assertThrowsInstanceOf(() => eval(`var o = {async *#a(v){}};`), SyntaxError); +assert.throws(SyntaxError, () => eval(`var o = {#a: 0};`)); +assert.throws(SyntaxError, () => eval(`var o = {#a};`)); +assert.throws(SyntaxError, () => eval(`var o = {#a(){}};`)); +assert.throws(SyntaxError, () => eval(`var o = {get #a(){}};`)); +assert.throws(SyntaxError, () => eval(`var o = {set #a(v){}};`)); +assert.throws(SyntaxError, () => eval(`var o = {*#a(v){}};`)); +assert.throws(SyntaxError, () => eval(`var o = {async #a(v){}};`)); +assert.throws(SyntaxError, () => eval(`var o = {async *#a(v){}};`)); diff --git a/test/staging/sm/PrivateName/lexical-presence.js b/test/staging/sm/PrivateName/lexical-presence.js index ecaeda512a..aeb126471a 100644 --- a/test/staging/sm/PrivateName/lexical-presence.js +++ b/test/staging/sm/PrivateName/lexical-presence.js @@ -16,9 +16,9 @@ class A { }; function assertThrowsSyntaxError(str) { - assertThrowsInstanceOf(() => eval(str), SyntaxError); // Direct Eval - assertThrowsInstanceOf(() => (1, eval)(str), SyntaxError); // Indirect Eval - assertThrowsInstanceOf(() => Function(str), SyntaxError); // Function + assert.throws(SyntaxError, () => eval(str)); // Direct Eval + assert.throws(SyntaxError, () => (1, eval)(str)); // Indirect Eval + assert.throws(SyntaxError, () => Function(str)); // Function } assertThrowsSyntaxError(` @@ -55,7 +55,7 @@ function assertNonExisting(fetchCode) { } var a = new X; a.b()` - assertThrowsInstanceOf(() => eval(source), SyntaxError); + assert.throws(SyntaxError, () => eval(source)); } assertNonExisting(`return eval("this.#x")"`);