1 files changed, 187 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/basic/non-extensible-elements9.js b/js/src/jit-test/tests/basic/non-extensible-elements9.js
new file mode 100644
index 0000000000..847a7d006e
--- /dev/null
+++ b/js/src/jit-test/tests/basic/non-extensible-elements9.js
@@ -0,0 +1,187 @@
+function testNonExtensibleStoreFallibleT() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    x.length = 1;
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = 4;
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleStoreFallibleT();
+
+// Repeat testNonExtensibleStoreFallibleT for the MIRType::Value specialization.
+function testNonExtensibleStoreFallibleV(i) {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, ""];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    x.length = 1;
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = [true, 1][i & 1];
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleStoreFallibleV(i);
+
+function testForInIterationNonExtensibleStoreFallibleT() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Modifying an array's length takes a different path during for-in
+    // iteration of the array.
+    for (var k in x) {
+        // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+        x.length = 1;
+    }
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = 4;
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testForInIterationNonExtensibleStoreFallibleT();
+
+// Repeat testForInIterationNonExtensibleStoreFallibleT for the MIRType::Value specialization.
+function testForInIterationNonExtensibleStoreFallibleV(i) {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, ""];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Modifying an array's length takes a different path during for-in
+    // iteration of the array.
+    for (var k in x) {
+        // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+        x.length = 1;
+        break;
+    }
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = [true, 1][i & 1];
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testForInIterationNonExtensibleStoreFallibleV(i);
+
+function testNonExtensibleArrayPop() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    x.pop();
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = 4;
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleArrayPop();
+
+function testNonExtensibleArrayPopNonWritable() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // And make the "length" property non-writable.
+    Object.defineProperty(x, "length", {writable: false});
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    // This doesn't update |x.length|, because the "length" property is non-writable.
+    try {
+        x.pop();
+    } catch {}
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    for (var i = 0; i < 100; ++i)
+        x[1] = 4;
+
+    assertEq(x.length, 2);
+    assertEq(x[0], 8);
+    assertEq(x[1], undefined);
+    assertEq(1 in x, false);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleArrayPopNonWritable();
+
+function testNonExtensibleArrayShift() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    x.shift();
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = 4;
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 0);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleArrayShift();
+
+function testNonExtensibleArraySplice() {
+    // Create an array with initialized-length = capacity = 2.
+    var x = [8, 0];
+
+    // Make it non-extensible.
+    Object.preventExtensions(x);
+
+    // Now reduce initialized-length by one, so that initialized-length < capacity is true.
+    x.splice(1, 1);
+
+    // There's enough capacity in the elements storage to save the new element,
+    // but we still need to reject the store since the object is non-extensible.
+    x[1] = 4;
+
+    assertEq(x.length, 1);
+    assertEq(x[0], 8);
+}
+
+for (var i = 0; i < 15; ++i)
+    testNonExtensibleArraySplice();