remove some auto-generated error messages in "assert.throws" tests

test/annexB/built-ins/Date/prototype/getYear/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   let date = new Date(Date.now()); new date.getYear();
-}, '`let date = new Date(Date.now()); new date.getYear()` throws TypeError');
+});
 

test/annexB/built-ins/Date/prototype/setYear/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   let date = new Date(Date.now()); new date.setYear();
-}, '`let date = new Date(Date.now()); new date.setYear()` throws TypeError');
+});
 

test/annexB/built-ins/Date/prototype/toGMTString/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   let date = new Date(Date.now()); new date.toGMTString();
-}, '`let date = new Date(Date.now()); new date.toGMTString()` throws TypeError');
+});
 

test/annexB/built-ins/RegExp/prototype/compile/this-cross-realm-instance.js

@@ -15,9 +15,7 @@ assert.throws(
   TypeError,
   function () {
     RegExp.prototype.compile.call(otherRealm_regexp);
-  },
-  "`RegExp.prototype.compile.call(otherRealm_regexp)` throws TypeError"
-);
+  });
 
 assert.throws(
   other.TypeError,

test/annexB/built-ins/RegExp/prototype/compile/this-subclass-instance.js

@@ -12,14 +12,10 @@ assert.throws(
   TypeError,
   function () {
     subclass_regexp.compile();
-  },
-  "`subclass_regexp.compile()` throws TypeError"
-);
+  });
 
 assert.throws(
   TypeError,
   function () {
     RegExp.prototype.compile.call(subclass_regexp);
-  },
-  "`RegExp.prototype.compile.call(subclass_regexp)` throws TypeError"
-);
+  });

test/annexB/built-ins/String/prototype/anchor/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.anchor();
-}, '`new String.prototype.anchor()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/big/not-a-constructor.js

@@ -24,5 +24,5 @@ assert.sameValue(isConstructor(String.prototype.big), false, 'isConstructor(Stri
 
 assert.throws(TypeError, () => {
   new String.prototype.big();
-}, '`new String.prototype.big()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/blink/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.blink();
-}, '`new String.prototype.blink()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/bold/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.bold();
-}, '`new String.prototype.bold()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/fixed/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.fixed();
-}, '`new String.prototype.fixed()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/fontcolor/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.fontcolor();
-}, '`new String.prototype.fontcolor()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/fontsize/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.fontsize();
-}, '`new String.prototype.fontsize()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/italics/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.italics();
-}, '`new String.prototype.italics()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/link/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.link();
-}, '`new String.prototype.link()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/small/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.small();
-}, '`new String.prototype.small()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/strike/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.strike();
-}, '`new String.prototype.strike()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/sub/not-a-constructor.js

@@ -24,5 +24,5 @@ assert.sameValue(isConstructor(String.prototype.sub), false, 'isConstructor(Stri
 
 assert.throws(TypeError, () => {
   new String.prototype.sub();
-}, '`new String.prototype.sub()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/substr/not-a-constructor.js

@@ -28,5 +28,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new String.prototype.substr();
-}, '`new String.prototype.substr()` throws TypeError');
+});
 

test/annexB/built-ins/String/prototype/sup/not-a-constructor.js

@@ -24,5 +24,5 @@ assert.sameValue(isConstructor(String.prototype.sup), false, 'isConstructor(Stri
 
 assert.throws(TypeError, () => {
   new String.prototype.sup();
-}, '`new String.prototype.sup()` throws TypeError');
+});
 

test/annexB/built-ins/escape/not-a-constructor.js

@@ -24,5 +24,5 @@ assert.sameValue(isConstructor(escape), false, 'isConstructor(escape) must retur
 
 assert.throws(TypeError, () => {
   new escape('');
-}, '`new escape(\'\')` throws TypeError');
+});
 

test/annexB/built-ins/unescape/not-a-constructor.js

@@ -24,5 +24,5 @@ assert.sameValue(isConstructor(unescape), false, 'isConstructor(unescape) must r
 
 assert.throws(TypeError, () => {
   new unescape('');
-}, '`new unescape(\'\')` throws TypeError');
+});
 

test/built-ins/Array/prototype/Symbol.iterator/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype[Symbol.iterator]();
-}, '`new Array.prototype[Symbol.iterator]()` throws TypeError');
+});
 

test/built-ins/Array/prototype/copyWithin/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.copyWithin();
-}, '`new Array.prototype.copyWithin()` throws TypeError');
+});
 

test/built-ins/Array/prototype/entries/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.entries();
-}, '`new Array.prototype.entries()` throws TypeError');
+});
 

test/built-ins/Array/prototype/every/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.every(() => {});
-}, '`new Array.prototype.every(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/fill/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.fill), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.fill();
-}, '`new Array.prototype.fill()` throws TypeError');
+});
 

test/built-ins/Array/prototype/filter/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.filter(() => {});
-}, '`new Array.prototype.filter(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/find/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.find), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.find(() => {});
-}, '`new Array.prototype.find(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/findIndex/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.findIndex(() => {});
-}, '`new Array.prototype.findIndex(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/findLast/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.findLast), false, 'isConstructor(
 
 assert.throws(TypeError, () => {
   new Array.prototype.findLast(() => {});
-}, '`new Array.prototype.findLast(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/findLastIndex/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.findLastIndex(() => {});
-}, '`new Array.prototype.findLastIndex(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/flat/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.flat), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.flat();
-}, '`new Array.prototype.flat()` throws TypeError');
+});
 

test/built-ins/Array/prototype/flatMap/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.flatMap(() => {});
-}, '`new Array.prototype.flatMap(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/forEach/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.forEach(() => {});
-}, '`new Array.prototype.forEach(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/includes/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.includes(1);
-}, '`new Array.prototype.includes(1)` throws TypeError');
+});
 

test/built-ins/Array/prototype/indexOf/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.indexOf();
-}, '`new Array.prototype.indexOf()` throws TypeError');
+});
 

test/built-ins/Array/prototype/join/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.join), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.join();
-}, '`new Array.prototype.join()` throws TypeError');
+});
 

test/built-ins/Array/prototype/keys/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.keys), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.keys();
-}, '`new Array.prototype.keys()` throws TypeError');
+});
 

test/built-ins/Array/prototype/lastIndexOf/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.lastIndexOf();
-}, '`new Array.prototype.lastIndexOf()` throws TypeError');
+});
 

test/built-ins/Array/prototype/map/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.map), false, 'isConstructor(Array
 
 assert.throws(TypeError, () => {
   new Array.prototype.map(() => {});
-}, '`new Array.prototype.map(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/pop/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.pop), false, 'isConstructor(Array
 
 assert.throws(TypeError, () => {
   new Array.prototype.pop();
-}, '`new Array.prototype.pop()` throws TypeError');
+});
 

test/built-ins/Array/prototype/push/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.push), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.push();
-}, '`new Array.prototype.push()` throws TypeError');
+});
 

test/built-ins/Array/prototype/reduce/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.reduce(() => {}, []);
-}, '`new Array.prototype.reduce(() => {}, [])` throws TypeError');
+});
 

test/built-ins/Array/prototype/reduceRight/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.reduceRight(() => {}, []);
-}, '`new Array.prototype.reduceRight(() => {}, [])` throws TypeError');
+});
 

test/built-ins/Array/prototype/reverse/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.reverse();
-}, '`new Array.prototype.reverse()` throws TypeError');
+});
 

test/built-ins/Array/prototype/shift/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.shift();
-}, '`new Array.prototype.shift()` throws TypeError');
+});
 

test/built-ins/Array/prototype/slice/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.slice();
-}, '`new Array.prototype.slice()` throws TypeError');
+});
 

test/built-ins/Array/prototype/some/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.some), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.some(() => {});
-}, '`new Array.prototype.some(() => {})` throws TypeError');
+});
 

test/built-ins/Array/prototype/sort/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Array.prototype.sort), false, 'isConstructor(Arra
 
 assert.throws(TypeError, () => {
   new Array.prototype.sort();
-}, '`new Array.prototype.sort()` throws TypeError');
+});
 

test/built-ins/Array/prototype/splice/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.splice();
-}, '`new Array.prototype.splice()` throws TypeError');
+});
 

test/built-ins/Array/prototype/toLocaleString/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.toLocaleString();
-}, '`new Array.prototype.toLocaleString()` throws TypeError');
+});
 

test/built-ins/Array/prototype/toReversed/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.toReversed();
-}, '`new Array.prototype.toReversed()` throws TypeError');
+});
 

test/built-ins/Array/prototype/toReversed/this-value-nullish.js

@@ -15,8 +15,8 @@ features: [change-array-by-copy]
 
 assert.throws(TypeError, () => {
   Array.prototype.toReversed.call(null);
-}, '`Array.prototype.toReversed.call(null)` throws TypeError');
+});
 
 assert.throws(TypeError, () => {
   Array.prototype.toReversed.call(undefined);
-}, '`Array.prototype.toReversed.call(undefined)` throws TypeError');
+});

test/built-ins/Array/prototype/toSorted/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.toSorted();
-}, '`new Array.prototype.toSorted()` throws TypeError');
+});
 

test/built-ins/Array/prototype/toSorted/this-value-nullish.js

@@ -15,8 +15,8 @@ features: [change-array-by-copy]
 
 assert.throws(TypeError, () => {
   Array.prototype.toSorted.call(null);
-}, '`Array.prototype.toSorted.call(null)` throws TypeError');
+});
 
 assert.throws(TypeError, () => {
   Array.prototype.toSorted.call(undefined);
-}, '`Array.prototype.toSorted.call(undefined)` throws TypeError');
+});

test/built-ins/Array/prototype/toSpliced/not-a-constructor.js

@@ -29,4 +29,4 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.toSpliced();
-}, '`new Array.prototype.toSpliced()` throws TypeError');
+});

test/built-ins/Array/prototype/toString/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.toString();
-}, '`new Array.prototype.toString()` throws TypeError');
+});
 

test/built-ins/Array/prototype/unshift/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.unshift();
-}, '`new Array.prototype.unshift()` throws TypeError');
+});
 

test/built-ins/Array/prototype/values/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.values();
-}, '`new Array.prototype.values()` throws TypeError');
+});
 

test/built-ins/Array/prototype/with/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Array.prototype.with();
-}, '`new Array.prototype.with()` throws TypeError');
+});
 

test/built-ins/Array/prototype/with/this-value-nullish.js

@@ -15,8 +15,8 @@ features: [change-array-by-copy]
 
 assert.throws(TypeError, () => {
   Array.prototype.with.call(null, 0, 0);
-}, '`Array.prototype.with.call(null, 0, 0)` throws TypeError');
+});
 
 assert.throws(TypeError, () => {
   Array.prototype.with.call(undefined, 0, 0);
-}, '`Array.prototype.with.call(undefined, 0, 0)` throws TypeError');
+});

test/built-ins/ArrayBuffer/isView/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(ArrayBuffer.isView), false, 'isConstructor(ArrayB
 
 assert.throws(TypeError, () => {
   new ArrayBuffer.isView();
-}, '`new ArrayBuffer.isView()` throws TypeError');
+});
 

test/built-ins/ArrayBuffer/prototype/slice/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   let ab = new ArrayBuffer(); new ab.slice();
-}, '`let ab = new ArrayBuffer(); new ab.slice()` throws TypeError');
+});
 

test/built-ins/Atomics/add/bad-range.js

@@ -17,6 +17,6 @@ testWithTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.add(view, IdxGen(view), 10);
-    }, '`Atomics.add(view, IdxGen(view), 10)` throws RangeError');
+    });
   });
 }, views);

test/built-ins/Atomics/add/bigint/bad-range.js

@@ -15,6 +15,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.add(view, IdxGen(view), 10n);
-    }, '`Atomics.add(view, IdxGen(view), 10n)` throws RangeError');
+    });
   });
 });

test/built-ins/Atomics/add/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(view) {
   assert.throws(TypeError, function() {
     Atomics.add(view, 0, 0);
-  }, '`Atomics.add(view, 0, 0)` throws TypeError');
+  });
 });

test/built-ins/Atomics/add/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Atomics.add), false, 'isConstructor(Atomics.add)
 
 assert.throws(TypeError, () => {
   new Atomics.add(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.add(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/and/bad-range.js

@@ -17,6 +17,6 @@ testWithTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.and(view, IdxGen(view), 10);
-    }, '`Atomics.and(view, IdxGen(view), 10)` throws RangeError');
+    });
   });
 }, views);

test/built-ins/Atomics/and/bigint/bad-range.js

@@ -15,6 +15,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.and(view, IdxGen(view), 10n);
-    }, '`Atomics.and(view, IdxGen(view), 10n)` throws RangeError');
+    });
   });
 });

test/built-ins/Atomics/and/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(view) {
   assert.throws(TypeError, function() {
     Atomics.and(view, 0, 0);
-  }, '`Atomics.and(view, 0, 0)` throws TypeError');
+  });
 });

test/built-ins/Atomics/and/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Atomics.and), false, 'isConstructor(Atomics.and)
 
 assert.throws(TypeError, () => {
   new Atomics.and(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.and(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/compareExchange/bad-range.js

@@ -17,6 +17,6 @@ testWithTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.compareExchange(view, IdxGen(view), 10, 0);
-    }, '`Atomics.compareExchange(view, IdxGen(view), 10, 0)` throws RangeError');
+    });
   });
 }, views);

test/built-ins/Atomics/compareExchange/bigint/bad-range.js

@@ -15,6 +15,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.compareExchange(view, IdxGen(view), 10, 0n);
-    }, '`Atomics.compareExchange(view, IdxGen(view), 10, 0n)` throws RangeError');
+    });
   });
 });

test/built-ins/Atomics/compareExchange/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(view) {
   assert.throws(TypeError, function() {
     Atomics.compareExchange(view, 0, 0, 0);
-  }, '`Atomics.compareExchange(view, 0, 0, 0)` throws TypeError');
+  });
 });

test/built-ins/Atomics/compareExchange/not-a-constructor.js

@@ -29,5 +29,5 @@ assert.sameValue(
 
 assert.throws(TypeError, () => {
   new Atomics.compareExchange(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.compareExchange(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/exchange/bad-range.js

@@ -17,6 +17,6 @@ testWithTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.exchange(view, IdxGen(view), 10, 0);
-    }, '`Atomics.exchange(view, IdxGen(view), 10, 0)` throws RangeError');
+    });
   });
 }, views);

test/built-ins/Atomics/exchange/bigint/bad-range.js

@@ -15,6 +15,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.exchange(view, IdxGen(view), 10n, 0n);
-    }, '`Atomics.exchange(view, IdxGen(view), 10n, 0n)` throws RangeError');
+    });
   });
 });

test/built-ins/Atomics/exchange/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(view) {
   assert.throws(TypeError, function() {
     Atomics.exchange(view, 0, 0);
-  }, '`Atomics.exchange(view, 0, 0)` throws TypeError');
+  });
 });

test/built-ins/Atomics/exchange/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Atomics.exchange), false, 'isConstructor(Atomics.
 
 assert.throws(TypeError, () => {
   new Atomics.exchange(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.exchange(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/isLockFree/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Atomics.isLockFree), false, 'isConstructor(Atomic
 
 assert.throws(TypeError, () => {
   new Atomics.isLockFree(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.isLockFree(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/load/bad-range.js

@@ -17,6 +17,6 @@ testWithTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.load(view, IdxGen(view));
-    }, '`Atomics.load(view, IdxGen(view))` throws RangeError');
+    });
   });
 }, views);

test/built-ins/Atomics/load/bigint/bad-range.js

@@ -16,6 +16,6 @@ testWithBigIntTypedArrayConstructors(function(TA) {
   testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
     assert.throws(RangeError, function() {
       Atomics.load(view, IdxGen(view));
-    }, '`Atomics.load(view, IdxGen(view))` throws RangeError');
+    });
   });
 });

test/built-ins/Atomics/load/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(view) {
   assert.throws(TypeError, function() {
     Atomics.load(view, 0);
-  }, '`Atomics.load(view, 0)` throws TypeError');
+  });
 });

test/built-ins/Atomics/load/not-a-constructor.js

@@ -25,5 +25,5 @@ assert.sameValue(isConstructor(Atomics.load), false, 'isConstructor(Atomics.load
 
 assert.throws(TypeError, () => {
   new Atomics.load(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)));
-}, '`new Atomics.load(new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT)))` throws TypeError');
+});
 

test/built-ins/Atomics/notify/bad-range.js

@@ -22,5 +22,5 @@ const i32a = new Int32Array(
 testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
   assert.throws(RangeError, function() {
     Atomics.notify(i32a, IdxGen(i32a), 0);
-  }, '`Atomics.notify(i32a, IdxGen(i32a), 0)` throws RangeError');
+  });
 });

test/built-ins/Atomics/notify/bigint/bad-range.js

@@ -22,5 +22,5 @@ const i64a = new BigInt64Array(
 testWithAtomicsOutOfBoundsIndices(function(IdxGen) {
   assert.throws(RangeError, function() {
     Atomics.notify(i64a, IdxGen(i64a), 0);
-  }, '`Atomics.notify(i64a, IdxGen(i64a), 0)` throws RangeError');
+  });
 });

test/built-ins/Atomics/notify/bigint/non-bigint64-typedarray-throws.js

@@ -27,8 +27,8 @@ const poisoned = {
 
 assert.throws(TypeError, function() {
   Atomics.wait(i64a, 0, 0);
-}, '`Atomics.wait(i64a, 0, 0)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.wait(i64a, poisoned, poisoned);
-}, '`Atomics.wait(i64a, poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/bigint/non-shared-bufferdata-count-evaluation-throws.js

@@ -30,4 +30,4 @@ const poisoned = {
 
 assert.throws(Test262Error, function() {
   Atomics.notify(i64a, poisoned, 0);
-}, '`Atomics.notify(i64a, poisoned, 0)` throws Test262Error');
+});

test/built-ins/Atomics/notify/bigint/non-shared-bufferdata-index-evaluation-throws.js

@@ -27,6 +27,6 @@ const poisoned = {
 
 assert.throws(Test262Error, function() {
   Atomics.notify(i64a, 0, poisoned);
-}, '`Atomics.notify(i64a, 0, poisoned)` throws Test262Error');
+});
 
 

test/built-ins/Atomics/notify/bigint/non-shared-bufferdata-non-shared-int-views-throws.js

@@ -18,4 +18,4 @@ const poisoned = {
 
 assert.throws(TypeError, function() {
   Atomics.notify(new BigUint64Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new BigUint64Array(nonsab), poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/bigint/null-bufferdata-throws.js

@@ -33,4 +33,4 @@ try {
 
 assert.throws(TypeError, function() {
   Atomics.notify(i64a, poisoned, poisoned);
-}, '`Atomics.notify(i64a, poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/count-symbol-throws.js

@@ -23,4 +23,4 @@ const i32a = new Int32Array(
 
 assert.throws(TypeError, function() {
   Atomics.notify(i32a, 0, Symbol());
-}, '`Atomics.notify(i32a, 0, Symbol())` throws TypeError');
+});

test/built-ins/Atomics/notify/count-tointeger-throws-then-wake-throws.js

@@ -29,4 +29,4 @@ const poisoned = {
 
 assert.throws(Test262Error, function() {
   Atomics.notify(i32a, 0, poisoned);
-}, '`Atomics.notify(i32a, 0, poisoned)` throws Test262Error');
+});

test/built-ins/Atomics/notify/negative-index-throws.js

@@ -28,13 +28,13 @@ const poisoned = {
 
 assert.throws(RangeError, function() {
   Atomics.notify(i32a, -Infinity, poisoned);
-}, '`Atomics.notify(i32a, -Infinity, poisoned)` throws RangeError');
+});
 assert.throws(RangeError, function() {
   Atomics.notify(i32a, -7.999, poisoned);
-}, '`Atomics.notify(i32a, -7.999, poisoned)` throws RangeError');
+});
 assert.throws(RangeError, function() {
   Atomics.notify(i32a, -1, poisoned);
-}, '`Atomics.notify(i32a, -1, poisoned)` throws RangeError');
+});
 assert.throws(RangeError, function() {
   Atomics.notify(i32a, -300, poisoned);
-}, '`Atomics.notify(i32a, -300, poisoned)` throws RangeError');
+});

test/built-ins/Atomics/notify/non-int32-typedarray-throws.js

@@ -26,14 +26,14 @@ assert.throws(TypeError, function() {
     new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * 8)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Float64Array( new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * 8) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Float32Array(
     new SharedArrayBuffer(Float32Array.BYTES_PER_ELEMENT * 4)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Float32Array( new SharedArrayBuffer(Float32Array.BYTES_PER_ELEMENT * 4) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 if (typeof Float16Array !== 'undefined') {
   assert.throws(TypeError, function() {
@@ -41,7 +41,7 @@ if (typeof Float16Array !== 'undefined') {
       new SharedArrayBuffer(Float16Array.BYTES_PER_ELEMENT * 2)
     );
     Atomics.notify(view, poisoned, poisoned);
-  }, '`const view = new Float16Array( new SharedArrayBuffer(Float16Array.BYTES_PER_ELEMENT * 2) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+  });
 }
 
 assert.throws(TypeError, function() {
@@ -49,39 +49,39 @@ assert.throws(TypeError, function() {
     new SharedArrayBuffer(Int16Array.BYTES_PER_ELEMENT * 2)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Int16Array( new SharedArrayBuffer(Int16Array.BYTES_PER_ELEMENT * 2) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Int8Array(
     new SharedArrayBuffer(Int8Array.BYTES_PER_ELEMENT)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Int8Array( new SharedArrayBuffer(Int8Array.BYTES_PER_ELEMENT) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Uint32Array(
     new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * 4)
   );
   Atomics.notify(new Uint32Array(),  poisoned, poisoned);
-}, '`const view = new Uint32Array( new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT * 4) ); Atomics.notify(new Uint32Array(), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Uint16Array(
     new SharedArrayBuffer(Uint16Array.BYTES_PER_ELEMENT * 2)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Uint16Array( new SharedArrayBuffer(Uint16Array.BYTES_PER_ELEMENT * 2) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Uint8Array(
     new SharedArrayBuffer(Uint8Array.BYTES_PER_ELEMENT)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Uint8Array( new SharedArrayBuffer(Uint8Array.BYTES_PER_ELEMENT) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   const view = new Uint8ClampedArray(
     new SharedArrayBuffer(Uint8ClampedArray.BYTES_PER_ELEMENT)
   );
   Atomics.notify(view, poisoned, poisoned);
-}, '`const view = new Uint8ClampedArray( new SharedArrayBuffer(Uint8ClampedArray.BYTES_PER_ELEMENT) ); Atomics.notify(view, poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/non-shared-bufferdata-count-evaluation-throws.js

@@ -31,6 +31,6 @@ const poisoned = {
 
 assert.throws(Test262Error, function() {
   Atomics.notify(i32a, 0, poisoned);
-}, '`Atomics.notify(i32a, 0, poisoned)` throws Test262Error');
+});
 
 

test/built-ins/Atomics/notify/non-shared-bufferdata-index-evaluation-throws.js

@@ -27,6 +27,6 @@ const poisoned = {
 
 assert.throws(Test262Error, function() {
   Atomics.notify(i32a, poisoned, 0);
-}, '`Atomics.notify(i32a, poisoned, 0)` throws Test262Error');
+});
 
 

test/built-ins/Atomics/notify/non-shared-bufferdata-non-shared-int-views-throws.js

@@ -18,24 +18,24 @@ const poisoned = {
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Int16Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Int16Array(nonsab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Int8Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Int8Array(nonsab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint32Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint32Array(nonsab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint16Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint16Array(nonsab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint8Array(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint8Array(nonsab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint8ClampedArray(nonsab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint8ClampedArray(nonsab), poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/non-shared-int-views.js

@@ -18,24 +18,24 @@ const poisoned = {
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Int16Array(sab), poisoned, poisoned);
-}, '`Atomics.notify(new Int16Array(sab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Int8Array(sab), poisoned, poisoned);
-}, '`Atomics.notify(new Int8Array(sab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint32Array(sab),  poisoned, poisoned);
-}, '`Atomics.notify(new Uint32Array(sab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint16Array(sab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint16Array(sab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint8Array(sab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint8Array(sab), poisoned, poisoned)` throws TypeError');
+});
 
 assert.throws(TypeError, function() {
   Atomics.notify(new Uint8ClampedArray(sab), poisoned, poisoned);
-}, '`Atomics.notify(new Uint8ClampedArray(sab), poisoned, poisoned)` throws TypeError');
+});

test/built-ins/Atomics/notify/non-views.js

@@ -12,5 +12,5 @@ features: [ArrayBuffer, Atomics, DataView, SharedArrayBuffer, Symbol, TypedArray
 testWithAtomicsNonViewValues(function(nonView) {
   assert.throws(TypeError, function() {
     Atomics.notify(nonView, 0, 0);
-  }, '`Atomics.notify(nonView, 0, 0)` throws TypeError'); // Even with count == 0
+  }); // Even with count == 0
 });