Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/mjsunit/es6/typedarray-from.js b/test/mjsunit/es6/typedarray-from.js
new file mode 100644
index 0000000..709c453
--- /dev/null
+++ b/test/mjsunit/es6/typedarray-from.js
@@ -0,0 +1,121 @@
+// 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);
+}