//-------------------------------------------------------------------------------------------------------
// 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" });