[immutable-arraybuffer] Include immutable ArrayBuffers in TypedArray testing (#4545)

Author: gibson042

harness/testTypedArray.js

@@ -102,7 +102,7 @@ function makeArrayBuffer(TA, primitiveOrIterable) {
   return new TA(arr).buffer;
 }
 
-var makeResizableArrayBuffer, makeGrownArrayBuffer, makeShrunkArrayBuffer;
+var makeResizableArrayBuffer, makeGrownArrayBuffer, makeShrunkArrayBuffer, makeImmutableArrayBuffer;
 if (ArrayBuffer.prototype.resize) {
   var copyIntoArrayBuffer = function(destBuffer, srcBuffer) {
     var destView = new Uint8Array(destBuffer);
@@ -152,16 +152,28 @@ if (ArrayBuffer.prototype.resize) {
     return shrunk;
   };
 }
+if (ArrayBuffer.prototype.transferToImmutable) {
+  makeImmutableArrayBuffer = function makeImmutableArrayBuffer(TA, primitiveOrIterable) {
+    if (isPrimitive(primitiveOrIterable)) {
+      var n = Number(primitiveOrIterable) * TA.BYTES_PER_ELEMENT;
+      if (!(n >= 0 && n < 9007199254740992)) return primitiveOrIterable;
+      return (new ArrayBuffer(n)).transferToImmutable();
+    }
+    var mutable = makeArrayBuffer(TA, primitiveOrIterable);
+    return mutable.transferToImmutable();
+  };
+}
 
 var typedArrayCtorArgFactories = [makePassthrough, makeArray, makeArrayLike];
 if (makeIterable) typedArrayCtorArgFactories.push(makeIterable);
 typedArrayCtorArgFactories.push(makeArrayBuffer);
 if (makeResizableArrayBuffer) typedArrayCtorArgFactories.push(makeResizableArrayBuffer);
 if (makeGrownArrayBuffer) typedArrayCtorArgFactories.push(makeGrownArrayBuffer);
 if (makeShrunkArrayBuffer) typedArrayCtorArgFactories.push(makeShrunkArrayBuffer);
+if (makeImmutableArrayBuffer) typedArrayCtorArgFactories.push(makeImmutableArrayBuffer);
 
 /**
- * @typedef {"passthrough" | "arraylike" | "iterable" | "arraybuffer" | "resizable"} typedArrayArgFactoryFeature
+ * @typedef {"passthrough" | "arraylike" | "iterable" | "arraybuffer" | "resizable" | "immutable"} typedArrayArgFactoryFeature
  */
 
 /**
@@ -189,7 +201,8 @@ function ctorArgFactoryMatchesSome(argFactory, features) {
           argFactory === makeArrayBuffer ||
           argFactory === makeResizableArrayBuffer ||
           argFactory === makeGrownArrayBuffer ||
-          argFactory === makeShrunkArrayBuffer
+          argFactory === makeShrunkArrayBuffer ||
+          argFactory === makeImmutableArrayBuffer
         ) {
           return true;
         }
@@ -203,6 +216,9 @@ function ctorArgFactoryMatchesSome(argFactory, features) {
           return true;
         }
         break;
+      case "immutable":
+        if (argFactory === makeImmutableArrayBuffer) return true;
+        break;
       default:
         throw Test262Error("unknown feature: " + features[i]);
     }
@@ -317,26 +333,46 @@ var nonAtomicsFriendlyTypedArrayConstructors = floatArrayConstructors.concat([Ui
  *
  * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor.
  * @param {Array} selected - An optional Array with filtered typed arrays
+ * @param {typedArrayArgFactoryFeature[]} [includeArgFactories] - for selecting
+ *   initial constructor argument factory functions, rather than starting with
+ *   all argument factories
+ * @param {typedArrayArgFactoryFeature[]} [excludeArgFactories] - for excluding
+ *   constructor argument factory functions, after an initial selection
  */
-function testWithNonAtomicsFriendlyTypedArrayConstructors(f) {
-  testWithTypedArrayConstructors(f, nonAtomicsFriendlyTypedArrayConstructors);
+function testWithNonAtomicsFriendlyTypedArrayConstructors(f, includeArgFactories, excludeArgFactories) {
+  testWithAllTypedArrayConstructors(
+    f,
+    nonAtomicsFriendlyTypedArrayConstructors,
+    includeArgFactories,
+    excludeArgFactories
+  );
 }
 
 /**
  * Calls the provided function for every "Atomics Friendly" typed array constructor.
  *
  * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor.
  * @param {Array} selected - An optional Array with filtered typed arrays
+ * @param {typedArrayArgFactoryFeature[]} [includeArgFactories] - for selecting
+ *   initial constructor argument factory functions, rather than starting with
+ *   all argument factories
+ * @param {typedArrayArgFactoryFeature[]} [excludeArgFactories] - for excluding
+ *   constructor argument factory functions, after an initial selection
  */
-function testWithAtomicsFriendlyTypedArrayConstructors(f) {
-  testWithTypedArrayConstructors(f, [
-    Int32Array,
-    Int16Array,
-    Int8Array,
-    Uint32Array,
-    Uint16Array,
-    Uint8Array,
-  ]);
+function testWithAtomicsFriendlyTypedArrayConstructors(f, includeArgFactories, excludeArgFactories) {
+  testWithAllTypedArrayConstructors(
+    f,
+    [
+      Int32Array,
+      Int16Array,
+      Int8Array,
+      Uint32Array,
+      Uint16Array,
+      Uint8Array,
+    ],
+    includeArgFactories,
+    excludeArgFactories
+  );
 }
 
 /**
@@ -363,7 +399,7 @@ function testTypedArrayConversions(byteConversionValues, fn) {
       }
       fn(TA, value, exp, initial);
     });
-  });
+  }, null, ["passthrough"]);
 }
 
 /**

test/built-ins/ArrayBuffer/isView/arg-is-typedarray-buffer.js

@@ -15,8 +15,8 @@ features: [TypedArray]
 includes: [testTypedArray.js]
 ---*/
 
-testWithTypedArrayConstructors(function(ctor) {
-  var sample = new ctor().buffer;
+testWithAllTypedArrayConstructors(function(ctor, makeCtorArg) {
+  var sample = new ctor(makeCtorArg(0)).buffer;
 
   assert.sameValue(ArrayBuffer.isView(sample), false);
-}, null, ["passthrough"]);
+});

test/built-ins/ArrayBuffer/isView/arg-is-typedarray-constructor.js

@@ -15,6 +15,6 @@ features: [TypedArray]
 includes: [testTypedArray.js]
 ---*/
 
-testWithTypedArrayConstructors(function(ctor) {
+testWithAllTypedArrayConstructors(function(ctor) {
   assert.sameValue(ArrayBuffer.isView(ctor), false);
 }, null, ["passthrough"]);

test/built-ins/ArrayBuffer/isView/arg-is-typedarray-subclass-instance.js

@@ -15,10 +15,10 @@ features: [class, TypedArray]
 includes: [testTypedArray.js]
 ---*/
 
-testWithTypedArrayConstructors(function(ctor) {
+testWithAllTypedArrayConstructors(function(ctor, makeCtorArg) {
   class TA extends ctor {}
 
-  var sample = new TA();
+  var sample = new TA(makeCtorArg(0));
 
   assert(ArrayBuffer.isView(sample));
-}, null, ["passthrough"]);
+});

test/built-ins/ArrayBuffer/isView/arg-is-typedarray.js

@@ -15,8 +15,8 @@ features: [TypedArray]
 includes: [testTypedArray.js]
 ---*/
 
-testWithTypedArrayConstructors(function(ctor) {
-  var sample = new ctor();
+testWithAllTypedArrayConstructors(function(ctor, makeCtorArg) {
+  var sample = new ctor(makeCtorArg(0));
 
   assert.sameValue(ArrayBuffer.isView(sample), true);
-}, null, ["passthrough"]);
+});

test/built-ins/ArrayBuffer/isView/invoked-as-a-fn.js

@@ -17,10 +17,10 @@ includes: [testTypedArray.js]
 
 var isView = ArrayBuffer.isView;
 
-testWithTypedArrayConstructors(function(ctor) {
-  var sample = new ctor();
+testWithAllTypedArrayConstructors(function(ctor, makeCtorArg) {
+  var sample = new ctor(makeCtorArg(0));
   assert.sameValue(isView(sample), true, "instance of TypedArray");
-}, null, ["passthrough"]);
+});
 
 var dv = new DataView(new ArrayBuffer(1), 0, 0);
 assert.sameValue(isView(dv), true, "instance of DataView");

test/built-ins/ArrayIteratorPrototype/next/detach-typedarray-in-progress.js

@@ -13,8 +13,8 @@ includes: [testTypedArray.js, detachArrayBuffer.js]
 features: [TypedArray]
 ---*/
 
-testWithTypedArrayConstructors(TA => {
-  var typedArray = new TA(5);
+testWithAllTypedArrayConstructors((TA, makeCtorArg) => {
+  var typedArray = new TA(makeCtorArg(5));
   var i = 0;
   assert.throws(TypeError, () => {
     for (let key of typedArray.keys()) {
@@ -23,4 +23,4 @@ testWithTypedArrayConstructors(TA => {
     }
   });
   assert.sameValue(i, 1);
-}, null, ["passthrough"]);
+}, null, null, ["immutable"]);

test/built-ins/Atomics/add/bad-range.js

@@ -19,4 +19,4 @@ testWithTypedArrayConstructors(function(TA) {
       Atomics.add(view, IdxGen(view), 10);
     });
   });
-}, views);
+}, views, ["passthrough"]);

test/built-ins/Atomics/add/bigint/non-shared-bufferdata.js

@@ -7,9 +7,9 @@ description: >
 includes: [testTypedArray.js]
 features: [ArrayBuffer, Atomics, BigInt, TypedArray]
 ---*/
-testWithBigIntTypedArrayConstructors(TA => {
-  const buffer = new ArrayBuffer(TA.BYTES_PER_ELEMENT * 4);
+testWithBigIntTypedArrayConstructors((TA, makeCtorArg) => {
+  const buffer = makeCtorArg(4);
   const view = new TA(buffer);
   assert.sameValue(Atomics.add(view, 0, 1n), 0n, 'Atomics.add(view, 0, 1n) returns 0n');
   assert.sameValue(Atomics.load(view, 0), 1n, 'Atomics.load(view, 0) returns 1n');
-}, null, ["passthrough"]);
+}, null, ["arraybuffer"], ["immutable"]);

test/built-ins/Atomics/add/good-views.js

@@ -51,4 +51,4 @@ testWithTypedArrayConstructors(function(TA) {
     Atomics.store(view, Idx, 37);
     assert.sameValue(Atomics.add(view, Idx, 0), 37, 'Atomics.add(view, Idx, 0) returns 37');
   });
-}, views);
+}, views, ["passthrough"]);