[test] Expand Array#{flat,flatMap} test coverage

Bug: v8:7220
Change-Id: I9fef685f19cadbe87cd6451fe887f4c9c7d23b19
Reviewed-on: https://chromium-review.googlesource.com/1070337
Commit-Queue: Mathias Bynens <mathias@chromium.org>
Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53315}

test/mjsunit/harmony/array-flat-species.js

+// Copyright 2018 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-array-flat
+
+{
+  class MyArray extends Array {
+    static get [Symbol.species]() {
+      return Array;
+    }
+  }
+
+  const wannabe = new MyArray();
+  const flattened = wannabe.flat(Infinity);
+  assertEquals(false, flattened instanceof MyArray);
+  assertEquals(true, flattened instanceof Array);
+}
+
+{
+  class MyArray extends Array {
+    static get [Symbol.species]() {
+      return this;
+    }
+  }
+
+  const wannabe = new MyArray();
+  const flattened = wannabe.flat(Infinity);
+  assertEquals(true, flattened instanceof MyArray);
+  assertEquals(true, flattened instanceof Array);
+}

test/mjsunit/harmony/array-flat.js

@@ -7,32 +7,59 @@
 assertEquals(Array.prototype.flat.length, 0);
 assertEquals(Array.prototype.flat.name, 'flat');
 
-const input = [1, [2], [[3]]];
-
-assertEquals(input.flat(),          [1, 2, [3]]);
-assertEquals(input.flat(1),         [1, 2, [3]]);
-assertEquals(input.flat(true),      [1, 2, [3]]);
-assertEquals(input.flat(undefined), [1, 2, [3]]);
-
-assertEquals(input.flat(-Infinity), [1, [2], [[3]]]);
-assertEquals(input.flat(-1),        [1, [2], [[3]]]);
-assertEquals(input.flat(-0),        [1, [2], [[3]]]);
-assertEquals(input.flat(0),         [1, [2], [[3]]]);
-assertEquals(input.flat(false),     [1, [2], [[3]]]);
-assertEquals(input.flat(null),      [1, [2], [[3]]]);
-assertEquals(input.flat(''),        [1, [2], [[3]]]);
-assertEquals(input.flat('foo'),     [1, [2], [[3]]]);
-assertEquals(input.flat(/./),       [1, [2], [[3]]]);
-assertEquals(input.flat([]),        [1, [2], [[3]]]);
-assertEquals(input.flat({}),        [1, [2], [[3]]]);
-assertEquals(
+{
+  const input = [1, [2], [[3]]];
+
+  assertEquals(input.flat(),          [1, 2, [3]]);
+  assertEquals(input.flat(1),         [1, 2, [3]]);
+  assertEquals(input.flat(true),      [1, 2, [3]]);
+  assertEquals(input.flat(undefined), [1, 2, [3]]);
+
+  assertEquals(input.flat(-Infinity), [1, [2], [[3]]]);
+  assertEquals(input.flat(-1),        [1, [2], [[3]]]);
+  assertEquals(input.flat(-0),        [1, [2], [[3]]]);
+  assertEquals(input.flat(0),         [1, [2], [[3]]]);
+  assertEquals(input.flat(false),     [1, [2], [[3]]]);
+  assertEquals(input.flat(null),      [1, [2], [[3]]]);
+  assertEquals(input.flat(''),        [1, [2], [[3]]]);
+  assertEquals(input.flat('foo'),     [1, [2], [[3]]]);
+  assertEquals(input.flat(/./),       [1, [2], [[3]]]);
+  assertEquals(input.flat([]),        [1, [2], [[3]]]);
+  assertEquals(input.flat({}),        [1, [2], [[3]]]);
+  assertEquals(
     input.flat(new Proxy({}, {})),    [1, [2], [[3]]]);
-assertEquals(input.flat((x) => x),  [1, [2], [[3]]]);
-assertEquals(
+  assertEquals(input.flat((x) => x),  [1, [2], [[3]]]);
+  assertEquals(
     input.flat(String),               [1, [2], [[3]]]);
 
-assertEquals(input.flat(2),         [1, 2, 3]);
-assertEquals(input.flat(Infinity),  [1, 2, 3]);
+  assertEquals(input.flat(2),         [1, 2, 3]);
+  assertEquals(input.flat(Infinity),  [1, 2, 3]);
+
+  assertThrows(() => { input.flat(Symbol()); }, TypeError);
+  assertThrows(() => { input.flat(Object.create(null)); }, TypeError);
+}
+
+{
+  const input = { 0: 'a', 1: 'b', 2: 'c', length: 'wat' };
+  assertEquals(Array.prototype.flat.call(input, Infinity), []);
+}
+
+{
+  let count = 0;
+  const input = {
+    get length() { ++count; return 0; }
+  };
+  const result = Array.prototype.flat.call(input, Infinity);
+  assertEquals(count, 1);
+}
 
-assertThrows(() => { input.flat(Symbol()); }, TypeError);
-assertThrows(() => { input.flat(Object.create(null)); }, TypeError);
+{
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Array.prototype,
+    'flat'
+  );
+  assertEquals(descriptor.value, Array.prototype.flat);
+  assertEquals(descriptor.writable, true);
+  assertEquals(descriptor.enumerable, false);
+  assertEquals(descriptor.configurable, true);
+}

test/mjsunit/harmony/array-flatMap-species.js

+// Copyright 2018 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-array-flat
+
+{
+  class MyArray extends Array {
+    static get [Symbol.species]() {
+      return Array;
+    }
+  }
+
+  const wannabe = new MyArray();
+  const result = wannabe.flatMap(x => [x, x]);
+  assertEquals(false, result instanceof MyArray);
+  assertEquals(true, result instanceof Array);
+}
+
+{
+  class MyArray extends Array {
+    static get [Symbol.species]() {
+      return this;
+    }
+  }
+
+  const wannabe = new MyArray();
+  const result = wannabe.flatMap(x => [x, x]);
+  assertEquals(true, result instanceof MyArray);
+  assertEquals(true, result instanceof Array);
+}

test/mjsunit/harmony/array-flatMap.js

@@ -16,7 +16,8 @@ assertEquals(
   [[1, 1], [2, 4], [3, 9], [4, 16]]
 );
 
-const elements = new Set([
+{
+  const elements = new Set([
     -Infinity,
     -1,
     -0,
@@ -37,22 +38,26 @@ const elements = new Set([
     Symbol(),
     x => x ** 2,
     String
-]);
+  ]);
 
-for (const value of elements) {
+  for (const value of elements) {
     assertEquals(
       [value].flatMap((element) => [element, element]),
       [value, value]
     );
+  }
 }
 
-const array = [42];
-assertEquals(
+{
+  const array = [42];
+  assertEquals(
     [array].flatMap((element) => [element, element]),
     [array, array]
-);
+  );
+}
 
-const nonCallables = new Set([
+{
+  const nonCallables = new Set([
     -Infinity,
     -1,
     -0,
@@ -71,23 +76,26 @@ const nonCallables = new Set([
     Object.create(null),
     new Proxy({}, {}),
     Symbol(),
-]);
-for (const nonCallable of nonCallables) {
+  ]);
+  for (const nonCallable of nonCallables) {
     assertThrows(() => {
       [].flatMap(nonCallable);
     }, TypeError);
+  }
 }
 
-const object = {
+{
+  const object = {
     foo: 42,
     get length() {
       object.foo = 0;
     }
-};
-const result = [object].flatMap((element) => [element, element]);
-%HeapObjectVerify(result);
-assertEquals(result, [object, object]);
-assertEquals(result[0].foo, 42);
+  };
+  const result = [object].flatMap((element) => [element, element]);
+  %HeapObjectVerify(result);
+  assertEquals(result, [object, object]);
+  assertEquals(result[0].foo, 42);
+}
 
 assertThrows(() => {
   Array.prototype.flatMap.call(null, (element) => element);
@@ -118,3 +126,37 @@ assertEquals(
   ),
   ['a', 'b']
 );
+
+{
+  const result = [1, 2, 3].flatMap(function() {
+    return [this];
+  }, 'abc');
+  assertEquals(true, result[0] == 'abc');
+  assertEquals(true, result[1] == 'abc');
+  assertEquals(true, result[2] == 'abc');
+}
+
+{
+  const input = { 0: 'a', 1: 'b', 2: 'c', length: 'wat' };
+  assertEquals(Array.prototype.flatMap.call(input, x => [x]), []);
+}
+
+{
+  let count = 0;
+  const input = {
+    get length() { ++count; return 0; }
+  };
+  const result = Array.prototype.flatMap.call(input, x => [x]);
+  assertEquals(count, 1);
+}
+
+{
+  const descriptor = Object.getOwnPropertyDescriptor(
+    Array.prototype,
+    'flatMap'
+  );
+  assertEquals(descriptor.value, Array.prototype.flatMap);
+  assertEquals(descriptor.writable, true);
+  assertEquals(descriptor.enumerable, false);
+  assertEquals(descriptor.configurable, true);
+}