diff options
Diffstat (limited to 'deps/v8/test/mjsunit/harmony/super.js')
| -rw-r--r-- | deps/v8/test/mjsunit/harmony/super.js | 2497 |
1 files changed, 1321 insertions, 1176 deletions
diff --git a/deps/v8/test/mjsunit/harmony/super.js b/deps/v8/test/mjsunit/harmony/super.js index 6dcc393cce..988cef22e2 100644 --- a/deps/v8/test/mjsunit/harmony/super.js +++ b/deps/v8/test/mjsunit/harmony/super.js @@ -1,36 +1,38 @@ // Copyright 2014 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-classes +// Flags: --harmony-classes --allow-natives-syntax (function TestSuperNamedLoads() { function Base() { } + function fBase() { } + Base.prototype = { + f() { + return "Base " + this.toString(); + }, + x: 15, + toString() { + return "this is Base"; + } + }; + function Derived() { this.derivedDataProperty = "xxx"; } - Derived.prototype = Object.create(Base.prototype); - - function fBase() { return "Base " + this.toString(); } - - Base.prototype.f = fBase.toMethod(Base.prototype); - - function fDerived() { - assertEquals("Base this is Derived", super.f()); - var a = super.x; - assertEquals(15, a); - assertEquals(15, super.x); - assertEquals(27, this.x); - - return "Derived" - } - - Base.prototype.x = 15; - Base.prototype.toString = function() { return "this is Base"; }; - Derived.prototype.toString = function() { return "this is Derived"; }; - Derived.prototype.x = 27; - Derived.prototype.f = fDerived.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + toString() { return "this is Derived"; }, + x: 27, + f() { + assertEquals("Base this is Derived", super.f()); + var a = super.x; + assertEquals(15, a); + assertEquals(15, super.x); + assertEquals(27, this.x); + return "Derived"; + } + }; assertEquals("Base this is Base", new Base().f()); assertEquals("Derived", new Derived().f()); @@ -38,34 +40,39 @@ (function TestSuperKeyedLoads() { + 'use strict'; + var x = 'x'; var derivedDataProperty = 'derivedDataProperty'; var f = 'f'; - function Base() { } - function Derived() { - this[derivedDataProperty] = 'xxx'; - } - Derived.prototype = Object.create(Base.prototype); - - function fBase() { return "Base " + this.toString(); } - - Base.prototype[f] = fBase.toMethod(Base.prototype); - - function fDerived() { - assertEquals("Base this is Derived", super[f]()); - var a = super[x]; - assertEquals(15, a); - assertEquals(15, super[x]); - assertEquals(27, this[x]); - return "Derived" + class Base { + f() { + return "Base " + this.toString(); + } + toString() { + return "this is Base"; + } } Base.prototype[x] = 15; - Base.prototype.toString = function() { return "this is Base"; }; - Derived.prototype.toString = function() { return "this is Derived"; }; - Derived.prototype[x] = 27; - Derived.prototype[f] = fDerived.toMethod(Derived.prototype); + + function Derived() { + this[derivedDataProperty] = "xxx"; + } + Derived.prototype = { + __proto__: Base.prototype, + toString() { return "this is Derived"; }, + x: 27, + f() { + assertEquals("Base this is Derived", super[f]()); + var a = super[x]; + assertEquals(15, a); + assertEquals(15, super[x]); + assertEquals(27, this[x]); + return "Derived"; + } + }; assertEquals("Base this is Base", new Base().f()); assertEquals("Derived", new Derived().f()); @@ -76,31 +83,29 @@ var x = 1; var derivedDataProperty = 2; var f = 3; - function Base() { } - function Derived() { - this[derivedDataProperty] = 'xxx'; - } - Derived.prototype = Object.create(Base.prototype); + function Base() { } function fBase() { return "Base " + this.toString(); } - - Base.prototype[f] = fBase.toMethod(Base.prototype); - - function fDerived() { - assertEquals("Base this is Derived", super[f]()); - var a = super[x]; - assertEquals(15, a); - assertEquals(15, super[x]); - assertEquals(27, this[x]); - - return "Derived" - } - + Base.prototype[f] = %ToMethod(fBase, Base.prototype); Base.prototype[x] = 15; Base.prototype.toString = function() { return "this is Base"; }; - Derived.prototype.toString = function() { return "this is Derived"; }; - Derived.prototype[x] = 27; - Derived.prototype[f] = fDerived.toMethod(Derived.prototype); + + function Derived() { + this[derivedDataProperty] = "xxx"; + } + Derived.prototype = { + __proto__: Base.prototype, + toString() { return "this is Derived"; }, + 1: 27, + 3() { + assertEquals("Base this is Derived", super[f]()); + var a = super[x]; + assertEquals(15, a); + assertEquals(15, super[x]); + assertEquals(27, this[x]); + return "Derived"; + } + }; assertEquals("Base this is Base", new Base()[f]()); assertEquals("Derived", new Derived()[f]()); @@ -108,11 +113,17 @@ (function TestSuperKeywordNonMethod() { - function f() { - super.unknown(); + 'use strict'; + + class C { + f() { + super.unknown(); + } } - assertThrows(f, ReferenceError); + assertThrows(function() { + new C().f(); + }, TypeError); }()); @@ -133,15 +144,16 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testGetter() { + return super.x; + }, + testGetterStrict() { + 'use strict'; + return super.x; + } }; - Derived.prototype.testGetter = function() { - return super.x; - }.toMethod(Derived.prototype); - Derived.prototype.testGetterStrict = function() { - 'use strict'; - return super.x; - }.toMethod(Derived.prototype); + derived = new Derived(); assertEquals('derived', derived.testGetter()); derived = new Derived(); @@ -167,44 +179,45 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testGetter() { + return super[x]; + }, + testGetterStrict() { + 'use strict'; + return super[x]; + }, + testGetterWithToString() { + var toStringCalled; + var o = { toString: function() { + toStringCalled++; + return 'x'; + } }; + + toStringCalled = 0; + assertEquals('derived', super[o]); + assertEquals(1, toStringCalled); + + var eToThrow = new Error(); + var oThrowsInToString = { toString: function() { + throw eToThrow; + } }; + + var ex = null; + try { + super[oThrowsInToString]; + } catch(e) { ex = e } + assertEquals(eToThrow, ex); + + var oReturnsNumericString = { toString: function() { + return "1"; + } }; + + assertEquals(undefined, super[oReturnsNumericString]); + assertEquals(undefined, super[1]); + } }; - Derived.prototype.testGetter = function() { - return super[x]; - }.toMethod(Derived.prototype); - Derived.prototype.testGetterStrict = function() { - 'use strict'; - return super[x]; - }.toMethod(Derived.prototype); - Derived.prototype.testGetterWithToString = function() { - var toStringCalled; - var o = { toString: function() { - toStringCalled++; - return 'x'; - } }; - - toStringCalled = 0; - assertEquals('derived', super[o]); - assertEquals(1, toStringCalled); - - var eToThrow = new Error(); - var oThrowsInToString = { toString: function() { - throw eToThrow; - } }; - - var ex = null; - try { - super[oThrowsInToString]; - } catch(e) { ex = e } - assertEquals(eToThrow, ex); - - var oReturnsNumericString = { toString: function() { - return "1"; - } }; - - assertEquals(undefined, super[oReturnsNumericString]); - assertEquals(undefined, super[1]); - }.toMethod(Derived.prototype); + derived = new Derived(); assertEquals('derived', derived.testGetter()); derived = new Derived(); @@ -233,45 +246,51 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testGetter() { + return super[x]; + }, + testGetterStrict() { + 'use strict'; + return super[x]; + }, + testGetterWithToString() { + var toStringCalled; + var o = { + toString: function() { + toStringCalled++; + return '42'; + } + }; + + toStringCalled = 0; + assertEquals('derived', super[o]); + assertEquals(1, toStringCalled); + + var eToThrow = new Error(); + var oThrowsInToString = { + toString: function() { + throw eToThrow; + } + }; + + var ex = null; + try { + super[oThrowsInToString]; + } catch(e) { ex = e } + assertEquals(eToThrow, ex); + + var oReturnsNumericString = { + toString: function() { + return "42"; + } + }; + + assertEquals('derived', super[oReturnsNumericString]); + assertEquals('derived', super[42]); + } }; - Derived.prototype.testGetter = function() { - return super[x]; - }.toMethod(Derived.prototype); - Derived.prototype.testGetterStrict = function() { - 'use strict'; - return super[x]; - }.toMethod(Derived.prototype); - - Derived.prototype.testGetterWithToString = function() { - var toStringCalled; - var o = { toString: function() { - toStringCalled++; - return '42'; - } }; - - toStringCalled = 0; - assertEquals('derived', super[o]); - assertEquals(1, toStringCalled); - - var eToThrow = new Error(); - var oThrowsInToString = { toString: function() { - throw eToThrow; - } }; - - var ex = null; - try { - super[oThrowsInToString]; - } catch(e) { ex = e } - assertEquals(eToThrow, ex); - - var oReturnsNumericString = { toString: function() { - return "42"; - } }; - - assertEquals('derived', super[oReturnsNumericString]); - assertEquals('derived', super[42]); - }.toMethod(Derived.prototype); + derived = new Derived(); assertEquals('derived', derived.testGetter()); derived = new Derived(); @@ -299,22 +318,24 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testSetter() { + assertEquals('foobar', super.x = 'foobar'); + assertEquals('foobarabc', super.x += 'abc'); + }, + testSetterStrict() { + 'use strict'; + assertEquals('foobar', super.x = 'foobar'); + assertEquals('foobarabc', super.x += 'abc'); + } }; - Derived.prototype.testSetter = function() { - assertEquals('foobar', super.x = 'foobar'); - assertEquals('foobarabc', super.x += 'abc'); - }.toMethod(Derived.prototype); + var d = new Derived(); d.testSetter(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); d._x = ''; - Derived.prototype.testSetterStrict = function() { - 'use strict'; - assertEquals('foobar', super.x = 'foobar'); - assertEquals('foobarabc', super.x += 'abc'); - }.toMethod(Derived.prototype); + d.testSetterStrict(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); @@ -339,51 +360,56 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testSetter() { + assertEquals('foobar', super[x] = 'foobar'); + assertEquals('foobarabc', super[x] += 'abc'); + }, + testSetterStrict() { + 'use strict'; + assertEquals('foobar', super[x] = 'foobar'); + assertEquals('foobarabc', super[x] += 'abc'); + }, + testSetterWithToString() { + var toStringCalled; + var o = { + toString: function() { + toStringCalled++; + return x; + } + }; + + toStringCalled = 0; + super[o] = 'set'; + assertEquals(1, toStringCalled); + assertEquals('set', this._x); + + var eToThrow = new Error(); + var oThrowsInToString = { + toString: function() { + throw eToThrow; + } + }; + + var ex = null; + try { + super[oThrowsInToString] = 'xyz'; + } catch(e) { ex = e } + assertEquals(eToThrow, ex); + assertEquals('set', this._x); + } }; - Derived.prototype.testSetter = function() { - assertEquals('foobar', super[x] = 'foobar'); - assertEquals('foobarabc', super[x] += 'abc'); - }.toMethod(Derived.prototype); + var d = new Derived(); d.testSetter(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); d._x = ''; - Derived.prototype.testSetterStrict = function() { - 'use strict'; - assertEquals('foobar', super[x] = 'foobar'); - assertEquals('foobarabc', super[x] += 'abc'); - }.toMethod(Derived.prototype); + d.testSetterStrict(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); - - Derived.prototype.testSetterWithToString = function() { - var toStringCalled; - var o = { toString: function() { - toStringCalled++; - return x; - } }; - - toStringCalled = 0; - super[o] = 'set'; - assertEquals(1, toStringCalled); - assertEquals('set', this._x); - - var eToThrow = new Error(); - var oThrowsInToString = { toString: function() { - throw eToThrow; - } }; - - var ex = null; - try { - super[oThrowsInToString] = 'xyz'; - } catch(e) { ex = e } - assertEquals(eToThrow, ex); - assertEquals('set', this._x); - }.toMethod(Derived.prototype); d = new Derived(); d.testSetterWithToString(); }()); @@ -408,61 +434,67 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 'derived' + _x: 'derived', + testSetter() { + assertEquals('foobar', super[x] = 'foobar'); + assertEquals('foobarabc', super[x] += 'abc'); + }, + testSetterStrict() { + 'use strict'; + assertEquals('foobar', super[x] = 'foobar'); + assertEquals('foobarabc', super[x] += 'abc'); + }, + testSetterWithToString() { + var toStringCalled; + var o = { + toString: function() { + toStringCalled++; + return 'x'; + } + }; + + toStringCalled = 0; + super[o] = 'set'; + assertEquals(1, toStringCalled); + assertEquals('set', this._x); + + var eToThrow = new Error(); + var oThrowsInToString = { + toString: function() { + throw eToThrow; + } + }; + + var ex = null; + try { + super[oThrowsInToString] = 'xyz'; + } catch(e) { ex = e } + assertEquals(eToThrow, ex); + assertEquals('set', this._x); + + var oReturnsNumericString = { + toString: function() { + return "1"; + } + }; + + assertEquals('abc', super[oReturnsNumericString] = 'abc'); + + assertEquals('set', this._x); + + assertEquals(10, super[1] = 10); + } }; - Derived.prototype.testSetter = function() { - assertEquals('foobar', super[x] = 'foobar'); - assertEquals('foobarabc', super[x] += 'abc'); - }.toMethod(Derived.prototype); + var d = new Derived(); d.testSetter(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); d._x = ''; - Derived.prototype.testSetterStrict = function() { - 'use strict'; - assertEquals('foobar', super[x] = 'foobar'); - assertEquals('foobarabc', super[x] += 'abc'); - }.toMethod(Derived.prototype); d.testSetterStrict(); assertEquals('base', Base.prototype._x); assertEquals('foobarabc', d._x); - - Derived.prototype.testSetterWithToString = function() { - var toStringCalled; - var o = { toString: function() { - toStringCalled++; - return 'x'; - } }; - - toStringCalled = 0; - super[o] = 'set'; - assertEquals(1, toStringCalled); - assertEquals('set', this._x); - - var eToThrow = new Error(); - var oThrowsInToString = { toString: function() { - throw eToThrow; - } }; - - var ex = null; - try { - super[oThrowsInToString] = 'xyz'; - } catch(e) { ex = e } - assertEquals(eToThrow, ex); - assertEquals('set', this._x); - - var oReturnsNumericString = { toString: function() { - return "1"; - } }; - - assertEquals('abc', super[oReturnsNumericString] = 'abc'); - - assertEquals('set', this._x); - - assertEquals(10, super[1] = 10); - }.toMethod(Derived.prototype); d = new Derived(); d.testSetterWithToString(); }()); @@ -479,15 +511,14 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, + testSetter() { + assertEquals('x from Base', super.x); + super.x = 'data property'; + assertEquals('x from Base', super.x); + assertEquals('data property', this.x); + } }; - Derived.prototype.testSetter = function() { - assertEquals('x from Base', super.x); - super.x = 'data property'; - assertEquals('x from Base', super.x); - assertEquals('data property', this.x); - }.toMethod(Derived.prototype); - new Derived().testSetter(); }()); @@ -504,15 +535,14 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, + testSetter() { + assertEquals('x from Base', super[x]); + super[x] = 'data property'; + assertEquals('x from Base', super[x]); + assertEquals('data property', this[x]); + } }; - Derived.prototype.testSetter = function() { - assertEquals('x from Base', super[x]); - super[x] = 'data property'; - assertEquals('x from Base', super[x]); - assertEquals('data property', this[x]); - }.toMethod(Derived.prototype); - new Derived().testSetter(); }()); @@ -529,15 +559,14 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, + testSetter() { + assertEquals('x from Base', super[x]); + super[x] = 'data property'; + assertEquals('x from Base', super[x]); + assertEquals('data property', this[x]); + } }; - Derived.prototype.testSetter = function() { - assertEquals('x from Base', super[x]); - super[x] = 'data property'; - assertEquals('x from Base', super[x]); - assertEquals('data property', this[x]); - }.toMethod(Derived.prototype); - new Derived().testSetter(); }()); @@ -562,73 +591,74 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - }; - Derived.prototype.testSetter = function() { - setCalled = 0; - getCalled = 0; - assertEquals('object', typeof this); - assertTrue(this instanceof Number) - assertEquals(42, this.valueOf()); - assertEquals(1, super.x); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super.x = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super.x += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - super.newProperty = 15; - assertEquals(15, this.newProperty); - assertEquals(undefined, super.newProperty); - }.toMethod(Derived.prototype); - - Derived.prototype.testSetterStrict = function() { - 'use strict'; - getCalled = 0; - setCalled = 0; - assertTrue(42 === this); - - assertEquals(1, super.x); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super.x = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super.x += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - var ex; - try { + testSetter() { + setCalled = 0; + getCalled = 0; + assertEquals('object', typeof this); + assertInstanceof(this, Number) + assertEquals(42, this.valueOf()); + assertEquals(1, super.x); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super.x = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super.x += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + super.newProperty = 15; - } catch (e) { ex = e; } - assertTrue(ex instanceof TypeError); - }.toMethod(Derived.prototype); + assertEquals(15, this.newProperty); + assertEquals(undefined, super.newProperty); + }, + testSetterStrict() { + 'use strict'; + getCalled = 0; + setCalled = 0; + assertTrue(42 === this); + + assertEquals(1, super.x); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super.x = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super.x += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + + var ex; + try { + super.newProperty = 15; + } catch (e) { ex = e; } + assertInstanceof(ex, TypeError); + } + } Derived.prototype.testSetter.call(42); Derived.prototype.testSetterStrict.call(42); function DerivedFromString() {} - DerivedFromString.prototype = Object.create(String.prototype); - - function f() { - 'use strict'; - assertTrue(42 === this); - assertEquals(String.prototype.toString, super.toString); - var ex; - try { - super.toString(); - } catch(e) { ex = e; } - - assertTrue(ex instanceof TypeError); - } - f.toMethod(DerivedFromString.prototype).call(42); + DerivedFromString.prototype = { + __proto__: String.prototype, + f() { + 'use strict'; + assertTrue(42 === this); + assertEquals(String.prototype.toString, super.toString); + var ex; + try { + super.toString(); + } catch(e) { ex = e; } + + assertInstanceof(ex, TypeError); + } + }; + + DerivedFromString.prototype.f.call(42); }()); @@ -655,73 +685,73 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - }; - Derived.prototype.testSetter = function() { - setCalled = 0; - getCalled = 0; - assertEquals('object', typeof this); - assertTrue(this instanceof Number) - assertEquals(42, this.valueOf()); - assertEquals(1, super[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super[x] = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super[x] += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - super[newProperty] = 15; - assertEquals(15, this[newProperty]); - assertEquals(undefined, super[newProperty]); - }.toMethod(Derived.prototype); - - Derived.prototype.testSetterStrict = function() { - 'use strict'; - getCalled = 0; - setCalled = 0; - assertTrue(42 === this); - - assertEquals(1, super[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super[x] = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super[x] += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - var ex; - try { + testSetter() { + setCalled = 0; + getCalled = 0; + assertEquals('object', typeof this); + assertInstanceof(this, Number) + assertEquals(42, this.valueOf()); + assertEquals(1, super[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super[x] = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super[x] += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + super[newProperty] = 15; - } catch (e) { ex = e; } - assertTrue(ex instanceof TypeError); - }.toMethod(Derived.prototype); + assertEquals(15, this[newProperty]); + assertEquals(undefined, super[newProperty]); + }, + testSetterStrict() { + 'use strict'; + getCalled = 0; + setCalled = 0; + assertTrue(42 === this); + + assertEquals(1, super[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super[x] = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super[x] += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + + var ex; + try { + super[newProperty] = 15; + } catch (e) { ex = e; } + assertInstanceof(ex,TypeError); + } + }; Derived.prototype.testSetter.call(42); Derived.prototype.testSetterStrict.call(42); function DerivedFromString() {} - DerivedFromString.prototype = Object.create(String.prototype); - - function f() { - 'use strict'; - assertTrue(42 === this); - assertEquals(String.prototype.toString, super[toString]); - var ex; - try { - super[toString](); - } catch(e) { ex = e; } - - assertTrue(ex instanceof TypeError); - } - f.toMethod(DerivedFromString.prototype).call(42); + DerivedFromString.prototype = { + __proto__: String.prototype, + f() { + 'use strict'; + assertTrue(42 === this); + assertEquals(String.prototype.toString, super[toString]); + var ex; + try { + super[toString](); + } catch(e) { ex = e; } + + assertInstanceof(ex, TypeError); + } + }; + DerivedFromString.prototype.f.call(42); }()); @@ -750,54 +780,53 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - }; - Derived.prototype.testSetter = function() { - setCalled = 0; - getCalled = 0; - assertEquals('object', typeof this); - assertTrue(this instanceof Number) - assertEquals(42, this.valueOf()); - assertEquals(1, super[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super[x] = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super[x] += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - super[newProperty] = 15; - assertEquals(15, this[newProperty]); - assertEquals(undefined, super[newProperty]); - }.toMethod(Derived.prototype); - - Derived.prototype.testSetterStrict = function() { - 'use strict'; - getCalled = 0; - setCalled = 0; - assertTrue(42 === this); - - assertEquals(1, super[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - assertEquals(5, super[x] = 5); - assertEquals(1, getCalled); - assertEquals(1, setCalled); - - assertEquals(6, super[x] += 5); - assertEquals(2, getCalled); - assertEquals(2, setCalled); - - var ex; - try { + testSetter() { + setCalled = 0; + getCalled = 0; + assertEquals('object', typeof this); + assertInstanceof(this, Number) + assertEquals(42, this.valueOf()); + assertEquals(1, super[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super[x] = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super[x] += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + super[newProperty] = 15; - } catch (e) { ex = e; } - assertTrue(ex instanceof TypeError); - }.toMethod(Derived.prototype); + assertEquals(15, this[newProperty]); + assertEquals(undefined, super[newProperty]); + }, + testSetterStrict() { + 'use strict'; + getCalled = 0; + setCalled = 0; + assertTrue(42 === this); + + assertEquals(1, super[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + assertEquals(5, super[x] = 5); + assertEquals(1, getCalled); + assertEquals(1, setCalled); + + assertEquals(6, super[x] += 5); + assertEquals(2, getCalled); + assertEquals(2, setCalled); + + var ex; + try { + super[newProperty] = 15; + } catch (e) { ex = e; } + assertInstanceof(ex, TypeError); + } + }; Derived.prototype.testSetter.call(42); Derived.prototype.testSetterStrict.call(42); @@ -807,28 +836,28 @@ (function TestKeyedNumericSetterOnExotics() { function Base() {} function Derived() {} - Derived.prototype = { __proto__: Base.prototype }; - - Derived.prototype.callSetterOnArray = function() { - super[42] = 1; - }.toMethod(Derived.prototype); - - Derived.prototype.callStrictSetterOnString = function() { - 'use strict'; - assertEquals('string', typeof this); - assertTrue('abcdef' === this); - var ex = null; - try { - super[5] = 'q'; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - - ex = null; - try { - super[1024] = 'q'; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + callSetterOnArray() { + super[42] = 1; + }, + callStrictSetterOnString() { + 'use strict'; + assertEquals('string', typeof this); + assertTrue('abcdef' === this); + var ex = null; + try { + super[5] = 'q'; + } catch(e) { ex = e; } + assertInstanceof(ex, TypeError); + + ex = null; + try { + super[1024] = 'q'; + } catch(e) { ex = e; } + assertInstanceof(ex, TypeError); + } + }; var x = []; assertEquals(0, x.length); @@ -844,23 +873,25 @@ (function TestSetterUndefinedProperties() { function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - Derived.prototype.mSloppy = function () { - assertEquals(undefined, super.x); - assertEquals(undefined, this.x); - super.x = 10; - assertEquals(10, this.x); - assertEquals(undefined, super.x); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function () { - 'use strict'; - assertEquals(undefined, super.x); - assertEquals(undefined, this.x); - super.x = 10; - assertEquals(10, this.x); - assertEquals(undefined, super.x); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(undefined, super.x); + assertEquals(undefined, this.x); + super.x = 10; + assertEquals(10, this.x); + assertEquals(undefined, super.x); + }, + mStrict() { + 'use strict'; + assertEquals(undefined, super.x); + assertEquals(undefined, this.x); + super.x = 10; + assertEquals(10, this.x); + assertEquals(undefined, super.x); + } + }; + var d = new Derived(); d.mSloppy(); assertEquals(10, d.x); @@ -874,23 +905,24 @@ var x = 'x'; function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - Derived.prototype.mSloppy = function () { - assertEquals(undefined, super[x]); - assertEquals(undefined, this[x]); - super[x] = 10; - assertEquals(10, this[x]); - assertEquals(undefined, super[x]); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function () { - 'use strict'; - assertEquals(undefined, super[x]); - assertEquals(undefined, this[x]); - super[x] = 10; - assertEquals(10, this[x]); - assertEquals(undefined, super[x]); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(undefined, super[x]); + assertEquals(undefined, this[x]); + super[x] = 10; + assertEquals(10, this[x]); + assertEquals(undefined, super[x]); + }, + mStrict() { + 'use strict'; + assertEquals(undefined, super[x]); + assertEquals(undefined, this[x]); + super[x] = 10; + assertEquals(10, this[x]); + assertEquals(undefined, super[x]); + } + }; var d = new Derived(); d.mSloppy(); assertEquals(10, d.x); @@ -904,23 +936,24 @@ var x = 42; function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - Derived.prototype.mSloppy = function () { - assertEquals(undefined, super[x]); - assertEquals(undefined, this[x]); - super[x] = 10; - assertEquals(10, this[x]); - assertEquals(undefined, super[x]); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function () { - 'use strict'; - assertEquals(undefined, super[x]); - assertEquals(undefined, this[x]); - super[x] = 10; - assertEquals(10, this[x]); - assertEquals(undefined, super[x]); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(undefined, super[x]); + assertEquals(undefined, this[x]); + super[x] = 10; + assertEquals(10, this[x]); + assertEquals(undefined, super[x]); + }, + mStrict() { + 'use strict'; + assertEquals(undefined, super[x]); + assertEquals(undefined, this[x]); + super[x] = 10; + assertEquals(10, this[x]); + assertEquals(undefined, super[x]); + } + }; var d = new Derived(); d.mSloppy(); assertEquals(10, d[x]); @@ -930,53 +963,180 @@ }()); -(function TestSetterCreatingOwnProperties() { +(function TestSetterCreatingOwnPropertiesReconfigurable() { function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - var setterCalled; - - Derived.prototype.mSloppy = function() { - assertEquals(42, this.ownReadOnly); - super.ownReadOnly = 55; - assertEquals(42, this.ownReadOnly); - - assertEquals(15, this.ownReadonlyAccessor); - super.ownReadonlyAccessor = 55; - assertEquals(15, this.ownReadonlyAccessor); - - setterCalled = 0; - super.ownSetter = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(42, this.ownReadOnly); - var ex; - try { + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(42, this.ownReadOnly); + super.ownReadOnly = 55; + assertEquals(55, this.ownReadOnly); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly'); + assertEquals(55, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownReadOnly')); + + assertEquals(15, this.ownReadonlyAccessor); + super.ownReadonlyAccessor = 25; + assertEquals(25, this.ownReadonlyAccessor); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor'); + assertEquals(25, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor')); + + super.ownSetter = 35; + assertEquals(35, this.ownSetter); + var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter'); + assertEquals(35, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownSetter')); + }, + mStrict() { + 'use strict'; + assertEquals(42, this.ownReadOnly); super.ownReadOnly = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(42, this.ownReadOnly); - - assertEquals(15, this.ownReadonlyAccessor); - ex = null; - try { - super.ownReadonlyAccessor = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(15, this.ownReadonlyAccessor); - - setterCalled = 0; - super.ownSetter = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); + assertEquals(55, this.ownReadOnly); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly'); + assertEquals(55, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownReadOnly')); + + assertEquals(15, this.ownReadonlyAccessor); + super.ownReadonlyAccessor = 25; + assertEquals(25, this.ownReadonlyAccessor); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor'); + assertEquals(25, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor')); + + super.ownSetter = 35; + assertEquals(35, this.ownSetter); + var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter'); + assertEquals(35, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownSetter')); + }, + }; + + var d = new Derived(); + Object.defineProperty(d, 'ownReadOnly', { + value: 42, + writable: false, + configurable: true + }); + Object.defineProperty(d, 'ownSetter', { + set: function() { assertUnreachable(); }, + configurable: true + }); + Object.defineProperty(d, 'ownReadonlyAccessor', { + get: function() { return 15; }, + configurable: true + }); + + d.mSloppy(); + + var d = new Derived(); + Object.defineProperty(d, 'ownReadOnly', { + value: 42, + writable: false, + configurable: true + }); + Object.defineProperty(d, 'ownSetter', { + set: function() { assertUnreachable(); }, + configurable: true + }); + Object.defineProperty(d, 'ownReadonlyAccessor', { + get: function() { return 15; }, + configurable: true + }); + d.mStrict(); +}()); + + +(function TestSetterCreatingOwnPropertiesNonConfigurable() { + function Base() {} + function Derived() {} + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(42, this.ownReadOnly); + super.ownReadOnly = 55; + assertEquals(42, this.ownReadOnly); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly'); + assertEquals(42, descr.value); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty('ownReadOnly')); + + assertEquals(15, this.ownReadonlyAccessor); + super.ownReadonlyAccessor = 25; + assertEquals(15, this.ownReadonlyAccessor); + var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor'); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor')); + + super.ownSetter = 35; + var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter'); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(Base.prototype.hasOwnProperty('ownSetter')); + }, + mStrict() { + 'use strict'; + var ex; + assertEquals(42, this.ownReadOnly); + try { + super.ownReadOnly = 55; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals( + "Cannot assign to read only property 'ownReadOnly' of #<Base>", + ex.message); + assertEquals(42, this.ownReadOnly); + + ex = null; + assertEquals(15, this.ownReadonlyAccessor); + try { + super.ownReadonlyAccessor = 25; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals('Cannot redefine property: ownReadonlyAccessor', ex.message); + assertEquals(15, this.ownReadonlyAccessor); + + ex = null; + try { + super.ownSetter = 35; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals('Cannot redefine property: ownSetter', ex.message); + } + }; var d = new Derived(); Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false }); Object.defineProperty(d, 'ownSetter', - { set : function() { setterCalled++; } }); + { set : function() { assertUnreachable(); } }); Object.defineProperty(d, 'ownReadonlyAccessor', { get : function() { return 15; }}); d.mSloppy(); @@ -1006,156 +1166,233 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, + testIter() { + setCalled = 0; + getCalled = 0; + for (super.x in [1,2,3]) {} + assertEquals(0, getCalled); + assertEquals(3, setCalled); + assertEquals(["0", "1", "2"], this.x_); + }, + testIterKeyed() { + setCalled = 0; + getCalled = 0; + for (super[x] in [1,2,3]) {} + assertEquals(0, getCalled); + assertEquals(3, setCalled); + assertEquals(["0","1","2"], this.x_); + + this.x_ = []; + setCalled = 0; + getCalled = 0; + var toStringCalled = 0; + var o = {toString: function () { toStringCalled++; return x }}; + for (super[o] in [1,2,3]) {} + assertEquals(0, getCalled); + assertEquals(3, setCalled); + assertEquals(3, toStringCalled); + assertEquals(["0","1","2"], this.x_); + } }; - Derived.prototype.testIter = function() { - setCalled = 0; - getCalled = 0; - for (super.x in [1,2,3]) {} - assertEquals(0, getCalled); - assertEquals(3, setCalled); - assertEquals(["0","1","2"], this.x_); - }.toMethod(Derived.prototype); - new Derived().testIter(); var x = 'x'; - Derived.prototype.testIterKeyed = function() { - setCalled = 0; - getCalled = 0; - for (super[x] in [1,2,3]) {} - assertEquals(0, getCalled); - assertEquals(3, setCalled); - assertEquals(["0","1","2"], this.x_); - - this.x_ = []; - setCalled = 0; - getCalled = 0; - var toStringCalled = 0; - var o = {toString: function () { toStringCalled++; return x }}; - for (super[o] in [1,2,3]) {} - assertEquals(0, getCalled); - assertEquals(3, setCalled); - assertEquals(3, toStringCalled); - assertEquals(["0","1","2"], this.x_); - }.toMethod(Derived.prototype); new Derived().testIterKeyed(); }()); -(function TestKeyedSetterCreatingOwnProperties() { - var ownReadOnly = 'ownReadOnly'; - var ownReadonlyAccessor = 'ownReadonlyAccessor'; - var ownSetter = 'ownSetter'; +function TestKeyedSetterCreatingOwnPropertiesReconfigurable(ownReadOnly, + ownReadonlyAccessor, ownSetter) { function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - var setterCalled; - - Derived.prototype.mSloppy = function() { - assertEquals(42, this[ownReadOnly]); - super[ownReadOnly] = 55; - assertEquals(42, this[ownReadOnly]); - - assertEquals(15, this[ownReadonlyAccessor]); - super[ownReadonlyAccessor] = 55; - assertEquals(15, this[ownReadonlyAccessor]); - - setterCalled = 0; - super[ownSetter] = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(42, this[ownReadOnly]); - var ex; - try { + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(42, this[ownReadOnly]); super[ownReadOnly] = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(42, this[ownReadOnly]); - - assertEquals(15, this[ownReadonlyAccessor]); - ex = null; - try { - super[ownReadonlyAccessor] = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(15, this[ownReadonlyAccessor]); - - setterCalled = 0; - super[ownSetter] = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); + assertEquals(55, this[ownReadOnly]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly); + assertEquals(55, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownReadOnly)); + + assertEquals(15, this[ownReadonlyAccessor]); + super[ownReadonlyAccessor] = 25; + assertEquals(25, this[ownReadonlyAccessor]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor); + assertEquals(25, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor)); + + super[ownSetter] = 35; + assertEquals(35, this[ownSetter]); + var descr = Object.getOwnPropertyDescriptor(this, ownSetter); + assertEquals(35, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownSetter)); + }, + mStrict() { + 'use strict'; + assertEquals(42, this[ownReadOnly]); + super[ownReadOnly] = 55; + assertEquals(55, this[ownReadOnly]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly); + assertEquals(55, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownReadOnly)); + + assertEquals(15, this[ownReadonlyAccessor]); + super[ownReadonlyAccessor] = 25; + assertEquals(25, this[ownReadonlyAccessor]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor); + assertEquals(25, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor)); + + super[ownSetter] = 35; + assertEquals(35, this[ownSetter]); + var descr = Object.getOwnPropertyDescriptor(this, ownSetter); + assertEquals(35, descr.value); + assertTrue(descr.configurable); + assertFalse(descr.enumerable); + assertTrue(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownSetter)); + }, + }; var d = new Derived(); - Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false }); - Object.defineProperty(d, 'ownSetter', - { set : function() { setterCalled++; } }); - Object.defineProperty(d, 'ownReadonlyAccessor', - { get : function() { return 15; }}); + Object.defineProperty(d, ownReadOnly, { + value: 42, + writable: false, + configurable: true + }); + Object.defineProperty(d, ownSetter, { + set: function() { assertUnreachable(); }, + configurable: true + }); + Object.defineProperty(d, ownReadonlyAccessor, { + get: function() { return 15; }, + configurable: true + }); + d.mSloppy(); + + var d = new Derived(); + Object.defineProperty(d, ownReadOnly, { + value: 42, + writable: false, + configurable: true + }); + Object.defineProperty(d, ownSetter, { + set: function() { assertUnreachable(); }, + configurable: true + }); + Object.defineProperty(d, ownReadonlyAccessor, { + get: function() { return 15; }, + configurable: true + }); d.mStrict(); -}()); +} +TestKeyedSetterCreatingOwnPropertiesReconfigurable('ownReadOnly', + 'ownReadonlyAccessor', + 'ownSetter'); +TestKeyedSetterCreatingOwnPropertiesReconfigurable(42, 43, 44); -(function TestKeyedNumericSetterCreatingOwnProperties() { - var ownReadOnly = 42; - var ownReadonlyAccessor = 43; - var ownSetter = 44; +function TestKeyedSetterCreatingOwnPropertiesNonConfigurable( + ownReadOnly, ownReadonlyAccessor, ownSetter) { function Base() {} function Derived() {} - Derived.prototype = { __proto__ : Base.prototype }; - var setterCalled; - - Derived.prototype.mSloppy = function() { - assertEquals(42, this[ownReadOnly]); - super[ownReadOnly] = 55; - assertEquals(42, this[ownReadOnly]); - - assertEquals(15, this[ownReadonlyAccessor]); - super[ownReadonlyAccessor] = 55; - assertEquals(15, this[ownReadonlyAccessor]); - - setterCalled = 0; - super[ownSetter] = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(42, this[ownReadOnly]); - var ex; - try { + Derived.prototype = { + __proto__: Base.prototype, + mSloppy() { + assertEquals(42, this[ownReadOnly]); super[ownReadOnly] = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(42, this[ownReadOnly]); - - assertEquals(15, this[ownReadonlyAccessor]); - ex = null; - try { - super[ownReadonlyAccessor] = 55; - } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(15, this[ownReadonlyAccessor]); - - setterCalled = 0; - super[ownSetter] = 42; - assertEquals(1, setterCalled); - }.toMethod(Derived.prototype); + assertEquals(42, this[ownReadOnly]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly); + assertEquals(42, descr.value); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(descr.writable); + assertFalse(Base.prototype.hasOwnProperty(ownReadOnly)); + + assertEquals(15, this[ownReadonlyAccessor]); + super[ownReadonlyAccessor] = 25; + assertEquals(15, this[ownReadonlyAccessor]); + var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor)); + + super[ownSetter] = 35; + var descr = Object.getOwnPropertyDescriptor(this, ownSetter); + assertFalse(descr.configurable); + assertFalse(descr.enumerable); + assertFalse(Base.prototype.hasOwnProperty(ownSetter)); + }, + mStrict() { + 'use strict'; + var ex; + assertEquals(42, this[ownReadOnly]); + try { + super[ownReadOnly] = 55; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals( + "Cannot assign to read only property '" + ownReadOnly + + "' of #<Base>", + ex.message); + assertEquals(42, this[ownReadOnly]); + + ex = null; + assertEquals(15, this[ownReadonlyAccessor]); + try { + super[ownReadonlyAccessor] = 25; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals('Cannot redefine property: ' + ownReadonlyAccessor, + ex.message); + assertEquals(15, this[ownReadonlyAccessor]); + + ex = null; + try { + super[ownSetter] = 35; + } catch (e) { + ex = e; + } + assertInstanceof(ex, TypeError); + assertEquals('Cannot redefine property: ' + ownSetter, ex.message); + } + }; var d = new Derived(); Object.defineProperty(d, ownReadOnly, { value : 42, writable : false }); Object.defineProperty(d, ownSetter, - { set : function() { setterCalled++; } }); + { set : function() { assertUnreachable(); } }); Object.defineProperty(d, ownReadonlyAccessor, { get : function() { return 15; }}); d.mSloppy(); d.mStrict(); -}()); +} +TestKeyedSetterCreatingOwnPropertiesNonConfigurable('ownReadOnly', + 'ownReadonlyAccessor', 'ownSetter'); +TestKeyedSetterCreatingOwnPropertiesNonConfigurable(42, 43, 44); (function TestSetterNoProtoWalk() { @@ -1164,62 +1401,58 @@ var getCalled; var setCalled; Derived.prototype = { - __proto__ : Base.prototype, + __proto__: Base.prototype, get x() { getCalled++; return 42; }, - set x(v) { setCalled++; } + set x(v) { setCalled++; }, + mSloppy() { + setCalled = 0; + getCalled = 0; + assertEquals(42, this.x); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this.x = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super.x = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this.x); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + }, + mStrict() { + 'use strict'; + setCalled = 0; + getCalled = 0; + assertEquals(42, this.x); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this.x = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super.x = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this.x); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + } }; - Derived.prototype.mSloppy = function() { - setCalled = 0; - getCalled = 0; - assertEquals(42, this.x); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this.x = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super.x = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this.x); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - setCalled = 0; - getCalled = 0; - assertEquals(42, this.x); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this.x = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super.x = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this.x); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - new Derived().mSloppy(); new Derived().mStrict(); }()); @@ -1232,62 +1465,58 @@ var getCalled; var setCalled; Derived.prototype = { - __proto__ : Base.prototype, + __proto__: Base.prototype, get x() { getCalled++; return 42; }, - set x(v) { setCalled++; } + set x(v) { setCalled++; }, + mSloppy() { + setCalled = 0; + getCalled = 0; + assertEquals(42, this[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this[x] = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super[x] = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this[x]); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + }, + mStrict() { + 'use strict'; + setCalled = 0; + getCalled = 0; + assertEquals(42, this[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this[x] = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super[x] = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this[x]); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + } }; - Derived.prototype.mSloppy = function() { - setCalled = 0; - getCalled = 0; - assertEquals(42, this[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this[x] = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super[x] = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this[x]); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - setCalled = 0; - getCalled = 0; - assertEquals(42, this[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this[x] = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super[x] = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this[x]); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - new Derived().mSloppy(); new Derived().mStrict(); }()); @@ -1300,7 +1529,54 @@ var getCalled; var setCalled; Derived.prototype = { - __proto__ : Base.prototype, + __proto__: Base.prototype, + mSloppy() { + setCalled = 0; + getCalled = 0; + assertEquals(42, this[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this[x] = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super[x] = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this[x]); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + }, + mStrict() { + 'use strict'; + setCalled = 0; + getCalled = 0; + assertEquals(42, this[x]); + assertEquals(1, getCalled); + assertEquals(0, setCalled); + + getCalled = 0; + setCalled = 0; + this[x] = 43; + assertEquals(0, getCalled); + assertEquals(1, setCalled); + + getCalled = 0; + setCalled = 0; + super[x] = 15; + assertEquals(0, setCalled); + assertEquals(0, getCalled); + + assertEquals(15, this[x]); + assertEquals(0, getCalled); + assertEquals(0, setCalled); + } }; Object.defineProperty(Derived.prototype, x, { @@ -1308,57 +1584,6 @@ set: function(v) { setCalled++; } }); - Derived.prototype.mSloppy = function() { - setCalled = 0; - getCalled = 0; - assertEquals(42, this[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this[x] = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super[x] = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this[x]); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - - Derived.prototype.mStrict = function() { - 'use strict'; - setCalled = 0; - getCalled = 0; - assertEquals(42, this[x]); - assertEquals(1, getCalled); - assertEquals(0, setCalled); - - getCalled = 0; - setCalled = 0; - this[x] = 43; - assertEquals(0, getCalled); - assertEquals(1, setCalled); - - getCalled = 0; - setCalled = 0; - super[x] = 15; - assertEquals(0, setCalled); - assertEquals(0, getCalled); - - assertEquals(15, this[x]); - assertEquals(0, getCalled); - assertEquals(0, setCalled); - - }.toMethod(Derived.prototype); - new Derived().mSloppy(); new Derived().mStrict(); }()); @@ -1367,35 +1592,36 @@ (function TestSetterDoesNotReconfigure() { function Base() {} function Derived() {} - - Derived.prototype.mStrict = function (){ - 'use strict'; - super.nonEnumConfig = 5; - var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig'); - assertEquals(5, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super.nonEnumNonConfig = 5; - var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig'); - assertEquals(5, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); - - Derived.prototype.mSloppy = function (){ - super.nonEnumConfig = 42; - var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig'); - assertEquals(42, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super.nonEnumNonConfig = 42; - var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig'); - assertEquals(42, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Derived.prototype, + mStrict(){ + 'use strict'; + super.nonEnumConfig = 5; + var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig'); + assertEquals(5, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super.nonEnumNonConfig = 5; + var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig'); + assertEquals(5, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + }, + mSloppy(){ + super.nonEnumConfig = 42; + var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumConfig'); + assertEquals(42, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super.nonEnumNonConfig = 42; + var d1 = Object.getOwnPropertyDescriptor(this, 'nonEnumNonConfig'); + assertEquals(42, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + } + }; var d = new Derived(); Object.defineProperty(d, 'nonEnumConfig', @@ -1413,36 +1639,36 @@ function Base() {} function Derived() {} - Derived.prototype = { __proto__: Base.prototype }; - - Derived.prototype.mStrict = function (){ - 'use strict'; - super[nonEnumConfig] = 5; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); - assertEquals(5, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super[nonEnumNonConfig] = 5; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); - assertEquals(5, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); - - Derived.prototype.mSloppy = function (){ - super[nonEnumConfig] = 42; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); - assertEquals(42, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super[nonEnumNonConfig] = 42; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); - assertEquals(42, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + mStrict(){ + 'use strict'; + super[nonEnumConfig] = 5; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); + assertEquals(5, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super[nonEnumNonConfig] = 5; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); + assertEquals(5, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + }, + mSloppy(){ + super[nonEnumConfig] = 42; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); + assertEquals(42, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super[nonEnumNonConfig] = 42; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); + assertEquals(42, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + } + }; var d = new Derived(); Object.defineProperty(d, nonEnumConfig, @@ -1460,36 +1686,36 @@ function Base() {} function Derived() {} - Derived.prototype = { __proto__: Base.prototype }; - - Derived.prototype.mStrict = function (){ - 'use strict'; - super[nonEnumConfig] = 5; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); - assertEquals(5, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super[nonEnumNonConfig] = 5; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); - assertEquals(5, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); - - Derived.prototype.mSloppy = function (){ - super[nonEnumConfig] = 42; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); - assertEquals(42, d1.value); - assertTrue(d1.configurable); - assertFalse(d1.enumerable); - - super[nonEnumNonConfig] = 42; - var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); - assertEquals(42, d1.value); - assertFalse(d1.configurable); - assertFalse(d1.enumerable); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + mStrict(){ + 'use strict'; + super[nonEnumConfig] = 5; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); + assertEquals(5, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super[nonEnumNonConfig] = 5; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); + assertEquals(5, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + }, + mSloppy(){ + super[nonEnumConfig] = 42; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumConfig); + assertEquals(42, d1.value); + assertTrue(d1.configurable); + assertFalse(d1.enumerable); + + super[nonEnumNonConfig] = 42; + var d1 = Object.getOwnPropertyDescriptor(this, nonEnumNonConfig); + assertEquals(42, d1.value); + assertFalse(d1.configurable); + assertFalse(d1.enumerable); + } + }; var d = new Derived(); Object.defineProperty(d, nonEnumConfig, @@ -1519,32 +1745,31 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 2 + _x: 2, + testCounts() { + assertEquals(2, this._x); + assertEquals(2, super.x); + super.x++; + assertEquals(3, super.x); + ++super.x; + assertEquals(4, super.x); + assertEquals(4, super.x++); + assertEquals(5, super.x); + assertEquals(6, ++super.x); + assertEquals(6, super.x); + assertEquals(6, this._x); + + super.x--; + assertEquals(5, super.x); + --super.x; + assertEquals(4, super.x); + assertEquals(4, super.x--); + assertEquals(3, super.x); + assertEquals(2, --super.x); + assertEquals(2, super.x); + assertEquals(2, this._x); + } }; - - Derived.prototype.testCounts = function() { - assertEquals(2, this._x); - assertEquals(2, super.x); - super.x++; - assertEquals(3, super.x); - ++super.x; - assertEquals(4, super.x); - assertEquals(4, super.x++); - assertEquals(5, super.x); - assertEquals(6, ++super.x); - assertEquals(6, super.x); - assertEquals(6, this._x); - - super.x--; - assertEquals(5, super.x); - --super.x; - assertEquals(4, super.x); - assertEquals(4, super.x--); - assertEquals(3, super.x); - assertEquals(2, --super.x); - assertEquals(2, super.x); - assertEquals(2, this._x); - }.toMethod(Derived.prototype); new Derived().testCounts(); }()); @@ -1568,32 +1793,31 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 2 + _x: 2, + testCounts() { + assertEquals(2, this._x); + assertEquals(2, super[x]); + super[x]++; + assertEquals(3, super[x]); + ++super[x]; + assertEquals(4, super[x]); + assertEquals(4, super[x]++); + assertEquals(5, super[x]); + assertEquals(6, ++super[x]); + assertEquals(6, super[x]); + assertEquals(6, this._x); + + super[x]--; + assertEquals(5, super[x]); + --super[x]; + assertEquals(4, super[x]); + assertEquals(4, super[x]--); + assertEquals(3, super[x]); + assertEquals(2, --super[x]); + assertEquals(2, super[x]); + assertEquals(2, this._x); + } }; - - Derived.prototype.testCounts = function() { - assertEquals(2, this._x); - assertEquals(2, super[x]); - super[x]++; - assertEquals(3, super[x]); - ++super[x]; - assertEquals(4, super[x]); - assertEquals(4, super[x]++); - assertEquals(5, super[x]); - assertEquals(6, ++super[x]); - assertEquals(6, super[x]); - assertEquals(6, this._x); - - super[x]--; - assertEquals(5, super[x]); - --super[x]; - assertEquals(4, super[x]); - assertEquals(4, super[x]--); - assertEquals(3, super[x]); - assertEquals(2, --super[x]); - assertEquals(2, super[x]); - assertEquals(2, this._x); - }.toMethod(Derived.prototype); new Derived().testCounts(); }()); @@ -1616,32 +1840,31 @@ Derived.prototype = { __proto__: Base.prototype, constructor: Derived, - _x: 2 + _x: 2, + testCounts() { + assertEquals(2, this._x); + assertEquals(2, super[x]); + super[x]++; + assertEquals(3, super[x]); + ++super[x]; + assertEquals(4, super[x]); + assertEquals(4, super[x]++); + assertEquals(5, super[x]); + assertEquals(6, ++super[x]); + assertEquals(6, super[x]); + assertEquals(6, this._x); + + super[x]--; + assertEquals(5, super[x]); + --super[x]; + assertEquals(4, super[x]); + assertEquals(4, super[x]--); + assertEquals(3, super[x]); + assertEquals(2, --super[x]); + assertEquals(2, super[x]); + assertEquals(2, this._x); + } }; - - Derived.prototype.testCounts = function() { - assertEquals(2, this._x); - assertEquals(2, super[x]); - super[x]++; - assertEquals(3, super[x]); - ++super[x]; - assertEquals(4, super[x]); - assertEquals(4, super[x]++); - assertEquals(5, super[x]); - assertEquals(6, ++super[x]); - assertEquals(6, super[x]); - assertEquals(6, this._x); - - super[x]--; - assertEquals(5, super[x]); - --super[x]; - assertEquals(4, super[x]); - assertEquals(4, super[x]--); - assertEquals(3, super[x]); - assertEquals(2, --super[x]); - assertEquals(2, super[x]); - assertEquals(2, this._x); - }.toMethod(Derived.prototype); new Derived().testCounts(); }()); @@ -1650,26 +1873,27 @@ function Base() {} Object.defineProperty(Base.prototype, 'x', { value : 27, writable: false }); function Derived() {} - - Derived.prototype = { __proto__: Base.prototype, constructor: Derived }; - - Derived.prototype.mSloppy = function() { - assertEquals(27, super.x); - assertEquals(27, this.x); - super.x = 10; - assertEquals(27, super.x); - assertEquals(27, this.x); - }.toMethod(Derived.prototype); - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(27, super.x); - assertEquals(27, this.x); - var ex = null; - try { super.x = 10; } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(27, super.x); - assertEquals(27, this.x); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + constructor: Derived, + mSloppy() { + assertEquals(27, super.x); + assertEquals(27, this.x); + super.x = 10; + assertEquals(27, super.x); + assertEquals(27, this.x); + }, + mStrict() { + 'use strict'; + assertEquals(27, super.x); + assertEquals(27, this.x); + var ex = null; + try { super.x = 10; } catch(e) { ex = e; } + assertInstanceof(ex, TypeError); + assertEquals(27, super.x); + assertEquals(27, this.x); + } + }; new Derived().mSloppy(); new Derived().mStrict(); }()); @@ -1681,25 +1905,27 @@ Object.defineProperty(Base.prototype, x, { value : 27, writable: false }); function Derived() {} - Derived.prototype = { __proto__: Base.prototype, constructor: Derived }; - - Derived.prototype.mSloppy = function() { - assertEquals(27, super[x]); - assertEquals(27, this[x]); - super[x] = 10; - assertEquals(27, super[x]); - assertEquals(27, this[x]); - }.toMethod(Derived.prototype); - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(27, super[x]); - assertEquals(27, this[x]); - var ex = null; - try { super[x] = 10; } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(27, super[x]); - assertEquals(27, this[x]); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + constructor: Derived, + mSloppy() { + assertEquals(27, super[x]); + assertEquals(27, this[x]); + super[x] = 10; + assertEquals(27, super[x]); + assertEquals(27, this[x]); + }, + mStrict() { + 'use strict'; + assertEquals(27, super[x]); + assertEquals(27, this[x]); + var ex = null; + try { super[x] = 10; } catch(e) { ex = e; } + assertInstanceof(ex, TypeError); + assertEquals(27, super[x]); + assertEquals(27, this[x]); + } + }; new Derived().mSloppy(); new Derived().mStrict(); }()); @@ -1711,55 +1937,51 @@ Object.defineProperty(Base.prototype, x, { value : 27, writable: false }); function Derived() {} - Derived.prototype = { __proto__: Base.prototype, constructor: Derived }; - - Derived.prototype.mSloppy = function() { - assertEquals(27, super[x]); - assertEquals(27, this[x]); - super[x] = 10; - assertEquals(27, super[x]); - assertEquals(27, this[x]); - }.toMethod(Derived.prototype); - Derived.prototype.mStrict = function() { - 'use strict'; - assertEquals(27, super[x]); - assertEquals(27, this[x]); - var ex = null; - try { super[x] = 10; } catch(e) { ex = e; } - assertTrue(ex instanceof TypeError); - assertEquals(27, super[x]); - assertEquals(27, this[x]); - }.toMethod(Derived.prototype); + Derived.prototype = { + __proto__: Base.prototype, + constructor: Derived, + mSloppy() { + assertEquals(27, super[x]); + assertEquals(27, this[x]); + super[x] = 10; + assertEquals(27, super[x]); + assertEquals(27, this[x]); + }, + mStrict() { + 'use strict'; + assertEquals(27, super[x]); + assertEquals(27, this[x]); + var ex = null; + try { super[x] = 10; } catch(e) { ex = e; } + assertInstanceof(ex, TypeError); + assertEquals(27, super[x]); + assertEquals(27, this[x]); + } + }; new Derived().mSloppy(); new Derived().mStrict(); }()); -function Subclass(base, constructor) { - var homeObject = { - __proto__: base.prototype, - constructor: constructor - }; - constructor.__proto__ = base; - constructor.prototype = homeObject; - // not doing toMethod: home object is not required for - // super constructor calls. - return constructor; -} - (function TestSuperCall() { + 'use strict'; + var baseCalled = 0; var derivedCalled = 0; var derivedDerivedCalled = 0; - function Base() { - baseCalled++; + class Base { + constructor() { + baseCalled++; + } } - var Derived = Subclass(Base, function () { - super(); - derivedCalled++; - }); + class Derived extends Base { + constructor() { + super(); + derivedCalled++; + } + } assertEquals(Base, Base.prototype.constructor); assertEquals(Base.prototype, Derived.prototype.__proto__); @@ -1770,10 +1992,12 @@ function Subclass(base, constructor) { assertEquals(1, baseCalled); assertEquals(1, derivedCalled); - var DerivedDerived = Subclass(Derived, function () { - super(); - derivedDerivedCalled++; - }); + class DerivedDerived extends Derived { + constructor() { + super(); + derivedDerivedCalled++; + } + } baseCalled = 0; derivedCalled = 0; @@ -1783,32 +2007,33 @@ function Subclass(base, constructor) { assertEquals(1, derivedCalled); assertEquals(1, derivedDerivedCalled); - function Base2(v) { - this.fromBase = v; + class Base2 { + constructor(v) { + this.fromBase = v; + } + } + class Derived2 extends Base2 { + constructor(v1, v2) { + super(v1); + this.fromDerived = v2; + } } - var Derived2 = Subclass(Base2, function (v1, v2) { - super(v1); - this.fromDerived = v2; - }); var d = new Derived2("base", "derived"); assertEquals("base", d.fromBase); assertEquals("derived", d.fromDerived); - function ImplicitSubclassOfFunction() { - super(); - this.x = 123; - } - - var o = new ImplicitSubclassOfFunction(); - assertEquals(123, o.x); - var calls = 0; - function G() { - calls++; + class G { + constructor() { + calls++; + } } - function F() { - super(); + + class F extends Object { + constructor() { + super(); + } } F.__proto__ = G; new F(); @@ -1819,103 +2044,23 @@ function Subclass(base, constructor) { }()); -(function TestNewSuper() { - var baseCalled = 0; - var derivedCalled = 0; - - function Base() { - baseCalled++; - this.x = 15; - } - - - var Derived = Subclass(Base, function() { - baseCalled = 0; - var b = new super(); - assertEquals(1, baseCalled) - assertEquals(Base.prototype, b.__proto__); - assertEquals(15, b.x); - assertEquals(undefined, this.x); - derivedCalled++; - }); +(function TestExtendsObject() { + 'use strict'; + class F extends Object { } + var f = new F(42); - derivedCalled = 0; - new Derived(); - assertEquals(1, derivedCalled); + // TODO(dslomov,arv): Fix this. BUG=v8:3886. + assertInstanceof(f, Number); }()); - (function TestSuperCallErrorCases() { - function T() { - super(); + 'use strict'; + class T extends Object { + constructor() { + super(); + } } + T.__proto__ = null; - // Spec says ReferenceError here, but for other IsCallable failures - // we throw TypeError. - // Filed https://bugs.ecmascript.org/show_bug.cgi?id=3282 assertThrows(function() { new T(); }, TypeError); - - function T1() { - var b = new super(); - } - T1.__proto = null; - assertThrows(function() { new T1(); }, TypeError); -}()); - - -(function TestSuperCallSyntacticRestriction() { - assertThrows(function() { - function C() { - var y; - super(); - } - new C(); - }, TypeError); - assertThrows(function() { - function C() { - super(this.x); - } - new C(); - }, TypeError); - assertThrows(function() { - function C() { - super(this); - } - new C(); - }, TypeError); - assertThrows(function() { - function C() { - super(1, 2, Object.getPrototypeOf(this)); - } - new C(); - }, TypeError); - assertThrows(function() { - function C() { - { super(1, 2); } - }; new C(); - }, TypeError); - assertThrows(function() { - function C() { - if (1) super(); - }; new C(); - }, TypeError); - - function C1() { - 'use strict'; - super(); - }; - new C1(); - - function C2() { - ; 'use strict';;;;; - super(); - }; - new C2(); - - function C3() { - ; 'use strict';;;;; - // This is a comment. - super(); - } - new C3(); }()); |