9 files changed, 194 insertions, 0 deletions
diff --git a/js/src/tests/non262/pipeline/browser.js b/js/src/tests/non262/pipeline/browser.js
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/js/src/tests/non262/pipeline/browser.js
diff --git a/js/src/tests/non262/pipeline/eval.js b/js/src/tests/non262/pipeline/eval.js
new file mode 100644
index 0000000000..50f096b0f2
--- /dev/null
+++ b/js/src/tests/non262/pipeline/eval.js
@@ -0,0 +1,19 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (eval)";
+
+print(BUGNUMBER + ": " + summary);
+
+const testvalue = 10;
+
+if (hasPipeline()) {
+    eval(`
+    // Pipelined eval should be indirect eval call
+    (() => {
+        const testvalue = 20;
+        assertEq("testvalue" |> eval, 10);
+    })();
+    `);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/evaluation-order.js b/js/src/tests/non262/pipeline/evaluation-order.js
new file mode 100644
index 0000000000..642ad78f55
--- /dev/null
+++ b/js/src/tests/non262/pipeline/evaluation-order.js
@@ -0,0 +1,18 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (evaluation order)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    eval(`
+    // It tests evaluation order.
+    // Considering the expression A |> B, A should be evaluated before B.
+    let value = null;
+    const result = (value = 10, "42") |> (value = 20, parseInt);
+    assertEq(result, 42);
+    assertEq(value, 20);
+    `);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/parse-error.js b/js/src/tests/non262/pipeline/parse-error.js
new file mode 100644
index 0000000000..ce191651f7
--- /dev/null
+++ b/js/src/tests/non262/pipeline/parse-error.js
@@ -0,0 +1,18 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (parse error)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    // Invalid Token
+    assertThrowsInstanceOf(() => Function("2 | > parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 ||> parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 |>> parseInt"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("2 <| parseInt"), SyntaxError);
+    // Invalid Syntax
+    assertThrowsInstanceOf(() => Function("2 |>"), SyntaxError);
+    assertThrowsInstanceOf(() => Function("|> parseInt"), SyntaxError);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/precedence.js b/js/src/tests/non262/pipeline/precedence.js
new file mode 100644
index 0000000000..0ef6ff7281
--- /dev/null
+++ b/js/src/tests/non262/pipeline/precedence.js
@@ -0,0 +1,56 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (operator precedence)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    // Operator precedence
+    eval(`
+    const double = (n) => n * 2;
+    const increment = (n) => n + 1;
+    const getType = (v) => typeof v;
+    const toString = (v) => v.toString();
+    let a = 8;
+    assertEq(10 |> double |> increment |> double, 42);
+    assertEq(++ a |> double, 18);
+    assertEq(typeof 42 |> toString, "number");
+    assertEq(! true |> toString, "false");
+    assertEq(delete 42 |> toString, "true");
+    assertEq(10 ** 2 |> double, 200);
+    assertEq(10 * 2 |> increment, 21);
+    assertEq(5 + 5 |> double, 20);
+    assertEq(1 << 4 |> double, 32);
+    assertEq(0 < 1 |> toString, "true");
+    assertEq("a" in {} |> toString, "false");
+    assertEq(10 instanceof String |> toString, "false");
+    assertEq(10 == 10 |> toString, "true");
+    assertEq(0b0101 & 0b1101 |> increment, 0b0110);
+    assertEq(false && true |> toString, "false");
+    assertEq(0 |> double ? toString : null, null);
+    assertEq(true ? 20 |> toString : 10, '20');
+    assertEq(true ? 10 : 20 |> toString, 10);
+    a = 10 |> toString;
+    assertEq(a, "10");
+    a = 10;
+    a += 2 |> increment;
+    assertEq(a, 13);
+
+    // Right-side association
+    a = toString;
+    assertThrowsInstanceOf(() => "42" |> parseInt ** 2, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt * 1, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt + 0, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt << 1, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt < 0, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt in {}, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt instanceof String, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt == 255, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt & 0b1111, TypeError);
+    assertThrowsInstanceOf(() => "42" |> parseInt && true, TypeError);
+    assertThrowsInstanceOf(() => Function('"42" |> a = parseInt'), ReferenceError);
+    assertThrowsInstanceOf(() => Function('"42" |> a += parseInt'), ReferenceError);
+    `);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/receiver.js b/js/src/tests/non262/pipeline/receiver.js
new file mode 100644
index 0000000000..588a83e169
--- /dev/null
+++ b/js/src/tests/non262/pipeline/receiver.js
@@ -0,0 +1,24 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (receiver)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    // Receiver
+    eval(`
+    const receiver = {
+        foo: function (value, extra) {
+            assertEq(value, 10);
+            assertEq(extra, undefined);
+            assertEq(arguments.length, 1);
+            assertEq(arguments[0], 10)
+            assertEq(this, receiver);
+        },
+    };
+
+    10 |> receiver.foo;
+    `);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/reflect-parse.js b/js/src/tests/non262/pipeline/reflect-parse.js
new file mode 100644
index 0000000000..247f6657b7
--- /dev/null
+++ b/js/src/tests/non262/pipeline/reflect-parse.js
@@ -0,0 +1,28 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (Reflect.parse)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    if (typeof Reflect !== "undefined" && Reflect.parse) {
+        const parseTree1 = Reflect.parse("a |> b");
+        assertEq(parseTree1.body[0].type, "ExpressionStatement");
+        assertEq(parseTree1.body[0].expression.type, "BinaryExpression");
+        assertEq(parseTree1.body[0].expression.operator, "|>");
+        assertEq(parseTree1.body[0].expression.left.name, "a");
+        assertEq(parseTree1.body[0].expression.right.name, "b");
+
+        const parseTree2 = Reflect.parse("a |> b |> c");
+        assertEq(parseTree2.body[0].type, "ExpressionStatement");
+        assertEq(parseTree2.body[0].expression.type, "BinaryExpression");
+        assertEq(parseTree2.body[0].expression.operator, "|>");
+        assertEq(parseTree2.body[0].expression.left.type, "BinaryExpression");
+        assertEq(parseTree2.body[0].expression.left.operator, "|>");
+        assertEq(parseTree2.body[0].expression.left.left.name, "a");
+        assertEq(parseTree2.body[0].expression.left.right.name, "b");
+        assertEq(parseTree2.body[0].expression.right.name, "c");
+    }
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);
diff --git a/js/src/tests/non262/pipeline/shell.js b/js/src/tests/non262/pipeline/shell.js
new file mode 100644
index 0000000000..1ee63dd18c
--- /dev/null
+++ b/js/src/tests/non262/pipeline/shell.js
@@ -0,0 +1,9 @@
+function hasPipeline() {
+    try {
+        Function('a |> a');
+    } catch (e) {
+        return false;
+    }
+
+    return true;
+}
diff --git a/js/src/tests/non262/pipeline/type-error.js b/js/src/tests/non262/pipeline/type-error.js
new file mode 100644
index 0000000000..b34cc2712a
--- /dev/null
+++ b/js/src/tests/non262/pipeline/type-error.js
@@ -0,0 +1,22 @@
+const BUGNUMBER = 1405943;
+const summary = "Implement pipeline operator (type error)";
+
+print(BUGNUMBER + ": " + summary);
+
+if (hasPipeline()) {
+    // Type error
+    eval(`
+    assertThrowsInstanceOf(() => 10 |> 10, TypeError);
+    assertThrowsInstanceOf(() => 10 |> "foo", TypeError);
+    assertThrowsInstanceOf(() => 10 |> null, TypeError);
+    assertThrowsInstanceOf(() => 10 |> undefined, TypeError);
+    assertThrowsInstanceOf(() => 10 |> true, TypeError);
+    assertThrowsInstanceOf(() => 10 |> { a: 1 }, TypeError);
+    assertThrowsInstanceOf(() => 10 |> [ 0, 1 ], TypeError);
+    assertThrowsInstanceOf(() => 10 |> /regexp/, TypeError);
+    assertThrowsInstanceOf(() => 10 |> Symbol(), TypeError);
+    `);
+}
+
+if (typeof reportCompare === "function")
+    reportCompare(0, 0);