Replace assertThrowsInstanceOf with assert.throws in sm/async-functions

test/staging/sm/async-functions/async-contains-unicode-escape.js

@@ -24,7 +24,7 @@ function test(code, eval)
   var unescaped = code.replace("###", "async");
   var escaped = code.replace("###", "\\u0061");
 
-  assertThrowsInstanceOf(() => eval(escaped), SyntaxError);
+  assert.throws(SyntaxError, () => eval(escaped));
   eval(unescaped);
 }
 
@@ -42,10 +42,8 @@ test("var x = ### function f() {}", eval);
 if (typeof parseModule === "function")
   test("export default ### function f() {}", parseModule);
 
-assertThrowsInstanceOf(() => eval("async await => 1;"),
+assert.throws(SyntaxError, () => eval("async await => 1;"));
-                       SyntaxError);
+assert.throws(SyntaxError, () => eval("async aw\\u0061it => 1;"));
-assertThrowsInstanceOf(() => eval("async aw\\u0061it => 1;"),
-                       SyntaxError);
 
 var async = 0;
 assert.sameValue(\u0061sync, 0);

test/staging/sm/async-functions/async-property-name-error.js

@@ -10,10 +10,10 @@ description: |
 esid: pending
 ---*/
 function assertSyntaxError(code) {
-    assertThrowsInstanceOf(() => { Function(code); }, SyntaxError, "Function:" + code);
+    assert.throws(SyntaxError, () => { Function(code); }, "Function:" + code);
-    assertThrowsInstanceOf(() => { eval(code); }, SyntaxError, "eval:" + code);
+    assert.throws(SyntaxError, () => { eval(code); }, "eval:" + code);
     var ieval = eval;
-    assertThrowsInstanceOf(() => { ieval(code); }, SyntaxError, "indirect eval:" + code);
+    assert.throws(SyntaxError, () => { ieval(code); }, "indirect eval:" + code);
 }
 
 assertSyntaxError(`({async async: 0})`);

test/staging/sm/async-functions/await-in-arrow-parameters.js

@@ -30,14 +30,14 @@ function assertSyntaxError(kind, code) {
     var body = toSourceBody(code);
     var parameter = toSourceParameter(code);
 
-    assertThrowsInstanceOf(() => { constructor(code); }, SyntaxError, constructor.name + ":" + code);
+    assert.throws(SyntaxError, () => { constructor(code); }, constructor.name + ":" + code);
-    assertThrowsInstanceOf(() => { constructor(`x = ${code}`, ""); }, SyntaxError, constructor.name + ":" + code);
+    assert.throws(SyntaxError, () => { constructor(`x = ${code}`, ""); }, constructor.name + ":" + code);
 
-    assertThrowsInstanceOf(() => { eval(body); }, SyntaxError, "eval:" + body);
+    assert.throws(SyntaxError, () => { eval(body); }, "eval:" + body);
-    assertThrowsInstanceOf(() => { ieval(body); }, SyntaxError, "indirect eval:" + body);
+    assert.throws(SyntaxError, () => { ieval(body); }, "indirect eval:" + body);
 
-    assertThrowsInstanceOf(() => { eval(parameter); }, SyntaxError, "eval:" + parameter);
+    assert.throws(SyntaxError, () => { eval(parameter); }, "eval:" + parameter);
-    assertThrowsInstanceOf(() => { ieval(parameter); }, SyntaxError, "indirect eval:" + parameter);
+    assert.throws(SyntaxError, () => { ieval(parameter); }, "indirect eval:" + parameter);
 }
 
 function assertNoSyntaxError(kind, code) {

test/staging/sm/async-functions/create-function-parse-before-getprototype.js

@@ -20,9 +20,9 @@ var newTarget = Object.defineProperty(function(){}.bind(), "prototype", {
 
 var AsyncFunction = async function(){}.constructor;
 
-assertThrowsInstanceOf(() => {
+assert.throws(SyntaxError, () => {
     Reflect.construct(AsyncFunction, ["@error"], newTarget);
-}, SyntaxError);
+});
 
 assert.sameValue(getProtoCalled, false);
 

test/staging/sm/async-functions/no-expression-closure.js

@@ -10,10 +10,10 @@ description: |
 esid: pending
 ---*/
 function assertSyntaxError(code) {
-    assertThrowsInstanceOf(function () { Function(code); }, SyntaxError, "Function:" + code);
+    assert.throws(SyntaxError, function () { Function(code); }, "Function:" + code);
-    assertThrowsInstanceOf(function () { eval(code); }, SyntaxError, "eval:" + code);
+    assert.throws(SyntaxError, function () { eval(code); }, "eval:" + code);
     var ieval = eval;
-    assertThrowsInstanceOf(function () { ieval(code); }, SyntaxError, "indirect eval:" + code);
+    assert.throws(SyntaxError, function () { ieval(code); }, "indirect eval:" + code);
 }
 
 // AsyncFunction statement