summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js')
-rw-r--r--src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js748
1 files changed, 0 insertions, 748 deletions
diff --git a/src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js b/src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js
deleted file mode 100644
index 6b8d098..0000000
--- a/src/3rdparty/v8/test/mjsunit/harmony/proxies-function.js
+++ /dev/null
@@ -1,748 +0,0 @@
-// 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
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (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 --allow-natives-syntax
-
-
-// Helper.
-
-function CreateFrozen(handler, callTrap, constructTrap) {
- if (handler.fix === undefined) handler.fix = function() { return {} }
- var f = Proxy.createFunction(handler, callTrap, constructTrap)
- Object.freeze(f)
- return f
-}
-
-
-// Ensures that checking the "length" property of a function proxy doesn't
-// crash due to lack of a [[Get]] method.
-var handler = {
- get : function(r, n) { return n == "length" ? 2 : undefined }
-}
-
-
-// Calling (call, Function.prototype.call, Function.prototype.apply,
-// Function.prototype.bind).
-
-var global_object = this
-var receiver
-
-function TestCall(isStrict, callTrap) {
- assertEquals(42, callTrap(5, 37))
- // TODO(rossberg): strict mode seems to be broken on x64...
- // assertSame(isStrict ? undefined : global_object, receiver)
-
- var handler = {
- get: function(r, k) {
- return k == "length" ? 2 : Function.prototype[k]
- }
- }
- var f = Proxy.createFunction(handler, callTrap)
- var o = {f: f}
- global_object.f = f
-
- receiver = 333
- assertEquals(42, f(11, 31))
- // TODO(rossberg): strict mode seems to be broken on x64...
- // assertSame(isStrict ? undefined : global_object, receiver)
- receiver = 333
- assertEquals(42, o.f(10, 32))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, o["f"](9, 33))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, (1, o).f(8, 34))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, (1, o)["f"](7, 35))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, f.call(o, 32, 10))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, f.call(undefined, 33, 9))
- assertSame(isStrict ? undefined : global_object, receiver)
- receiver = 333
- assertEquals(42, f.call(null, 33, 9))
- assertSame(isStrict ? null : global_object, receiver)
- receiver = 333
- assertEquals(44, f.call(2, 21, 23))
- assertSame(2, receiver.valueOf())
- receiver = 333
- assertEquals(42, Function.prototype.call.call(f, o, 20, 22))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(43, Function.prototype.call.call(f, null, 20, 23))
- assertSame(isStrict ? null : global_object, receiver)
- assertEquals(44, Function.prototype.call.call(f, 2, 21, 23))
- assertEquals(2, receiver.valueOf())
- receiver = 333
- assertEquals(32, f.apply(o, [16, 16]))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(32, Function.prototype.apply.call(f, o, [17, 15]))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Call(o, 11, 31, f))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Call(null, 11, 31, f))
- assertSame(isStrict ? null : global_object, receiver)
- receiver = 333
- assertEquals(42, %Apply(f, o, [11, 31], 0, 2))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Apply(f, null, [11, 31], 0, 2))
- assertSame(isStrict ? null : global_object, receiver)
- receiver = 333
- assertEquals(42, %_CallFunction(o, 11, 31, f))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %_CallFunction(null, 11, 31, f))
- assertSame(isStrict ? null : global_object, receiver)
-
- var ff = Function.prototype.bind.call(f, o, 12)
- assertTrue(ff.length <= 1) // TODO(rossberg): Not spec'ed yet, be lax.
- receiver = 333
- assertEquals(42, ff(30))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(33, Function.prototype.call.call(ff, {}, 21))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(32, Function.prototype.apply.call(ff, {}, [20]))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(23, %Call({}, 11, ff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(23, %Call({}, 11, 3, ff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(24, %Apply(ff, {}, [12, 13], 0, 1))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(24, %Apply(ff, {}, [12, 13], 0, 2))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(34, %_CallFunction({}, 22, ff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(34, %_CallFunction({}, 22, 3, ff))
- assertSame(o, receiver)
-
- var fff = Function.prototype.bind.call(ff, o, 30)
- assertEquals(0, fff.length)
- receiver = 333
- assertEquals(42, fff())
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, Function.prototype.call.call(fff, {}))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, Function.prototype.apply.call(fff, {}))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Call({}, fff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Call({}, 11, 3, fff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Apply(fff, {}, [], 0, 0))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Apply(fff, {}, [12, 13], 0, 0))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %Apply(fff, {}, [12, 13], 0, 2))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %_CallFunction({}, fff))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %_CallFunction({}, 3, 4, 5, fff))
- assertSame(o, receiver)
-
- var f = CreateFrozen({}, callTrap)
- receiver = 333
- assertEquals(42, f(11, 31))
- assertSame(isStrict ? undefined : global_object, receiver)
- var o = {f: f}
- receiver = 333
- assertEquals(42, o.f(10, 32))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, o["f"](9, 33))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, (1, o).f(8, 34))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, (1, o)["f"](7, 35))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, Function.prototype.call.call(f, o, 20, 22))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(32, Function.prototype.apply.call(f, o, [17, 15]))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(23, %Call(o, 11, 12, f))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(27, %Apply(f, o, [12, 13, 14], 1, 2))
- assertSame(o, receiver)
- receiver = 333
- assertEquals(42, %_CallFunction(o, 18, 24, f))
- assertSame(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, function() {
- receiver = this
- return arguments[0] + arguments[1]
-})
-
-TestCall(false, Proxy.createFunction(handler, function(x, y) {
- receiver = this
- return x + y
-}))
-
-TestCall(true, Proxy.createFunction(handler, function(x, y) {
- "use strict"
- receiver = this
- return x + y
-}))
-
-TestCall(false, CreateFrozen(handler, function(x, y) {
- receiver = this
- return x + y
-}))
-
-
-
-// Using intrinsics as call traps.
-
-function TestCallIntrinsic(type, callTrap) {
- var f = Proxy.createFunction({}, callTrap)
- var x = f()
- assertTrue(typeof x == type)
-}
-
-TestCallIntrinsic("boolean", Boolean)
-TestCallIntrinsic("number", Number)
-TestCallIntrinsic("string", String)
-TestCallIntrinsic("object", Object)
-TestCallIntrinsic("function", Function)
-
-
-
-// Throwing from call trap.
-
-function TestCallThrow(callTrap) {
- var f = Proxy.createFunction({}, callTrap)
- assertThrows(function(){ f(11) }, "myexn")
- assertThrows(function(){ ({x: f}).x(11) }, "myexn")
- assertThrows(function(){ ({x: f})["x"](11) }, "myexn")
- assertThrows(function(){ Function.prototype.call.call(f, {}, 2) }, "myexn")
- assertThrows(function(){ Function.prototype.apply.call(f, {}, [1]) }, "myexn")
- assertThrows(function(){ %Call({}, f) }, "myexn")
- assertThrows(function(){ %Call({}, 1, 2, f) }, "myexn")
- assertThrows(function(){ %Apply({}, f, [], 3, 0) }, "myexn")
- assertThrows(function(){ %Apply({}, f, [3, 4], 0, 1) }, "myexn")
- assertThrows(function(){ %_CallFunction({}, f) }, "myexn")
- assertThrows(function(){ %_CallFunction({}, 1, 2, f) }, "myexn")
-
- var f = CreateFrozen({}, callTrap)
- assertThrows(function(){ f(11) }, "myexn")
- assertThrows(function(){ ({x: f}).x(11) }, "myexn")
- assertThrows(function(){ ({x: f})["x"](11) }, "myexn")
- assertThrows(function(){ Function.prototype.call.call(f, {}, 2) }, "myexn")
- assertThrows(function(){ Function.prototype.apply.call(f, {}, [1]) }, "myexn")
- assertThrows(function(){ %Call({}, f) }, "myexn")
- assertThrows(function(){ %Call({}, 1, 2, f) }, "myexn")
- assertThrows(function(){ %Apply({}, f, [], 3, 0) }, "myexn")
- assertThrows(function(){ %Apply({}, f, [3, 4], 0, 1) }, "myexn")
- assertThrows(function(){ %_CallFunction({}, f) }, "myexn")
- assertThrows(function(){ %_CallFunction({}, 1, 2, f) }, "myexn")
-}
-
-TestCallThrow(function() { throw "myexn" })
-TestCallThrow(Proxy.createFunction({}, function() { throw "myexn" }))
-TestCallThrow(CreateFrozen({}, function() { throw "myexn" }))
-
-
-
-// Construction (new).
-
-var prototype = {myprop: 0}
-var receiver
-
-var handlerWithPrototype = {
- fix: function() { return { prototype: { value: prototype } }; },
- get: function(r, n) {
- if (n == "length") return 2;
- assertEquals("prototype", n);
- return prototype;
- }
-}
-
-var handlerSansPrototype = {
- fix: function() { return { length: { value: 2 } } },
- get: function(r, n) {
- if (n == "length") return 2;
- assertEquals("prototype", n);
- return undefined;
- }
-}
-
-function ReturnUndef(x, y) {
- "use strict";
- receiver = this;
- this.sum = x + y;
-}
-
-function ReturnThis(x, y) {
- "use strict";
- receiver = this;
- this.sum = x + y;
- return this;
-}
-
-function ReturnNew(x, y) {
- "use strict";
- receiver = this;
- return {sum: x + y};
-}
-
-function ReturnNewWithProto(x, y) {
- "use strict";
- receiver = this;
- var result = Object.create(prototype);
- result.sum = x + y;
- return result;
-}
-
-function TestConstruct(proto, constructTrap) {
- TestConstruct2(proto, constructTrap, handlerWithPrototype)
- TestConstruct2(proto, constructTrap, handlerSansPrototype)
-}
-
-function TestConstruct2(proto, constructTrap, handler) {
- var f = Proxy.createFunction(handler, function() {}, constructTrap)
- var o = new f(11, 31)
- assertEquals(undefined, receiver)
- assertEquals(42, o.sum)
- assertSame(proto, Object.getPrototypeOf(o))
-
- var f = CreateFrozen(handler, function() {}, constructTrap)
- var o = new f(11, 32)
- assertEquals(undefined, receiver)
- assertEquals(43, o.sum)
- assertSame(proto, Object.getPrototypeOf(o))
-}
-
-TestConstruct(Object.prototype, ReturnNew)
-TestConstruct(prototype, ReturnNewWithProto)
-
-TestConstruct(Object.prototype, Proxy.createFunction(handler, ReturnNew))
-TestConstruct(prototype, Proxy.createFunction(handler, ReturnNewWithProto))
-
-TestConstruct(Object.prototype, CreateFrozen(handler, ReturnNew))
-TestConstruct(prototype, CreateFrozen(handler, ReturnNewWithProto))
-
-
-
-// Construction with derived construct trap.
-
-function TestConstructFromCall(proto, returnsThis, callTrap) {
- TestConstructFromCall2(prototype, returnsThis, callTrap, handlerWithPrototype)
- TestConstructFromCall2(proto, returnsThis, callTrap, handlerSansPrototype)
-}
-
-function TestConstructFromCall2(proto, returnsThis, callTrap, handler) {
- // TODO(rossberg): handling of prototype for derived construct trap will be
- // fixed in a separate change. Commenting out checks below for now.
- var f = Proxy.createFunction(handler, callTrap)
- var o = new f(11, 31)
- if (returnsThis) assertEquals(o, receiver)
- assertEquals(42, o.sum)
- // assertSame(proto, Object.getPrototypeOf(o))
-
- var g = CreateFrozen(handler, callTrap)
- // assertSame(f.prototype, g.prototype)
- var o = new g(11, 32)
- if (returnsThis) assertEquals(o, receiver)
- assertEquals(43, o.sum)
- // assertSame(proto, Object.getPrototypeOf(o))
-}
-
-TestConstructFromCall(Object.prototype, true, ReturnUndef)
-TestConstructFromCall(Object.prototype, true, ReturnThis)
-TestConstructFromCall(Object.prototype, false, ReturnNew)
-TestConstructFromCall(prototype, false, ReturnNewWithProto)
-
-TestConstructFromCall(Object.prototype, true,
- Proxy.createFunction(handler, ReturnUndef))
-TestConstructFromCall(Object.prototype, true,
- Proxy.createFunction(handler, ReturnThis))
-TestConstructFromCall(Object.prototype, false,
- Proxy.createFunction(handler, ReturnNew))
-TestConstructFromCall(prototype, false,
- Proxy.createFunction(handler, ReturnNewWithProto))
-
-TestConstructFromCall(Object.prototype, true, CreateFrozen({}, ReturnUndef))
-TestConstructFromCall(Object.prototype, true, CreateFrozen({}, ReturnThis))
-TestConstructFromCall(Object.prototype, false, CreateFrozen({}, ReturnNew))
-TestConstructFromCall(prototype, false, CreateFrozen({}, ReturnNewWithProto))
-
-ReturnUndef.prototype = prototype
-ReturnThis.prototype = prototype
-ReturnNew.prototype = prototype
-ReturnNewWithProto.prototype = prototype
-
-TestConstructFromCall(prototype, true, ReturnUndef)
-TestConstructFromCall(prototype, true, ReturnThis)
-TestConstructFromCall(Object.prototype, false, ReturnNew)
-TestConstructFromCall(prototype, false, ReturnNewWithProto)
-
-TestConstructFromCall(Object.prototype, true,
- Proxy.createFunction(handler, ReturnUndef))
-TestConstructFromCall(Object.prototype, true,
- Proxy.createFunction(handler, ReturnThis))
-TestConstructFromCall(Object.prototype, false,
- Proxy.createFunction(handler, ReturnNew))
-TestConstructFromCall(prototype, false,
- Proxy.createFunction(handler, ReturnNewWithProto))
-
-TestConstructFromCall(prototype, true,
- Proxy.createFunction(handlerWithPrototype, ReturnUndef))
-TestConstructFromCall(prototype, true,
- Proxy.createFunction(handlerWithPrototype, ReturnThis))
-TestConstructFromCall(Object.prototype, false,
- Proxy.createFunction(handlerWithPrototype, ReturnNew))
-TestConstructFromCall(prototype, false,
- Proxy.createFunction(handlerWithPrototype,
- ReturnNewWithProto))
-
-TestConstructFromCall(prototype, true,
- CreateFrozen(handlerWithPrototype, ReturnUndef))
-TestConstructFromCall(prototype, true,
- CreateFrozen(handlerWithPrototype, ReturnThis))
-TestConstructFromCall(Object.prototype, false,
- CreateFrozen(handlerWithPrototype, ReturnNew))
-TestConstructFromCall(prototype, false,
- CreateFrozen(handlerWithPrototype, ReturnNewWithProto))
-
-
-
-// Throwing from the construct trap.
-
-function TestConstructThrow(trap) {
- TestConstructThrow2(Proxy.createFunction({ fix: function() {return {};} },
- trap))
- TestConstructThrow2(Proxy.createFunction({ fix: function() {return {};} },
- function() {},
- trap))
-}
-
-function TestConstructThrow2(f) {
- assertThrows(function(){ new f(11) }, "myexn")
- Object.freeze(f)
- assertThrows(function(){ new f(11) }, "myexn")
-}
-
-TestConstructThrow(function() { throw "myexn" })
-TestConstructThrow(Proxy.createFunction({}, function() { throw "myexn" }))
-TestConstructThrow(CreateFrozen({}, function() { throw "myexn" }))
-
-
-
-// Using function proxies as getters and setters.
-
-var value
-var receiver
-
-function TestAccessorCall(getterCallTrap, setterCallTrap) {
- var handler = { fix: function() { return {} } }
- var pgetter = Proxy.createFunction(handler, getterCallTrap)
- var psetter = Proxy.createFunction(handler, setterCallTrap)
-
- var o = {}
- var oo = Object.create(o)
- Object.defineProperty(o, "a", {get: pgetter, set: psetter})
- Object.defineProperty(o, "b", {get: pgetter})
- Object.defineProperty(o, "c", {set: psetter})
- Object.defineProperty(o, "3", {get: pgetter, set: psetter})
- Object.defineProperty(oo, "a", {value: 43})
-
- receiver = ""
- assertEquals(42, o.a)
- assertSame(o, receiver)
- receiver = ""
- assertEquals(42, o.b)
- assertSame(o, receiver)
- receiver = ""
- assertEquals(undefined, o.c)
- assertEquals("", receiver)
- receiver = ""
- assertEquals(42, o["a"])
- assertSame(o, receiver)
- receiver = ""
- assertEquals(42, o[3])
- assertSame(o, receiver)
-
- receiver = ""
- assertEquals(43, oo.a)
- assertEquals("", receiver)
- receiver = ""
- assertEquals(42, oo.b)
- assertSame(oo, receiver)
- receiver = ""
- assertEquals(undefined, oo.c)
- assertEquals("", receiver)
- receiver = ""
- assertEquals(43, oo["a"])
- assertEquals("", receiver)
- receiver = ""
- assertEquals(42, oo[3])
- assertSame(oo, receiver)
-
- receiver = ""
- assertEquals(50, o.a = 50)
- assertSame(o, receiver)
- assertEquals(50, value)
- receiver = ""
- assertEquals(51, o.b = 51)
- assertEquals("", receiver)
- assertEquals(50, value) // no setter
- assertThrows(function() { "use strict"; o.b = 51 }, TypeError)
- receiver = ""
- assertEquals(52, o.c = 52)
- assertSame(o, receiver)
- assertEquals(52, value)
- receiver = ""
- assertEquals(53, o["a"] = 53)
- assertSame(o, receiver)
- assertEquals(53, value)
- receiver = ""
- assertEquals(54, o[3] = 54)
- assertSame(o, receiver)
- assertEquals(54, value)
-
- value = 0
- receiver = ""
- assertEquals(60, oo.a = 60)
- assertEquals("", receiver)
- assertEquals(0, value) // oo has own 'a'
- assertEquals(61, oo.b = 61)
- assertSame("", receiver)
- assertEquals(0, value) // no setter
- assertThrows(function() { "use strict"; oo.b = 61 }, TypeError)
- receiver = ""
- assertEquals(62, oo.c = 62)
- assertSame(oo, receiver)
- assertEquals(62, value)
- receiver = ""
- assertEquals(63, oo["c"] = 63)
- assertSame(oo, receiver)
- assertEquals(63, value)
- receiver = ""
- assertEquals(64, oo[3] = 64)
- assertSame(oo, receiver)
- assertEquals(64, value)
-}
-
-TestAccessorCall(
- function() { receiver = this; return 42 },
- function(x) { receiver = this; value = x }
-)
-
-TestAccessorCall(
- function() { "use strict"; receiver = this; return 42 },
- function(x) { "use strict"; receiver = this; value = x }
-)
-
-TestAccessorCall(
- Proxy.createFunction({}, function() { receiver = this; return 42 }),
- Proxy.createFunction({}, function(x) { receiver = this; value = x })
-)
-
-TestAccessorCall(
- CreateFrozen({}, function() { receiver = this; return 42 }),
- CreateFrozen({}, function(x) { receiver = this; value = x })
-)
-
-
-
-// Passing a proxy function to higher-order library functions.
-
-function TestHigherOrder(f) {
- assertEquals(6, [6, 2].map(f)[0])
- assertEquals(4, [5, 2].reduce(f, 4))
- assertTrue([1, 2].some(f))
- assertEquals("a.b.c", "a.b.c".replace(".", f))
-}
-
-TestHigherOrder(function(x) { return x })
-TestHigherOrder(function(x) { "use strict"; return x })
-TestHigherOrder(Proxy.createFunction({}, function(x) { return x }))
-TestHigherOrder(CreateFrozen({}, function(x) { return x }))
-
-
-
-// TODO(rossberg): Ultimately, I want to have the following test function
-// run through, but it currently fails on so many cases (some not even
-// involving proxies), that I leave that for later...
-/*
-function TestCalls() {
- var handler = {
- get: function(r, k) {
- return k == "length" ? 2 : Function.prototype[k]
- }
- }
- var bind = Function.prototype.bind
- var o = {}
-
- var traps = [
- function(x, y) {
- return {receiver: this, result: x + y, strict: false}
- },
- function(x, y) { "use strict";
- return {receiver: this, result: x + y, strict: true}
- },
- function() {
- var x = arguments[0], y = arguments[1]
- return {receiver: this, result: x + y, strict: false}
- },
- Proxy.createFunction(handler, function(x, y) {
- return {receiver: this, result: x + y, strict: false}
- }),
- Proxy.createFunction(handler, function() {
- var x = arguments[0], y = arguments[1]
- return {receiver: this, result: x + y, strict: false}
- }),
- Proxy.createFunction(handler, function(x, y) { "use strict"
- return {receiver: this, result: x + y, strict: true}
- }),
- CreateFrozen(handler, function(x, y) {
- return {receiver: this, result: x + y, strict: false}
- }),
- CreateFrozen(handler, function(x, y) { "use strict"
- return {receiver: this, result: x + y, strict: true}
- }),
- ]
- var creates = [
- function(trap) { return trap },
- function(trap) { return CreateFrozen({}, callTrap) },
- function(trap) { return Proxy.createFunction(handler, callTrap) },
- function(trap) {
- return Proxy.createFunction(handler, CreateFrozen({}, callTrap))
- },
- function(trap) {
- return Proxy.createFunction(handler, Proxy.createFunction(handler, callTrap))
- },
- ]
- var binds = [
- function(f, o, x, y) { return f },
- function(f, o, x, y) { return bind.call(f, o) },
- function(f, o, x, y) { return bind.call(f, o, x) },
- function(f, o, x, y) { return bind.call(f, o, x, y) },
- function(f, o, x, y) { return bind.call(f, o, x, y, 5) },
- function(f, o, x, y) { return bind.call(bind.call(f, o), {}, x, y) },
- function(f, o, x, y) { return bind.call(bind.call(f, o, x), {}, y) },
- function(f, o, x, y) { return bind.call(bind.call(f, o, x, y), {}, 5) },
- ]
- var calls = [
- function(f, x, y) { return f(x, y) },
- function(f, x, y) { var g = f; return g(x, y) },
- function(f, x, y) { with ({}) return f(x, y) },
- function(f, x, y) { var g = f; with ({}) return g(x, y) },
- function(f, x, y, o) { with (o) return f(x, y) },
- function(f, x, y, o) { return f.call(o, x, y) },
- function(f, x, y, o) { return f.apply(o, [x, y]) },
- function(f, x, y, o) { return Function.prototype.call.call(f, o, x, y) },
- function(f, x, y, o) { return Function.prototype.apply.call(f, o, [x, y]) },
- function(f, x, y, o) { return %_CallFunction(o, x, y, f) },
- function(f, x, y, o) { return %Call(o, x, y, f) },
- function(f, x, y, o) { return %Apply(f, o, [null, x, y, null], 1, 2) },
- function(f, x, y, o) { return %Apply(f, o, arguments, 2, 2) },
- function(f, x, y, o) { if (typeof o == "object") return o.f(x, y) },
- function(f, x, y, o) { if (typeof o == "object") return o["f"](x, y) },
- function(f, x, y, o) { if (typeof o == "object") return (1, o).f(x, y) },
- function(f, x, y, o) { if (typeof o == "object") return (1, o)["f"](x, y) },
- ]
- var receivers = [o, global_object, undefined, null, 2, "bla", true]
- var expectedNonStricts = [o, global_object, global_object, global_object]
-
- for (var t = 0; t < traps.length; ++t) {
- for (var i = 0; i < creates.length; ++i) {
- for (var j = 0; j < binds.length; ++j) {
- for (var k = 0; k < calls.length; ++k) {
- for (var m = 0; m < receivers.length; ++m) {
- for (var n = 0; n < receivers.length; ++n) {
- var bound = receivers[m]
- var receiver = receivers[n]
- var func = binds[j](creates[i](traps[t]), bound, 31, 11)
- var expected = j > 0 ? bound : receiver
- var expectedNonStrict = expectedNonStricts[j > 0 ? m : n]
- o.f = func
- global_object.f = func
- var x = calls[k](func, 11, 31, receiver)
- if (x !== undefined) {
- assertEquals(42, x.result)
- if (calls[k].length < 4)
- assertSame(x.strict ? undefined : global_object, x.receiver)
- else if (x.strict)
- assertSame(expected, x.receiver)
- else if (expectedNonStrict === undefined)
- assertSame(expected, x.receiver.valueOf())
- else
- assertSame(expectedNonStrict, x.receiver)
- }
- }
- }
- }
- }
- }
- }
-}
-
-TestCalls()
-*/
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-26 23:23:03 +0000