| // 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. |
| |
| // Flags: --allow-natives-syntax |
| |
| var typedArrayConstructors = [ |
| Uint8Array, |
| Int8Array, |
| Uint16Array, |
| Int16Array, |
| Uint32Array, |
| Int32Array, |
| Uint8ClampedArray, |
| Float32Array, |
| Float64Array |
| ]; |
| |
| function defaultValue(constr) { |
| if (constr == Float32Array || constr == Float64Array) return NaN; |
| return 0; |
| } |
| |
| 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]); |
| } |
| } |
| |
| (function() { |
| var source = [-0, 0, 2**40, 2**41, 2**42]; |
| var arr = Float64Array.from(source); |
| assertArrayLikeEquals(arr, source, Float64Array); |
| |
| arr = Float32Array.from(source); |
| assertArrayLikeEquals(arr, source, Float32Array); |
| })(); |
| |
| (function() { |
| var source = [-0, 0, , 2**42]; |
| var expected = [-0, 0, NaN, 2**42]; |
| var arr = Float64Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float64Array); |
| |
| arr = Float32Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float32Array); |
| })(); |
| |
| (function() { |
| var source = {0: -0, 1: 0, 2: 2**40, 3: 2**41, 4: 2**42, length: 5}; |
| var expected = [-0, 0, 2**40, 2**41, 2**42]; |
| var arr = Float64Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float64Array); |
| |
| arr = Float32Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float32Array); |
| })(); |
| |
| (function() { |
| var source = [-0, 0, , 2**42]; |
| Object.getPrototypeOf(source)[2] = 27; |
| var expected = [-0, 0, 27, 2**42]; |
| var arr = Float64Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float64Array); |
| |
| arr = Float32Array.from(source); |
| assertArrayLikeEquals(arr, expected, Float32Array); |
| })(); |
| |
| 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); |
| |
| |
| // 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); |
| |
| // Use a map function that returns non-numbers. |
| function mapper(value, index) { |
| return String.fromCharCode(value); |
| } |
| var d = defaultValue(constructor); |
| assertArrayLikeEquals( |
| constructor.from([72, 69, 89], mapper), [d, d, d], constructor); |
| |
| // 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); |
| |
| // Check mapper is used for non-iterator case. |
| function mapper2(value, index) { |
| return value + 1; |
| } |
| var array_like = { |
| 0: 1, |
| 1: 2, |
| 2: 3, |
| length: 3 |
| }; |
| assertArrayLikeEquals(constructor.from(array_like, mapper2), |
| [2, 3, 4], constructor); |
| |
| // With a smi source. Step 10 will set len = 0. |
| var source = 1; |
| assertArrayLikeEquals(constructor.from(source), [], 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); |
| |
| source = [1, 2, 3]; |
| var proxy = new Proxy(source, {}); |
| assertArrayLikeEquals(constructor.from(proxy), source, constructor); |
| |
| proxy = new Proxy(source, { |
| get: function(target, name) { |
| if (name === Symbol.iterator) return target[name]; |
| if (name === "length") return 3; |
| return target[name] + 1; |
| } |
| }); |
| assertArrayLikeEquals(constructor.from(proxy), [2, 3, 4], constructor); |
| } |
| |
| // Tests that modify global state in a way that affects fast paths e.g. by |
| // invalidating protectors or changing prototypes. |
| for (var constructor of typedArrayConstructors) { |
| source = [1, 2, 3]; |
| source[Symbol.iterator] = undefined; |
| assertArrayLikeEquals(constructor.from(source), source, constructor); |
| |
| source = [{ valueOf: function(){ return 42; }}]; |
| source[Symbol.iterator] = undefined; |
| assertArrayLikeEquals(constructor.from(source), [42], constructor); |
| |
| Number.prototype[Symbol.iterator] = function* () { |
| yield 1; |
| yield 2; |
| yield 3; |
| } |
| assertArrayLikeEquals(constructor.from(1), [1, 2, 3], constructor); |
| assertArrayLikeEquals(constructor.from(1.1), [1, 2, 3], constructor); |
| |
| 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); |
| |
| d = defaultValue(constructor); |
| let ta1 = new constructor(3).fill(1); |
| Object.defineProperty(ta1, "length", {get: function() { |
| return 6; |
| }}); |
| delete ta1[Symbol.iterator]; |
| delete ta1.__proto__[Symbol.iterator]; |
| delete ta1.__proto__.__proto__[Symbol.iterator]; |
| assertArrayLikeEquals(constructor.from(ta1), [1, 1, 1, d, d, d], constructor); |
| |
| let ta2 = new constructor(3).fill(1); |
| Object.defineProperty(ta2, "length", {get: function() { |
| %ArrayBufferDetach(ta2.buffer); |
| return 6; |
| }}); |
| assertArrayLikeEquals(constructor.from(ta2), [d, d, d, d, d, d], constructor); |
| |
| var o1 = {0: 0, 1: 1, 2: 2, length: 6}; |
| assertArrayLikeEquals(constructor.from(o1), [0, 1, 2, d, d, d], constructor); |
| |
| // 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); |
| } |