Upgrade to V8 3.6
Merge V8 at 3.6.6.11
Simple merge required updates to makefiles only.
Bug: 5688872
Change-Id: Ib38b7ffbcd409585f6cb6fccc59c767029cecc77
diff --git a/test/mjsunit/harmony/proxies.js b/test/mjsunit/harmony/proxies.js
index 640033d..3c4e5f6 100644
--- a/test/mjsunit/harmony/proxies.js
+++ b/test/mjsunit/harmony/proxies.js
@@ -1,5 +1,3 @@
-// Flags: --harmony-proxies
-
// Copyright 2008 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
@@ -27,16 +25,39 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Flags: --harmony-proxies
-// TODO(rossberg): test exception cases.
+
+// TODO(rossberg): for-in for proxies not implemented.
+// TODO(rossberg): inheritance from proxies not implemented.
+// TODO(rossberg): function proxies as constructors not implemented.
+
+
+// Helper.
+
+function TestWithProxies(test, handler) {
+ test(handler, Proxy.create)
+ test(handler, function(h) {return Proxy.createFunction(h, function() {})})
+}
// Getters.
function TestGet(handler) {
- var o = Proxy.create(handler)
- assertEquals(42, o.a)
- assertEquals(42, o["b"])
+ TestWithProxies(TestGet2, handler)
+}
+
+function TestGet2(handler, create) {
+ var p = create(handler)
+ assertEquals(42, p.a)
+ assertEquals(42, p["b"])
+
+ // TODO(rossberg): inheritance from proxies not yet implemented.
+ // var o = Object.create(p, {x: {value: 88}})
+ // assertEquals(42, o.a)
+ // assertEquals(42, o["b"])
+ // assertEquals(88, o.x)
+ // assertEquals(88, o["x"])
}
TestGet({
@@ -76,7 +97,11 @@
function TestGetCall(handler) {
- var p = Proxy.create(handler)
+ TestWithProxies(TestGetCall2, handler)
+}
+
+function TestGetCall2(handler, create) {
+ var p = create(handler)
assertEquals(55, p.f())
assertEquals(55, p.f("unused", "arguments"))
assertEquals(55, p.f.call(p))
@@ -139,17 +164,72 @@
}))
+function TestGetThrow(handler) {
+ TestWithProxies(TestGetThrow2, handler)
+}
+
+function TestGetThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ p.a }, "myexn")
+ assertThrows(function(){ p["b"] }, "myexn")
+}
+
+TestGetThrow({
+ get: function(r, k) { throw "myexn" }
+})
+
+TestGetThrow({
+ get: function(r, k) { return this.get2(r, k) },
+ get2: function(r, k) { throw "myexn" }
+})
+
+TestGetThrow({
+ getPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestGetThrow({
+ getPropertyDescriptor: function(k) { return this.getPropertyDescriptor2(k) },
+ getPropertyDescriptor2: function(k) { throw "myexn" }
+})
+
+TestGetThrow({
+ getPropertyDescriptor: function(k) {
+ return {get value() { throw "myexn" }}
+ }
+})
+
+TestGetThrow({
+ get: undefined,
+ getPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestGetThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestGetThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(r, k) { throw "myexn" }
+ }
+}))
+
+
// Setters.
var key
var val
-function TestSet(handler) {
- var o = Proxy.create(handler)
- assertEquals(42, o.a = 42)
+
+function TestSet(handler, create) {
+ TestWithProxies(TestSet2, handler)
+}
+
+function TestSet2(handler, create) {
+ var p = create(handler)
+ assertEquals(42, p.a = 42)
assertEquals("a", key)
assertEquals(42, val)
- assertEquals(43, o["b"] = 43)
+ assertEquals(43, p["b"] = 43)
assertEquals("b", key)
assertEquals(43, val)
}
@@ -225,31 +305,156 @@
+function TestSetThrow(handler, create) {
+ TestWithProxies(TestSetThrow2, handler)
+}
+
+function TestSetThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ p.a = 42 }, "myexn")
+ assertThrows(function(){ p["b"] = 42 }, "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} },
+ 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} },
+ 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 }}
+ },
+ 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(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestSetThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(r, k, v) { throw "myexn" }
+ }
+}))
+
+
+
// Property definition (Object.defineProperty and Object.defineProperties).
var key
var desc
+
function TestDefine(handler) {
- var o = Proxy.create(handler)
- assertEquals(o, Object.defineProperty(o, "a", {value: 44}))
+ TestWithProxies(TestDefine2, handler)
+}
+
+function TestDefine2(handler, create) {
+ var p = create(handler)
+ assertEquals(p, Object.defineProperty(p, "a", {value: 44}))
assertEquals("a", key)
assertEquals(1, Object.getOwnPropertyNames(desc).length)
assertEquals(44, desc.value)
- assertEquals(o, Object.defineProperty(o, "b", {value: 45, writable: false}))
+ assertEquals(p, Object.defineProperty(p, "b", {value: 45, writable: false}))
assertEquals("b", key)
assertEquals(2, Object.getOwnPropertyNames(desc).length)
assertEquals(45, desc.value)
assertEquals(false, desc.writable)
- assertEquals(o, Object.defineProperty(o, "c", {value: 46, enumerable: false}))
+ assertEquals(p, Object.defineProperty(p, "c", {value: 46, enumerable: false}))
assertEquals("c", key)
assertEquals(2, Object.getOwnPropertyNames(desc).length)
assertEquals(46, desc.value)
assertEquals(false, desc.enumerable)
var attributes = {configurable: true, mine: 66, minetoo: 23}
- assertEquals(o, Object.defineProperty(o, "d", attributes))
+ assertEquals(p, Object.defineProperty(p, "d", attributes))
assertEquals("d", key)
// Modifying the attributes object after the fact should have no effect.
attributes.configurable = false
@@ -260,23 +465,23 @@
assertEquals(66, desc.mine)
assertEquals(23, desc.minetoo)
- assertEquals(o, Object.defineProperty(o, "e", {get: function(){ return 5 }}))
+ assertEquals(p, Object.defineProperty(p, "e", {get: function(){ return 5 }}))
assertEquals("e", key)
assertEquals(1, Object.getOwnPropertyNames(desc).length)
assertEquals(5, desc.get())
- assertEquals(o, Object.defineProperty(o, "zzz", {}))
+ assertEquals(p, Object.defineProperty(p, "zzz", {}))
assertEquals("zzz", key)
assertEquals(0, Object.getOwnPropertyNames(desc).length)
-// TODO(rossberg): This test requires [s in proxy] to be implemented first.
-// var d = Proxy.create({
+// TODO(rossberg): This test requires for-in on proxies.
+// var d = create({
// get: function(r, k) { return (k === "value") ? 77 : void 0 },
// getOwnPropertyNames: function() { return ["value"] }
// })
// assertEquals(1, Object.getOwnPropertyNames(d).length)
// assertEquals(77, d.value)
-// assertEquals(o, Object.defineProperty(o, "p", d))
+// assertEquals(p, Object.defineProperty(p, "p", d))
// assertEquals("p", key)
// assertEquals(1, Object.getOwnPropertyNames(desc).length)
// assertEquals(77, desc.value)
@@ -288,12 +493,15 @@
last: {value: 21, configurable: true, mine: "eyes"}
}
Object.defineProperty(props, "hidden", {value: "hidden", enumerable: false})
- assertEquals(o, Object.defineProperties(o, props))
+ 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")
}
TestDefine({
@@ -312,42 +520,91 @@
}))
+function TestDefineThrow(handler) {
+ TestWithProxies(TestDefineThrow2, handler)
+}
+
+function TestDefineThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.defineProperty(p, "a", {value: 44})}, "myexn")
+
+// TODO(rossberg): These tests require for-in on proxies.
+// var d1 = create({
+// get: function(r, k) { throw "myexn" },
+// getOwnPropertyNames: function() { return ["value"] }
+// })
+// assertThrows(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")
+
+ var props = {bla: {get value() { throw "otherexn" }}}
+ assertThrows(function(){ 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" }
+})
+
+TestDefineThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestDefineThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(k, d) { throw "myexn" }
+ }
+}))
+
+
// Property deletion (delete).
var key
+
function TestDelete(handler) {
- var o = Proxy.create(handler)
- assertEquals(true, delete o.a)
+ TestWithProxies(TestDelete2, handler)
+}
+
+function TestDelete2(handler, create) {
+ var p = create(handler)
+ assertEquals(true, delete p.a)
assertEquals("a", key)
- assertEquals(true, delete o["b"])
+ assertEquals(true, delete p["b"])
assertEquals("b", key)
- assertEquals(false, delete o.z1)
+ assertEquals(false, delete p.z1)
assertEquals("z1", key)
- assertEquals(false, delete o["z2"])
+ assertEquals(false, delete p["z2"])
assertEquals("z2", key);
(function() {
"use strict"
- assertEquals(true, delete o.c)
+ assertEquals(true, delete p.c)
assertEquals("c", key)
- assertEquals(true, delete o["d"])
+ assertEquals(true, delete p["d"])
assertEquals("d", key)
- assertThrows(function() { delete o.z3 }, TypeError)
+ assertThrows(function(){ delete p.z3 }, TypeError)
assertEquals("z3", key)
- assertThrows(function() { delete o["z4"] }, TypeError)
+ assertThrows(function(){ delete p["z4"] }, TypeError)
assertEquals("z4", key)
})()
}
TestDelete({
- 'delete': function(k) { key = k; return k < "z" }
+ delete: function(k) { key = k; return k < "z" }
})
TestDelete({
- 'delete': function(k) { return this.delete2(k) },
+ delete: function(k) { return this.delete2(k) },
delete2: function(k) { key = k; return k < "z" }
})
@@ -358,11 +615,51 @@
}))
+function TestDeleteThrow(handler) {
+ TestWithProxies(TestDeleteThrow2, handler)
+}
+
+function TestDeleteThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ delete p.a }, "myexn")
+ assertThrows(function(){ delete p["b"] }, "myexn");
+
+ (function() {
+ "use strict"
+ assertThrows(function(){ delete p.c }, "myexn")
+ assertThrows(function(){ delete p["d"] }, "myexn")
+ })()
+}
+
+TestDeleteThrow({
+ delete: function(k) { throw "myexn" }
+})
+
+TestDeleteThrow({
+ delete: function(k) { return this.delete2(k) },
+ delete2: function(k) { throw "myexn" }
+})
+
+TestDeleteThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestDeleteThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(k) { throw "myexn" }
+ }
+}))
+
+
// Property descriptors (Object.getOwnPropertyDescriptor).
function TestDescriptor(handler) {
- var o = Proxy.create(handler)
+ TestWithProxies(TestDescriptor2, handler)
+}
+
+function TestDescriptor2(handler, create) {
+ var p = create(handler)
var descs = [
{configurable: true},
{value: 34, enumerable: true, configurable: true},
@@ -371,18 +668,17 @@
{get: function() { "get" }, set: function() { "set" }, configurable: true}
]
for (var i = 0; i < descs.length; ++i) {
- assertEquals(o, Object.defineProperty(o, i, descs[i]))
- var desc = Object.getOwnPropertyDescriptor(o, i)
- for (p in descs[i]) {
+ assertEquals(p, Object.defineProperty(p, i, descs[i]))
+ var desc = Object.getOwnPropertyDescriptor(p, i)
+ for (prop in descs[i]) {
// TODO(rossberg): Ignore user attributes as long as the spec isn't
// fixed suitably.
- if (p != "mine") assertEquals(descs[i][p], desc[p])
+ if (prop != "mine") assertEquals(descs[i][prop], desc[prop])
}
- assertEquals(undefined, Object.getOwnPropertyDescriptor(o, "absent"))
+ assertEquals(undefined, Object.getOwnPropertyDescriptor(p, "absent"))
}
}
-
TestDescriptor({
defineProperty: function(k, d) { this["__" + k] = d; return true },
getOwnPropertyDescriptor: function(k) { return this["__" + k] }
@@ -397,18 +693,43 @@
})
+function TestDescriptorThrow(handler) {
+ TestWithProxies(TestDescriptorThrow2, handler)
+}
+
+function TestDescriptorThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.getOwnPropertyDescriptor(p, "a") }, "myexn")
+}
+
+TestDescriptorThrow({
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestDescriptorThrow({
+ getOwnPropertyDescriptor: function(k) {
+ return this.getOwnPropertyDescriptor2(k)
+ },
+ getOwnPropertyDescriptor2: function(k) { throw "myexn" }
+})
+
+
// Comparison.
function TestComparison(eq) {
- var o1 = Proxy.create({})
- var o2 = Proxy.create({})
+ TestWithProxies(TestComparison2, eq)
+}
- assertTrue(eq(o1, o1))
- assertTrue(eq(o2, o2))
- assertTrue(!eq(o1, o2))
- assertTrue(!eq(o1, {}))
- assertTrue(!eq({}, o2))
+function TestComparison2(eq, create) {
+ var p1 = create({})
+ var p2 = create({})
+
+ assertTrue(eq(p1, p1))
+ assertTrue(eq(p2, p2))
+ assertTrue(!eq(p1, p2))
+ assertTrue(!eq(p1, {}))
+ assertTrue(!eq({}, p2))
assertTrue(!eq({}, {}))
}
@@ -419,45 +740,61 @@
-// Type.
+// Type (typeof).
-assertEquals("object", typeof Proxy.create({}))
-assertTrue(typeof Proxy.create({}) == "object")
-assertTrue("object" == typeof Proxy.create({}))
+function TestTypeof() {
+ assertEquals("object", typeof Proxy.create({}))
+ assertTrue(typeof Proxy.create({}) == "object")
+ assertTrue("object" == typeof Proxy.create({}))
-// No function proxies yet.
+ assertEquals("function", typeof Proxy.createFunction({}, function() {}))
+ assertTrue(typeof Proxy.createFunction({}, function() {}) == "function")
+ assertTrue("function" == typeof Proxy.createFunction({}, function() {}))
+}
+
+TestTypeof()
// Membership test (in).
var key
+
function TestIn(handler) {
- var o = Proxy.create(handler)
- assertTrue("a" in o)
+ TestWithProxies(TestIn2, handler)
+}
+
+function TestIn2(handler, create) {
+ var p = create(handler)
+ assertTrue("a" in p)
assertEquals("a", key)
- assertTrue(99 in o)
+ assertTrue(99 in p)
assertEquals("99", key)
- assertFalse("z" in o)
+ assertFalse("z" in p)
assertEquals("z", key)
- if ("b" in o) {
+ assertEquals(2, ("a" in p) ? 2 : 0)
+ assertEquals(0, !("a" in p) ? 2 : 0)
+ assertEquals(0, ("zzz" in p) ? 2 : 0)
+ assertEquals(2, !("zzz" in p) ? 2 : 0)
+
+ if ("b" in p) {
} else {
assertTrue(false)
}
assertEquals("b", key)
- if ("zz" in o) {
+ if ("zz" in p) {
assertTrue(false)
}
assertEquals("zz", key)
- if (!("c" in o)) {
+ if (!("c" in p)) {
assertTrue(false)
}
assertEquals("c", key)
- if (!("zzz" in o)) {
+ if (!("zzz" in p)) {
} else {
assertTrue(false)
}
@@ -506,17 +843,70 @@
}))
+function TestInThrow(handler) {
+ TestWithProxies(TestInThrow2, handler)
+}
+
+function TestInThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ return "a" 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")
+}
+
+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({
+ get: undefined,
+ getPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestInThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestInThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(k) { throw "myexn" }
+ }
+}))
+
+
// Own Properties (Object.prototype.hasOwnProperty).
var key
+
function TestHasOwn(handler) {
- var o = Proxy.create(handler)
- assertTrue(Object.prototype.hasOwnProperty.call(o, "a"))
+ TestWithProxies(TestHasOwn2, handler)
+}
+
+function TestHasOwn2(handler, create) {
+ var p = create(handler)
+ assertTrue(Object.prototype.hasOwnProperty.call(p, "a"))
assertEquals("a", key)
- assertTrue(Object.prototype.hasOwnProperty.call(o, 99))
+ assertTrue(Object.prototype.hasOwnProperty.call(p, 99))
assertEquals("99", key)
- assertFalse(Object.prototype.hasOwnProperty.call(o, "z"))
+ assertFalse(Object.prototype.hasOwnProperty.call(p, "z"))
assertEquals("z", key)
}
@@ -564,6 +954,54 @@
}))
+function TestHasOwnThrow(handler) {
+ TestWithProxies(TestHasOwnThrow2, handler)
+}
+
+function TestHasOwnThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.prototype.hasOwnProperty.call(p, "a")},
+ "myexn")
+ assertThrows(function(){ Object.prototype.hasOwnProperty.call(p, 99)},
+ "myexn")
+}
+
+TestHasOwnThrow({
+ hasOwn: function(k) { throw "myexn" }
+})
+
+TestHasOwnThrow({
+ hasOwn: function(k) { return this.hasOwn2(k) },
+ hasOwn2: function(k) { throw "myexn" }
+})
+
+TestHasOwnThrow({
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestHasOwnThrow({
+ getOwnPropertyDescriptor: function(k) {
+ return this.getOwnPropertyDescriptor2(k)
+ },
+ getOwnPropertyDescriptor2: function(k) { throw "myexn" }
+})
+
+TestHasOwnThrow({
+ hasOwn: undefined,
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestHasOwnThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestHasOwnThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(k) { throw "myexn" }
+ }
+}))
+
+
// Instanceof (instanceof)
@@ -573,29 +1011,32 @@
var p2 = Proxy.create({}, o)
var p3 = Proxy.create({}, p2)
- var f = function() {}
- f.prototype = o
+ var f0 = function() {}
+ f0.prototype = o
var f1 = function() {}
f1.prototype = p1
var f2 = function() {}
f2.prototype = p2
assertTrue(o instanceof Object)
- assertFalse(o instanceof f)
+ assertFalse(o instanceof f0)
assertFalse(o instanceof f1)
assertFalse(o instanceof f2)
assertFalse(p1 instanceof Object)
- assertFalse(p1 instanceof f)
+ assertFalse(p1 instanceof f0)
assertFalse(p1 instanceof f1)
assertFalse(p1 instanceof f2)
assertTrue(p2 instanceof Object)
- assertTrue(p2 instanceof f)
+ assertTrue(p2 instanceof f0)
assertFalse(p2 instanceof f1)
assertFalse(p2 instanceof f2)
assertTrue(p3 instanceof Object)
- assertTrue(p3 instanceof f)
+ assertTrue(p3 instanceof f0)
assertFalse(p3 instanceof f1)
assertTrue(p3 instanceof f2)
+
+ var f = Proxy.createFunction({}, function() {})
+ assertTrue(f instanceof Function)
}
TestInstanceof()
@@ -642,6 +1083,11 @@
assertTrue(Object.prototype.isPrototypeOf.call(p2, p3))
assertFalse(Object.prototype.isPrototypeOf.call(p2, p4))
assertFalse(Object.prototype.isPrototypeOf.call(p3, p2))
+
+ var f = Proxy.createFunction({}, function() {})
+ assertSame(Object.getPrototypeOf(f), Function.prototype)
+ assertTrue(Object.prototype.isPrototypeOf(f))
+ assertTrue(Object.prototype.isPrototypeOf.call(Function.prototype, f))
}
TestPrototype()
@@ -651,8 +1097,12 @@
// Property names (Object.getOwnPropertyNames, Object.keys).
function TestPropertyNames(names, handler) {
- var p = Proxy.create(handler)
- assertArrayEquals(names, Object.getOwnPropertyNames(p))
+ TestWithProxies(TestPropertyNames2, [names, handler])
+}
+
+function TestPropertyNames2(names_handler, create) {
+ var p = create(names_handler[1])
+ assertArrayEquals(names_handler[0], Object.getOwnPropertyNames(p))
}
TestPropertyNames([], {
@@ -675,9 +1125,32 @@
})
+function TestPropertyNamesThrow(handler) {
+ TestWithProxies(TestPropertyNamesThrow2, handler)
+}
+
+function TestPropertyNamesThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.getOwnPropertyNames(p) }, "myexn")
+}
+
+TestPropertyNamesThrow({
+ getOwnPropertyNames: function() { throw "myexn" }
+})
+
+TestPropertyNamesThrow({
+ getOwnPropertyNames: function() { return this.getOwnPropertyNames2() },
+ getOwnPropertyNames2: function() { throw "myexn" }
+})
+
+
function TestKeys(names, handler) {
- var p = Proxy.create(handler)
- assertArrayEquals(names, Object.keys(p))
+ TestWithProxies(TestKeys2, [names, handler])
+}
+
+function TestKeys2(names_handler, create) {
+ var p = create(names_handler[1])
+ assertArrayEquals(names_handler[0], Object.keys(p))
}
TestKeys([], {
@@ -730,10 +1203,71 @@
})
+function TestKeysThrow(handler) {
+ TestWithProxies(TestKeysThrow2, handler)
+}
+
+function TestKeysThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.keys(p) }, "myexn")
+}
+
+TestKeysThrow({
+ keys: function() { throw "myexn" }
+})
+
+TestKeysThrow({
+ keys: function() { return this.keys2() },
+ keys2: function() { throw "myexn" }
+})
+
+TestKeysThrow({
+ getOwnPropertyNames: function() { throw "myexn" },
+ getOwnPropertyDescriptor: function(k) { return true }
+})
+
+TestKeysThrow({
+ getOwnPropertyNames: function() { return [1, 2] },
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestKeysThrow({
+ getOwnPropertyNames: function() { return this.getOwnPropertyNames2() },
+ getOwnPropertyNames2: function() { throw "myexn" },
+})
+
+TestKeysThrow({
+ getOwnPropertyNames: function() { return this.getOwnPropertyNames2() },
+ getOwnPropertyNames2: function() { return [1, 2] },
+ getOwnPropertyDescriptor: function(k) {
+ return this.getOwnPropertyDescriptor2(k)
+ },
+ getOwnPropertyDescriptor2: function(k) { throw "myexn" }
+})
+
+TestKeysThrow({
+ get getOwnPropertyNames() { throw "myexn" }
+})
+
+TestKeysThrow({
+ get getOwnPropertyNames() {
+ return function() { throw "myexn" }
+ },
+})
+
+TestKeysThrow([], {
+ get getOwnPropertyNames() {
+ return function() { return [1, 2] }
+ },
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+
// Fixing (Object.freeze, Object.seal, Object.preventExtensions,
// Object.isFrozen, Object.isSealed, Object.isExtensible)
+// TODO(rossberg): use TestWithProxies to include funciton proxies
function TestFix(names, handler) {
var proto = {p: 77}
var assertFixing = function(o, s, f, e) {
@@ -742,44 +1276,44 @@
assertEquals(e, Object.isExtensible(o))
}
- var o1 = Proxy.create(handler, proto)
- assertFixing(o1, false, false, true)
- Object.seal(o1)
- assertFixing(o1, true, names.length === 0, false)
- assertArrayEquals(names.sort(), Object.getOwnPropertyNames(o1).sort())
+ var p1 = Proxy.create(handler, proto)
+ assertFixing(p1, false, false, true)
+ Object.seal(p1)
+ assertFixing(p1, true, names.length === 0, false)
+ assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p1).sort())
assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
- Object.keys(o1).sort())
- assertEquals(proto, Object.getPrototypeOf(o1))
- assertEquals(77, o1.p)
- for (var n in o1) {
- var desc = Object.getOwnPropertyDescriptor(o1, n)
+ Object.keys(p1).sort())
+ assertEquals(proto, Object.getPrototypeOf(p1))
+ assertEquals(77, p1.p)
+ for (var n in p1) {
+ var desc = Object.getOwnPropertyDescriptor(p1, n)
if (desc !== undefined) assertFalse(desc.configurable)
}
- var o2 = Proxy.create(handler, proto)
- assertFixing(o2, false, false, true)
- Object.freeze(o2)
- assertFixing(o2, true, true, false)
- assertArrayEquals(names.sort(), Object.getOwnPropertyNames(o2).sort())
+ var p2 = Proxy.create(handler, proto)
+ assertFixing(p2, false, false, true)
+ Object.freeze(p2)
+ assertFixing(p2, true, true, false)
+ assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p2).sort())
assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
- Object.keys(o2).sort())
- assertEquals(proto, Object.getPrototypeOf(o2))
- assertEquals(77, o2.p)
- for (var n in o2) {
- var desc = Object.getOwnPropertyDescriptor(o2, n)
+ Object.keys(p2).sort())
+ assertEquals(proto, Object.getPrototypeOf(p2))
+ assertEquals(77, p2.p)
+ for (var n in p2) {
+ var desc = Object.getOwnPropertyDescriptor(p2, n)
if (desc !== undefined) assertFalse(desc.writable)
if (desc !== undefined) assertFalse(desc.configurable)
}
- var o3 = Proxy.create(handler, proto)
- assertFixing(o3, false, false, true)
- Object.preventExtensions(o3)
- assertFixing(o3, names.length === 0, names.length === 0, false)
- assertArrayEquals(names.sort(), Object.getOwnPropertyNames(o3).sort())
+ var p3 = Proxy.create(handler, proto)
+ assertFixing(p3, false, false, true)
+ Object.preventExtensions(p3)
+ assertFixing(p3, names.length === 0, names.length === 0, false)
+ assertArrayEquals(names.sort(), Object.getOwnPropertyNames(p3).sort())
assertArrayEquals(names.filter(function(x) {return x < "z"}).sort(),
- Object.keys(o3).sort())
- assertEquals(proto, Object.getPrototypeOf(o3))
- assertEquals(77, o3.p)
+ Object.keys(p3).sort())
+ assertEquals(proto, Object.getPrototypeOf(p3))
+ assertEquals(77, p3.p)
}
TestFix([], {
@@ -814,17 +1348,84 @@
})
+function TestFixFunction(fix) {
+ var f1 = Proxy.createFunction({
+ fix: function() { return {} }
+ }, function() {})
+ fix(f1)
+ assertEquals(0, f1.length)
-// String conversion (Object.prototype.toString, Object.prototype.toLocaleString)
+ var f2 = Proxy.createFunction({
+ fix: function() { return {length: {value: 3}} }
+ }, function() {})
+ fix(f2)
+ assertEquals(3, f2.length)
+
+ var f3 = Proxy.createFunction({
+ fix: function() { return {length: {value: "huh"}} }
+ }, function() {})
+ fix(f3)
+ assertEquals(0, f1.length)
+}
+
+TestFixFunction(Object.seal)
+TestFixFunction(Object.freeze)
+TestFixFunction(Object.preventExtensions)
+
+
+function TestFixThrow(handler) {
+ TestWithProxies(TestFixThrow2, handler)
+}
+
+function TestFixThrow2(handler) {
+ var p = Proxy.create(handler, {})
+ assertThrows(function(){ Object.seal(p) }, "myexn")
+ assertThrows(function(){ Object.freeze(p) }, "myexn")
+ assertThrows(function(){ Object.preventExtensions(p) }, "myexn")
+}
+
+TestFixThrow({
+ fix: function() { throw "myexn" }
+})
+
+TestFixThrow({
+ fix: function() { return this.fix2() },
+ fix2: function() { throw "myexn" }
+})
+
+TestFixThrow({
+ get fix() { throw "myexn" }
+})
+
+TestFixThrow({
+ get fix() {
+ return function() { throw "myexn" }
+ }
+})
+
+
+
+// String conversion (Object.prototype.toString,
+// Object.prototype.toLocaleString,
+// Function.prototype.toString)
var key
+
function TestToString(handler) {
- var o = Proxy.create(handler)
+ var p = Proxy.create(handler)
key = ""
- assertEquals("[object Object]", Object.prototype.toString.call(o))
+ assertEquals("[object Object]", Object.prototype.toString.call(p))
assertEquals("", key)
- assertEquals("my_proxy", Object.prototype.toLocaleString.call(o))
+ assertEquals("my_proxy", Object.prototype.toLocaleString.call(p))
assertEquals("toString", key)
+
+ var f = Proxy.createFunction(handler, function() {})
+ key = ""
+ assertEquals("[object Function]", Object.prototype.toString.call(f))
+ assertEquals("", key)
+ assertEquals("my_proxy", Object.prototype.toLocaleString.call(f))
+ assertEquals("toString", key)
+ assertDoesNotThrow(function(){ Function.prototype.toString.call(f) })
}
TestToString({
@@ -843,12 +1444,50 @@
}))
+function TestToStringThrow(handler) {
+ var p = Proxy.create(handler)
+ assertEquals("[object Object]", Object.prototype.toString.call(p))
+ assertThrows(function(){ Object.prototype.toLocaleString.call(p) }, "myexn")
+
+ var f = Proxy.createFunction(handler, function() {})
+ assertEquals("[object Function]", Object.prototype.toString.call(f))
+ assertThrows(function(){ Object.prototype.toLocaleString.call(f) }, "myexn")
+}
+
+TestToStringThrow({
+ get: function(r, k) { throw "myexn" }
+})
+
+TestToStringThrow({
+ get: function(r, k) { return function() { throw "myexn" } }
+})
+
+TestToStringThrow({
+ get: function(r, k) { return this.get2(r, k) },
+ get2: function(r, k) { throw "myexn" }
+})
+
+TestToStringThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestToStringThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(r, k) { throw "myexn" }
+ }
+}))
+
+
// Value conversion (Object.prototype.toValue)
function TestValueOf(handler) {
- var o = Proxy.create(handler)
- assertSame(o, Object.prototype.valueOf.call(o))
+ TestWithProxies(TestValueOf2, handler)
+}
+
+function TestValueOf2(handler, create) {
+ var p = create(handler)
+ assertSame(p, Object.prototype.valueOf.call(p))
}
TestValueOf({})
@@ -858,13 +1497,18 @@
// Enumerability (Object.prototype.propertyIsEnumerable)
var key
+
function TestIsEnumerable(handler) {
- var o = Proxy.create(handler)
- assertTrue(Object.prototype.propertyIsEnumerable.call(o, "a"))
+ TestWithProxies(TestIsEnumerable2, handler)
+}
+
+function TestIsEnumerable2(handler, create) {
+ var p = create(handler)
+ assertTrue(Object.prototype.propertyIsEnumerable.call(p, "a"))
assertEquals("a", key)
- assertTrue(Object.prototype.propertyIsEnumerable.call(o, 2))
+ assertTrue(Object.prototype.propertyIsEnumerable.call(p, 2))
assertEquals("2", key)
- assertFalse(Object.prototype.propertyIsEnumerable.call(o, "z"))
+ assertFalse(Object.prototype.propertyIsEnumerable.call(p, "z"))
assertEquals("z", key)
}
@@ -896,3 +1540,143 @@
}
}
}))
+
+
+function TestIsEnumerableThrow(handler) {
+ TestWithProxies(TestIsEnumerableThrow2, handler)
+}
+
+function TestIsEnumerableThrow2(handler, create) {
+ var p = create(handler)
+ assertThrows(function(){ Object.prototype.propertyIsEnumerable.call(p, "a") },
+ "myexn")
+ assertThrows(function(){ Object.prototype.propertyIsEnumerable.call(p, 11) },
+ "myexn")
+}
+
+TestIsEnumerableThrow({
+ getOwnPropertyDescriptor: function(k) { throw "myexn" }
+})
+
+TestIsEnumerableThrow({
+ getOwnPropertyDescriptor: function(k) {
+ return this.getOwnPropertyDescriptor2(k)
+ },
+ getOwnPropertyDescriptor2: function(k) { throw "myexn" }
+})
+
+TestIsEnumerableThrow({
+ getOwnPropertyDescriptor: function(k) {
+ return {get enumerable() { throw "myexn" }, configurable: true}
+ },
+})
+
+TestIsEnumerableThrow(Proxy.create({
+ get: function(pr, pk) { throw "myexn" }
+}))
+
+TestIsEnumerableThrow(Proxy.create({
+ get: function(pr, pk) {
+ return function(k) { throw "myexn" }
+ }
+}))
+
+
+
+// Calling (call, Function.prototype.call, Function.prototype.apply,
+// Function.prototype.bind).
+
+var global = this
+var receiver
+
+function TestCall(isStrict, callTrap) {
+ assertEquals(42, callTrap(5, 37))
+// TODO(rossberg): unrelated bug: this does not succeed for optimized code.
+// assertEquals(isStrict ? undefined : global, receiver)
+
+ var f = Proxy.createFunction({fix: function() { return {} }}, callTrap)
+ receiver = 333
+ assertEquals(42, f(11, 31))
+ assertEquals(isStrict ? undefined : global, receiver)
+ var o = {}
+ assertEquals(42, Function.prototype.call.call(f, o, 20, 22))
+ assertEquals(o, receiver)
+ assertEquals(43, Function.prototype.call.call(f, null, 20, 23))
+ assertEquals(isStrict ? null : global, receiver)
+ assertEquals(44, Function.prototype.call.call(f, 2, 21, 23))
+ assertEquals(2, receiver.valueOf())
+ receiver = 333
+ assertEquals(32, Function.prototype.apply.call(f, o, [17, 15]))
+ assertEquals(o, receiver)
+ var ff = Function.prototype.bind.call(f, o, 12)
+ receiver = 333
+ assertEquals(42, ff(30))
+ assertEquals(o, receiver)
+ receiver = 333
+ assertEquals(32, Function.prototype.apply.call(ff, {}, [20]))
+ assertEquals(o, receiver)
+
+ Object.freeze(f)
+ receiver = 333
+ assertEquals(42, f(11, 31))
+// TODO(rossberg): unrelated bug: this does not succeed for optimized code.
+// assertEquals(isStrict ? undefined : global, receiver)
+ receiver = 333
+ assertEquals(42, Function.prototype.call.call(f, o, 20, 22))
+ assertEquals(o, receiver)
+ receiver = 333
+ assertEquals(32, Function.prototype.apply.call(f, o, [17, 15]))
+ assertEquals(o, receiver)
+ receiver = 333
+ assertEquals(42, ff(30))
+ assertEquals(o, receiver)
+ receiver = 333
+ assertEquals(32, Function.prototype.apply.call(ff, {}, [20]))
+ assertEquals(o, receiver)
+}
+
+TestCall(false, function(x, y) {
+ receiver = this; return x + y
+})
+
+TestCall(true, function(x, y) {
+ "use strict";
+ receiver = this; return x + y
+})
+
+TestCall(false, Proxy.createFunction({}, function(x, y) {
+ receiver = this; return x + y
+}))
+
+TestCall(true, Proxy.createFunction({}, function(x, y) {
+ "use strict";
+ receiver = this; return x + y
+}))
+
+var p = Proxy.createFunction({fix: function() {return {}}}, function(x, y) {
+ receiver = this; return x + y
+})
+TestCall(false, p)
+Object.freeze(p)
+TestCall(false, p)
+
+
+function TestCallThrow(callTrap) {
+ var f = Proxy.createFunction({fix: function() {return {}}}, callTrap)
+ assertThrows(function(){ f(11) }, "myexn")
+ assertThrows(function(){ Function.prototype.call.call(f, {}, 2) }, "myexn")
+ assertThrows(function(){ Function.prototype.apply.call(f, {}, [1]) }, "myexn")
+
+ Object.freeze(f)
+ assertThrows(function(){ f(11) }, "myexn")
+ assertThrows(function(){ Function.prototype.call.call(f, {}, 2) }, "myexn")
+ assertThrows(function(){ Function.prototype.apply.call(f, {}, [1]) }, "myexn")
+}
+
+TestCallThrow(function() { throw "myexn" })
+TestCallThrow(Proxy.createFunction({}, function() { throw "myexn" }))
+
+var p = Proxy.createFunction(
+ {fix: function() {return {}}}, function() { throw "myexn" })
+Object.freeze(p)
+TestCallThrow(p)