flatMap/flatten test improvements

test/built-ins/Array/prototype/flatMap/array-like-objects.js

@@ -7,27 +7,28 @@ description: >
 includes: [compareArray.js]
 ---*/
 
-function takesTwoParams(a, b) {
+function getArgumentsObject() {
-  return Array.prototype.flatMap.call(arguments, function(ele) { return ele * 2});
+  return arguments;
 }
 
-var actual = takesTwoParams(1,[2]);
+function double(e) {
-var expected = [2, 4];
+  return [e * 2];
+}
 
-assert(compareArray(actual, expected), 'arguments array like object');
+var a = getArgumentsObject(1, 2);
+var actual = [].flatMap.call(a, double);
+assert.compareArray(actual, [2, 4], 'arguments objects');
 
 var a = {
-  "length": 1,
+  length: 1,
-  "0": 1
+  0: 1,
 };
-
+var actual = [].flatMap.call(a, double);
-actual = Array.prototype.flatMap.call(a, function(ele) { return ele * 2});
+assert.compareArray(actual, [2], 'array-like objects');
-assert.sameValue(JSON.stringify(actual), JSON.stringify(['2']), 'array like objects');
 
 var a = {
-  "length": undefined,
+  length: void 0,
-  "0": 1
+  0: 1,
 };
-
+var actual = [].flatMap.call(a, double);
-actual = Array.prototype.flatMap.call(a, function(ele) { return ele * 2});
+assert.compareArray(actual, [], 'array-like objects; undefined length');
-assert.sameValue(JSON.stringify(actual), JSON.stringify([]), 'array like objects');

test/built-ins/Array/prototype/flatMap/bound-function-argument.js

@@ -3,11 +3,9 @@
 /*---
 esid: sec-array.prototype.flatMap
 description: >
-    Behavior when array is depth more than 1
+    Behavior when given a bound function
 includes: [compareArray.js]
 ---*/
 
-var a = [void 0,[void 0]];
+var a = [0, 0];
-var flattenMap = [].flatMap.bind(a, function() {});
+assert.compareArray(a.flatMap(function(){ return this; }.bind([1, 2])), [1, 2, 1, 2]);
-
-assert.compareArray(a.flatMap(flattenMap), [undefined, undefined, undefined, undefined]);

test/built-ins/Array/prototype/flatMap/depth-always-one.js

@@ -7,18 +7,10 @@ description: >
 includes: [compareArray.js]
 ---*/
 
-assert(compareArray([1, [2]].flatMap(function(ele) {
+assert.compareArray([1, 2].flatMap(function(e) {
-  return ele * 2;
+  return [e, e * 2];
-}), [2, 4]), 'array depth is 1');
+}), [1, 2, 2, 4], 'array depth is 1');
 
-assert(compareArray([1, [2], [[3]]].flatMap(function(ele) {
+assert.compareArray([1, 2, 3].flatMap(function(ele) {
-  return ele * 2;
+  return [[ele * 2]];
-}), [2, 4, 6]), 'array depth is more than 1');
+}), [[2], [4], [6]], 'array depth is more than 1');
-
-var actual = [1, [2], [3, [3]]].flatMap(function(ele) {
-  return ele * 2;
-});
-
-assert.sameValue(actual[0], 2);
-assert.sameValue(actual[1], 4);
-assert(isNaN(actual[2]));

test/built-ins/Array/prototype/flatMap/non-object-ctor-throws.js

@@ -8,25 +8,24 @@ description: >
 ---*/
 
 var a = [];
-
 a.constructor = null;
 assert.throws(TypeError, function() {
   a.flatMap();
 }, 'null value');
 
-a = [];
+var a = [];
 a.constructor = 1;
 assert.throws(TypeError, function() {
   a.flatMap();
 }, 'number value');
 
-a = [];
+var a = [];
 a.constructor = 'string';
 assert.throws(TypeError, function() {
   a.flatMap();
 }, 'string value');
 
-a = [];
+var a = [];
 a.constructor = true;
 assert.throws(TypeError, function() {
   a.flatMap();

test/built-ins/Array/prototype/flatMap/thisArg-argument.js

@@ -10,11 +10,11 @@ includes: [compareArray.js]
 
 "use strict";
 
-var a;
+var a = {};
 
-assert(compareArray([1].flatMap(function() { return this}, "TestString"), ["TestString"]));
+assert(compareArray([1].flatMap(function() { return [this]; }, "TestString"), ["TestString"]));
-assert(compareArray([1].flatMap(function() { return this}, 1), [1]));
+assert(compareArray([1].flatMap(function() { return [this]; }, 1), [1]));
-assert(compareArray([1].flatMap(function() { return this}, null), [null]));
+assert(compareArray([1].flatMap(function() { return [this]; }, null), [null]));
-assert(compareArray([1].flatMap(function() { return this}, true), [true]));
+assert(compareArray([1].flatMap(function() { return [this]; }, true), [true]));
-assert(compareArray([1].flatMap(function() { return this}, a = {}), [a]));
+assert(compareArray([1].flatMap(function() { return [this]; }, a), [a]));
-assert(compareArray([1].flatMap(function() { return this}, void 0), [undefined]));
+assert(compareArray([1].flatMap(function() { return [this]; }, void 0), [undefined]));

test/built-ins/Array/prototype/flatten/array-like-objects.js

@@ -7,25 +7,24 @@ description: >
 includes: [compareArray.js]
 ---*/
 
-function takesTwoParams(a, b) {
+function getArgumentsObject() {
-  return Array.prototype.flatten.call(arguments);
+  return arguments;
 }
 
-var actual = takesTwoParams(1,[2]);
+var a = getArgumentsObject([1], [2]);
-var expected = [1, 2];
+var actual = [].flatten.call(a);
-
+assert.compareArray(actual, [1, 2], 'arguments objects');
-assert(compareArray(actual, expected), 'arguments array like object');
 
 var a = {
-  "length": 1,
+  length: 1,
-  "0": 'a'
+  0: [1],
 };
+var actual = [].flatten.call(a);
+assert.compareArray(actual, [1], 'array-like objects');
 
-actual = Array.prototype.flatten.call(a);
+var a = {
-assert.sameValue(JSON.stringify(actual), JSON.stringify(['a']), 'array like objects');
+  length: undefined,
-
+  0: [1],
-a = {
-  "length": undefined,
-  "0": 'a'
 };
-assert.sameValue(JSON.stringify(actual), JSON.stringify([]), 'array like objects undefined length');
+var actual = [].flatten.call(a);
+assert.compareArray(actual, [], 'array-like objects; undefined length');

test/built-ins/Array/prototype/flatten/bound-function-call.js

@@ -7,7 +7,7 @@ description: >
 includes: [compareArray.js]
 ---*/
 
-var a = [1,[1]];
+var a = [[0],[1]];
-var flattenIt = [].flatten.bind(a);
+var actual = [].flatten.bind(a)();
 
-assert(compareArray(flattenIt(), [1, 1]), 'bound functions');
+assert.compareArray(actual, [0, 1], 'bound flatten');

test/built-ins/Array/prototype/flatten/empty-array-elements.js

@@ -7,9 +7,8 @@ description: >
 includes: [compareArray.js]
 ---*/
 
-var a;
+var a = {};
-assert(compareArray([].flatten([[]]), []));
+assert.compareArray([].flatten(), []);
-assert(compareArray(Array.prototype.flatten.call([[], []]), []));
+assert.compareArray([[], []].flatten(), []);
-assert(compareArray(Array.prototype.flatten.call([[], [1]]), [1]));
+assert.compareArray([[], [1]].flatten(), [1]);
-assert(compareArray(Array.prototype.flatten.call([[], [1, a = []]]), [1, a]));
+assert.compareArray([[], [1, a]].flatten(), [1, a]);
-assert.sameValue(JSON.stringify(Array.prototype.flatten.call([{}, []])), JSON.stringify([{}]));

test/built-ins/Array/prototype/flatten/empty-object-elements.js

@@ -6,7 +6,9 @@ description: >
     arrays with empty object elements
 ---*/
 
-assert.sameValue(JSON.stringify(Array.prototype.flatten.call([{}])), JSON.stringify([{}]));
+var a = {}, b = {};
-assert.sameValue(JSON.stringify(Array.prototype.flatten.call([{}, [{}]])), JSON.stringify([{}, {}]));
+
-assert.sameValue(JSON.stringify(Array.prototype.flatten.call([[{null: {}}], [{}]])), JSON.stringify([{null: {}}, {}]));
+assert.compareArrays([a].flatten(), [a]);
-assert.sameValue(JSON.stringify(Array.prototype.flatten.call([[{null: null}], [{}]])), JSON.stringify([{null: null}, {}]));
+assert.compareArrays([a, [b]].flatten(), [a, b]);
+assert.compareArrays([[a], b].flatten(), [a, b]);
+assert.compareArrays([[a], [b]].flatten(), [a, b]);

test/built-ins/Array/prototype/flatten/non-numeric-depth-should-not-throw.js

@@ -16,27 +16,27 @@ var actual = a.flatten(depthNum);
 assert(compareArray(actual, expected), 'non integral string depthNum');
 
 // object type depthNum is converted to 0
-depthNum = {};
+var depthNum = {};
 var actual = a.flatten(depthNum);
 assert(compareArray(actual, expected), 'object type depthNum');
 
 // negative infinity depthNum is converted to 0
-depthNum = Number.NEGATIVE_INFINITY;
+var depthNum = Number.NEGATIVE_INFINITY;
 var actual = a.flatten(depthNum);
 assert(compareArray(actual, expected), 'negative infinity depthNum');
 
 // positive zero depthNum is converted to 0
-depthNum = +0;
+var depthNum = +0;
 var actual = a.flatten(depthNum);
 assert(compareArray(actual, expected), 'positive zero depthNum');
 
 // negative zero depthNum is converted to 0
-depthNum = -0;
+var depthNum = -0;
 var actual = a.flatten(depthNum);
 assert(compareArray(actual, expected), 'negative zero depthNum');
 
 // integral string depthNum is converted to an integer
-depthNum = '1';
+var depthNum = '1';
 var actual = a.flatten(depthNum);
-expected = [1, 2]
+var expected = [1, 2]
 assert(compareArray(actual, expected), 'integral string depthNum');

test/built-ins/Array/prototype/flatten/non-object-ctor-throws.js

@@ -8,25 +8,24 @@ description: >
 ---*/
 
 var a = [];
-
 a.constructor = null;
 assert.throws(TypeError, function() {
   a.flatten();
 }, 'null value');
 
-a = [];
+var a = [];
 a.constructor = 1;
 assert.throws(TypeError, function() {
   a.flatten();
 }, 'number value');
 
-a = [];
+var a = [];
 a.constructor = 'string';
 assert.throws(TypeError, function() {
   a.flatten();
 }, 'string value');
 
-a = [];
+var a = [];
 a.constructor = true;
 assert.throws(TypeError, function() {
   a.flatten();

test/built-ins/Array/prototype/flatten/null-undefined-elements.js

@@ -6,10 +6,10 @@ description: >
     arrays with null, and undefined
 includes: [compareArray.js]
 ---*/
-var a;
+var a = [void 0];
 
-assert(compareArray(Array.prototype.flatten.call([1, null, void 0]), [1, null, undefined]));
+assert(compareArray([1, null, void 0].flatten(), [1, null, undefined]));
-assert(compareArray(Array.prototype.flatten.call([1,[null, void 0]]), [1, null, undefined]));
+assert(compareArray([1,[null, void 0]].flatten(), [1, null, undefined]));
-assert(compareArray(Array.prototype.flatten.call([[null, void 0], [null, void 0]]), [null, undefined, null, undefined]));
+assert(compareArray([[null, void 0], [null, void 0]].flatten(), [null, undefined, null, undefined]));
-assert(compareArray(Array.prototype.flatten.call([1,[null, a = [void 0]]], 1), [1, null, a]));
+assert(compareArray([1,[null, a]].flatten(1), [1, null, a]));
-assert(compareArray(Array.prototype.flatten.call([1,[null, [void 0]]], 2), [1, null, undefined]));
+assert(compareArray([1,[null, a]].flatten(2), [1, null, undefined]));

test/built-ins/Array/prototype/flatten/symbol-object-create-null-depth-throws.js

@@ -6,16 +6,11 @@ description: >
     if the argument is a Symbol or Object null, it throws exception
 ---*/
 
-var a = [];
-var depthNum = Symbol();
-
 assert.throws(TypeError, function() {
-  a.flatten(depthNum);
+  [].flatten(Symbol());
 }, 'symbol value');
 
-depthNum = Object.create(null);
-
 assert.throws(TypeError, function() {
-  a.flatten(depthNum);
+  [].flatten(Object.create(null));
 }, 'object create null');