[tests] Fix bogus uses of assertThrows.

test/mjsunit/harmony/proxies.js

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 28 matching lines @@
   TestWithObjectProxy(test, x, y, z);
   TestWithFunctionProxy(test, x, y, z);
 }
 
 function TestWithObjectProxy(test, x, y, z) {
   test((handler) => { return new Proxy({}, handler) }, x, y, z)
 
 }
 
 function TestWithFunctionProxy(test, x, y, z) {
-  test((handler) => {
-    return new Proxy(function() {}, handler)
-  }, x, y, z)
+  test((handler) => { return new Proxy(() => {}, handler) }, x, y, z)
 }
 
 // ---------------------------------------------------------------------------
 // Getting property descriptors (Object.getOwnPropertyDescriptor).
 
 var key
 
 function TestGetOwnProperty(handler) {
   TestWithProxies(TestGetOwnProperty2, handler)
 }
@@ skipping 37 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestGetOwnPropertyThrow(handler) {
   TestWithProxies(TestGetOwnPropertyThrow2, handler)
 }
 
 function TestGetOwnPropertyThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.getOwnPropertyDescriptor(p, "a") }, "myexn")
-  assertThrows(function(){ Object.getOwnPropertyDescriptor(p, 77) }, "myexn")
+  assertThrowsEquals(() => Object.getOwnPropertyDescriptor(p, "a"), "myexn")
+  assertThrowsEquals(() => Object.getOwnPropertyDescriptor(p, 77), "myexn")
 }
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) {
-    return this.getPropertyDescriptor2(k)
+    return this.getOwnPropertyDescriptor2(k)
   },
   getOwnPropertyDescriptor2: function(k) { throw "myexn" }
 })
 
 TestGetOwnPropertyThrow({
   getOwnPropertyDescriptor: function(k) {
     return {get value() { throw "myexn" }}
   }
 })
 
@@ skipping 130 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestGetThrow(handler) {
   TestWithProxies(TestGetThrow2, handler)
 }
 
 function TestGetThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ p.a }, "myexn")
-  assertThrows(function(){ p["b"] }, "myexn")
-  assertThrows(function(){ p[3] }, "myexn")
-  assertThrows(function(){ (function(n) { p[n] })("c") }, "myexn")
-  assertThrows(function(){ (function(n) { p[n] })(99) }, "myexn")
+  assertThrowsEquals(function(){ p.a }, "myexn")
+  assertThrowsEquals(function(){ p["b"] }, "myexn")
+  assertThrowsEquals(function(){ p[3] }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { p[n] })("c") }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { p[n] })(99) }, "myexn")
 
   var o = Object.create(p, {x: {value: 88}, '4': {value: 89}})
-  assertThrows(function(){ o.a }, "myexn")
-  assertThrows(function(){ o["b"] }, "myexn")
-  assertThrows(function(){ o[3] }, "myexn")
-  assertThrows(function(){ (function(n) { o[n] })("c") }, "myexn")
-  assertThrows(function(){ (function(n) { o[n] })(99) }, "myexn")
+  assertThrowsEquals(function(){ o.a }, "myexn")
+  assertThrowsEquals(function(){ o["b"] }, "myexn")
+  assertThrowsEquals(function(){ o[3] }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { o[n] })("c") }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { o[n] })(99) }, "myexn")
 }
 
 TestGetThrow({
   get(r, k) { throw "myexn" }
 })
 
 TestGetThrow({
   get(r, k) { return this.get2(r, k) },
   get2(r, k) { throw "myexn" }
 })
@@ skipping 59 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestSetThrow(handler) {
   TestWithProxies(TestSetThrow2, handler)
 }
 
 function TestSetThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ p.a = 42 }, "myexn")
-  assertThrows(function(){ p["b"] = 42 }, "myexn")
-  assertThrows(function(){ p[22] = 42 }, "myexn")
-  assertThrows(function(){ (function(n) { p[n] = 45 })("c") }, "myexn")
-  assertThrows(function(){ (function(n) { p[n] = 46 })(99) }, "myexn")
+  assertThrowsEquals(function(){ p.a = 42 }, "myexn")
+  assertThrowsEquals(function(){ p["b"] = 42 }, "myexn")
+  assertThrowsEquals(function(){ p[22] = 42 }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { p[n] = 45 })("c") }, "myexn")
+  assertThrowsEquals(function(){ (function(n) { p[n] = 46 })(99) }, "myexn")
 }
 
 TestSetThrow({
   set: function(r, k, v) { throw "myexn" }
 })
 
 TestSetThrow({
   set: function(r, k, v) { return this.set2(r, k, v) },
   set2: function(r, k, v) { throw "myexn" }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" },
   defineProperty: function(k, desc) { key = k; val = desc.value }
 })
 
 TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return {writable: true} },
+  getOwnPropertyDescriptor: function(k) {
+    return {configurable: true, writable: true}
+  },
   defineProperty: function(k, desc) { throw "myexn" }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
   getOwnPropertyDescriptor2: function(k) { throw "myexn" },
   defineProperty: function(k, desc) { this.defineProperty2(k, desc) },
   defineProperty2: function(k, desc) { key = k; val = desc.value }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
-  getOwnPropertyDescriptor2: function(k) { return {writable: true} },
+  getOwnPropertyDescriptor2: function(k) {
+    return {configurable: true, writable: true}
+  },
   defineProperty: function(k, desc) { this.defineProperty2(k, desc) },
   defineProperty2: function(k, desc) { throw "myexn" }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" },
   defineProperty: function(k, desc) { key = k; val = desc.value }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) {
-    return {get writable() { return true }}
+    return {
+      get configurable() { return true },
+      get writable() { return true }
+    }
   },
   defineProperty: function(k, desc) { throw "myexn" }
 })
 
 TestSetThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 TestSetThrow({
-  getOwnPropertyDescriptor: function(k) {
-    return {set: function(v) { throw "myexn" }}
-  }
-})
-
-TestSetThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" },
-  getPropertyDescriptor: function(k) { return {writable: true} },
   defineProperty: function(k, desc) { key = k; val = desc.value }
 })
 
-TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return null },
-  getPropertyDescriptor: function(k) { throw "myexn" },
-  defineProperty: function(k, desc) { key = k; val = desc.value }
-})
-
-TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return null },
-  getPropertyDescriptor: function(k) { return {writable: true} },
-  defineProperty: function(k, desc) { throw "myexn" }
-})
-
-TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return null },
-  getPropertyDescriptor: function(k) {
-    return {get writable() { throw "myexn" }}
-  },
-  defineProperty: function(k, desc) { key = k; val = desc.value }
-})
-
-TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return null },
-  getPropertyDescriptor: function(k) {
-    return {set: function(v) { throw "myexn" }}
-  }
-})
-
-TestSetThrow({
-  getOwnPropertyDescriptor: function(k) { return null },
-  getPropertyDescriptor: function(k) { return null },
-  defineProperty: function(k, desc) { throw "myexn" }
-})
-
 TestSetThrow(new Proxy({}, {
   get: function(pr, pk) { throw "myexn" }
 }))
 
 TestSetThrow(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k, v) { throw "myexn" }
   }
 }))
 
@@ skipping 94 matching lines @@
   }
   Object.defineProperty(props, "hidden", {value: "hidden", enumerable: false})
   assertEquals(p, Object.defineProperties(p, props))
   assertEquals("last", key)
   assertEquals(2, Object.getOwnPropertyNames(desc).length)
   assertEquals(21, desc.value)
   assertEquals(true, desc.configurable)
   assertEquals(undefined, desc.mine)  // Arguably a bug in the spec...
 
   var props = {bla: {get value() { throw "myexn" }}}
-  assertThrows(function(){ Object.defineProperties(p, props) }, "myexn")
+  assertThrowsEquals(function(){ Object.defineProperties(p, props) }, "myexn")
 }
 
 TestDefine({
   defineProperty(t, k, d) { key = k; desc = d; return true }
 })
 
 TestDefine({
   defineProperty(t, k, d) { return this.defineProperty2(k, d) },
   defineProperty2(k, d) { key = k; desc = d; return true }
 })
 
 
 // ---------------------------------------------------------------------------
 function TestDefineThrow(handler) {
   TestWithProxies(TestDefineThrow2, handler)
 }
 
 function TestDefineThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.defineProperty(p, "a", {value: 44})}, "myexn")
-  assertThrows(function(){ Object.defineProperty(p, 0, {value: 44})}, "myexn")
+  assertThrowsEquals(() => Object.defineProperty(p, "a", {value: 44}), "myexn")
+  assertThrowsEquals(() => Object.defineProperty(p, 0, {value: 44}), "myexn")
 
   var d1 = create({
     get: function(r, k) { throw "myexn" },
     getOwnPropertyNames: function() { return ["value"] }
   })
-  assertThrows(function(){ Object.defineProperty(p, "p", d1) }, "myexn")
+  assertThrowsEquals(function(){ Object.defineProperty(p, "p", d1) }, "myexn")
   var d2 = create({
     get: function(r, k) { return 77 },
     getOwnPropertyNames: function() { throw "myexn" }
   })
-  assertThrows(function(){ Object.defineProperty(p, "p", d2) }, "myexn")
+  assertThrowsEquals(function(){ Object.defineProperty(p, "p", d2) }, "myexn")
 
   var props = {bla: {get value() { throw "otherexn" }}}
-  assertThrows(function(){ Object.defineProperties(p, props) }, "otherexn")
+  assertThrowsEquals(() => Object.defineProperties(p, props), "otherexn")
 }
 
 TestDefineThrow({
   defineProperty: function(k, d) { throw "myexn" }
 })
 
 TestDefineThrow({
   defineProperty: function(k, d) { return this.defineProperty2(k, d) },
   defineProperty2: function(k, d) { throw "myexn" }
 })
@@ skipping 65 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestDeleteThrow(handler) {
   TestWithProxies(TestDeleteThrow2, handler)
 }
 
 function TestDeleteThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ delete p.a }, "myexn")
-  assertThrows(function(){ delete p["b"] }, "myexn");
-  assertThrows(function(){ delete p[3] }, "myexn");
+  assertThrowsEquals(function(){ delete p.a }, "myexn")
+  assertThrowsEquals(function(){ delete p["b"] }, "myexn");
+  assertThrowsEquals(function(){ delete p[3] }, "myexn");
 
   (function() {
     "use strict"
-    assertThrows(function(){ delete p.c }, "myexn")
-    assertThrows(function(){ delete p["d"] }, "myexn")
-    assertThrows(function(){ delete p[4] }, "myexn");
+    assertThrowsEquals(function(){ delete p.c }, "myexn")
+    assertThrowsEquals(function(){ delete p["d"] }, "myexn")
+    assertThrowsEquals(function(){ delete p[4] }, "myexn");
   })()
 }
 
 TestDeleteThrow({
   deleteProperty(t, k) { throw "myexn" }
 })
 
 TestDeleteThrow({
   deleteProperty(t, k) { return this.delete2(k) },
   delete2(k) { throw "myexn" }
@@ skipping 52 matching lines @@
 })
 
 
 // ---------------------------------------------------------------------------
 function TestDescriptorThrow(handler) {
   TestWithProxies(TestDescriptorThrow2, handler)
 }
 
 function TestDescriptorThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.getOwnPropertyDescriptor(p, "a") }, "myexn")
+  assertThrowsEquals(() => Object.getOwnPropertyDescriptor(p, "a"), "myexn")
 }
 
 TestDescriptorThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 TestDescriptorThrow({
   getOwnPropertyDescriptor: function(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
@@ skipping 107 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestInThrow(handler) {
   TestWithProxies(TestInThrow2, handler)
 }
 
 function TestInThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ return "a" in o }, "myexn")
-  assertThrows(function(){ return 99 in o }, "myexn")
-  assertThrows(function(){ return !("a" in o) }, "myexn")
-  assertThrows(function(){ return ("a" in o) ? 2 : 3 }, "myexn")
-  assertThrows(function(){ if ("b" in o) {} }, "myexn")
-  assertThrows(function(){ if (!("b" in o)) {} }, "myexn")
-  assertThrows(function(){ if ("zzz" in o) {} }, "myexn")
+  assertThrowsEquals(function(){ return "a" in p }, "myexn")
+  assertThrowsEquals(function(){ return 99 in p }, "myexn")
+  assertThrowsEquals(function(){ return !("a" in p) }, "myexn")
+  assertThrowsEquals(function(){ return ("a" in p) ? 2 : 3 }, "myexn")
+  assertThrowsEquals(function(){ if ("b" in p) {} }, "myexn")
+  assertThrowsEquals(function(){ if (!("b" in p)) {} }, "myexn")
+  assertThrowsEquals(function(){ if ("zzz" in p) {} }, "myexn")
 }
 
 TestInThrow({
   has: function(k) { throw "myexn" }
 })
 
 TestInThrow({
   has: function(k) { return this.has2(k) },
   has2: function(k) { throw "myexn" }
 })
 
-TestInThrow({
-  getPropertyDescriptor: function(k) { throw "myexn" }
-})
-
-TestInThrow({
-  getPropertyDescriptor: function(k) { return this.getPropertyDescriptor2(k) },
-  getPropertyDescriptor2: function(k) { throw "myexn" }
-})
-
-TestInThrow({
-  has: undefined,
-  getPropertyDescriptor: function(k) { throw "myexn" }
-})
-
 TestInThrow(new Proxy({},{
   get: function(pr, pk) { throw "myexn" }
 }))
 
 TestInThrow(new Proxy({},{
   get: function(pr, pk) {
     return function(k) { throw "myexn" }
   }
 }))
 
@@ skipping 34 matching lines @@
 
 
 
 // ---------------------------------------------------------------------------
 function TestHasOwnThrow(handler) {
   TestWithProxies(TestHasOwnThrow2, handler)
 }
 
 function TestHasOwnThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.prototype.hasOwnProperty.call(p, "a")},
+  assertThrowsEquals(function(){ Object.prototype.hasOwnProperty.call(p, "a")},
     "myexn")
-  assertThrows(function(){ Object.prototype.hasOwnProperty.call(p, 99)},
+  assertThrowsEquals(function(){ Object.prototype.hasOwnProperty.call(p, 99)},
     "myexn")
 }
 
 TestHasOwnThrow({
   getOwnPropertyDescriptor(t, k) { throw "myexn" }
 })
 
 TestHasOwnThrow({
   getOwnPropertyDescriptor(t, k) { return this.getOwnPropertyDescriptor2(k) },
   getOwnPropertyDescriptor2(k) { throw "myexn" }
@@ skipping 166 matching lines @@
 })();
 
 
 // ---------------------------------------------------------------------------
 function TestPropertyNamesThrow(handler) {
   TestWithProxies(TestPropertyNamesThrow2, handler)
 }
 
 function TestPropertyNamesThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.getOwnPropertyNames(p) }, "myexn")
+  assertThrowsEquals(function(){ Object.getOwnPropertyNames(p) }, "myexn")
 }
 
 TestPropertyNamesThrow({
   ownKeys() { throw "myexn" }
 })
 
 TestPropertyNamesThrow({
   ownKeys() { return this.getOwnPropertyNames2() },
   getOwnPropertyNames2() { throw "myexn" }
 })
@@ skipping 60 matching lines @@
   getOwnPropertyDescriptor: function(k) { return {configurable: true} }
 })
 
 
 // ---------------------------------------------------------------------------
 function TestKeysThrow(handler) {
   TestWithProxies(TestKeysThrow2, handler)
 }
 
 function TestKeysThrow2(create, handler) {
-  var p = create(handler)
-  assertThrows(function(){ Object.keys(p) }, "myexn")
+  var p = create(handler);
+  assertThrowsEquals(function(){ Object.keys(p) }, "myexn");
 }
 
 TestKeysThrow({
   ownKeys() { throw "myexn" }
 })
 
 TestKeysThrow({
   ownKeys() { return this.keys2() },
   keys2() { throw "myexn" }
 })
 
 TestKeysThrow({
   ownKeys() { return ['1'] },
   getOwnPropertyDescriptor: function() { throw "myexn" },
 })
 
 TestKeysThrow({
   ownKeys() { return this.getOwnPropertyNames2() },
-  getOwnPropertyNames2() { return [1, 2] },
+  getOwnPropertyNames2() { return ['1', '2'] },
   getOwnPropertyDescriptor(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
   getOwnPropertyDescriptor2(k) { throw "myexn" }
 })
 
 TestKeysThrow({
   get ownKeys() { throw "myexn" }
 })
 
 TestKeysThrow({
   get ownKeys() {
     return function() { throw "myexn" }
   },
 })
 
 TestKeysThrow({
   get ownKeys() {
-    return function() { return [1, 2] }
+    return function() { return ['1', '2'] }
   },
   getOwnPropertyDescriptor(k) { throw "myexn" }
 })
 
 
 
 // ---------------------------------------------------------------------------
 // String conversion (Object.prototype.toString,
 //                    Object.prototype.toLocaleString,
 //                    Function.prototype.toString)
@@ skipping 38 matching lines @@
 TestToString(new Proxy({}, {
   get: function(pr, pk) {
     return function(r, k) { key = k; return function() { return "my_proxy" } }
   }
 }))
 
 
 function TestToStringThrow(handler) {
   var p = new Proxy({}, handler)
   assertEquals("[object Object]", Object.prototype.toString.call(p))
-  assertThrows(function(){ Object.prototype.toLocaleString.call(p) }, "myexn")
+  assertThrowsEquals(() => Object.prototype.toLocaleString.call(p), "myexn")
 
   var f = new Proxy(function(){}, handler)
   assertEquals("[object Function]", Object.prototype.toString.call(f))
-  assertThrows(function(){ Object.prototype.toLocaleString.call(f) }, "myexn")
+  assertThrowsEquals(() => Object.prototype.toLocaleString.call(f), "myexn")
 
   var o = Object.create(p)
   assertEquals("[object Object]", Object.prototype.toString.call(o))
-  assertThrows(function(){ Object.prototype.toLocaleString.call(o) }, "myexn")
+  assertThrowsEquals(() => Object.prototype.toLocaleString.call(o), "myexn")
 }
 
 TestToStringThrow({
   get: function(r, k) { throw "myexn" }
 })
 
 TestToStringThrow({
   get: function(r, k) { return function() { throw "myexn" } }
 })
 
@@ skipping 88 matching lines @@
 }))
 
 
 // ---------------------------------------------------------------------------
 function TestIsEnumerableThrow(handler) {
   TestWithProxies(TestIsEnumerableThrow2, handler)
 }
 
 function TestIsEnumerableThrow2(create, handler) {
   var p = create(handler)
-  assertThrows(function(){ Object.prototype.propertyIsEnumerable.call(p, "a") },
-    "myexn")
-  assertThrows(function(){ Object.prototype.propertyIsEnumerable.call(p, 11) },
-    "myexn")
+  assertThrowsEquals(() => Object.prototype.propertyIsEnumerable.call(p, "a"),
+      "myexn")
+  assertThrowsEquals(() => Object.prototype.propertyIsEnumerable.call(p, 11),
+      "myexn")
 }
 
 TestIsEnumerableThrow({
   getOwnPropertyDescriptor: function(k) { throw "myexn" }
 })
 
 TestIsEnumerableThrow({
   getOwnPropertyDescriptor: function(k) {
     return this.getOwnPropertyDescriptor2(k)
   },
@@ skipping 46 matching lines @@
   var o = new C();
 
   function f() {
     return o.x;
   }
   assertEquals(10, f());
   assertEquals(10, f());
   %OptimizeFunctionOnNextCall(f);
   assertEquals(10, f());
 })();