// 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.

'use strict';
(function TestArgumentsAccess() {
  class Base {
    constructor() {
      assertEquals(2, arguments.length);
      assertEquals(1, arguments[0]);
      assertEquals(2, arguments[1]);
    }
  }

  let b = new Base(1,2);

  class Subclass extends Base {
    constructor() {
      assertEquals(2, arguments.length);
      assertEquals(3, arguments[0]);
      assertEquals(4, arguments[1]);
      super(1,2);
    }
  }

  let s = new Subclass(3,4);
  assertEquals(0, Subclass.length);

  class Subclass2 extends Base {
    constructor(x,y) {
      assertEquals(2, arguments.length);
      assertEquals(3, arguments[0]);
      assertEquals(4, arguments[1]);
      super(1,2);
    }
  }

  let s2 = new Subclass2(3,4);
  assertEquals(2, Subclass2.length);
}());

(function TestThisAccessRestriction() {
  class Base {
    constructor(a, b) {
      let o = new Object();
      o.prp = a + b;
      return o;
    }
  }

  class Subclass extends Base {
    constructor(a, b) {
      var exn;
      try {
        this.prp1 = 3;
      } catch (e) {
        exn = e;
      }
      assertTrue(exn instanceof ReferenceError);
      super(a, b);
      assertSame(a + b, this.prp);
      assertSame(undefined, this.prp1);
      assertFalse(this.hasOwnProperty("prp1"));
      return this;
    }
  }

  let b = new Base(1, 2);
  assertSame(3, b.prp);


  let s = new Subclass(2, -1);
  assertSame(1, s.prp);
  assertSame(undefined, s.prp1);
  assertFalse(s.hasOwnProperty("prp1"));

  class Subclass2 extends Base {
    constructor(x) {
      super(1,2);

      if (x < 0) return;

      let called = false;
      function tmp() { called = true; return 3; }
      var exn = null;
      try {
        super(tmp(),4);
      } catch (e) { exn = e; }
      assertTrue(exn instanceof ReferenceError);
      assertTrue(called);
    }
  }

  var s2 = new Subclass2(1);
  assertSame(3, s2.prp);

  var s3 = new Subclass2(-1);
  assertSame(3, s3.prp);

  assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
  assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);

  class BadSubclass extends Base {
    constructor() {}
  }

  assertThrows(function() { new BadSubclass(); }, ReferenceError);
}());

(function TestThisCheckOrdering() {
  let baseCalled = 0;
  class Base {
    constructor() { baseCalled++ }
  }

  let fCalled = 0;
  function f() { fCalled++; return 3; }

  class Subclass1 extends Base {
    constructor() {
      baseCalled = 0;
      super();
      assertEquals(1, baseCalled);
      let obj = this;

      let exn = null;
      baseCalled = 0;
      fCalled = 0;
      try {
        super(f());
      } catch (e) { exn = e; }
      assertTrue(exn instanceof ReferenceError);
      assertEquals(1, fCalled);
      assertEquals(1, baseCalled);
      assertSame(obj, this);

      exn = null;
      baseCalled = 0;
      fCalled = 0;
      try {
        super(super(), f());
      } catch (e) { exn = e; }
      assertTrue(exn instanceof ReferenceError);
      assertEquals(0, fCalled);
      assertEquals(1, baseCalled);
      assertSame(obj, this);

      exn = null;
      baseCalled = 0;
      fCalled = 0;
      try {
        super(f(), super());
      } catch (e) { exn = e; }
      assertTrue(exn instanceof ReferenceError);
      assertEquals(1, fCalled);
      assertEquals(1, baseCalled);
      assertSame(obj, this);
    }
  }

  new Subclass1();
}());


(function TestPrototypeWiring() {
  class Base {
    constructor(x) {
      this.foobar = x;
    }
  }

  class Subclass extends Base {
    constructor(x) {
      super(x);
    }
  }

  let s = new Subclass(1);
  assertSame(1, s.foobar);
  assertSame(Subclass.prototype, s.__proto__);

  let s1 = new Subclass(1, 2);
  assertSame(1, s1.foobar);
  assertTrue(s1.__proto__ === Subclass.prototype);

  let s2 = new Subclass();
  assertSame(undefined, s2.foobar);
  assertSame(Subclass.prototype, s2.__proto__);
  assertThrows(function() { Subclass(1); }, TypeError);
  assertThrows(function() { Subclass(1,2,3,4); }, TypeError);

  class Subclass2 extends Subclass {
    constructor() {
      super(5, 6, 7);
    }
  }

  let ss2 = new Subclass2();
  assertSame(5, ss2.foobar);
  assertSame(Subclass2.prototype, ss2.__proto__);

  class Subclass3 extends Base {
    constructor(x,y) {
      super(x + y);
    }
  }

  let ss3 = new Subclass3(27,42-27);
  assertSame(42, ss3.foobar);
  assertSame(Subclass3.prototype, ss3.__proto__);
}());

(function TestSublclassingBuiltins() {
  class ExtendedUint8Array extends Uint8Array {
    constructor() {
      super(10);
      this[0] = 255;
      this[1] = 0xFFA;
    }
  }

  var eua = new ExtendedUint8Array();
  assertEquals(10, eua.length);
  assertEquals(10, eua.byteLength);
  assertEquals(0xFF, eua[0]);
  assertEquals(0xFA, eua[1]);
  assertSame(ExtendedUint8Array.prototype, eua.__proto__);
  assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
}());

(function TestSubclassingNull() {
  let N = null;

  class Foo extends N {
    constructor(x,y) {
      assertSame(1, x);
      assertSame(2, y);
      return {};
    }
  }

  new Foo(1,2);
}());

(function TestSubclassBinding() {
  class Base {
    constructor(x, y) {
      this.x = x;
      this.y = y;
    }
  }

  let obj = {};
  class Subclass extends Base {
    constructor(x,y) {
      super(x,y);
      assertTrue(this !== obj);
    }
  }

  let f = Subclass.bind(obj);
  assertThrows(function () { f(1, 2); }, TypeError);
  let s = new f(1, 2);
  assertSame(1, s.x);
  assertSame(2, s.y);
  assertSame(Subclass.prototype, s.__proto__);

  let s1 = new f(1);
  assertSame(1, s1.x);
  assertSame(undefined, s1.y);
  assertSame(Subclass.prototype, s1.__proto__);

  let g = Subclass.bind(obj, 1);
  assertThrows(function () { g(8); }, TypeError);
  let s2 = new g(8);
  assertSame(1, s2.x);
  assertSame(8, s2.y);
  assertSame(Subclass.prototype, s.__proto__);
}());


(function TestDefaultConstructor() {
  class Base1 { }
  assertThrows(function() { Base1(); }, TypeError);

  class Subclass1 extends Base1 { }

  assertThrows(function() { Subclass1(); }, TypeError);

  let s1 = new Subclass1();
  assertSame(s1.__proto__, Subclass1.prototype);

  class Base2 {
    constructor(x, y) {
      this.x = x;
      this.y = y;
    }
  }

  class Subclass2 extends Base2 {};

  let s2 = new Subclass2(1, 2);

  assertSame(s2.__proto__, Subclass2.prototype);
  assertSame(1, s2.x);
  assertSame(2, s2.y);

  let f = Subclass2.bind({}, 3, 4);
  let s2prime = new f();
  assertSame(s2prime.__proto__, Subclass2.prototype);
  assertSame(3, s2prime.x);
  assertSame(4, s2prime.y);

  let obj = {};
  class Base3 {
    constructor() {
      return obj;
    }
  }

  class Subclass3 extends Base3 {};

  let s3 = new Subclass3();
  assertSame(obj, s3);

  class ExtendedUint8Array extends Uint8Array { }

  var eua = new ExtendedUint8Array(10);
  assertEquals(10, eua.length);
  assertEquals(10, eua.byteLength);
  eua[0] = 0xFF;
  eua[1] = 0xFFA;
  assertEquals(0xFF, eua[0]);
  assertEquals(0xFA, eua[1]);
  assertSame(ExtendedUint8Array.prototype, eua.__proto__);
  assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
}());