// Copyright 2015 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. var typedArrayConstructors = [ Uint8Array, Int8Array, Uint16Array, Int16Array, Uint32Array, Int32Array, Uint8ClampedArray, Float32Array, Float64Array ]; for (var constructor of typedArrayConstructors) { assertEquals(1, constructor.from.length); // TypedArray.from only callable on this subclassing %TypedArray% assertThrows(function () {constructor.from.call(Array, [])}, TypeError); function assertArrayLikeEquals(value, expected, type) { assertEquals(value.__proto__, type.prototype); assertEquals(expected.length, value.length); for (var i = 0; i < value.length; ++i) { assertEquals(expected[i], value[i]); } } // Assert that calling mapfn with / without thisArg in sloppy and strict modes // works as expected. var global = this; function non_strict() { assertEquals(global, this); } function strict() { 'use strict'; assertEquals(undefined, this); } function strict_null() { 'use strict'; assertEquals(null, this); } constructor.from([1], non_strict); constructor.from([1], non_strict, void 0); constructor.from([1], non_strict, null); constructor.from([1], strict); constructor.from([1], strict, void 0); constructor.from([1], strict_null, null); // TypedArray.from can only be called on TypedArray constructors assertThrows(function() {constructor.from.call({}, [])}, TypeError); assertThrows(function() {constructor.from.call([], [])}, TypeError); assertThrows(function() {constructor.from.call(1, [])}, TypeError); assertThrows(function() {constructor.from.call(undefined, [])}, TypeError); // Converting from various other types, demonstrating that it can // operate on array-like objects as well as iterables. // TODO(littledan): constructors should have similar flexibility. assertArrayLikeEquals(constructor.from( { length: 1, 0: 5 }), [5], constructor); assertArrayLikeEquals(constructor.from( { length: -1, 0: 5 }), [], constructor); assertArrayLikeEquals(constructor.from( [1, 2, 3]), [1, 2, 3], constructor); var set = new Set([1, 2, 3]); assertArrayLikeEquals(constructor.from(set), [1, 2, 3], constructor); function* generator() { yield 4; yield 5; yield 6; } assertArrayLikeEquals(constructor.from(generator()), [4, 5, 6], constructor); assertThrows(function() { constructor.from(null); }, TypeError); assertThrows(function() { constructor.from(undefined); }, TypeError); assertThrows(function() { constructor.from([], null); }, TypeError); assertThrows(function() { constructor.from([], 'noncallable'); }, TypeError); var nullIterator = {}; nullIterator[Symbol.iterator] = null; assertArrayLikeEquals(constructor.from(nullIterator), [], constructor); var nonObjIterator = {}; nonObjIterator[Symbol.iterator] = function() { return 'nonObject'; }; assertThrows(function() { constructor.from(nonObjIterator); }, TypeError); assertThrows(function() { constructor.from([], null); }, TypeError); // Ensure iterator is only accessed once, and only invoked once var called = 0; var arr = [1, 2, 3]; var obj = {}; var counter = 0; // Test order --- only get iterator method once function testIterator() { called++; assertEquals(obj, this); return arr[Symbol.iterator](); } var getCalled = 0; Object.defineProperty(obj, Symbol.iterator, { get: function() { getCalled++; return testIterator; }, set: function() { assertUnreachable('@@iterator should not be set'); } }); assertArrayLikeEquals(constructor.from(obj), [1, 2, 3], constructor); assertEquals(getCalled, 1); assertEquals(called, 1); assertEquals(constructor, Uint8Array.from.call(constructor, [1]).constructor); assertEquals(Uint8Array, constructor.from.call(Uint8Array, [1]).constructor); }