test: cover immutable ArrayBuffer known issues

Cover native writes, immutable source copies, and view serialization
across the affected API families. Exercise the Node-API detach abort
using the existing typed-array addon and mark it as an expected failure.

Signed-off-by: Filip Skokan <panva.ip@gmail.com>
Assisted-by: Codex

Author: panva

test/js-native-api/js-native-api.status

@@ -0,0 +1,5 @@
+prefix js-native-api
+
+[true]
+# napi_detach_arraybuffer() aborts when given an immutable ArrayBuffer.
+test_typedarray/test-immutable-arraybuffer: FAIL

test/js-native-api/test_typedarray/test-immutable-arraybuffer.js

@@ -0,0 +1,28 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+const common = require('../../common');
+const assert = require('node:assert');
+
+if (process.argv[2] === 'child') {
+  const binding = require(`./build/${common.buildType}/test_typedarray`);
+  const mutable = Uint8Array.from([65, 66, 67, 68]);
+  binding.Detach(mutable);
+  assert.strictEqual(binding.IsDetached(mutable.buffer), true);
+
+  const buffer = Uint8Array.from([65, 66, 67, 68]).buffer.transferToImmutable();
+  const view = new Uint8Array(buffer);
+
+  // napi_detach_arraybuffer() must return an error or propagate an exception
+  // when detaching an immutable ArrayBuffer, without aborting the process.
+  assert.throws(() => binding.Detach(view), Error);
+  assert.strictEqual(binding.IsDetached(buffer), false);
+  assert.strictEqual(buffer.immutable, true);
+  assert.deepStrictEqual([...view], [65, 66, 67, 68]);
+} else {
+  const { spawnSyncAndExitWithoutError } = require('../../common/child_process');
+  const [command, options] = common.escapePOSIXShell`"${process.execPath}" --js-immutable-arraybuffer "${__filename}" child`;
+  // Avoid core files while this known issue still aborts the child.
+  const childCommand = common.isWindows ? command : `ulimit -c 0 && exec ${command}`;
+  spawnSyncAndExitWithoutError(childCommand, { ...options, shell: true });
+}

test/known_issues/test-immutable-arraybuffer-buffer.js

@@ -0,0 +1,79 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { test } = require('node:test');
+
+// Native Buffer mutators must preserve immutable backing storage, whether they
+// reject the operation or return without modifying the bytes.
+function checkImmutable(mutate) {
+  const expected = Array.from({ length: 64 }, (_, i) => i);
+  const ab = Uint8Array.from(expected).buffer.transferToImmutable();
+  const buffer = Buffer.from(ab);
+
+  try {
+    mutate(buffer);
+  } catch (err) {
+    if (!(err instanceof TypeError)) throw err;
+  }
+
+  assert.deepStrictEqual(Array.from(new Uint8Array(ab)), expected);
+}
+
+const encodings = [
+  ['utf8', 'hello'],
+  ['utf-8', 'hello'],
+  ['ascii', 'hello'],
+  ['latin1', 'hello'],
+  ['binary', 'hello'],
+  ['hex', '68656c6c6f'],
+  ['base64', 'aGVsbG8='],
+  ['base64url', 'aGVsbG8'],
+  ['ucs2', 'hello'],
+  ['ucs-2', 'hello'],
+  ['utf16le', 'hello'],
+  ['utf-16le', 'hello'],
+];
+
+for (const [encoding, value] of encodings) {
+  test(`Buffer.write with ${encoding} preserves immutable bytes`, () => {
+    checkImmutable((buffer) => buffer.write(value, encoding));
+  });
+}
+
+const writers = [
+  ['utf8Write', 'hello'],
+  ['asciiWrite', 'hello'],
+  ['latin1Write', 'hello'],
+  ['hexWrite', '68656c6c6f'],
+  ['base64Write', 'aGVsbG8='],
+  ['base64urlWrite', 'aGVsbG8'],
+  ['ucs2Write', 'hello'],
+];
+
+for (const [method, value] of writers) {
+  test(`Buffer.${method} preserves immutable bytes`, () => {
+    checkImmutable((buffer) => buffer[method](value, 0, buffer.length));
+  });
+}
+
+const fills = [
+  ['string', 'AB'],
+  ['non-ASCII character', 'é'],
+  ['Buffer', Buffer.from([0xfe, 0xff])],
+  ['coerced value', true],
+];
+
+for (const [name, value] of fills) {
+  test(`Buffer.fill with ${name} preserves immutable bytes`, () => {
+    checkImmutable((buffer) => buffer.fill(value));
+  });
+}
+
+for (const method of ['swap16', 'swap32', 'swap64']) {
+  test(`Buffer.${method} preserves immutable bytes`, () => {
+    // A 64-byte buffer reaches the native path for all three swap methods.
+    checkImmutable((buffer) => buffer[method]());
+  });
+}

test/known_issues/test-immutable-arraybuffer-copy.js

@@ -0,0 +1,100 @@
+// Flags: --js-immutable-arraybuffer --experimental-stream-iter
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { test } = require('node:test');
+const { Readable } = require('node:stream');
+const iter = require('node:stream/iter');
+const { serialize, deserialize } = require('node:v8');
+
+// V8 currently checks the source of TypedArray.prototype.set() for write
+// access. Copying immutable bytes into a mutable destination must be allowed.
+function immutable(bytes = [65, 66, 67, 68]) {
+  return new Uint8Array(Uint8Array.from(bytes).buffer.transferToImmutable());
+}
+
+for (const [name, copy] of [
+  ['Buffer.from', (view) => Buffer.from(view)],
+  ['Buffer.copyBytesFrom', (view) => Buffer.copyBytesFrom(view)],
+  ['Buffer.concat', (view) => Buffer.concat([view])],
+  ['Buffer.concat with length', (view) => Buffer.concat([view], view.length)],
+]) {
+  test(name, () => {
+    const source = immutable();
+    assert.deepStrictEqual([...copy(source)], [...source]);
+  });
+}
+
+test('TextDecoder single-byte non-ASCII input', () => {
+  assert.strictEqual(new TextDecoder('windows-1252').decode(immutable([0xe9])), '\u00e9');
+});
+
+test('TextDecoder split UTF-8 sequence', () => {
+  const decoder = new TextDecoder();
+  assert.strictEqual(decoder.decode(immutable([0xc3]), { stream: true }), '');
+  assert.strictEqual(decoder.decode(immutable([0xa9])), '\u00e9');
+});
+
+test('TextDecoderStream split UTF-8 sequence', async () => {
+  const source = new ReadableStream({
+    start(controller) {
+      controller.enqueue(immutable([0xc3]));
+      controller.enqueue(immutable([0xa9]));
+      controller.close();
+    },
+  });
+  let result = '';
+  for await (const chunk of source.pipeThrough(new TextDecoderStream())) {
+    result += chunk;
+  }
+  assert.strictEqual(result, '\u00e9');
+});
+
+test('Readable.read spanning chunks', (t) => {
+  const stream = new Readable({ read() {} });
+  t.after(() => stream.destroy());
+  stream.push(Buffer.from(immutable().buffer));
+  stream.push(Buffer.from(immutable().buffer));
+  stream.push(null);
+  assert.deepStrictEqual([...stream.read(6)], [65, 66, 67, 68, 65, 66]);
+});
+
+for (const name of ['bytes', 'bytesSync', 'arrayBuffer', 'arrayBufferSync', 'text', 'textSync']) {
+  test(`stream/iter.${name}`, async () => {
+    // A partial view cannot use the full-buffer fast path.
+    const result = await iter[name](immutable().subarray(1));
+    if (typeof result === 'string') {
+      assert.strictEqual(result, 'BCD');
+    } else {
+      assert.deepStrictEqual([...new Uint8Array(result)], [66, 67, 68]);
+    }
+  });
+}
+
+for (const [name, consume] of [
+  ['Response', (view) => new Response(view).text()],
+  ['Request', (view) => new Request('http://localhost/', {
+    method: 'POST', body: view,
+  }).text()],
+]) {
+  test(`${name} body`, async () => {
+    assert.strictEqual(await consume(immutable()), 'ABCD');
+  });
+}
+
+test('Response consumes immutable stream chunks', async () => {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(immutable());
+      controller.close();
+    },
+  });
+  assert.strictEqual(await new Response(stream).text(), 'ABCD');
+});
+
+test('v8.deserialize copies an unaligned payload from immutable storage', () => {
+  const wire = serialize(new Uint32Array([1, 2]));
+  const source = wire.buffer.sliceToImmutable(wire.byteOffset, wire.byteOffset + wire.length);
+  assert.deepStrictEqual([...deserialize(new Uint8Array(source))], [1, 2]);
+});

test/known_issues/test-immutable-arraybuffer-crypto.js

@@ -0,0 +1,52 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+const common = require('../common');
+
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const { test } = require('node:test');
+
+const cases = [
+  ['randomFillSync with an ArrayBuffer', (buffer) => {
+    crypto.randomFillSync(buffer);
+  }],
+  ['randomFill with a DataView', (buffer) => {
+    return new Promise((resolve, reject) => {
+      crypto.randomFill(new DataView(buffer), (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve();
+      });
+    });
+  }],
+  ['getRandomValues with a Uint8Array', (buffer) => {
+    crypto.getRandomValues(new Uint8Array(buffer));
+  }],
+  ['global crypto.getRandomValues with a Buffer', (buffer) => {
+    globalThis.crypto.getRandomValues(Buffer.from(buffer));
+  }],
+];
+
+for (const [name, fill] of cases) {
+  test(name, async () => {
+    const buffer = new ArrayBuffer(32).transferToImmutable();
+    const bytes = new Uint8Array(buffer);
+    const original = Array.from(bytes);
+
+    try {
+      await fill(buffer);
+    } catch (err) {
+      if (!(err instanceof TypeError))
+        throw err;
+    }
+
+    assert.strictEqual(buffer.immutable, true);
+    assert.deepStrictEqual(Array.from(bytes), original);
+  });
+}

test/known_issues/test-immutable-arraybuffer-encoding.js

@@ -0,0 +1,24 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { test } = require('node:test');
+
+for (const [name, input] of [['short', 'hello'], ['long', 'hello'.repeat(16)]]) {
+  test(`TextEncoder.encodeInto with ${name} input preserves immutable bytes`, () => {
+    const expected = Array(128).fill(0xaa);
+    const ab = Uint8Array.from(expected).buffer.transferToImmutable();
+    const destination = new Uint8Array(ab);
+
+    // The short and long inputs exercise different native encoding paths.
+    // Do not require a particular rejection behavior, only unchanged bytes.
+    try {
+      new TextEncoder().encodeInto(input, destination);
+    } catch (err) {
+      if (!(err instanceof TypeError)) throw err;
+    }
+
+    assert.deepStrictEqual(Array.from(new Uint8Array(ab)), expected);
+  });
+}