Replace assertThrowsInstanceOf with assert.throws in sm/Symbol

test/staging/sm/Symbol/as-base-value.js

@@ -89,7 +89,7 @@ for (var sym of symbols) {
     assert.sameValue(sym[noSuchPropName], undefined);
 
     // non-existent method
-    assertThrowsInstanceOf(() => sym.noSuchProp(), TypeError);
-    assertThrowsInstanceOf(() => sym[noSuchPropName](), TypeError);
+    assert.throws(TypeError, () => sym.noSuchProp());
+    assert.throws(TypeError, () => sym[noSuchPropName]());
 }
 

test/staging/sm/Symbol/comparisons.js

@@ -36,7 +36,7 @@ for (var comparator of ["<", "<=", ">", ">="]) {
     var f = Function("a, b", "return a " + comparator + " b;");
     for (var a of symbols) {
         for (var b of values)
-            assertThrowsInstanceOf(() => f(a, b), TypeError);
+            assert.throws(TypeError, () => f(a, b));
     }
 }
 

test/staging/sm/Symbol/constructor.js

@@ -13,7 +13,7 @@ esid: pending
 ---*/
 // Symbol(symbol) throws a TypeError.
 var sym = Symbol();
-assertThrowsInstanceOf(() => Symbol(sym), TypeError);
+assert.throws(TypeError, () => Symbol(sym));
 
 // Symbol(undefined) is equivalent to Symbol().
 assert.sameValue(Symbol(undefined).toString(), "Symbol()");
@@ -24,7 +24,7 @@ assert.sameValue(Symbol(true).toString(), "Symbol(true)");
 assert.sameValue(Symbol(null).toString(), "Symbol(null)");
 assert.sameValue(Symbol([1, 2]).toString(), "Symbol(1,2)");
 var symobj = Object(sym);
-assertThrowsInstanceOf(() => Symbol(symobj), TypeError);
+assert.throws(TypeError, () => Symbol(symobj));
 
 var hits = 0;
 var obj = {
@@ -39,5 +39,5 @@ assert.sameValue(hits, 1);
 assert.sameValue(Object.getPrototypeOf(Symbol.prototype), Object.prototype);
 
 // Symbol.prototype is not itself a Symbol object.
-assertThrowsInstanceOf(() => Symbol.prototype.valueOf(), TypeError);
+assert.throws(TypeError, () => Symbol.prototype.valueOf());
 

test/staging/sm/Symbol/conversions.js

@@ -26,20 +26,20 @@ function testSymbolConversions(sym) {
     assert.sameValue(sym && 13, 13);
 
     // 7.1.3 ToNumber
-    assertThrowsInstanceOf(() => +sym, TypeError);
-    assertThrowsInstanceOf(() => sym | 0, TypeError);
+    assert.throws(TypeError, () => +sym);
+    assert.throws(TypeError, () => sym | 0);
 
     // 7.1.12 ToString
-    assertThrowsInstanceOf(() => "" + sym, TypeError);
-    assertThrowsInstanceOf(() => sym + "", TypeError);
-    assertThrowsInstanceOf(() => "" + [1, 2, sym], TypeError);
-    assertThrowsInstanceOf(() => ["simple", "thimble", sym].join(), TypeError);
+    assert.throws(TypeError, () => "" + sym);
+    assert.throws(TypeError, () => sym + "");
+    assert.throws(TypeError, () => "" + [1, 2, sym]);
+    assert.throws(TypeError, () => ["simple", "thimble", sym].join());
 
     // 21.1.1.1 String()
     assert.sameValue(String(sym), sym.toString());
 
     // 21.1.1.2 new String()
-    assertThrowsInstanceOf(() => new String(sym), TypeError);
+    assert.throws(TypeError, () => new String(sym));
 
     // 7.1.13 ToObject
     var obj = Object(sym);
@@ -58,19 +58,19 @@ for (var sym of symbols) {
 
     // 7.1.1 ToPrimitive
     var symobj = Object(sym);
-    assertThrowsInstanceOf(() => Number(symobj), TypeError);
-    assertThrowsInstanceOf(() => String(symobj), TypeError);
-    assertThrowsInstanceOf(() => symobj < 0, TypeError);
-    assertThrowsInstanceOf(() => 0 < symobj, TypeError);
-    assertThrowsInstanceOf(() => symobj + 1, TypeError);
-    assertThrowsInstanceOf(() => "" + symobj, TypeError);
+    assert.throws(TypeError, () => Number(symobj));
+    assert.throws(TypeError, () => String(symobj));
+    assert.throws(TypeError, () => symobj < 0);
+    assert.throws(TypeError, () => 0 < symobj);
+    assert.throws(TypeError, () => symobj + 1);
+    assert.throws(TypeError, () => "" + symobj);
     assert.sameValue(sym == symobj, true);
     assert.sameValue(sym === symobj, false);
     assert.sameValue(symobj == 0, false);
     assert.sameValue(0 != symobj, true);
 
     // 7.1.12 ToString
-    assertThrowsInstanceOf(() => String(Object(sym)), TypeError);
+    assert.throws(TypeError, () => String(Object(sym)));
 }
 
 // Deleting Symbol.prototype[@@toPrimitive] does not change the behavior of

test/staging/sm/Symbol/errors.js

@@ -16,10 +16,10 @@ esid: pending
 var sym = Symbol();
 
 // 7.2.2 IsCallable
-assertThrowsInstanceOf(() => sym(), TypeError);
-assertThrowsInstanceOf(() => Function.prototype.call.call(sym), TypeError);
+assert.throws(TypeError, () => sym());
+assert.throws(TypeError, () => Function.prototype.call.call(sym));
 
 // 7.2.5 IsConstructor
-assertThrowsInstanceOf(() => new sym(), TypeError);
-assertThrowsInstanceOf(() => new Symbol(), TypeError);
+assert.throws(TypeError, () => new sym());
+assert.throws(TypeError, () => new Symbol());
 

test/staging/sm/Symbol/keyFor.js

@@ -16,8 +16,8 @@ assert.sameValue(Symbol.keyFor(Symbol.for("")), "");
 assert.sameValue(Symbol.keyFor(Symbol("moon")), undefined);
 assert.sameValue(Symbol.keyFor(Symbol.iterator), undefined);
 
-assertThrowsInstanceOf(() => Symbol.keyFor(), TypeError);
-assertThrowsInstanceOf(() => Symbol.keyFor(Object(Symbol("moon"))), TypeError);
+assert.throws(TypeError, () => Symbol.keyFor());
+assert.throws(TypeError, () => Symbol.keyFor(Object(Symbol("moon"))));
 
 assert.sameValue(Symbol.keyFor.length, 1);
 

test/staging/sm/Symbol/property-inheritance.js

@@ -48,7 +48,7 @@ assert.sameValue(value, "gravity");
 Object.defineProperty(F.prototype, sym, {
     set: undefined
 });
-assertThrowsInstanceOf(function () { "use strict"; f[sym] = 0; }, TypeError);
+assert.throws(TypeError, function () { "use strict"; f[sym] = 0; });
 
 // deeply inherited accessor property
 var g = Object.create(f);

test/staging/sm/Symbol/property-nonwritable.js

@@ -18,7 +18,7 @@ function checkNotWritable(obj) {
     assert.sameValue(obj[sym], "cheese");
 
     // In strict mode code, it throws.
-    assertThrowsInstanceOf(function () { "use strict"; obj[sym] = "robots"; }, TypeError);
+    assert.throws(TypeError, function () { "use strict"; obj[sym] = "robots"; });
     assert.sameValue(obj[sym], "cheese");
 }
 

test/staging/sm/Symbol/property-reflection.js

@@ -88,7 +88,7 @@ assert.sameValue(descs.propertyIsEnumerable(s3), false); // inherited properties
 var obj = {};
 obj[s1] = 1;
 assert.sameValue(Object.preventExtensions(obj), obj);
-assertThrowsInstanceOf(function () { "use strict"; obj[s2] = 2; }, TypeError);
+assert.throws(TypeError, function () { "use strict"; obj[s2] = 2; });
 obj[s2] = 2;  // still no effect
 assert.sameValue(s2 in obj, false);
 

test/staging/sm/Symbol/toPrimitive-undefined-or-null.js

@@ -22,6 +22,6 @@ for (let method of [true, false, 0, 123, "", "abc", Symbol(), {}]) {
         [Symbol.toPrimitive]: method,
         toString: () => "pass",
     };
-    assertThrowsInstanceOf(() => "" + obj, TypeError);
+    assert.throws(TypeError, () => "" + obj);
 }
 

test/staging/sm/Symbol/toPrimitive.js

@@ -37,7 +37,7 @@ var nonSymbols = [
     new Proxy(obj, {})
 ];
 for (var value of nonSymbols) {
-    assertThrowsInstanceOf(() => symbolToPrimitive.call(value, "string"), TypeError);
+    assert.throws(TypeError, () => symbolToPrimitive.call(value, "string"));
 }
 
 // Surface features:

test/staging/sm/Symbol/toString.js

@@ -31,5 +31,5 @@ var nonsymbols = [
     undefined, null, "not-ok", new String("still-not-ok"), {}, []
 ];
 for (var nonsym of nonsymbols)
-    assertThrowsInstanceOf(() => Symbol.prototype.toString.call(nonsym), TypeError);
+    assert.throws(TypeError, () => Symbol.prototype.toString.call(nonsym));
 

test/staging/sm/Symbol/toStringTag.js

@@ -62,7 +62,7 @@ function testProxy() {
     assert.sameValue(Object.prototype.toString.call(new Proxy(function() {}, metaHandler)), "[object Function]")
     var {proxy, revoke} = Proxy.revocable({}, metaHandler);
     revoke();
-    assertThrowsInstanceOf(() => Object.prototype.toString.call(proxy), TypeError);
+    assert.throws(TypeError, () => Object.prototype.toString.call(proxy));
 
     assert.sameValue(count, 4);
 }

test/staging/sm/Symbol/typed-arrays.js

@@ -15,11 +15,11 @@ esid: pending
 
 for (var T of [Uint8Array, Uint8ClampedArray, Int16Array, Float32Array]) {
     // Typed array constructors convert symbols using ToNumber(), which throws.
-    assertThrowsInstanceOf(() => new T([Symbol("a")]), TypeError);
+    assert.throws(TypeError, () => new T([Symbol("a")]));
 
     // Assignment does the same.
     var arr = new T([1]);
-    assertThrowsInstanceOf(() => { arr[0] = Symbol.iterator; }, TypeError);
+    assert.throws(TypeError, () => { arr[0] = Symbol.iterator; });
     assert.sameValue(arr[0], 1);
 }
 

test/staging/sm/Symbol/valueOf.js

@@ -26,5 +26,5 @@ for (var sym of symbols) {
 // Any other value throws.
 var nonsymbols = [undefined, null, NaN, {}, Symbol.prototype];
 for (var nonsym of nonsymbols)
-    assertThrowsInstanceOf(() => Symbol.prototype.valueOf.call(nonsym), TypeError);
+    assert.throws(TypeError, () => Symbol.prototype.valueOf.call(nonsym));