diff options
Diffstat (limited to 'deps/v8/test/mjsunit/es6/proxies-construct.js')
-rw-r--r-- | deps/v8/test/mjsunit/es6/proxies-construct.js | 156 |
1 files changed, 156 insertions, 0 deletions
diff --git a/deps/v8/test/mjsunit/es6/proxies-construct.js b/deps/v8/test/mjsunit/es6/proxies-construct.js new file mode 100644 index 0000000000..344c50a7e4 --- /dev/null +++ b/deps/v8/test/mjsunit/es6/proxies-construct.js @@ -0,0 +1,156 @@ +// 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. + +(function testNonConstructable() { + var proxy = new Proxy({},{}); + assertThrows(function(){ new proxy() }, TypeError); + + var proxy2 = new Proxy(proxy, {}); + assertThrows(function(){ proxy2() }, TypeError); +})(); + +(function testFailingConstructRevoked() { + var pair = Proxy.revocable(Array, {}); + var instance = new pair.proxy(); + pair.revoke(); + assertThrows(function(){ new pair.proxy() }, TypeError); +})(); + +(function testFailingGetTrap() { + var handler = { + get() { + throw TypeError(); + } + } + var proxy = new Proxy({},{}); + var proxy2 = new Proxy({}, proxy); + assertThrows(function(){ new proxy2() }, TypeError); +})(); + +(function testConstructFallback() { + var called = false; + function Target() { + called = true; + this.property1 = 'value1'; + }; + Target.prototype = {}; + var proxy = new Proxy(Target, {}); + + assertFalse(called); + var instance = new proxy(); + assertTrue(called); + assertEquals('value1', instance.property1); + assertSame(Target.prototype, Reflect.getPrototypeOf(instance)); + + var proxy2 = new Proxy(proxy, {}); + called = false; + var instance2 = new proxy2(); + assertTrue(called); + assertEquals('value1', instance2.property1); + assertSame(Target.prototype, Reflect.getPrototypeOf(instance)); +})(); + +(function testConstructTrapDirectReturn() { + function Target(a, b) { + this.sum = a + b; + }; + var handler = { + construct(t, c, args) { + return { sum: 42 }; + } + }; + var proxy = new Proxy(Target, handler); + assertEquals(42, (new proxy(1, 2)).sum); +})(); + +(function testConstructTrap() { + function Target(arg1, arg2) { + this.arg1 = arg1; + this.arg2 = arg2; + } + var seen_target, seen_arguments, seen_new_target; + var handler = { + construct(target, args, new_target) { + seen_target = target; + seen_arguments = args; + seen_new_target = new_target; + return Reflect.construct(target, args, new_target); + } + } + var proxy = new Proxy(Target, handler); + var instance = new proxy('a', 'b'); + assertEquals(Target, seen_target); + assertEquals(['a','b'], seen_arguments); + assertEquals(proxy, seen_new_target); + assertEquals('a', instance.arg1); + assertEquals('b', instance.arg2); + + var instance2 = Reflect.construct(proxy, ['a1', 'b1'], Array); + assertEquals(Target, seen_target); + assertEquals(['a1', 'b1'], seen_arguments); + assertEquals(Array, seen_new_target); + assertEquals('a1', instance2.arg1); + assertEquals('b1', instance2.arg2); +})(); + +(function testConstructCrossRealm() { + var realm1 = Realm.create(); + var handler = { + construct(target, args, new_target) { + return args; + } + }; + var OtherProxy = Realm.eval(realm1, "Proxy"); + var otherArrayPrototype = Realm.eval(realm1, 'Array.prototype'); + + // Proxy and handler are from this realm. + var proxy = new Proxy(Array, handler); + var result = new proxy(); + assertSame(Array.prototype, Reflect.getPrototypeOf(result)); + + // Proxy is from this realm, handler is from realm1. + var otherProxy = new OtherProxy(Array, handler); + var otherResult = new otherProxy(); + assertSame(Array.prototype, Reflect.getPrototypeOf(otherResult)); + + // Proxy and handler are from realm1. + var otherProxy2 = Realm.eval(realm1, 'new Proxy('+ + 'Array, { construct(target, args, new_target) { return args }} )'); + var otherResult2 = new otherProxy2(); + assertSame(Array.prototype, Reflect.getPrototypeOf(otherResult2)); +})(); + +(function testReflectConstructCrossReal() { + var realm1 = Realm.create(); + var realm2 = Realm.create(); + var realm3 = Realm.create(); + var realm4 = Realm.create(); + + var argsRealm1 = Realm.eval(realm1, '[]'); + var ProxyRealm2 = Realm.eval(realm2, 'Proxy'); + var constructorRealm3 = Realm.eval(realm3, '(function(){})'); + var handlerRealm4 = Realm.eval(realm4, + '({ construct(target, args, new_target) {return args} })'); + + var proxy = new ProxyRealm2(constructorRealm3, handlerRealm4); + + // Check that the arguments array returned by handlerRealm4 is created in the + // realm of the Reflect.construct function. + var result = Reflect.construct(proxy, argsRealm1); + assertSame(Array.prototype, Reflect.getPrototypeOf(result)); + + var ReflectConstructRealm1 = Realm.eval(realm1, 'Reflect.construct'); + var result2 = ReflectConstructRealm1(proxy, argsRealm1); + assertSame(Realm.eval(realm1, 'Array.prototype'), + Reflect.getPrototypeOf(result2)); + + var result3 = ReflectConstructRealm1(proxy, []); + assertSame(Realm.eval(realm1, 'Array.prototype'), + Reflect.getPrototypeOf(result3)); + + var ReflectConstructRealm2 = Realm.eval(realm2, 'Reflect.construct'); + var result4 = ReflectConstructRealm2(proxy, argsRealm1); + assertSame(Realm.eval(realm2, 'Array.prototype'), + Reflect.getPrototypeOf(result4)); +})(); |