blob: 086282b957f1c129f38fea5a48534f3707f15720 [file] [log] [blame]
//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");
var sym1 = Symbol("bart");
var count = 0;
class A {
constructor() {
count++;
}
increment() {
count++;
}
decrement() {
count--;
}
getCount()
{
return count;
}
1() { return 1; }
2() { return 2; }
1.1() { return 1.1; }
2.2() { return 2.2; }
[1+3]() { return 4; }
[1.1+1]() { return 2.1; }
["foo"+1]() { return "foo1"; }
[sym1](){return "bart";}
}
A.prototype.x = 42;
A.prototype["y"] = 30;
A.prototype[10] = 10;
A.prototype[10.1] = 10.1;
Object.defineProperty(A.prototype, "length", {writable : true, value : 2 });
Object.defineProperty(A, "length", {writable : true, value : -1 });
var tests = [
{
name: "Access length",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(2, super.length, "confirm we can make dot property call to access A.prototype.length");
var super_arrow = () => {
assert.areEqual(2, super.length, "confirm we can make dot property call to access A.prototype.length when it is in a lambda");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "Access of property fields on super",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(42, super.x, "confirm we can make dot property calls on non function types");
assert.areEqual(42, super["x"], "confirm we can make index property calls of properties defined as dot properties");
assert.areEqual(30, super["y"], "confirm we can make index property calls on string properties promoted to dot properties");
assert.areEqual(10, super[10], "confirm we can make index property calls on integer properties");
assert.areEqual(10.1, super[10.1], "confirm we can make index property calls on float point properties");
assert.areEqual(10, super["10"], "confirm we can make index property calls on integer properties accessed as strings");
assert.areEqual(10.1, super["10.1"], "confirm we can make index property calls on float point properties accessed as strings");
}
}
var bar = new B();
}
},
{
name: "Access of property fields on super in a lambda",
body: function ()
{
class B extends A {
constructor() {
super();
var super_arrow = () => {
assert.areEqual(42, super.x, "confirm we can make dot property calls on non function types");
assert.areEqual(42, super["x"], "confirm we can make index property calls of properties defined as dot properties");
assert.areEqual(30, super["y"], "confirm we can make index property calls on string properties promoted to dot properties");
assert.areEqual(10, super[10], "confirm we can make index property calls on integer properties");
assert.areEqual(10.1, super[10.1], "confirm we can make index property calls on float point properties");
assert.areEqual(10, super["10"], "confirm we can make index property calls on integer properties accessed as strings");
assert.areEqual(10.1, super["10.1"], "confirm we can make index property calls on float point properties accessed as strings");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "Access of property fields on super in a lambda with super also inside the lambda",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(42, super.x, "confirm we can make dot property calls on non function types");
assert.areEqual(42, super["x"], "confirm we can make index property calls of properties defined as dot properties");
assert.areEqual(30, super["y"], "confirm we can make index property calls on string properties promoted to dot properties");
assert.areEqual(10, super[10], "confirm we can make index property calls on integer properties");
assert.areEqual(10.1, super[10.1], "confirm we can make index property calls on float point properties");
assert.areEqual(10, super["10"], "confirm we can make index property calls on integer properties accessed as strings");
assert.areEqual(10.1, super["10.1"], "confirm we can make index property calls on float point properties accessed as strings");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lamda call on super before making a super call",
body: function ()
{
count = 0;
class B extends A {
constructor() {
var super_arrow = () => {
assert.throws(()=>{ super.increment(); }, ReferenceError, "Use before declaration");
assert.areEqual(0,count,"We should not have incremented");
assert.throws(()=>{ super.increment.call(5); }, ReferenceError, "Use before declaration");
assert.throws(()=>{ super[1](); }, ReferenceError, "Use before declaration");
assert.throws(()=>{ super[1].call(5); }, ReferenceError, "Use before declaration");
super();
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "super.<method>.call",
body: function ()
{
count = 0;
class B extends A {
constructor() {
super();
var super_arrow = () => {
super.increment.call(this);
assert.areEqual(2,super.getCount.call(this), "confirm we can make the the method call on class A's method inside a lambda");
assert.areEqual(1,super[1].call(this), "confirm we can make index method call on class A's method inside a lambda");
}
super_arrow();
super.decrement.call(this);
assert.areEqual(1,super.getCount.call(this),"confirm we can make the the method call on class A's method");
assert.areEqual(2,super[2].call(this), "confirm we can make index method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "lamda super dot calls",
body: function ()
{
count = 0;
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(1,super.getCount(),"confirm we can make the the method call on class A's method");
super.increment();
assert.areEqual(2, super.getCount(), "confirm we can make the the method call on class A's method");
super.decrement();
assert.areEqual(1, super.getCount(), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lamda super string index calls",
body: function ()
{
count = 0;
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(1,super["getCount"](), "confirm we can make the the method call on class A's method");
super["increment"]();
assert.areEqual(2, super["getCount"](), "confirm we can make the the method call on class A's method");
super["decrement"]();
assert.areEqual(1, super["getCount"](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lambda super double index calls",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(1.1,super[1.1](), "confirm we can make the the method call on class A's method");
assert.areEqual(2.2, super[2.2](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lambda super int index calls",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(1,super[1](), "confirm we can make the the method call on class A's method");
assert.areEqual(2, super[2](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lamda super computed property double index calls",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual(2.1,super[2.1](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lamda super computed property int index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(4,super[4](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "lamda super computed property string concatenated to integer index calls",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual("foo1",super["foo1"](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "lamda super computed property Symbol index calls",
body: function ()
{
class B extends A {
constructor() {
var super_arrow = () => {
super();
assert.areEqual("bart",super[sym1](), "confirm we can make the the method call on class A's method");
}
super_arrow();
}
}
var bar = new B();
}
},
{
name: "regular super dot calls",
body: function ()
{
count = 0;
class B extends A {
constructor() {
super();
assert.areEqual(1,super.getCount(), "confirm we can make the the method call on class A's method");
super.increment();
assert.areEqual(2, super.getCount(), "confirm we can make the the method call on class A's method");
super.decrement();
assert.areEqual(1, super.getCount(), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super string index calls",
body: function ()
{
count = 0;
class B extends A {
constructor() {
super();
assert.areEqual(1,super["getCount"](), "confirm we can make the the method call on class A's method");
super["increment"]();
assert.areEqual(2, super["getCount"](), "confirm we can make the the method call on class A's method");
super["decrement"]();
assert.areEqual(1, super["getCount"](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super double index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(1.1,super[1.1](), "confirm we can make the the method call on class A's method");
assert.areEqual(2.2, super[2.2](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super int index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(1,super[1](), "confirm we can make the the method call on class A's method");
assert.areEqual(2, super[2](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super computed property double index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(2.1,super[2.1](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super computed property int index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual(4,super[4](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super computed property string concatenated to integer index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual("foo1",super["foo1"](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
},
{
name: "regular super computed property Symbol index calls",
body: function ()
{
class B extends A {
constructor() {
super();
assert.areEqual("bart",super[sym1](), "confirm we can make the the method call on class A's method");
}
}
var bar = new B();
}
}
];
testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });