1// Copyright 2014 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5'use strict';
6(function TestArgumentsAccess() {
7  class Base {
8    constructor() {
9      assertEquals(2, arguments.length);
10      assertEquals(1, arguments[0]);
11      assertEquals(2, arguments[1]);
12    }
13  }
14
15  let b = new Base(1,2);
16
17  class Subclass extends Base {
18    constructor() {
19      assertEquals(2, arguments.length);
20      assertEquals(3, arguments[0]);
21      assertEquals(4, arguments[1]);
22      super(1,2);
23    }
24  }
25
26  let s = new Subclass(3,4);
27  assertEquals(0, Subclass.length);
28
29  class Subclass2 extends Base {
30    constructor(x,y) {
31      assertEquals(2, arguments.length);
32      assertEquals(3, arguments[0]);
33      assertEquals(4, arguments[1]);
34      super(1,2);
35    }
36  }
37
38  let s2 = new Subclass2(3,4);
39  assertEquals(2, Subclass2.length);
40}());
41
42(function TestThisAccessRestriction() {
43  class Base {
44    constructor(a, b) {
45      let o = new Object();
46      o.prp = a + b;
47      return o;
48    }
49  }
50
51  class Subclass extends Base {
52    constructor(a, b) {
53      var exn;
54      try {
55        this.prp1 = 3;
56      } catch (e) {
57        exn = e;
58      }
59      assertTrue(exn instanceof ReferenceError);
60      super(a, b);
61      assertSame(a + b, this.prp);
62      assertSame(undefined, this.prp1);
63      assertFalse(this.hasOwnProperty("prp1"));
64      return this;
65    }
66  }
67
68  let b = new Base(1, 2);
69  assertSame(3, b.prp);
70
71
72  let s = new Subclass(2, -1);
73  assertSame(1, s.prp);
74  assertSame(undefined, s.prp1);
75  assertFalse(s.hasOwnProperty("prp1"));
76
77  class Subclass2 extends Base {
78    constructor(x) {
79      super(1,2);
80
81      if (x < 0) return;
82
83      let called = false;
84      function tmp() { called = true; return 3; }
85      var exn = null;
86      try {
87        super(tmp(),4);
88      } catch (e) { exn = e; }
89      assertTrue(exn instanceof ReferenceError);
90      assertTrue(called);
91    }
92  }
93
94  var s2 = new Subclass2(1);
95  assertSame(3, s2.prp);
96
97  var s3 = new Subclass2(-1);
98  assertSame(3, s3.prp);
99
100  assertThrows(function() { Subclass.call(new Object(), 1, 2); }, TypeError);
101  assertThrows(function() { Base.call(new Object(), 1, 2); }, TypeError);
102
103  class BadSubclass extends Base {
104    constructor() {}
105  }
106
107  assertThrows(function() { new BadSubclass(); }, ReferenceError);
108}());
109
110(function TestThisCheckOrdering() {
111  let baseCalled = 0;
112  class Base {
113    constructor() { baseCalled++ }
114  }
115
116  let fCalled = 0;
117  function f() { fCalled++; return 3; }
118
119  class Subclass1 extends Base {
120    constructor() {
121      baseCalled = 0;
122      super();
123      assertEquals(1, baseCalled);
124      let obj = this;
125
126      let exn = null;
127      baseCalled = 0;
128      fCalled = 0;
129      try {
130        super(f());
131      } catch (e) { exn = e; }
132      assertTrue(exn instanceof ReferenceError);
133      assertEquals(1, fCalled);
134      assertEquals(1, baseCalled);
135      assertSame(obj, this);
136
137      exn = null;
138      baseCalled = 0;
139      fCalled = 0;
140      try {
141        super(super(), f());
142      } catch (e) { exn = e; }
143      assertTrue(exn instanceof ReferenceError);
144      assertEquals(0, fCalled);
145      assertEquals(1, baseCalled);
146      assertSame(obj, this);
147
148      exn = null;
149      baseCalled = 0;
150      fCalled = 0;
151      try {
152        super(f(), super());
153      } catch (e) { exn = e; }
154      assertTrue(exn instanceof ReferenceError);
155      assertEquals(1, fCalled);
156      assertEquals(1, baseCalled);
157      assertSame(obj, this);
158    }
159  }
160
161  new Subclass1();
162}());
163
164
165(function TestPrototypeWiring() {
166  class Base {
167    constructor(x) {
168      this.foobar = x;
169    }
170  }
171
172  class Subclass extends Base {
173    constructor(x) {
174      super(x);
175    }
176  }
177
178  let s = new Subclass(1);
179  assertSame(1, s.foobar);
180  assertSame(Subclass.prototype, s.__proto__);
181
182  let s1 = new Subclass(1, 2);
183  assertSame(1, s1.foobar);
184  assertTrue(s1.__proto__ === Subclass.prototype);
185
186  let s2 = new Subclass();
187  assertSame(undefined, s2.foobar);
188  assertSame(Subclass.prototype, s2.__proto__);
189  assertThrows(function() { Subclass(1); }, TypeError);
190  assertThrows(function() { Subclass(1,2,3,4); }, TypeError);
191
192  class Subclass2 extends Subclass {
193    constructor() {
194      super(5, 6, 7);
195    }
196  }
197
198  let ss2 = new Subclass2();
199  assertSame(5, ss2.foobar);
200  assertSame(Subclass2.prototype, ss2.__proto__);
201
202  class Subclass3 extends Base {
203    constructor(x,y) {
204      super(x + y);
205    }
206  }
207
208  let ss3 = new Subclass3(27,42-27);
209  assertSame(42, ss3.foobar);
210  assertSame(Subclass3.prototype, ss3.__proto__);
211}());
212
213(function TestSublclassingBuiltins() {
214  class ExtendedUint8Array extends Uint8Array {
215    constructor() {
216      super(10);
217      this[0] = 255;
218      this[1] = 0xFFA;
219    }
220  }
221
222  var eua = new ExtendedUint8Array();
223  assertEquals(10, eua.length);
224  assertEquals(10, eua.byteLength);
225  assertEquals(0xFF, eua[0]);
226  assertEquals(0xFA, eua[1]);
227  assertSame(ExtendedUint8Array.prototype, eua.__proto__);
228  assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
229}());
230
231(function TestSubclassingNull() {
232  let N = null;
233
234  class Foo extends N {
235    constructor(x,y) {
236      assertSame(1, x);
237      assertSame(2, y);
238      return {};
239    }
240  }
241
242  new Foo(1,2);
243}());
244
245(function TestSubclassBinding() {
246  class Base {
247    constructor(x, y) {
248      this.x = x;
249      this.y = y;
250    }
251  }
252
253  let obj = {};
254  class Subclass extends Base {
255    constructor(x,y) {
256      super(x,y);
257      assertTrue(this !== obj);
258    }
259  }
260
261  let f = Subclass.bind(obj);
262  assertThrows(function () { f(1, 2); }, TypeError);
263  let s = new f(1, 2);
264  assertSame(1, s.x);
265  assertSame(2, s.y);
266  assertSame(Subclass.prototype, s.__proto__);
267
268  let s1 = new f(1);
269  assertSame(1, s1.x);
270  assertSame(undefined, s1.y);
271  assertSame(Subclass.prototype, s1.__proto__);
272
273  let g = Subclass.bind(obj, 1);
274  assertThrows(function () { g(8); }, TypeError);
275  let s2 = new g(8);
276  assertSame(1, s2.x);
277  assertSame(8, s2.y);
278  assertSame(Subclass.prototype, s.__proto__);
279}());
280
281
282(function TestDefaultConstructor() {
283  class Base1 { }
284  assertThrows(function() { Base1(); }, TypeError);
285
286  class Subclass1 extends Base1 { }
287
288  assertThrows(function() { Subclass1(); }, TypeError);
289
290  let s1 = new Subclass1();
291  assertSame(s1.__proto__, Subclass1.prototype);
292
293  class Base2 {
294    constructor(x, y) {
295      this.x = x;
296      this.y = y;
297    }
298  }
299
300  class Subclass2 extends Base2 {};
301
302  let s2 = new Subclass2(1, 2);
303
304  assertSame(s2.__proto__, Subclass2.prototype);
305  assertSame(1, s2.x);
306  assertSame(2, s2.y);
307
308  let f = Subclass2.bind({}, 3, 4);
309  let s2prime = new f();
310  assertSame(s2prime.__proto__, Subclass2.prototype);
311  assertSame(3, s2prime.x);
312  assertSame(4, s2prime.y);
313
314  let obj = {};
315  class Base3 {
316    constructor() {
317      return obj;
318    }
319  }
320
321  class Subclass3 extends Base3 {};
322
323  let s3 = new Subclass3();
324  assertSame(obj, s3);
325
326  class ExtendedUint8Array extends Uint8Array { }
327
328  var eua = new ExtendedUint8Array(10);
329  assertEquals(10, eua.length);
330  assertEquals(10, eua.byteLength);
331  eua[0] = 0xFF;
332  eua[1] = 0xFFA;
333  assertEquals(0xFF, eua[0]);
334  assertEquals(0xFA, eua[1]);
335  assertSame(ExtendedUint8Array.prototype, eua.__proto__);
336  assertEquals("[object Uint8Array]", Object.prototype.toString.call(eua));
337}());
338