Implement Array.from()

test/mjsunit/harmony/array-from.js

Index: test/mjsunit/harmony/array-from.js
diff --git a/test/mjsunit/harmony/array-from.js b/test/mjsunit/harmony/array-from.js
new file mode 100644
index 0000000000000000000000000000000000000000..31fc0d0266cde3cb5ab44edfec8d12c06494ed86
--- /dev/null
+++ b/test/mjsunit/harmony/array-from.js
@@ -0,0 +1,129 @@
+// 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.
+
+// Flags: --harmony-arrays --harmony-generators
+(function() {

[rossberg, 2014/09/10 07:23:55]

Nit: insert empty line before.

+
+assertEquals(1, Array.from.length);
+
+// Assert that constructor is called with "length" for array-like objects
+var myCollectionCalled = false;
+function MyCollection(length) {
+  myCollectionCalled = true;
+  assertEquals(1, arguments.length);
+  assertEquals(5, length);
+}
+
+Array.from.call(MyCollection, {length: 5});
+assertTrue(myCollectionCalled);
+
+// 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(void 0, this); }
+function strict_null(){ "use strict"; assertEquals(null, this); }
+Array.from([1], non_strict);
+Array.from([1], non_strict, undefined);
+Array.from([1], non_strict, null);
+Array.from([1], strict);
+Array.from([1], strict, undefined);
+Array.from([1], strict_null, null);
+
+function testArrayFrom(thisArg, constructor) {
+  assertArrayLikeEquals(Array.from.call(thisArg, [], undefined), [],
+    constructor);

[rossberg, 2014/09/10 07:23:56]

Nit: style guide requires indent of 4 for line continuations (also below).

+  assertArrayLikeEquals(Array.from.call(thisArg, NaN), [], constructor);
+  assertArrayLikeEquals(Array.from.call(thisArg, Infinity), [], constructor);
+  assertArrayLikeEquals(Array.from.call(thisArg, 10000000), [], constructor);
+  assertArrayLikeEquals(Array.from.call(thisArg, 'test'), ['t', 'e', 's', 't'],
+    constructor);
+
+  assertArrayLikeEquals(Array.from.call(thisArg, {
+    length: 1,
+    '0': {
+      'foo': 'bar'

[rossberg, 2014/09/10 07:23:55]

Nit: write this on one line

+    }
+  }), [{'foo': 'bar'}], constructor);
+
+  assertArrayLikeEquals(Array.from.call(thisArg, {
+    length: -1,
+    '0': {
+      'foo': 'bar'

[rossberg, 2014/09/10 07:23:56]

Same here

+    }
+  }), [], constructor);
+
+  assertArrayLikeEquals(Array.from.call(thisArg, [
+    'foo', 'bar', 'baz'
+  ]), ['foo', 'bar', 'baz'], constructor);
+
+  var kSet = (new Set).add('foo').add('bar').add('baz');

[rossberg, 2014/09/10 07:23:55]

The Set constructor can take an array argument.

+  assertArrayLikeEquals(Array.from.call(thisArg, kSet), ['foo', 'bar', 'baz'],
+                        constructor);
+
+  var kMap = (new Map).set(0, 'foo').set(1, 'bar').set(2, 'baz');

[rossberg, 2014/09/10 07:23:55]

Same here.

+  assertArrayLikeEquals(Array.from.call(thisArg, kMap),
+    [[0, 'foo'], [1, 'bar'], [2, 'baz']], constructor);
+
+  // TODO: re-enable generator test (failing with "Fatal error unimplemented code")

[rossberg, 2014/09/10 07:23:55]

Nit: line lengths

+  // Test applied in harmony/array-from-generators.js instead, to avoid TF testing
+  // assertArrayLikeEquals(Array.from.call(thisArg, generator()), ['a', 'b', 'c'],
+  //   constructor);
+
+  // Mozilla:
+  // Array.from on a string handles surrogate pairs correctly.
+  var gclef = "\uD834\uDD1E"; // U+1D11E MUSICAL SYMBOL G CLEF
+  assertArrayLikeEquals(Array.from.call(thisArg, gclef), [gclef], constructor);
+  assertArrayLikeEquals(Array.from.call(thisArg, gclef + " G"), [gclef, " ", "G"],

[rossberg, 2014/09/10 07:23:55]

Line length

+    constructor);
+
+  assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
+    return this.filter(x);
+  }, {
+    filter: function(x) { return x.toUpperCase(); }
+  }), ['T', 'E', 'S', 'T'], constructor);
+  assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
+    return x.toUpperCase();
+  }), ['T', 'E', 'S', 'T'], constructor);
+
+  this.thisArg = thisArg;
+  assertThrows('Array.from.call(thisArg, null)', TypeError);
+  assertThrows('Array.from.call(thisArg, undefined)', TypeError);
+  assertThrows('Array.from.call(thisArg, [], null)', TypeError);
+  assertThrows('Array.from.call(thisArg, [], "noncallable")', TypeError);
+
+  this.nullIterator = {};
+  nullIterator[Symbol.iterator] = null;
+  assertThrows('Array.from.call(thisArg, nullIterator)', TypeError);
+
+  this.nonObjIterator = {};
+  nonObjIterator[Symbol.iterator] = function() { return "nonObject"; };
+  assertThrows('Array.from.call(thisArg, nonObjIterator)', TypeError);
+
+  assertThrows('Array.from.call(thisArg, [], null)', TypeError);
+}
+
+testArrayFrom(Array, Array);
+testArrayFrom(null, Array);
+testArrayFrom({}, Array);
+testArrayFrom(Object, Object);
+testArrayFrom(Other, Other);

[rossberg, 2014/09/10 07:23:55]

Cover more cases here, e.g. a function with @@iterator, a function that is not a
constructor. Also test what happens on primitive constructors, esp String.

[caitp (gmail), 2014/09/10 14:26:05]

Can you provide examples of functions which we would not consider constructors?
I think .bind() is supposed to behave this way, as well as arrow functions ---
but I'm not sure if they actually _do_ behave this way currently.

[rossberg, 2014/09/10 14:32:35]

Yes, a test with .bind would be good. Also, most ES library functions are not
constructors.

[arv (Not doing code reviews), 2014/09/10 14:33:58]

Anything that is lacking a .prototype. For example Math.cos or
Array.prototype.filter for example.

+
+function Other() {}
+
+function* generator() {

[rossberg, 2014/09/10 07:23:56]

This seems unused here.

+  yield 'a';
+  yield 'b';
+  yield 'c';
+}
+
+function assertArrayLikeEquals(value, expected, type) {

[rossberg, 2014/09/10 07:23:55]

Move this to the start of the file.

+  assertInstanceof(value, type);
+  assertEquals(expected.length, value.length);
+  for (var i=0; i<value.length; ++i) {
+    assertEquals(expected[i], value[i]);
+  }
+}
+
+})();