Replace assertThrowsInstanceOf with assert.throws in sm/Iterator

test/staging/sm/Iterator/constructor-throw-when-called-directly.js

@@ -15,5 +15,5 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(() => new Iterator(), TypeError);
+assert.throws(TypeError, () => new Iterator());
 

test/staging/sm/Iterator/constructor-throw-without-new.js

@@ -15,5 +15,5 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(() => Iterator(), TypeError);
+assert.throws(TypeError, () => Iterator());
 

test/staging/sm/Iterator/from/iterator-not-callable-throws.js

@@ -15,9 +15,9 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(() => Iterator.from({ [Symbol.iterator]: 0 }), TypeError);
-assertThrowsInstanceOf(() => Iterator.from({ [Symbol.iterator]: false }), TypeError);
-assertThrowsInstanceOf(() => Iterator.from({ [Symbol.iterator]: "" }), TypeError);
-assertThrowsInstanceOf(() => Iterator.from({ [Symbol.iterator]: {} }), TypeError);
-assertThrowsInstanceOf(() => Iterator.from({ [Symbol.iterator]: Symbol('') }), TypeError);
+assert.throws(TypeError, () => Iterator.from({ [Symbol.iterator]: 0 }));
+assert.throws(TypeError, () => Iterator.from({ [Symbol.iterator]: false }));
+assert.throws(TypeError, () => Iterator.from({ [Symbol.iterator]: "" }));
+assert.throws(TypeError, () => Iterator.from({ [Symbol.iterator]: {} }));
+assert.throws(TypeError, () => Iterator.from({ [Symbol.iterator]: Symbol('') }));
 

test/staging/sm/Iterator/from/modify-return.js

@@ -25,7 +25,7 @@ assert.sameValue(done, true);
 assert.sameValue(value, "old return");
 
 iter.return = () => { throw new Error(); };
-assertThrowsInstanceOf(() => wrap.return(), Error);
+assert.throws(Error, () => wrap.return());
 
 iter.return = null;
 let nullResult = wrap.return("return argument ignored");

test/staging/sm/Iterator/from/o-not-object-throws.js

@@ -15,9 +15,9 @@ description: |
   pending
 esid: pending
 ---*/
-assertThrowsInstanceOf(() => Iterator.from(undefined), TypeError);
-assertThrowsInstanceOf(() => Iterator.from(null), TypeError);
-assertThrowsInstanceOf(() => Iterator.from(0), TypeError);
-assertThrowsInstanceOf(() => Iterator.from(false), TypeError);
-assertThrowsInstanceOf(() => Iterator.from(Symbol('')), TypeError);
+assert.throws(TypeError, () => Iterator.from(undefined));
+assert.throws(TypeError, () => Iterator.from(null));
+assert.throws(TypeError, () => Iterator.from(0));
+assert.throws(TypeError, () => Iterator.from(false));
+assert.throws(TypeError, () => Iterator.from(Symbol('')));
 

test/staging/sm/Iterator/from/wrap-functions-on-other-global.js

@@ -35,5 +35,5 @@ const otherWrap = otherGlobal.Iterator.from(iter);
 checkIterResult(thisWrap.next.call(otherWrap), false, 0);
 checkIterResult(thisWrap.next.call(otherWrap, 'value'), false, 0);
 
-assertThrowsInstanceOf(thisWrap.return.bind(otherWrap), TestError);
+assert.throws(TestError, thisWrap.return.bind(otherWrap));
 

test/staging/sm/Iterator/from/wrap-method-with-non-wrap-this-throws.js

@@ -26,29 +26,29 @@ class TestIterator {
 }
 
 const nextMethod = Iterator.from(new TestIterator()).next;
-assertThrowsInstanceOf(() => nextMethod.call(undefined), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call(null), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call(0), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call(false), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call('test'), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call(Object(1)), TypeError);
-assertThrowsInstanceOf(() => nextMethod.call({}), TypeError);
+assert.throws(TypeError, () => nextMethod.call(undefined));
+assert.throws(TypeError, () => nextMethod.call(null));
+assert.throws(TypeError, () => nextMethod.call(0));
+assert.throws(TypeError, () => nextMethod.call(false));
+assert.throws(TypeError, () => nextMethod.call('test'));
+assert.throws(TypeError, () => nextMethod.call(Object(1)));
+assert.throws(TypeError, () => nextMethod.call({}));
 
 const returnMethod = Iterator.from(new TestIterator()).next;
-assertThrowsInstanceOf(() => returnMethod.call(undefined), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call(null), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call(0), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call(false), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call('test'), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call(Object(1)), TypeError);
-assertThrowsInstanceOf(() => returnMethod.call({}), TypeError);
+assert.throws(TypeError, () => returnMethod.call(undefined));
+assert.throws(TypeError, () => returnMethod.call(null));
+assert.throws(TypeError, () => returnMethod.call(0));
+assert.throws(TypeError, () => returnMethod.call(false));
+assert.throws(TypeError, () => returnMethod.call('test'));
+assert.throws(TypeError, () => returnMethod.call(Object(1)));
+assert.throws(TypeError, () => returnMethod.call({}));
 
 const throwMethod = Iterator.from(new TestIterator()).next;
-assertThrowsInstanceOf(() => throwMethod.call(undefined), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call(null), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call(0), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call(false), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call('test'), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call(Object(1)), TypeError);
-assertThrowsInstanceOf(() => throwMethod.call({}), TypeError);
+assert.throws(TypeError, () => throwMethod.call(undefined));
+assert.throws(TypeError, () => throwMethod.call(null));
+assert.throws(TypeError, () => throwMethod.call(0));
+assert.throws(TypeError, () => throwMethod.call(false));
+assert.throws(TypeError, () => throwMethod.call('test'));
+assert.throws(TypeError, () => throwMethod.call(Object(1)));
+assert.throws(TypeError, () => throwMethod.call({}));
 

test/staging/sm/Iterator/prototype/every/check-fn-after-getting-iterator.js

@@ -28,7 +28,7 @@ class TestIterator extends Iterator {
 }
 
 const iter = new Proxy(new TestIterator(), handlerProxy);
-assertThrowsInstanceOf(() => iter.every(1), TypeError);
+assert.throws(TypeError, () => iter.every(1));
 
 assert.compareArray(
   log,

test/staging/sm/Iterator/prototype/every/error-from-correct-realm.js

@@ -19,10 +19,10 @@ assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.every(), TypeError);
-assertThrowsInstanceOf(
-  otherGlobal.Iterator.prototype.every.bind(iter),
+assert.throws(TypeError, () => iter.every());
+assert.throws(
   otherGlobal.TypeError,
+  otherGlobal.Iterator.prototype.every.bind(iter),
   'TypeError comes from the realm of the method.',
 );
 

test/staging/sm/Iterator/prototype/every/fn-not-callable-throws.js

@@ -16,12 +16,12 @@ esid: pending
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.every(), TypeError);
-assertThrowsInstanceOf(() => iter.every(undefined), TypeError);
-assertThrowsInstanceOf(() => iter.every(null), TypeError);
-assertThrowsInstanceOf(() => iter.every(0), TypeError);
-assertThrowsInstanceOf(() => iter.every(false), TypeError);
-assertThrowsInstanceOf(() => iter.every(''), TypeError);
-assertThrowsInstanceOf(() => iter.every(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => iter.every({}), TypeError);
+assert.throws(TypeError, () => iter.every());
+assert.throws(TypeError, () => iter.every(undefined));
+assert.throws(TypeError, () => iter.every(null));
+assert.throws(TypeError, () => iter.every(0));
+assert.throws(TypeError, () => iter.every(false));
+assert.throws(TypeError, () => iter.every(''));
+assert.throws(TypeError, () => iter.every(Symbol('')));
+assert.throws(TypeError, () => iter.every({}));
 

test/staging/sm/Iterator/prototype/every/fn-throws-close-iterator.js

@@ -29,6 +29,6 @@ const fn = () => { throw new Error(); };
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.every(fn), Error);
+assert.throws(Error, () => iter.every(fn));
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/every/next-throws-iterator-not-closed.js

@@ -29,6 +29,6 @@ const fn = () => {};
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.every(fn), Error);
+assert.throws(Error, () => iter.every(fn));
 assert.sameValue(iter.closed, false);
 

test/staging/sm/Iterator/prototype/every/this-not-iterator-throws.js

@@ -15,7 +15,7 @@ esid: pending
 ---*/
 
 const fn = x => x;
-assertThrowsInstanceOf(Iterator.prototype.every.bind(undefined, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.every.bind({}, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.every.bind({next: 0}, fn), TypeError);
+assert.throws(TypeError, Iterator.prototype.every.bind(undefined, fn));
+assert.throws(TypeError, Iterator.prototype.every.bind({}, fn));
+assert.throws(TypeError, Iterator.prototype.every.bind({next: 0}, fn));
 

test/staging/sm/Iterator/prototype/every/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.every(x => x), TestError);
+assert.throws(TestError, () => iterator.every(x => x));
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');
 

test/staging/sm/Iterator/prototype/find/check-fn-after-getting-iterator.js

@@ -28,7 +28,7 @@ class TestIterator extends Iterator {
 }
 
 const iter = new Proxy(new TestIterator(), handlerProxy);
-assertThrowsInstanceOf(() => iter.find(1), TypeError);
+assert.throws(TypeError, () => iter.find(1));
 
 assert.compareArray(
   log,

test/staging/sm/Iterator/prototype/find/error-from-correct-realm.js

@@ -19,10 +19,10 @@ assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.find(), TypeError);
-assertThrowsInstanceOf(
-  otherGlobal.Iterator.prototype.find.bind(iter),
+assert.throws(TypeError, () => iter.find());
+assert.throws(
   otherGlobal.TypeError,
+  otherGlobal.Iterator.prototype.find.bind(iter),
   'TypeError comes from the realm of the method.',
 );
 

test/staging/sm/Iterator/prototype/find/fn-not-callable-throws.js

@@ -16,12 +16,12 @@ esid: pending
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.find(), TypeError);
-assertThrowsInstanceOf(() => iter.find(undefined), TypeError);
-assertThrowsInstanceOf(() => iter.find(null), TypeError);
-assertThrowsInstanceOf(() => iter.find(0), TypeError);
-assertThrowsInstanceOf(() => iter.find(false), TypeError);
-assertThrowsInstanceOf(() => iter.find(''), TypeError);
-assertThrowsInstanceOf(() => iter.find(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => iter.find({}), TypeError);
+assert.throws(TypeError, () => iter.find());
+assert.throws(TypeError, () => iter.find(undefined));
+assert.throws(TypeError, () => iter.find(null));
+assert.throws(TypeError, () => iter.find(0));
+assert.throws(TypeError, () => iter.find(false));
+assert.throws(TypeError, () => iter.find(''));
+assert.throws(TypeError, () => iter.find(Symbol('')));
+assert.throws(TypeError, () => iter.find({}));
 

test/staging/sm/Iterator/prototype/find/fn-throws-close-iterator.js

@@ -29,6 +29,6 @@ const fn = (value) => { throw new Error(); };
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.find(fn), Error);
+assert.throws(Error, () => iter.find(fn));
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/find/next-throws-iterator-not-closed.js

@@ -29,6 +29,6 @@ const fn = x => x;
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.find(fn), Error);
+assert.throws(Error, () => iter.find(fn));
 assert.sameValue(iter.closed, false);
 

test/staging/sm/Iterator/prototype/find/this-not-iterator-throws.js

@@ -15,7 +15,7 @@ esid: pending
 ---*/
 
 const fn = x => x;
-assertThrowsInstanceOf(Iterator.prototype.find.bind(undefined, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.find.bind({}, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.find.bind({next: 0}, fn), TypeError);
+assert.throws(TypeError, Iterator.prototype.find.bind(undefined, fn));
+assert.throws(TypeError, Iterator.prototype.find.bind({}, fn));
+assert.throws(TypeError, Iterator.prototype.find.bind({next: 0}, fn));
 

test/staging/sm/Iterator/prototype/find/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.find(x => x), TestError);
+assert.throws(TestError, () => iterator.find(x => x));
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');
 

test/staging/sm/Iterator/prototype/flatMap/close-iterator-when-inner-complete-throws.js

@@ -44,6 +44,6 @@ const iter = new TestIterator();
 const mapped = iter.flatMap(x => new InnerIterator());
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => mapped.next(), TestError);
+assert.throws(TestError, () => mapped.next());
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/flatMap/close-iterator-when-inner-next-throws.js

@@ -40,6 +40,6 @@ const iter = new TestIterator();
 const mapped = iter.flatMap(x => new InnerIterator());
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => mapped.next(), TestError);
+assert.throws(TestError, () => mapped.next());
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/flatMap/close-iterator-when-inner-value-throws.js

@@ -47,6 +47,6 @@ const iter = new TestIterator();
 const mapped = iter.flatMap(x => new InnerIterator());
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => mapped.next(), TestError);
+assert.throws(TestError, () => mapped.next());
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/flatMap/throw-when-inner-not-iterable.js

@@ -50,7 +50,7 @@ for (const value of nonIterables) {
   const mapped = iter.flatMap(x => value);
 
   assert.sameValue(iter.closed, false);
-  assertThrowsInstanceOf(() => mapped.next(), TypeError);
+  assert.throws(TypeError, () => mapped.next());
   assert.sameValue(iter.closed, true);
 }
 

test/staging/sm/Iterator/prototype/forEach/check-fn-after-getting-iterator.js

@@ -28,7 +28,7 @@ class TestIterator extends Iterator {
 }
 
 const iter = new Proxy(new TestIterator(), handlerProxy);
-assertThrowsInstanceOf(() => iter.forEach(1), TypeError);
+assert.throws(TypeError, () => iter.forEach(1));
 
 assert.compareArray(
   log,

test/staging/sm/Iterator/prototype/forEach/error-from-correct-realm.js

@@ -19,10 +19,10 @@ assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.forEach(), TypeError);
-assertThrowsInstanceOf(
-  otherGlobal.Iterator.prototype.forEach.bind(iter),
+assert.throws(TypeError, () => iter.forEach(), TypeError);
+assert.throws(
   otherGlobal.TypeError,
+  otherGlobal.Iterator.prototype.forEach.bind(iter),
   'TypeError comes from the realm of the method.',
 );
 

test/staging/sm/Iterator/prototype/forEach/fn-not-callable-throws.js

@@ -16,12 +16,12 @@ esid: pending
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.forEach(), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(undefined), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(null), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(0), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(false), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(''), TypeError);
-assertThrowsInstanceOf(() => iter.forEach(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => iter.forEach({}), TypeError);
+assert.throws(TypeError, () => iter.forEach());
+assert.throws(TypeError, () => iter.forEach(undefined));
+assert.throws(TypeError, () => iter.forEach(null));
+assert.throws(TypeError, () => iter.forEach(0));
+assert.throws(TypeError, () => iter.forEach(false));
+assert.throws(TypeError, () => iter.forEach(''));
+assert.throws(TypeError, () => iter.forEach(Symbol('')));
+assert.throws(TypeError, () => iter.forEach({}));
 

test/staging/sm/Iterator/prototype/forEach/fn-throws-close-iterator.js

@@ -29,6 +29,6 @@ const fn = () => { throw new Error(); };
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.forEach(fn), Error);
+assert.throws(Error, () => iter.forEach(fn));
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/forEach/next-throws-iterator-not-closed.js

@@ -29,6 +29,6 @@ const fn = () => {};
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.forEach(fn), Error);
+assert.throws(Error, () => iter.forEach(fn));
 assert.sameValue(iter.closed, false);
 

test/staging/sm/Iterator/prototype/forEach/this-not-iterator-throws.js

@@ -15,7 +15,7 @@ esid: pending
 ---*/
 
 const fn = x => x;
-assertThrowsInstanceOf(Iterator.prototype.forEach.bind(undefined, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.forEach.bind({}, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.forEach.bind({next: 0}, fn), TypeError);
+assert.throws(TypeError, Iterator.prototype.forEach.bind(undefined, fn));
+assert.throws(TypeError, Iterator.prototype.forEach.bind({}, fn));
+assert.throws(TypeError, Iterator.prototype.forEach.bind({next: 0}, fn));
 

test/staging/sm/Iterator/prototype/forEach/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.forEach(x => x), TestError);
+assert.throws(TestError, () => iterator.forEach(x => x));
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');
 

test/staging/sm/Iterator/prototype/generator-methods-throw-on-iterator-helpers.js

@@ -20,7 +20,7 @@ const generatorProto = Object.getPrototypeOf(
 
 const iteratorHelper = [0].values().map(x => x);
 
-assertThrowsInstanceOf(() => generatorProto.next.call(iteratorHelper), TypeError);
-assertThrowsInstanceOf(() => generatorProto.return.call(iteratorHelper), TypeError);
-assertThrowsInstanceOf(() => generatorProto.throw.call(iteratorHelper), TypeError);
+assert.throws(TypeError, () => generatorProto.next.call(iteratorHelper));
+assert.throws(TypeError, () => generatorProto.return.call(iteratorHelper));
+assert.throws(TypeError, () => generatorProto.throw.call(iteratorHelper));
 

test/staging/sm/Iterator/prototype/iterator-helper-methods-throw-on-generators.js

@@ -18,7 +18,7 @@ function *gen() {
   yield 1;
 }
 
-assertThrowsInstanceOf(() => iteratorHelperProto.next.call(gen()), TypeError);
-assertThrowsInstanceOf(() => iteratorHelperProto.return.call(gen()), TypeError);
-assertThrowsInstanceOf(() => iteratorHelperProto.throw.call(gen()), TypeError);
+assert.throws(TypeError, () => iteratorHelperProto.next.call(gen()));
+assert.throws(TypeError, () => iteratorHelperProto.return.call(gen()));
+assert.throws(TypeError, () => iteratorHelperProto.throw.call(gen()));
 

test/staging/sm/Iterator/prototype/lazy-methods-iterator-closed-on-call-throws.js

@@ -41,7 +41,7 @@ const methods = [
 for (const method of methods) {
   const iter = new TestIterator();
   assert.sameValue(iter.closed, false);
-  assertThrowsInstanceOf(() => method(iter).next(), TestError);
+  assert.throws(TestError, () => method(iter).next());
   assert.sameValue(iter.closed, true);
 }
 

test/staging/sm/Iterator/prototype/lazy-methods-iterator-not-closed-on-next-throws.js

@@ -41,7 +41,7 @@ const methods = [
 
 for (const method of methods) {
   assert.sameValue(iterator.closed, false);
-  assertThrowsInstanceOf(() => method(iterator).next(), TestError);
+  assert.throws(TestError, () => method(iterator).next());
   assert.sameValue(iterator.closed, false);
 }
 

test/staging/sm/Iterator/prototype/lazy-methods-iterator-not-closed-on-value-throws.js

@@ -45,7 +45,7 @@ const methods = [
 
 for (const method of methods) {
   assert.sameValue(iterator.closed, false);
-  assertThrowsInstanceOf(() => method(iterator).next(), TestError);
+  assert.throws(TestError, () => method(iterator).next());
   assert.sameValue(iterator.closed, false);
 }
 

test/staging/sm/Iterator/prototype/lazy-methods-reentry-not-close-iterator.js

@@ -27,7 +27,7 @@ for (const method of methods) {
     if (x == 2) {
       // Reenter the currently running generator.
       reentered = true;
-      assertThrowsInstanceOf(() => iterHelper.next(), TypeError);
+      assert.throws(TypeError, () => iterHelper.next());
     }
     return method[1](x);
   });

test/staging/sm/Iterator/prototype/lazy-methods-throw-eagerly-on-non-callable.js

@@ -23,20 +23,20 @@ const methods = [
 ];
 
 for (const method of methods) {
-  assertThrowsInstanceOf(() => method(Iterator.prototype, 0), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, false), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, undefined), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, null), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, ''), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, Symbol('')), TypeError);
-  assertThrowsInstanceOf(() => method(Iterator.prototype, {}), TypeError);
+  assert.throws(TypeError, () => method(Iterator.prototype, 0));
+  assert.throws(TypeError, () => method(Iterator.prototype, false));
+  assert.throws(TypeError, () => method(Iterator.prototype, undefined));
+  assert.throws(TypeError, () => method(Iterator.prototype, null));
+  assert.throws(TypeError, () => method(Iterator.prototype, ''));
+  assert.throws(TypeError, () => method(Iterator.prototype, Symbol('')));
+  assert.throws(TypeError, () => method(Iterator.prototype, {}));
 
-  assertThrowsInstanceOf(() => method([].values(), 0), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), false), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), undefined), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), null), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), ''), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), Symbol('')), TypeError);
-  assertThrowsInstanceOf(() => method([].values(), {}), TypeError);
+  assert.throws(TypeError, () => method([].values(), 0));
+  assert.throws(TypeError, () => method([].values(), false));
+  assert.throws(TypeError, () => method([].values(), undefined));
+  assert.throws(TypeError, () => method([].values(), null));
+  assert.throws(TypeError, () => method([].values(), ''));
+  assert.throws(TypeError, () => method([].values(), Symbol('')));
+  assert.throws(TypeError, () => method([].values(), {}));
 }
 

test/staging/sm/Iterator/prototype/lazy-methods-throw-eagerly-on-non-iterator.js

@@ -25,12 +25,12 @@ const methods = [
 ];
 
 for (const method of methods) {
-  assertThrowsInstanceOf(method(undefined), TypeError);
-  assertThrowsInstanceOf(method(null), TypeError);
-  assertThrowsInstanceOf(method(0), TypeError);
-  assertThrowsInstanceOf(method(false), TypeError);
-  assertThrowsInstanceOf(method(''), TypeError);
-  assertThrowsInstanceOf(method(Symbol('')), TypeError);
+  assert.throws(TypeError, method(undefined));
+  assert.throws(TypeError, method(null));
+  assert.throws(TypeError, method(0));
+  assert.throws(TypeError, method(false));
+  assert.throws(TypeError, method(''));
+  assert.throws(TypeError, method(Symbol('')));
 
   // No error here.
   method({});

test/staging/sm/Iterator/prototype/lazy-methods-throw-next-done-throws.js

@@ -44,7 +44,7 @@ const methods = [
 for (const method of methods) {
   const iterator = new TestIterator();
   assert.sameValue(iterator.closed, false);
-  assertThrowsInstanceOf(() => method(iterator).next(), TestError);
+  assert.throws(TestError, () => method(iterator).next());
   assert.sameValue(iterator.closed, false);
 }
 

test/staging/sm/Iterator/prototype/lazy-methods-throw-next-not-object.js

@@ -40,7 +40,7 @@ for (const method of methods) {
   for (const value of [undefined, null, 0, false, '', Symbol('')]) {
     const iterator = new TestIterator();
     assert.sameValue(iterator.closed, false);
-    assertThrowsInstanceOf(() => method(iterator).next(value), TypeError);
+    assert.throws(TypeError, () => method(iterator).next(value));
     assert.sameValue(iterator.closed, false);
   }
 }

test/staging/sm/Iterator/prototype/lazy-methods-throw-on-reentry.js

@@ -23,6 +23,6 @@ for (const method of methods) {
   const iterMethod = method(iter);
   let iterHelper;
   iterHelper = iterMethod.call(iter, x => iterHelper.next());
-  assertThrowsInstanceOf(() => iterHelper.next(), TypeError);
+  assert.throws(TypeError, () => iterHelper.next());
 }
 

test/staging/sm/Iterator/prototype/map/clobber-symbol.js

@@ -16,7 +16,7 @@ info: |
   Iterator is not enabled unconditionally
 ---*/
 Symbol = undefined;
-assertThrowsInstanceOf(() => Symbol.iterator, TypeError);
+assert.throws(TypeError, () => Symbol.iterator);
 
 const iterator = [0].values();
 assert.sameValue(

test/staging/sm/Iterator/prototype/map/mapper-not-callable-throw.js

@@ -13,24 +13,24 @@ flags:
 ---*/
 //
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(undefined), TypeError);
-assertThrowsInstanceOf(() => [].values().map(undefined), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(undefined));
+assert.throws(TypeError, () => [].values().map(undefined));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(null), TypeError);
-assertThrowsInstanceOf(() => [].values().map(null), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(null));
+assert.throws(TypeError, () => [].values().map(null));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(0), TypeError);
-assertThrowsInstanceOf(() => [].values().map(0), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(0));
+assert.throws(TypeError, () => [].values().map(0));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(false), TypeError);
-assertThrowsInstanceOf(() => [].values().map(false), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(false));
+assert.throws(TypeError, () => [].values().map(false));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map({}), TypeError);
-assertThrowsInstanceOf(() => [].values().map({}), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map({}));
+assert.throws(TypeError, () => [].values().map({}));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(''), TypeError);
-assertThrowsInstanceOf(() => [].values().map(''), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(''));
+assert.throws(TypeError, () => [].values().map(''));
 
-assertThrowsInstanceOf(() => Iterator.prototype.map(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => [].values().map(Symbol('')), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map(Symbol('')));
+assert.throws(TypeError, () => [].values().map(Symbol('')));
 

test/staging/sm/Iterator/prototype/map/reenter-map-generator-from-mapper.js

@@ -21,5 +21,5 @@ function mapper(x) {
 }
 iterator = [0].values().map(mapper);
 
-assertThrowsInstanceOf(iterator.next, TypeError);
+assert.throws(TypeError, iterator.next);
 

test/staging/sm/Iterator/prototype/map/this-not-iterator-throw.js

@@ -15,10 +15,10 @@ flags:
 
 const mapper = (x) => x;
 
-assertThrowsInstanceOf(() => Iterator.prototype.map.call(undefined, mapper), TypeError);
-assertThrowsInstanceOf(() => Iterator.prototype.map.call(null, mapper), TypeError);
-assertThrowsInstanceOf(() => Iterator.prototype.map.call(0, mapper), TypeError);
-assertThrowsInstanceOf(() => Iterator.prototype.map.call(false, mapper), TypeError);
-assertThrowsInstanceOf(() => Iterator.prototype.map.call('', mapper), TypeError);
-assertThrowsInstanceOf(() => Iterator.prototype.map.call(new Symbol(''), mapper), TypeError);
+assert.throws(TypeError, () => Iterator.prototype.map.call(undefined, mapper));
+assert.throws(TypeError, () => Iterator.prototype.map.call(null, mapper));
+assert.throws(TypeError, () => Iterator.prototype.map.call(0, mapper));
+assert.throws(TypeError, () => Iterator.prototype.map.call(false, mapper));
+assert.throws(TypeError, () => Iterator.prototype.map.call('', mapper));
+assert.throws(TypeError, () => Iterator.prototype.map.call(new Symbol(''), mapper));
 

test/staging/sm/Iterator/prototype/map/throw-when-iterator-returns-non-object.js

@@ -18,10 +18,10 @@ const iterator = returnValue => Object.setPrototypeOf({
 }, Iterator.prototype);
 const mapper = x => x;
 
-assertThrowsInstanceOf(() => iterator(undefined).map(mapper).next(), TypeError);
-assertThrowsInstanceOf(() => iterator(null).map(mapper).next(), TypeError);
-assertThrowsInstanceOf(() => iterator(0).map(mapper).next(), TypeError);
-assertThrowsInstanceOf(() => iterator(false).map(mapper).next(), TypeError);
-assertThrowsInstanceOf(() => iterator('').map(mapper).next(), TypeError);
-assertThrowsInstanceOf(() => iterator(Symbol()).map(mapper).next(), TypeError);
+assert.throws(TypeError, () => iterator(undefined).map(mapper).next());
+assert.throws(TypeError, () => iterator(null).map(mapper).next());
+assert.throws(TypeError, () => iterator(0).map(mapper).next());
+assert.throws(TypeError, () => iterator(false).map(mapper).next());
+assert.throws(TypeError, () => iterator('').map(mapper).next());
+assert.throws(TypeError, () => iterator(Symbol()).map(mapper).next());
 

test/staging/sm/Iterator/prototype/reduce/check-fn-after-getting-iterator.js

@@ -28,7 +28,7 @@ class TestIterator extends Iterator {
 }
 
 const iter = new Proxy(new TestIterator(), handlerProxy);
-assertThrowsInstanceOf(() => iter.reduce(1), TypeError);
+assert.throws(TypeError, () => iter.reduce(1));
 
 assert.compareArray(
   log,

test/staging/sm/Iterator/prototype/reduce/empty-iterator-without-initial-value-throws.js

@@ -15,5 +15,5 @@ esid: pending
 ---*/
 
 const iter = [].values();
-assertThrowsInstanceOf(() => iter.reduce((x, y) => x + y), TypeError);
+assert.throws(TypeError, () => iter.reduce((x, y) => x + y));
 

test/staging/sm/Iterator/prototype/reduce/error-from-correct-realm.js

@@ -19,10 +19,10 @@ assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.reduce(), TypeError);
-assertThrowsInstanceOf(
-  otherGlobal.Iterator.prototype.reduce.bind(iter),
+assert.throws(TypeError, () => iter.reduce(), TypeError);
+assert.throws(
   otherGlobal.TypeError,
+  otherGlobal.Iterator.prototype.reduce.bind(iter),
   'TypeError comes from the realm of the method.',
 );
 

test/staging/sm/Iterator/prototype/reduce/iterator-next-return-non-object-throws.js

@@ -28,15 +28,15 @@ class TestIterator extends Iterator {
 const sum = (x, y) => x + y;
 
 let iter = new TestIterator(undefined);
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 iter = new TestIterator(null);
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 iter = new TestIterator(0);
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 iter = new TestIterator(false);
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 iter = new TestIterator('');
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 iter = new TestIterator(Symbol(''));
-assertThrowsInstanceOf(() => iter.reduce(sum), TypeError);
+assert.throws(TypeError, () => iter.reduce(sum));
 

test/staging/sm/Iterator/prototype/reduce/next-throws-iterator-not-closed.js

@@ -29,6 +29,6 @@ const sum = (x, y) => x + y;
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.reduce(sum), Error);
+assert.throws(Error, () => iter.reduce(sum));
 assert.sameValue(iter.closed, false);
 

test/staging/sm/Iterator/prototype/reduce/reducer-not-callable-throws.js

@@ -21,12 +21,12 @@ class TestIterator extends Iterator {
 }
 
 const iter = new TestIterator();
-assertThrowsInstanceOf(() => iter.reduce(), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(undefined), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(null), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(0), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(false), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(''), TypeError);
-assertThrowsInstanceOf(() => iter.reduce(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => iter.reduce({}), TypeError);
+assert.throws(TypeError, () => iter.reduce());
+assert.throws(TypeError, () => iter.reduce(undefined));
+assert.throws(TypeError, () => iter.reduce(null));
+assert.throws(TypeError, () => iter.reduce(0));
+assert.throws(TypeError, () => iter.reduce(false));
+assert.throws(TypeError, () => iter.reduce(''));
+assert.throws(TypeError, () => iter.reduce(Symbol('')));
+assert.throws(TypeError, () => iter.reduce({}));
 

test/staging/sm/Iterator/prototype/reduce/reducer-throws-iterator-closed.js

@@ -29,6 +29,6 @@ const reducer = (x, y) => { throw new Error(); };
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.reduce(reducer), Error);
+assert.throws(Error, () => iter.reduce(reducer));
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/reduce/this-not-iterator-throws.js

@@ -15,7 +15,7 @@ esid: pending
 ---*/
 
 const sum = (x, y) => x + y;
-assertThrowsInstanceOf(Iterator.prototype.reduce.bind(undefined, sum), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.reduce.bind({}, sum), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.reduce.bind({next: 0}, sum), TypeError);
+assert.throws(TypeError, Iterator.prototype.reduce.bind(undefined, sum));
+assert.throws(TypeError, Iterator.prototype.reduce.bind({}, sum));
+assert.throws(TypeError, Iterator.prototype.reduce.bind({next: 0}, sum));
 

test/staging/sm/Iterator/prototype/reduce/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.reduce((x, y) => x + y, 0), TestError);
+assert.throws(TestError, () => iterator.reduce((x, y) => x + y, 0));
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');
 

test/staging/sm/Iterator/prototype/some/check-fn-after-getting-iterator.js

@@ -28,7 +28,7 @@ class TestIterator extends Iterator {
 }
 
 const iter = new Proxy(new TestIterator(), handlerProxy);
-assertThrowsInstanceOf(() => iter.some(1), TypeError);
+assert.throws(TypeError, () => iter.some(1));
 
 assert.compareArray(
   log,

test/staging/sm/Iterator/prototype/some/error-from-correct-realm.js

@@ -19,10 +19,10 @@ assert.sameValue(TypeError !== otherGlobal.TypeError, true);
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.some(), TypeError);
-assertThrowsInstanceOf(
-  otherGlobal.Iterator.prototype.some.bind(iter),
+assert.throws(TypeError, () => iter.some());
+assert.throws(
   otherGlobal.TypeError, 
+  otherGlobal.Iterator.prototype.some.bind(iter),
   'TypeError comes from the realm of the method.',
 );
 

test/staging/sm/Iterator/prototype/some/fn-not-callable-throws.js

@@ -16,12 +16,12 @@ esid: pending
 
 const iter = [].values();
 
-assertThrowsInstanceOf(() => iter.some(), TypeError);
-assertThrowsInstanceOf(() => iter.some(undefined), TypeError);
-assertThrowsInstanceOf(() => iter.some(null), TypeError);
-assertThrowsInstanceOf(() => iter.some(0), TypeError);
-assertThrowsInstanceOf(() => iter.some(false), TypeError);
-assertThrowsInstanceOf(() => iter.some(''), TypeError);
-assertThrowsInstanceOf(() => iter.some(Symbol('')), TypeError);
-assertThrowsInstanceOf(() => iter.some({}), TypeError);
+assert.throws(TypeError, () => iter.some());
+assert.throws(TypeError, () => iter.some(undefined));
+assert.throws(TypeError, () => iter.some(null));
+assert.throws(TypeError, () => iter.some(0));
+assert.throws(TypeError, () => iter.some(false));
+assert.throws(TypeError, () => iter.some(''));
+assert.throws(TypeError, () => iter.some(Symbol('')));
+assert.throws(TypeError, () => iter.some({}));
 

test/staging/sm/Iterator/prototype/some/fn-throws-close-iterator.js

@@ -29,6 +29,6 @@ const fn = () => { throw new Error(); };
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.some(fn), Error);
+assert.throws(Error, () => iter.some(fn));
 assert.sameValue(iter.closed, true);
 

test/staging/sm/Iterator/prototype/some/next-throws-iterator-not-closed.js

@@ -29,6 +29,6 @@ const fn = () => {};
 const iter = new TestIterator();
 
 assert.sameValue(iter.closed, false);
-assertThrowsInstanceOf(() => iter.some(fn), Error);
+assert.throws(Error, () => iter.some(fn));
 assert.sameValue(iter.closed, false);
 

test/staging/sm/Iterator/prototype/some/this-not-iterator-throws.js

@@ -15,7 +15,7 @@ esid: pending
 ---*/
 
 const fn = x => x;
-assertThrowsInstanceOf(Iterator.prototype.some.bind(undefined, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.some.bind({}, fn), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.some.bind({next: 0}, fn), TypeError);
+assert.throws(TypeError, Iterator.prototype.some.bind(undefined, fn));
+assert.throws(TypeError, Iterator.prototype.some.bind({}, fn));
+assert.throws(TypeError, Iterator.prototype.some.bind({next: 0}, fn));
 

test/staging/sm/Iterator/prototype/some/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.some(x => x), TestError);
+assert.throws(TestError, () => iterator.some(x => x));
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');
 

test/staging/sm/Iterator/prototype/take-drop-throw-eagerly-on-negative.js

@@ -23,10 +23,10 @@ const methods = [
 ];
 
 for (const method of methods) {
-  assertThrowsInstanceOf(() => method(-1), RangeError);
-  assertThrowsInstanceOf(() => method(-Infinity), RangeError);
-  assertThrowsInstanceOf(() => method(NaN), RangeError);
-  assertThrowsInstanceOf(() => method(-NaN), RangeError);
+  assert.throws(RangeError, () => method(-1));
+  assert.throws(RangeError, () => method(-Infinity));
+  assert.throws(RangeError, () => method(NaN));
+  assert.throws(RangeError, () => method(-NaN));
 
   method(-0);
   method(-0.9);

test/staging/sm/Iterator/prototype/take-drop-throw-eagerly-on-non-integer.js

@@ -29,8 +29,8 @@ const objectWithToPrimitive = {
 };
 
 for (const method of methods) {
-  assertThrowsInstanceOf(() => method(0n), TypeError);
-  assertThrowsInstanceOf(() => method(Symbol('')), TypeError);
-  assertThrowsInstanceOf(() => method(objectWithToPrimitive), TypeError);
+  assert.throws(TypeError, () => method(0n));
+  assert.throws(TypeError, () => method(Symbol('')));
+  assert.throws(TypeError, () => method(objectWithToPrimitive));
 }
 

test/staging/sm/Iterator/prototype/toArray/next-throws.js

@@ -22,5 +22,5 @@ class TestIterator extends Iterator {
 
 const iter = new TestIterator();
 
-assertThrowsInstanceOf(() => iter.toArray(), Error);
+assert.throws(Error, () => iter.toArray());
 

test/staging/sm/Iterator/prototype/toArray/this-not-iterator-throws.js

@@ -14,7 +14,7 @@ description: |
 esid: pending
 ---*/
 
-assertThrowsInstanceOf(Iterator.prototype.toArray.bind(undefined), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.toArray.bind({}), TypeError);
-assertThrowsInstanceOf(Iterator.prototype.toArray.bind({next: 0}), TypeError);
+assert.throws(TypeError, Iterator.prototype.toArray.bind(undefined));
+assert.throws(TypeError, Iterator.prototype.toArray.bind({}));
+assert.throws(TypeError, Iterator.prototype.toArray.bind({next: 0}));
 

test/staging/sm/Iterator/prototype/toArray/value-throws-iterator-not-closed.js

@@ -32,6 +32,6 @@ class TestIterator extends Iterator {
 
 const iterator = new TestIterator();
 assert.sameValue(iterator.closed, false, 'iterator starts unclosed');
-assertThrowsInstanceOf(() => iterator.toArray(), TestError);
+assert.throws(TestError, () => iterator.toArray());
 assert.sameValue(iterator.closed, false, 'iterator remains unclosed');