Array/TypedArray/ArrayBuffer method subclassing and @@species

test/mjsunit/es6/typedarray-of.js

 // 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.
 
 // Based on Mozilla Array.of() tests at http://dxr.mozilla.org/mozilla-central/source/js/src/jit-test/tests/collections
 
+'use strict';
+
 var typedArrayConstructors = [
   Uint8Array,
   Int8Array,
   Uint16Array,
   Int16Array,
   Uint32Array,
   Int32Array,
   Uint8ClampedArray,
   Float32Array,
   Float64Array];
@@ skipping 27 matching lines @@
   }
 
   var aux = [];
   for (var i = 0; i < 100; i++)
     aux[i] = i;
 
   a = constructor.of.apply(constructor, aux);
   assertEquals(aux.length, a.length);
   assertArrayEquals(aux, a);
 
-  // %TypedArray%.of can be transplanted to other constructors.
+  // %TypedArray%.of can be called on subclasses of TypedArrays
   var hits = 0;
-  function Bag(length) {
-    assertEquals(arguments.length, 1);
-    assertEquals(length, 2);
-    this.length = length;
-    hits++;
+  class Bag extends constructor {
+    constructor(length) {
+      super(length);
+      assertEquals(arguments.length, 1);
+      assertEquals(length, 2);
+      hits++;
+    }
   }
-  Bag.of = constructor.of;
 
   hits = 0;
-  a = Bag.of("zero", "one");
+  a = Bag.of(5, 6);
   assertEquals(1, hits);
   assertEquals(2, a.length);
-  assertArrayEquals(["zero", "one"], a);
+  assertArrayEquals([5, 6], a);
   assertEquals(Bag.prototype, a.__proto__);
 
   hits = 0;
-  actual = constructor.of.call(Bag, "zero", "one");
+  var actual = constructor.of.call(Bag, 5, 6);
   assertEquals(1, hits);
   assertEquals(2, a.length);
-  assertArrayEquals(["zero", "one"], a);
+  assertArrayEquals([5, 6], a);
   assertEquals(Bag.prototype, a.__proto__);
 
   // %TypedArray%.of does not trigger prototype setters.
   // (It defines elements rather than assigning to them.)
   var status = "pass";
   Object.defineProperty(constructor.prototype, "0", {
     set: function(v) { status = "fail"; }
   });
   assertEquals(1, constructor.of(1)[0], 1);
   assertEquals("pass", status);
 
   // Note that %TypedArray%.of does not trigger "length" setter itself, as
   // it relies on the constructor to set "length" to the value passed to it.
   // If the constructor does not assign "length", the setter should not be
   // invoked.
 
   // Setter on the newly created object.
-  function Pack() {
-    Object.defineProperty(this, "length", {
-      set: function (v) { status = "fail"; }
-    });
+  class Pack extends constructor {
+    constructor(length) {
+      super(length);
+      Object.defineProperty(this, "length", {
+        set: function (v) { status = "fail"; }
+      });
+    }
   }
-  Pack.of = constructor.of;
-  var pack = Pack.of("wolves", "cards", "cigarettes", "lies");
+  var pack = Pack.of(5, 6, 7, 8);
   assertEquals("pass", status);
 
   // when the setter is on the new object's prototype
-  function Bevy() {}
+  class Bevy extends constructor {}
   Object.defineProperty(Bevy.prototype, "length", {
     set: function (v) { status = "fail"; }
   });
-  Bevy.of = constructor.of;
-  var bevy = Bevy.of("quail");
+  var bevy = Bevy.of(3);
   assertEquals("pass", status);
 
   // Check superficial features of %TypedArray%.of.
   var desc = Object.getOwnPropertyDescriptor(constructor.__proto__, "of");
 
   assertEquals(desc.configurable, false);
   assertEquals(desc.enumerable, false);
   assertEquals(desc.writable, false);
   assertEquals(constructor.of.length, 0);
 
   // %TypedArray%.of is not a constructor.
   assertThrows(function() { new constructor.of(); }, TypeError);
 
   // For receivers which are not constructors %TypedArray%.of does not
   // allocate a typed array using a default constructor, but throws an
   // exception. Note that this is different from Array.of, which uses
   // Array as default constructor.
   for (var x of [undefined, null, false, true, "cow", 42, 3.14]) {
     assertThrows(function () { constructor.of.call(x); }, TypeError);
   }
 }
 
 for (var constructor of typedArrayConstructors) {
   TestTypedArrayOf(constructor);
 }