[rab/gsab] Tests for Array.p methods, part 16

In this part: at

Drive-by: test helper cleanup

Bug: v8:11111
Change-Id: I760d0c4ee078c397c8a8365ec96101b488986d41
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3764344Reviewed-by: Shu-yu Guo <syg@chromium.org>
Commit-Queue: Marja Hölttä <marja@chromium.org>
Cr-Commit-Position: refs/heads/main@{#81774}

test/mjsunit/typedarray-growablesharedarraybuffer.js

@@ -779,7 +779,7 @@ function TestFill(helper) {
 TestFill(TypedArrayFillHelper);
 TestFill(ArrayFillHelper);
 
-(function At() {
+function At(atHelper) {
   for (let ctor of ctors) {
     const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                                  8 * ctor.BYTES_PER_ELEMENT);
@@ -794,19 +794,21 @@ TestFill(ArrayFillHelper);
       WriteToTypedArray(ta_write, i, i);
     }
 
-    assertEquals(3, AtHelper(fixedLength, -1));
-    assertEquals(3, AtHelper(lengthTracking, -1));
-    assertEquals(3, AtHelper(fixedLengthWithOffset, -1));
-    assertEquals(3, AtHelper(lengthTrackingWithOffset, -1));
+    assertEquals(3, atHelper(fixedLength, -1));
+    assertEquals(3, atHelper(lengthTracking, -1));
+    assertEquals(3, atHelper(fixedLengthWithOffset, -1));
+    assertEquals(3, atHelper(lengthTrackingWithOffset, -1));
 
     // Grow. New memory is zeroed.
     gsab.grow(6 * ctor.BYTES_PER_ELEMENT);
-    assertEquals(3, AtHelper(fixedLength, -1));
-    assertEquals(0, AtHelper(lengthTracking, -1));
-    assertEquals(3, AtHelper(fixedLengthWithOffset, -1));
-    assertEquals(0, AtHelper(lengthTrackingWithOffset, -1));
+    assertEquals(3, atHelper(fixedLength, -1));
+    assertEquals(0, atHelper(lengthTracking, -1));
+    assertEquals(3, atHelper(fixedLengthWithOffset, -1));
+    assertEquals(0, atHelper(lengthTrackingWithOffset, -1));
   }
-})();
+}
+At(TypedArrayAtHelper);
+At(ArrayAtHelper);
 
 // The corresponding tests for Array.prototype.slice are in
 // typedarray-growablesharedarraybuffer-array-methods.js.

test/mjsunit/typedarray-helpers.js

@@ -109,14 +109,18 @@ function WriteToTypedArray(array, index, value) {
   }
 }
 
+// Also preserves undefined.
+function Convert(item) {
+  if (typeof item == 'bigint') {
+    return Number(item);
+  }
+  return item;
+}
+
 function ToNumbers(array) {
   let result = [];
   for (let item of array) {
-    if (typeof item == 'bigint') {
-      result.push(Number(item));
-    } else {
-      result.push(item);
-    }
+    result.push(Convert(item));
   }
   return result;
 }
@@ -176,19 +180,21 @@ function ValuesFromTypedArrayValues(ta) {
 }
 
 function ValuesFromArrayValues(ta) {
-  let result = [];
+  const result = [];
   for (let value of Array.prototype.values.call(ta)) {
     result.push(Number(value));
   }
   return result;
 }
 
-function AtHelper(array, index) {
-  let result = array.at(index);
-  if (typeof result == 'bigint') {
-    return Number(result);
-  }
-  return result;
+function TypedArrayAtHelper(ta, index) {
+  const result = ta.at(index);
+  return Convert(result);
+}
+
+function ArrayAtHelper(ta, index) {
+  const result = Array.prototype.at.call(ta, index);
+  return Convert(result);
 }
 
 function TypedArrayFillHelper(ta, n, start, end) {

test/mjsunit/typedarray-resizablearraybuffer-detach.js

@@ -1740,3 +1740,26 @@ SortCallbackDetaches(ArraySortHelper);
     assertEquals(2 * ctor.BYTES_PER_ELEMENT, rab.byteLength);
   }
 })();
+
+function AtParameterConversionDetaches(atHelper) {
+  for (let ctor of ctors) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    const fixedLength = new ctor(rab, 0, 4);
+
+    let evil = { valueOf: () => { %ArrayBufferDetach(rab); return 0;}};
+    assertEquals(undefined, atHelper(fixedLength, evil));
+  }
+
+  for (let ctor of ctors) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    const lengthTracking = new ctor(rab);
+
+    let evil = { valueOf: () => { %ArrayBufferDetach(rab); return -1;}};
+    // The TypedArray is *not* out of bounds since it's length-tracking.
+    assertEquals(undefined, atHelper(lengthTracking, evil));
+  }
+}
+AtParameterConversionDetaches(TypedArrayAtHelper);
+AtParameterConversionDetaches(ArrayAtHelper);

test/mjsunit/typedarray-resizablearraybuffer.js

@@ -1306,7 +1306,7 @@ TestFill(ArrayFillHelper, false);
   }
 })();
 
-(function At() {
+function At(atHelper, oobThrows) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
@@ -1321,45 +1321,58 @@ TestFill(ArrayFillHelper, false);
       WriteToTypedArray(ta_write, i, i);
     }
 
-    assertEquals(3, AtHelper(fixedLength, -1));
-    assertEquals(3, AtHelper(lengthTracking, -1));
-    assertEquals(3, AtHelper(fixedLengthWithOffset, -1));
-    assertEquals(3, AtHelper(lengthTrackingWithOffset, -1));
+    assertEquals(3, atHelper(fixedLength, -1));
+    assertEquals(3, atHelper(lengthTracking, -1));
+    assertEquals(3, atHelper(fixedLengthWithOffset, -1));
+    assertEquals(3, atHelper(lengthTrackingWithOffset, -1));
 
     // Shrink so that fixed length TAs go out of bounds.
     rab.resize(3 * ctor.BYTES_PER_ELEMENT);
 
-    assertThrows(() => { AtHelper(fixedLength, -1); });
-    assertThrows(() => { AtHelper(fixedLengthWithOffset, -1); });
+    if (oobThrows) {
+      assertThrows(() => { atHelper(fixedLength, -1); });
+      assertThrows(() => { atHelper(fixedLengthWithOffset, -1); });
+    } else {
+      assertEquals(undefined, atHelper(fixedLength, -1));
+      assertEquals(undefined, atHelper(fixedLengthWithOffset, -1));
+    }
 
-    assertEquals(2, AtHelper(lengthTracking, -1));
-    assertEquals(2, AtHelper(lengthTrackingWithOffset, -1));
+    assertEquals(2, atHelper(lengthTracking, -1));
+    assertEquals(2, atHelper(lengthTrackingWithOffset, -1));
 
     // Shrink so that the TAs with offset go out of bounds.
     rab.resize(1 * ctor.BYTES_PER_ELEMENT);
 
-    assertThrows(() => { AtHelper(fixedLength, -1); });
-    assertThrows(() => { AtHelper(fixedLengthWithOffset, -1); });
-    assertEquals(0, AtHelper(lengthTracking, -1));
-    assertThrows(() => { AtHelper(lengthTrackingWithOffset, -1); });
+    if (oobThrows) {
+      assertThrows(() => { atHelper(fixedLength, -1); });
+      assertThrows(() => { atHelper(fixedLengthWithOffset, -1); });
+      assertThrows(() => { atHelper(lengthTrackingWithOffset, -1); });
+    } else {
+      assertEquals(undefined, atHelper(fixedLength, -1));
+      assertEquals(undefined, atHelper(fixedLengthWithOffset, -1));
+      assertEquals(undefined, atHelper(lengthTrackingWithOffset, -1));
+    }
+    assertEquals(0, atHelper(lengthTracking, -1));
 
     // Grow so that all TAs are back in-bounds. New memory is zeroed.
     rab.resize(6 * ctor.BYTES_PER_ELEMENT);
-    assertEquals(0, AtHelper(fixedLength, -1));
-    assertEquals(0, AtHelper(lengthTracking, -1));
-    assertEquals(0, AtHelper(fixedLengthWithOffset, -1));
-    assertEquals(0, AtHelper(lengthTrackingWithOffset, -1));
+    assertEquals(0, atHelper(fixedLength, -1));
+    assertEquals(0, atHelper(lengthTracking, -1));
+    assertEquals(0, atHelper(fixedLengthWithOffset, -1));
+    assertEquals(0, atHelper(lengthTrackingWithOffset, -1));
   }
-})();
+}
+At(TypedArrayAtHelper, true);
+At(ArrayAtHelper, false);
 
-(function AtParameterConversionResizes() {
+function AtParameterConversionResizes(atHelper) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
     const fixedLength = new ctor(rab, 0, 4);
 
     let evil = { valueOf: () => { rab.resize(2); return 0;}};
-    assertEquals(undefined, AtHelper(fixedLength, evil));
+    assertEquals(undefined, atHelper(fixedLength, evil));
   }
 
   for (let ctor of ctors) {
@@ -1369,9 +1382,11 @@ TestFill(ArrayFillHelper, false);
 
     let evil = { valueOf: () => { rab.resize(2); return -1;}};
     // The TypedArray is *not* out of bounds since it's length-tracking.
-    assertEquals(undefined, AtHelper(lengthTracking, evil));
+    assertEquals(undefined, atHelper(lengthTracking, evil));
   }
-})();
+}
+AtParameterConversionResizes(TypedArrayAtHelper);
+AtParameterConversionResizes(ArrayAtHelper);
 
 // The corresponding tests for Array.prototype.slice are in
 // typedarray-resizablearraybuffer-array-methods.js.