[tests] Fix bogus uses of assertThrows.

test/mjsunit/harmony/reflect.js

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-reflect
 
 // TODO(neis): Test with proxies.
 
 
 
@@ skipping 69 matching lines @@
   assertThrows(function() { Reflect.get(42, "bla"); }, TypeError);
   assertThrows(function() { Reflect.get(null, "bla"); }, TypeError);
 })();
 
 
 (function testReflectGetKeyConversion() {
   var target = {bla: 42};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertEquals(42, Reflect.get(target, a));
-  assertThrows(function() { Reflect.get(target, b); }, "gaga");
+  assertThrowsEquals(function() { Reflect.get(target, b); }, "gaga");
 })();
 
 
 (function testReflectGetOnObject() {
   var receiver = {bla: false};
   for (let target of objects) {
     prepare(target);
     assertEquals(true, Reflect.get(target, "bla"));
     assertEquals(true, Reflect.get(target, "bla", target));
     assertEquals(true, Reflect.get(target, "bla", receiver));
@@ skipping 48 matching lines @@
   assertThrows(function() { Reflect.set(null, "bla"); }, TypeError);
 })();
 
 
 (function testReflectSetKeyConversion() {
   var target = {};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertTrue(Reflect.set(target, a, 42));
   assertEquals(42, target.bla);
-  assertThrows(function() { Reflect.set(target, b, 42); }, "gaga");
+  assertThrowsEquals(function() { Reflect.set(target, b, 42); }, "gaga");
 })();
 
 
 (function testReflectSetOnObject() {
   var receiver = {bla: false};
   var value = 34234;
   for (let target of objects) {
     prepare(target);
     assertTrue(Reflect.set(target, "bla", value));
     assertEquals(value, target.bla);
@@ skipping 120 matching lines @@
   assertThrows(function() { Reflect.has(42, "bla"); }, TypeError);
   assertThrows(function() { Reflect.has(null, "bla"); }, TypeError);
 })();
 
 
 (function testReflectHasKeyConversion() {
   var target = {bla: 42};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertTrue(Reflect.has(target, a));
-  assertThrows(function() { Reflect.has(target, b); }, "gaga");
+  assertThrowsEquals(function() { Reflect.has(target, b); }, "gaga");
 })();
 
 
 (function testReflectHasOnObject() {
   for (let target of objects) {
     prepare(target);
     assertTrue(Reflect.has(target, "bla"));
     assertTrue(Reflect.has(target, 4));
     assertTrue(Reflect.has(target, "4"));
     assertTrue(Reflect.has(target, sym));
@@ skipping 32 matching lines @@
       TypeError);
 })();
 
 
 (function testReflectDefinePropertyKeyConversion() {
   var target = {};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertTrue(Reflect.defineProperty(target, a, {value: 42}));
   assertEquals(target.bla, 42);
-  assertThrows(function() { Reflect.defineProperty(target, b); }, "gaga");
+  assertThrowsEquals(function() { Reflect.defineProperty(target, b); }, "gaga");
 })();
 
 
 // See reflect-define-property.js for further tests.
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.deleteProperty
 
 
 (function testReflectDeletePropertyArity() {
   assertEquals(2, Reflect.deleteProperty.length);
 })();
 
 
 (function testReflectDeletePropertyOnNonObject() {
   assertThrows(function() { Reflect.deleteProperty(); }, TypeError);
   assertThrows(function() { Reflect.deleteProperty(42, "bla"); }, TypeError);
   assertThrows(function() { Reflect.deleteProperty(null, "bla"); }, TypeError);
 })();
 
 
 (function testReflectDeletePropertyKeyConversion() {
   var target = {bla: 42};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertTrue(Reflect.deleteProperty(target, a));
-  assertThrows(function() { Reflect.deleteProperty(target, b); }, "gaga");
+  assertThrowsEquals(function() { Reflect.deleteProperty(target, b); }, "gaga");
 })();
 
 
 (function testReflectDeletePropertyOnObject() {
   for (let target of objects) {
     prepare(target);
     assertTrue(Reflect.deleteProperty(target, "bla"));
     assertEquals(undefined, Object.getOwnPropertyDescriptor(target, "bla"));
     if (target instanceof Int32Array) {
       assertFalse(Reflect.deleteProperty(target, 4));
@@ skipping 130 matching lines @@
   assertThrows(function() { Reflect.getOwnPropertyDescriptor(null); },
       TypeError);
 })();
 
 
 (function testReflectGetOwnPropertyDescriptorKeyConversion() {
   var target = {bla: 42};
   var a = { [Symbol.toPrimitive]: function() { return "bla" } };
   var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
   assertEquals(42, Reflect.getOwnPropertyDescriptor(target, a).value);
-  assertThrows(function() { Reflect.getOwnPropertyDescriptor(target, b); },
-      "gaga");
+  assertThrowsEquals(() => Reflect.getOwnPropertyDescriptor(target, b), "gaga");
 })();
 
 
 // See reflect-get-own-property-descriptor.js for further tests.
 
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Reflect.ownKeys
 
@@ skipping 40 matching lines @@
   assertThrows(function() { Reflect.preventExtensions(); }, TypeError);
   assertThrows(function() { Reflect.preventExtensions(42); }, TypeError);
   assertThrows(function() { Reflect.preventExtensions(null); }, TypeError);
 })();
 
 
 // See reflect-prevent-extensions.js for further tests.
 
 // TODO(neis): Need proxies to test the situation where
 // [[preventExtensions]] returns false.