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

In this part: forEach, reduce, reduceRight + missing tests for includes

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

test/mjsunit/typedarray-growablesharedarraybuffer.js

@@ -2026,7 +2026,8 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
   }
 })();
 
-(function ForEachReduceReduceRight() {
+function ForEachReduceReduceRight(
+    forEachHelper, reduceHelper, reduceRightHelper) {
   for (let ctor of ctors) {
     const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                                  8 * ctor.BYTES_PER_ELEMENT);
@@ -2052,13 +2053,13 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
       const reduceValues = [];
       const reduceRightValues = [];
 
-      array.forEach((n) => { forEachValues.push(n);});
+      forEachHelper(array, (n) => { forEachValues.push(n);});
 
-      array.reduce((acc, n) => {
+      reduceHelper(array, (acc, n) => {
         reduceValues.push(n);
       }, "initial value");
 
-      array.reduceRight((acc, n) => {
+      reduceRightHelper(array, (acc, n) => {
         reduceRightValues.push(n);
       }, "initial value");
 
@@ -2090,9 +2091,14 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
     assertEquals([0, 2, 4, 6, 8, 10], Helper(lengthTracking));
     assertEquals([4, 6, 8, 10], Helper(lengthTrackingWithOffset));
   }
-})();
+}
+ForEachReduceReduceRight(TypedArrayForEachHelper, TypedArrayReduceHelper,
+                         TypedArrayReduceRightHelper);
+ForEachReduceReduceRight(ArrayForEachHelper, ArrayReduceHelper,
+                         ArrayReduceRightHelper);
 
-(function ForEachReduceReduceRightGrowMidIteration() {
+function ForEachReduceReduceRightGrowMidIteration(
+    forEachHelper, reduceHelper, reduceRightHelper) {
   // Orig. array: [0, 2, 4, 6]
   //              [0, 2, 4, 6] << fixedLength
   //                    [4, 6] << fixedLengthWithOffset
@@ -2127,19 +2133,20 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
 
   function ForEachHelper(array) {
     values = [];
-    array.forEach(CollectValuesAndResize);
+    forEachHelper(array, CollectValuesAndResize);
     return values;
   }
 
   function ReduceHelper(array) {
     values = [];
-    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    reduceHelper(array, (acc, n) => { CollectValuesAndResize(n); },
+                 "initial value");
     return values;
   }
 
   function ReduceRightHelper(array) {
     values = [];
-    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+    reduceRightHelper(array, (acc, n) => { CollectValuesAndResize(n); },
                       "initial value");
     return values;
   }
@@ -2245,9 +2252,13 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
     growTo = 5 * ctor.BYTES_PER_ELEMENT;
     assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
   }
-})();
+}
+ForEachReduceReduceRightGrowMidIteration(TypedArrayForEachHelper,
+    TypedArrayReduceHelper, TypedArrayReduceRightHelper);
+ForEachReduceReduceRightGrowMidIteration(ArrayForEachHelper,
+    ArrayReduceHelper, ArrayReduceRightHelper);
 
-function TestIncludes(helper) {
+function Includes(helper) {
   for (let ctor of ctors) {
     const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                                  8 * ctor.BYTES_PER_ELEMENT);
@@ -2329,10 +2340,10 @@ function TestIncludes(helper) {
     assertTrue(helper(lengthTrackingWithOffset, 8));
   }
 }
-TestIncludes(IncludesHelper);
-TestIncludes(ArrayIncludesHelper);
+Includes(TypedArrayIncludesHelper);
+Includes(ArrayIncludesHelper);
 
-function TestIncludesParameterConversionGrows(helper) {
+function IncludesParameterConversionGrows(helper) {
   for (let ctor of ctors) {
     const gsab = CreateGrowableSharedArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                                  8 * ctor.BYTES_PER_ELEMENT);
@@ -2366,8 +2377,8 @@ function TestIncludesParameterConversionGrows(helper) {
     assertTrue(helper(lengthTracking, 1, evil));
   }
 }
-TestIncludesParameterConversionGrows(IncludesHelper);
-TestIncludesParameterConversionGrows(ArrayIncludesHelper);
+IncludesParameterConversionGrows(TypedArrayIncludesHelper);
+IncludesParameterConversionGrows(ArrayIncludesHelper);
 
 (function IncludesSpecialValues() {
   for (let ctor of floatCtors) {

test/mjsunit/typedarray-helpers.js

@@ -239,7 +239,7 @@ function ArrayFindLastIndexHelper(ta, p) {
   return Array.prototype.findLastIndex.call(ta, p);
 }
 
-function IncludesHelper(array, n, fromIndex) {
+function TypedArrayIncludesHelper(array, n, fromIndex) {
   if (typeof n == 'number' &&
       (array instanceof BigInt64Array || array instanceof BigUint64Array)) {
     return array.includes(BigInt(n), fromIndex);
@@ -461,3 +461,18 @@ const TypedArrayToLocaleStringHelper = (ta, ...rest) => {
     return ta.toLocaleString(...rest); }
 const ArrayToLocaleStringHelper = (ta, ...rest) => {
     return Array.prototype.toLocaleString.call(ta, ...rest); };
+
+const TypedArrayForEachHelper = (ta, ...rest) => {
+    return ta.forEach(...rest); }
+const ArrayForEachHelper = (ta, ...rest) => {
+    return Array.prototype.forEach.call(ta, ...rest); };
+
+const TypedArrayReduceHelper = (ta, ...rest) => {
+    return ta.reduce(...rest); }
+const ArrayReduceHelper = (ta, ...rest) => {
+    return Array.prototype.reduce.call(ta, ...rest); };
+
+const TypedArrayReduceRightHelper = (ta, ...rest) => {
+    return ta.reduceRight(...rest); }
+const ArrayReduceRightHelper = (ta, ...rest) => {
+    return Array.prototype.reduceRight.call(ta, ...rest); };

test/mjsunit/typedarray-resizablearraybuffer-array-methods.js

@@ -810,3 +810,312 @@ d8.file.execute('test/mjsunit/typedarray-helpers.js');
     assertEquals(0, rab.byteLength);
   }
 })();
+
+(function ArrayForEachReduceReduceRightShrinkMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let resizeAfter;
+  let resizeTo;
+  function CollectValuesAndResize(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == resizeAfter) {
+      rab.resize(resizeTo);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    ArrayForEachHelper(array, CollectValuesAndResize);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    ArrayReduceHelper(array,
+                 (acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    ArrayReduceRightHelper(array, (acc, n) => { CollectValuesAndResize(n); },
+                      "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduce.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([0, 2, 4], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([4], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduceRight.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 4], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 2;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    // Unaffected by the shrinking, since we've already iterated past the point.
+    assertEquals([6, 4, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    resizeAfter = 1;
+    resizeTo = 2 * ctor.BYTES_PER_ELEMENT;
+    assertEquals([6, 2, 0], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    resizeAfter = 1;
+    resizeTo = 3 * ctor.BYTES_PER_ELEMENT;
+    // Unaffected by the shrinking, since we've already iterated past the point.
+    assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();
+
+(function ArrayForEachReduceReduceRightDetachMidIteration() {
+  // Orig. array: [0, 2, 4, 6]
+  //              [0, 2, 4, 6] << fixedLength
+  //                    [4, 6] << fixedLengthWithOffset
+  //              [0, 2, 4, 6, ...] << lengthTracking
+  //                    [4, 6, ...] << lengthTrackingWithOffset
+  function CreateRabForTest(ctor) {
+    const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
+                                           8 * ctor.BYTES_PER_ELEMENT);
+    // Write some data into the array.
+    const taWrite = new ctor(rab);
+    for (let i = 0; i < 4; ++i) {
+      WriteToTypedArray(taWrite, i, 2 * i);
+    }
+    return rab;
+  }
+
+  let values;
+  let rab;
+  let detachAfter;
+  function CollectValuesAndDetach(n) {
+    if (typeof n == 'bigint') {
+      values.push(Number(n));
+    } else {
+      values.push(n);
+    }
+    if (values.length == detachAfter) {
+      %ArrayBufferDetach(rab);
+    }
+    return true;
+  }
+
+  function ForEachHelper(array) {
+    values = [];
+    ArrayForEachHelper(array, CollectValuesAndDetach);
+    return values;
+  }
+
+  function ReduceHelper(array) {
+    values = [];
+    ArrayReduceHelper(array, (acc, n) => { CollectValuesAndDetach(n); },
+                      "initial value");
+    return values;
+  }
+
+  function ReduceRightHelper(array) {
+    values = [];
+    ArrayReduceRightHelper(array, (acc, n) => { CollectValuesAndDetach(n); },
+                           "initial value");
+    return values;
+  }
+
+  // Test for forEach.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([0, 2], ForEachHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([4], ForEachHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+    assertEquals([0, 2], ForEachHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([4], ForEachHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduce.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([0, 2], ReduceHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([4], ReduceHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+    assertEquals([0, 2], ReduceHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([4], ReduceHelper(lengthTrackingWithOffset));
+  }
+
+  // Tests for reduceRight.
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLength = new ctor(rab, 0, 4);
+    detachAfter = 2;
+    assertEquals([6, 4], ReduceRightHelper(fixedLength));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const fixedLengthWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT, 2);
+    detachAfter = 1;
+    assertEquals([6], ReduceRightHelper(fixedLengthWithOffset));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTracking = new ctor(rab, 0);
+    detachAfter = 2;
+   assertEquals([6, 4], ReduceRightHelper(lengthTracking));
+  }
+
+  for (let ctor of ctors) {
+    rab = CreateRabForTest(ctor);
+    const lengthTrackingWithOffset = new ctor(rab, 2 * ctor.BYTES_PER_ELEMENT);
+    detachAfter = 1;
+    assertEquals([6], ReduceRightHelper(lengthTrackingWithOffset));
+  }
+})();

test/mjsunit/typedarray-resizablearraybuffer-detach.js

@@ -879,7 +879,7 @@ FindLastIndexDetachMidIteration(ArrayFindLastIndexHelper);
   }
 })();
 
-(function IncludesParameterConversionDetaches() {
+function IncludesParameterConversionDetaches(includesHelper) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
@@ -889,9 +889,9 @@ FindLastIndexDetachMidIteration(ArrayFindLastIndexHelper);
       %ArrayBufferDetach(rab);
       return 0;
     }};
-    assertFalse(IncludesHelper(fixedLength, undefined));
+    assertFalse(includesHelper(fixedLength, undefined));
     // The TA is detached so it includes only "undefined".
-    assertTrue(IncludesHelper(fixedLength, undefined, evil));
+    assertTrue(includesHelper(fixedLength, undefined, evil));
   }
 
   for (let ctor of ctors) {
@@ -903,11 +903,13 @@ FindLastIndexDetachMidIteration(ArrayFindLastIndexHelper);
       %ArrayBufferDetach(rab);
       return 0;
     }};
-    assertTrue(IncludesHelper(fixedLength, 0));
+    assertTrue(includesHelper(fixedLength, 0));
     // The TA is detached so it includes only "undefined".
-    assertFalse(IncludesHelper(fixedLength, 0, evil));
+    assertFalse(includesHelper(fixedLength, 0, evil));
   }
-})();
+}
+IncludesParameterConversionDetaches(TypedArrayIncludesHelper);
+IncludesParameterConversionDetaches(ArrayIncludesHelper);
 
 function IndexOfParameterConversionDetaches(indexOfHelper) {
   for (let ctor of ctors) {

test/mjsunit/typedarray-resizablearraybuffer.js

@@ -3877,7 +3877,8 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
   }
 })();
 
-(function ForEachReduceReduceRight() {
+function ForEachReduceReduceRight(
+    forEachHelper, reduceHelper, reduceRightHelper, oobThrows) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
@@ -3903,13 +3904,13 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
       const reduceValues = [];
       const reduceRightValues = [];
 
-      array.forEach((n) => { forEachValues.push(n);});
+      forEachHelper(array, (n) => { forEachValues.push(n);});
 
-      array.reduce((acc, n) => {
+      reduceHelper(array, (acc, n) => {
         reduceValues.push(n);
       }, "initial value");
 
-      array.reduceRight((acc, n) => {
+      reduceRightHelper(array, (acc, n) => {
         reduceRightValues.push(n);
       }, "initial value");
 
@@ -3931,28 +3932,41 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
     //              [0, 2, 4, ...] << lengthTracking
     //                    [4, ...] << lengthTrackingWithOffset
 
-    assertThrows(() => { Helper(fixedLength); });
-    assertThrows(() => { Helper(fixedLengthWithOffset); });
-
+    if (oobThrows) {
+      assertThrows(() => { Helper(fixedLength); });
+      assertThrows(() => { Helper(fixedLengthWithOffset); });
+    } else {
+      assertEquals([], Helper(fixedLength));
+      assertEquals([], Helper(fixedLengthWithOffset));
+    }
     assertEquals([0, 2, 4], Helper(lengthTracking));
     assertEquals([4], Helper(lengthTrackingWithOffset));
 
     // Shrink so that the TAs with offset go out of bounds.
     rab.resize(1 * ctor.BYTES_PER_ELEMENT);
 
-    assertThrows(() => { Helper(fixedLength); });
-    assertThrows(() => { Helper(fixedLengthWithOffset); });
-    assertThrows(() => { Helper(lengthTrackingWithOffset); });
-
+    if (oobThrows) {
+      assertThrows(() => { Helper(fixedLength); });
+      assertThrows(() => { Helper(fixedLengthWithOffset); });
+      assertThrows(() => { Helper(lengthTrackingWithOffset); });
+    } else {
+      assertEquals([], Helper(fixedLength));
+      assertEquals([], Helper(fixedLengthWithOffset));
+    }
     assertEquals([0], Helper(lengthTracking));
 
     // Shrink to zero.
     rab.resize(0);
 
-    assertThrows(() => { Helper(fixedLength); });
-    assertThrows(() => { Helper(fixedLengthWithOffset); });
-    assertThrows(() => { Helper(lengthTrackingWithOffset); });
-
+    if (oobThrows) {
+      assertThrows(() => { Helper(fixedLength); });
+      assertThrows(() => { Helper(fixedLengthWithOffset); });
+      assertThrows(() => { Helper(lengthTrackingWithOffset); });
+    } else {
+      assertEquals([], Helper(fixedLength));
+      assertEquals([], Helper(fixedLengthWithOffset));
+      assertEquals([], Helper(lengthTrackingWithOffset));
+    }
     assertEquals([], Helper(lengthTracking));
 
     // Grow so that all TAs are back in-bounds.
@@ -3972,8 +3986,14 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
     assertEquals([0, 2, 4, 6, 8, 10], Helper(lengthTracking));
     assertEquals([4, 6, 8, 10], Helper(lengthTrackingWithOffset));
   }
-})();
+}
+ForEachReduceReduceRight(TypedArrayForEachHelper, TypedArrayReduceHelper,
+                         TypedArrayReduceRightHelper, true);
+ForEachReduceReduceRight(ArrayForEachHelper, ArrayReduceHelper,
+                         ArrayReduceRightHelper, false);
 
+// The corresponding tests for Array.prototype.forEach etc are in
+// typedarray-resizablearraybuffer-array-methods.js.
 (function ForEachReduceReduceRightShrinkMidIteration() {
   // Orig. array: [0, 2, 4, 6]
   //              [0, 2, 4, 6] << fixedLength
@@ -4139,7 +4159,8 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
   }
 })();
 
-(function ForEachReduceReduceRightGrowMidIteration() {
+function ForEachReduceReduceRightGrowMidIteration(
+    forEachHelper, reduceHelper, reduceRightHelper) {
   // Orig. array: [0, 2, 4, 6]
   //              [0, 2, 4, 6] << fixedLength
   //                    [4, 6] << fixedLengthWithOffset
@@ -4174,19 +4195,20 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
 
   function ForEachHelper(array) {
     values = [];
-    array.forEach(CollectValuesAndResize);
+    forEachHelper(array, CollectValuesAndResize);
     return values;
   }
 
   function ReduceHelper(array) {
     values = [];
-    array.reduce((acc, n) => { CollectValuesAndResize(n); }, "initial value");
+    reduceHelper(array, (acc, n) => { CollectValuesAndResize(n); },
+                 "initial value");
     return values;
   }
 
   function ReduceRightHelper(array) {
     values = [];
-    array.reduceRight((acc, n) => { CollectValuesAndResize(n); },
+    reduceRightHelper(array, (acc, n) => { CollectValuesAndResize(n); },
                       "initial value");
     return values;
   }
@@ -4292,9 +4314,14 @@ FindLastIndexGrowMidIteration(ArrayFindLastIndexHelper);
     resizeTo = 5 * ctor.BYTES_PER_ELEMENT;
     assertEquals([6, 4], ReduceRightHelper(lengthTrackingWithOffset));
   }
-})();
+}
+ForEachReduceReduceRightGrowMidIteration(
+  TypedArrayForEachHelper, TypedArrayReduceHelper,
+  TypedArrayReduceRightHelper);
+ForEachReduceReduceRightGrowMidIteration(
+  ArrayForEachHelper, ArrayReduceHelper, ArrayReduceRightHelper);
 
-function TestIncludes(helper, oobThrows) {
+function Includes(helper, oobThrows) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
@@ -4427,10 +4454,10 @@ function TestIncludes(helper, oobThrows) {
     assertTrue(helper(lengthTrackingWithOffset, 8));
   }
 }
-TestIncludes(IncludesHelper, true);
-TestIncludes(ArrayIncludesHelper, false);
+Includes(TypedArrayIncludesHelper, true);
+Includes(ArrayIncludesHelper, false);
 
-function TestIncludesParameterConversionResizes(helper) {
+function IncludesParameterConversionResizes(helper) {
   for (let ctor of ctors) {
     const rab = CreateResizableArrayBuffer(4 * ctor.BYTES_PER_ELEMENT,
                                            8 * ctor.BYTES_PER_ELEMENT);
@@ -4506,8 +4533,8 @@ function TestIncludesParameterConversionResizes(helper) {
     assertTrue(helper(lengthTracking, 1, evil));
   }
 }
-TestIncludesParameterConversionResizes(IncludesHelper);
-TestIncludesParameterConversionResizes(ArrayIncludesHelper);
+IncludesParameterConversionResizes(TypedArrayIncludesHelper);
+IncludesParameterConversionResizes(ArrayIncludesHelper);
 
 (function IncludesSpecialValues() {
   for (let ctor of floatCtors) {