1 files changed, 114 insertions, 0 deletions
diff --git a/js/src/tests/non262/Tuple/prototype/flatMap/flatMap.js b/js/src/tests/non262/Tuple/prototype/flatMap/flatMap.js
new file mode 100644
index 0000000000..0fde7014a8
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/flatMap/flatMap.js
@@ -0,0 +1,114 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+/*
+8.2.3.17 Tuple.prototype.flatMap ( mapperFunction [ , thisArg ] )
+When the flatMap method is called with one or two arguments, the following steps are taken:
+
+1. Let T be ? thisTupleValue(this value).
+2. Let list be T.[[Sequence]].
+3. If ! IsCallable(mapperFunction) is false, throw a TypeError exception.
+4. Let flat be a new empty List.
+5. Perform ? FlattenIntoTuple(flat, list, 1, mapperFunction, thisArg).
+6. Return a new Tuple value whose [[Sequence]] is flat.
+
+8.2.3.16.1 FlattenIntoTuple ( target, source, depth [ , mapperFunction, thisArg ] )
+The abstract operation FlattenIntoTuple takes arguments target, source, and depth and optional arguments mapperFunction and thisArg. It performs the following steps when called:
+
+1. Assert: target is a List.
+2. Assert: source is a List.
+3. Assert: ! IsInteger(depth) is true, or depth is either +∞ or -∞.
+4. Assert: If mapperFunction is present, then ! IsCallable(mapperFunction) is true, thisArg is present, and depth is 1.
+5. Let sourceIndex be 0.
+6. For each element of source,
+a. If mapperFunction is present, then
+i. Set element to ? Call(mapperFunction, thisArg, « element, sourceIndex, source »).
+ii. If Type(element) is Object, throw a TypeError exception.
+b. If depth > 0 and Type(element) is Tuple, then
+i. Perform ? FlattenIntoTuple(target, element, depth - 1).
+c. Else,
+i. Let len be the length of target.
+ii. If len ≥ 253 - 1, throw a TypeError exception.
+iii. Append element to target.
+d. Set sourceIndex to sourceIndex + 1.
+ */
+
+/* Step 1 */
+/* flatMap() should throw on a non-Tuple */
+let method = Tuple.prototype.flatMap;
+let id = x => x;
+assertEq(method.call(#[1,#[2],3], id), #[1,2,3]);
+assertEq(method.call(Object(#[1,#[2],3]), id), #[1,2,3]);
+assertThrowsInstanceOf(() => method.call("monkeys", id), TypeError,
+                       "value of TupleObject must be a Tuple");
+assertThrowsInstanceOf(() => method.call(null, id), TypeError,
+                       "value of TupleObject must be a Tuple");
+assertThrowsInstanceOf(() => method.call(id), TypeError,
+                       "value of TupleObject must be a Tuple");
+
+
+let tup = #[1,2,#[3,#[4,5],6],#[5,6],7];
+let tup2 = #[1, #[2], 3];
+
+/* Step 4 */
+/* callbackfn not callable -- should throw */
+assertThrowsInstanceOf(() => tup.flatMap(), TypeError,
+                       "missing function argument to Tuple.prototype.flatMap");
+assertThrowsInstanceOf(() => tup.flatMap(undefined), TypeError,
+                       "missing function argument to Tuple.prototype.flatMap");
+assertThrowsInstanceOf(() => tup.flatMap("monkeys"), TypeError,
+                       "bad function argument to Tuple.prototype.flatMap");
+
+
+/* callbackfn with 1 argument -- should be allowed */
+var f2 = function(x) {
+    if (typeof(x) === "number") {
+        return(x * x);
+    } else {
+        return 0;
+    }
+};
+assertEq(tup2.flatMap(f2), #[1, 0, 9]);
+
+/* callbackfn with 2 arguments -- should be allowed */
+f2 = function(x, i) {
+    if (typeof(x) === "number") {
+        return(x + i);
+    } else {
+        return(i);
+    }
+};
+assertEq(tup2.flatMap(f2), #[1, 1, 5]);
+
+/* callbackfn with > 3 arguments -- subsequent ones will be undefined */
+var f3 = (a, b, c, d, e) => e === undefined;
+assertEq(tup2.flatMap(f3), #[true, true, true]);
+
+/* callbackfn should be able to use index and tuple */
+var f4 = function (x, i, tup) {
+    if (typeof(x) === "number") {
+        return(tup.indexOf(x+1) * i * x);
+    } else {
+        return(tup.indexOf(x) * i);
+    }
+}
+assertEq(tup2.flatMap(f4), #[-0, 1, -6]);
+
+/* explicit thisArg */
+f1 = function (x, i, tup) {
+    if (typeof(x) == "number") {
+        return(this.elements.indexOf(x) * x);
+    } else {
+        return(this.elements.indexOf(x));
+    }
+}
+assertEq(#[1,2,#[3,4],#[5]].flatMap(f1, { elements: [2, 4] }), #[-1, 0, -1, -1]);
+
+/* FlattenIntoTuple steps */
+/* Step 6.a.ii. */
+var badF = x => new Object(x);
+assertThrowsInstanceOf(() => tup.flatMap(badF), TypeError,
+                       "Tuple cannot contain Object");
+/* Step 6.b.i. */
+var f = x => #[x, x];
+assertEq(#[1,#[2,3],4].flatMap(f), #[1,1,#[2,3],#[2,3],4,4]);
+
+reportCompare(0, 0);