Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 375 insertions, 0 deletions

diff --git a/js/src/tests/non262/Tuple/prototype/slice/invoked-as-func.js b/js/src/tests/non262/Tuple/prototype/slice/invoked-as-func.js
new file mode 100644
index 0000000000..961ed9aff5
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/invoked-as-func.js
@@ -0,0 +1,7 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+var slice = Tuple.prototype.slice;
+
+assertThrowsInstanceOf(function() { slice() }, TypeError,
+                       "value of TupleObject must be a Tuple");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/invoked-as-method.js b/js/src/tests/non262/Tuple/prototype/slice/invoked-as-method.js
new file mode 100644
index 0000000000..291bf433cd
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/invoked-as-method.js
@@ -0,0 +1,9 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+var TuplePrototype = Tuple.prototype;
+
+assertEq(typeof TuplePrototype.slice, 'function');
+
+assertThrowsInstanceOf(function() { TuplePrototype.slice() }, TypeError,
+                       "value of TupleObject must be a Tuple");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/length.js b/js/src/tests/non262/Tuple/prototype/slice/length.js
new file mode 100644
index 0000000000..d0e9359934
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/length.js
@@ -0,0 +1,26 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+var desc = Object.getOwnPropertyDescriptor(Tuple.prototype.slice, "length");
+assertEq(desc.value, 2);
+assertEq(desc.writable, false);
+assertEq(desc.enumerable, false);
+assertEq(desc.configurable, true);
+
+desc = Object.getOwnPropertyDescriptor(Tuple.prototype.slice, "name");
+assertEq(desc.value, "slice");
+assertEq(desc.writable, false);
+assertEq(desc.enumerable, false);
+assertEq(desc.configurable, true);
+
+desc = Object.getOwnPropertyDescriptor(Tuple.prototype, "slice");
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, false);
+assertEq(desc.configurable, true);
+
+assertEq(isConstructor(Tuple.prototype.slice), false);
+
+assertThrowsInstanceOf(() => {
+  let t = #[1];
+  new t.slice();
+}, TypeError, '`let t = #[1]; new t.slice()` throws TypeError');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/name.js b/js/src/tests/non262/Tuple/prototype/slice/name.js
new file mode 100644
index 0000000000..19b6957105
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/name.js
@@ -0,0 +1,9 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+var desc = Object.getOwnPropertyDescriptor(Tuple.prototype.slice, "name");
+assertEq(desc.value, "slice");
+assertEq(desc.writable, false);
+assertEq(desc.enumerable, false);
+assertEq(desc.configurable, true);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/negative-zero.js b/js/src/tests/non262/Tuple/prototype/slice/negative-zero.js
new file mode 100644
index 0000000000..029455c5d0
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/negative-zero.js
@@ -0,0 +1,10 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+var sample = #[40,41,42,43];
+
+assertEq(sample.slice(-0), sample);
+assertEq(sample.slice(-0, 4), sample);
+assertEq(sample.slice(0, -0), #[]);
+assertEq(sample.slice(-0, -0), #[]);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/not-a-constructor.js b/js/src/tests/non262/Tuple/prototype/slice/not-a-constructor.js
new file mode 100644
index 0000000000..ebd27dd17d
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/not-a-constructor.js
@@ -0,0 +1,10 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+assertEq(isConstructor(Tuple.prototype.slice), false);
+
+assertThrowsInstanceOf(() => {
+  let t = #[1];
+  new t.slice();
+}, TypeError, '`let t = #[1]; new t.slice()` throws TypeError');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/prop-desc.js b/js/src/tests/non262/Tuple/prototype/slice/prop-desc.js
new file mode 100644
index 0000000000..1eda464d2f
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/prop-desc.js
@@ -0,0 +1,9 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+var desc = Object.getOwnPropertyDescriptor(Tuple.prototype, "slice");
+assertEq(desc.writable, true);
+assertEq(desc.enumerable, false);
+assertEq(desc.configurable, true);
+assertEq(typeof Tuple.prototype.slice, 'function');
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-end.js b/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-end.js
new file mode 100644
index 0000000000..9d9f8733a3
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-end.js
@@ -0,0 +1,13 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+var o1 = { valueOf: function() { throw new SyntaxError(); } };
+var o2 = { toString: function() { throw new SyntaxError(); } };
+
+var sample = #[];
+
+assertThrowsInstanceOf(() => sample.slice(0, o1),
+                       SyntaxError, "valueOf throws");
+assertThrowsInstanceOf(() => sample.slice(0, o2),
+                       SyntaxError, "toString throws");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-start.js b/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-start.js
new file mode 100644
index 0000000000..0c8b23acf7
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/return-abrupt-from-start.js
@@ -0,0 +1,13 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+var o1 = { valueOf: function() { throw new SyntaxError(); } };
+var o2 = { toString: function() { throw new SyntaxError(); } };
+
+var sample = #[];
+
+assertThrowsInstanceOf(() => sample.slice(o1),
+                       SyntaxError, "valueOf throws");
+assertThrowsInstanceOf(() => sample.slice(o2),
+                       SyntaxError, "toString throws");
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/slice.js b/js/src/tests/non262/Tuple/prototype/slice/slice.js
new file mode 100644
index 0000000000..c1d30dfefa
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/slice.js
@@ -0,0 +1,176 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+/*
+8.2.3.5 Tuple.prototype.slice ( start, end )
+When the slice method is called with two arguments, start and end, and returns a Tuple containing the elements of the Tuple from element start up to, but not including, element end (or through the end of the tuple if end is undefined). If start is negative, it is treated as length + start where length is the length of the tuple. If end is negative, it is treated as length + end where length is the length of the tuple.
+
+The following steps are taken:
+
+1. Let T be ? thisTupleValue(this value).
+2. Let list be T.[[Sequence]].
+3. Let len be the number of elements in list.
+4. Let relativeStart be ? ToInteger(start).
+5. If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
+6. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
+7. If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
+8. Let newList be a new empty List.
+9. Repeat, while k < final,
+a. Let kValue be list[k].
+b. Assert: Type(kValue) is not Object.
+c. Append kValue to the end of newList.
+d. Set k to k + 1.
+10. Return a new Tuple value whose [[Sequence]] is newList.
+*/
+
+/* Step 1 */
+/* slice() should throw on a non-Tuple */
+let method = Tuple.prototype.slice;
+assertEq(method.call(#[1,2,3,4,5,6], 2, 4), #[3,4]);
+assertEq(method.call(Object(#[1,2,3,4,5,6]), 2, 4), #[3,4]);
+assertThrowsInstanceOf(() => method.call("monkeys"), TypeError,
+                       "value of TupleObject must be a Tuple");
+assertThrowsInstanceOf(() => method.call(true), TypeError,
+                       "value of TupleObject must be a Tuple");
+assertThrowsInstanceOf(() => method.call(false), TypeError,
+                       "value of TupleObject must be a Tuple");
+
+
+let tup = #[1,2,3];
+let len = 3;
+/* Step 4 -- toInteger returns 0 for non-integers */
+assertEq(tup.slice("monkeys", 4), tup.slice(0, 4));
+assertThrowsInstanceOf(() => tup.slice(Symbol("1"), 4),
+                       TypeError, "can't convert symbol to number");
+assertEq(tup.slice(undefined, 4), tup.slice(0, 4));
+assertEq(tup.slice(undefined), tup.slice(0));
+assertEq(tup.slice(NaN), tup.slice(0));
+assertEq(tup.slice(Number.POSITIVE_INFINITY), tup.slice(len));
+assertEq(tup.slice(Number.NEGATIVE_INFINITY), tup.slice(0));
+assertEq(tup.slice({valueOf: function() { return 0 },
+                    toString: function() { return 3 }}),
+         tup.slice(0, 3));
+assertEq(tup.slice(), tup.slice(0));
+
+
+/* Step 5 -- if relativeStart < 0, k should be max((len + relativeStart), 0) */
+/* Case 1: len + relativeStart > 0 */
+var relativeStart = -2;
+assertEq(tup.slice(relativeStart, 4), tup.slice(len + relativeStart, 4));
+/* Case 2: len + relativeStart === 0 */
+relativeStart = (-1 * len);
+assertEq(tup.slice(relativeStart, 4), tup.slice(0, 4));
+/* Case 3: len + relativeStart < 0 */
+relativeStart = -256;
+assertEq(tup.slice(relativeStart, 4), tup.slice(0, 4));
+
+/* Step 5 -- start positive, end positive */
+var tup2 = #[1,2,3,4,5,6,7];
+relativeStart = 2;
+/* length > end > start */
+assertEq(tup2.slice(relativeStart, 4), #[3,4]);
+/* start == len */
+/* length == end == start */
+assertEq(tup2.slice(tup2.length, tup2.length), #[]);
+/* start > len */
+/* start > end == len */
+assertEq(tup2.slice(tup2.length + 5, tup2.length), tup2.slice(tup2.length, tup2.length));
+/* length > end > start = 0 */
+relativeStart = 0;
+assertEq(tup2.slice(relativeStart, 4), #[1,2,3,4]);
+/* length > end == start > 0 */
+relativeStart = 2;
+assertEq(tup2.slice(relativeStart, relativeStart), #[]);
+/* length > start > end > 0 */
+relativeStart = 4;
+relativeEnd = 2;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+/* length = end > start > 0 */
+relativeEnd = tup2.length;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[5,6,7]);
+/* end > length > start > 0 */
+relativeEnd = tup2.length + 3;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[5,6,7]);
+
+/* length > end == abs(start), start < 0 */
+relativeStart = -4;
+relativeEnd = 4;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[4]);
+/* length == end > abs(start), start < 0 */
+relativeEnd = tup2.length;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[4,5,6,7]);
+/* abs(start) = length > end > 0, start < 0 */
+relativeStart = -1*tup2.length;
+relativeEnd = 5;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[1,2,3,4,5]);
+/* abs(start) > length = end > 0 */
+relativeStart = (-1*tup2.length) - 4;
+relativeEnd = tup2.length;
+assertEq(tup2.slice(relativeStart, relativeEnd), tup2);
+
+/* Step 6 -- if end is undefined, let relativeEnd = len */
+assertEq(tup.slice(2, undefined), tup.slice(2, len));
+assertEq(tup.slice(2), tup.slice(2, len));
+/* relativeEnd converted with toInteger */
+assertEq(tup.slice(2, "monkeys"), tup.slice(2, 0));
+assertThrowsInstanceOf(() => tup.slice(2, Symbol("x")),
+                      TypeError, "can't convert Symbol to Number");
+assertEq(tup.slice(2, 2.5), tup.slice(2, 0));
+assertEq(tup.slice(2, NaN), tup.slice(2, 0));
+assertEq(tup.slice(2, Number.POSITIVE_INFINITY), tup.slice(2, len));
+assertEq(tup.slice(2, Number.NEGATIVE_INFINITY), tup.slice(2, 0));
+assertEq(tup.slice(0, Number.POSITIVE_INFINITY), tup.slice(0, len));
+assertEq(tup.slice(0, Number.NEGATIVE_INFINITY), tup.slice(0, 0));
+assertEq(tup.slice({valueOf: function() { return 3 },
+                    toString: function() { return 0 }}),
+         tup.slice(0, 0));
+
+/* Step 7 -- if relativeEnd < 0, final should be max((len + relativeEnd), 0) */
+/* Case 1: len + relativeEnd > 0 */
+var relativeEnd = -1;
+relativeStart = 2;
+assertEq(tup.slice(relativeStart, relativeEnd), tup.slice(relativeStart, len + relativeEnd));
+/* Case 2: len + relativeEnd === 0 */
+relativeEnd = (-1 * len);
+assertEq(tup.slice(relativeStart, relativeEnd), tup.slice(relativeStart, 0));
+/* Case 3: len + relativeEnd < 0 */
+relativeEnd = -256;
+assertEq(tup.slice(relativeStart, relativeEnd), tup.slice(relativeStart, 0));
+/* start and end both negative */
+relativeStart = -3;
+relativeEnd = -1;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[5, 6]);
+relativeEnd = (-1*len);
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+relativeEnd = -256;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+
+/* length > abs(end) > start === 0 */
+relativeStart = 0;
+relativeEnd = -3;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[1,2,3,4]);
+/* length > abs(end) > start > 0 */
+relativeStart = 2;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[3,4]);
+/* length == abs(end) > start == 0 */
+relativeEnd = -1*tup2.length;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+/* abs(end) > length > start > 0 */
+relativeEnd = (-1*tup2.length) - 5;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+/* -length == start < end < 0 */
+relativeStart = -1*tup2.length;
+relativeEnd = 5;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[1,2,3,4,5]);
+/* -length < start < end < 0 */
+relativeStart = -3;
+relativeEnd = -1;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[5,6]);
+/* start < -length < end < 0 */
+relativeStart = (-1*tup2.length) - 5;
+relativeEnd = -3;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[1,2,3,4]);
+/* start = end < -length */
+relativeEnd = relativeStart;
+assertEq(tup2.slice(relativeStart, relativeEnd), #[]);
+
+reportCompare(0, 0);
+
diff --git a/js/src/tests/non262/Tuple/prototype/slice/tointeger-end.js b/js/src/tests/non262/Tuple/prototype/slice/tointeger-end.js
new file mode 100644
index 0000000000..a379e5d7d3
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/tointeger-end.js
@@ -0,0 +1,35 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+/*
+8.2.3.5
+...
+6. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
+*/
+
+var obj = {
+  valueOf: function() {
+    return 2;
+  }
+};
+
+
+var sample = #[40, 41, 42, 43];
+
+assertEq(sample.slice(0, false), #[]);
+assertEq(sample.slice(0, true), #[40]);
+
+assertEq(sample.slice(0, NaN), #[]);
+assertEq(sample.slice(0, null), #[]);
+assertEq(sample.slice(0, undefined), #[40, 41, 42, 43]);
+
+assertEq(sample.slice(0, 0.6), #[]);
+assertEq(sample.slice(0, 1.1), #[40]);
+assertEq(sample.slice(0, 1.5), #[40]);
+assertEq(sample.slice(0, -0.6), #[]);
+assertEq(sample.slice(0, -1.1), #[40, 41, 42]);
+assertEq(sample.slice(0, -1.5), #[40, 41, 42]);
+
+assertEq(sample.slice(0, "3"), #[40, 41, 42]);
+
+assertEq(sample.slice(0, obj), #[40, 41]);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/tointeger-start.js b/js/src/tests/non262/Tuple/prototype/slice/tointeger-start.js
new file mode 100644
index 0000000000..55a59ad024
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/tointeger-start.js
@@ -0,0 +1,35 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+/*
+8.2.3.5
+...
+4. Let relativeStart be ? ToInteger(start).
+*/
+
+var obj = {
+  valueOf: function() {
+    return 2;
+  }
+};
+
+
+var sample = #[40, 41, 42, 43];
+
+assertEq(sample.slice(false), sample);
+assertEq(sample.slice(true), #[41, 42, 43]);
+
+assertEq(sample.slice(NaN), sample);
+assertEq(sample.slice(null), sample);
+assertEq(sample.slice(undefined), sample);
+
+assertEq(sample.slice(0.6), sample);
+assertEq(sample.slice(1.1), #[41, 42, 43]);
+assertEq(sample.slice(1.5), #[41, 42, 43]);
+assertEq(sample.slice(-0.6), sample);
+assertEq(sample.slice(-1.1), #[43]);
+assertEq(sample.slice(-1.5), #[43]);
+
+assertEq(sample.slice("3"), #[43]);
+
+assertEq(sample.slice(obj), #[42, 43]);
+
+reportCompare(0, 0);
diff --git a/js/src/tests/non262/Tuple/prototype/slice/tuple-length-internal.js b/js/src/tests/non262/Tuple/prototype/slice/tuple-length-internal.js
new file mode 100644
index 0000000000..f0fff9693e
--- /dev/null
+++ b/js/src/tests/non262/Tuple/prototype/slice/tuple-length-internal.js
@@ -0,0 +1,23 @@
+// |reftest| skip-if(!this.hasOwnProperty("Tuple"))
+
+/* Ensure that slice uses internal length and not length property */
+
+
+var getCalls = 0;
+var desc = {
+  get: function getLen() {
+    getCalls++;
+    return 0;
+  }
+};
+
+Object.defineProperty(Tuple.prototype, "length", desc);
+
+var sample = Object(#[42, 43]);
+
+var result = sample.slice();
+
+assertEq(getCalls, 0, "ignores length properties");
+assertEq(result, #[42, 43]);
+
+reportCompare(0, 0);