From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 02:47:55 +0200
Subject: Adding upstream version 124.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../tests/encoding/streams/realms.window.js        | 304 +++++++++++++++++++++
 1 file changed, 304 insertions(+)
 create mode 100644 testing/web-platform/tests/encoding/streams/realms.window.js

(limited to 'testing/web-platform/tests/encoding/streams/realms.window.js')
diff --git a/testing/web-platform/tests/encoding/streams/realms.window.js b/testing/web-platform/tests/encoding/streams/realms.window.js
new file mode 100644
index 0000000000..ca9ce21abc
--- /dev/null
+++ b/testing/web-platform/tests/encoding/streams/realms.window.js
@@ -0,0 +1,304 @@
+'use strict';
+
+// Test that objects created by the TextEncoderStream and TextDecoderStream APIs
+// are created in the correct realm. The tests work by creating an iframe for
+// each realm and then posting Javascript to them to be evaluated. Inputs and
+// outputs are passed around via global variables in each realm's scope.
+
+// Async setup is required before creating any tests, so require done() to be
+// called.
+setup({explicit_done: true});
+
+function createRealm() {
+  let iframe = document.createElement('iframe');
+  const scriptEndTag = '<' + '/script>';
+  iframe.srcdoc = `<!doctype html>
+<script>
+onmessage = event => {
+  if (event.source !== window.parent) {
+    throw new Error('unexpected message with source ' + event.source);
+  }
+  eval(event.data);
+};
+${scriptEndTag}`;
+  iframe.style.display = 'none';
+  document.body.appendChild(iframe);
+  let realmPromiseResolve;
+  const realmPromise = new Promise(resolve => {
+    realmPromiseResolve = resolve;
+  });
+  iframe.onload = () => {
+    realmPromiseResolve(iframe.contentWindow);
+  };
+  return realmPromise;
+}
+
+async function createRealms() {
+  // All realms are visible on the global object so they can access each other.
+
+  // The realm that the constructor function comes from.
+  window.constructorRealm = await createRealm();
+
+  // The realm in which the constructor object is called.
+  window.constructedRealm = await createRealm();
+
+  // The realm in which reading happens.
+  window.readRealm = await createRealm();
+
+  // The realm in which writing happens.
+  window.writeRealm = await createRealm();
+
+  // The realm that provides the definitions of Readable and Writable methods.
+  window.methodRealm = await createRealm();
+
+  await evalInRealmAndWait(methodRealm, `
+  window.ReadableStreamDefaultReader =
+      new ReadableStream().getReader().constructor;
+  window.WritableStreamDefaultWriter =
+      new WritableStream().getWriter().constructor;
+`);
+  window.readMethod = methodRealm.ReadableStreamDefaultReader.prototype.read;
+  window.writeMethod = methodRealm.WritableStreamDefaultWriter.prototype.write;
+}
+
+// In order for values to be visible between realms, they need to be
+// global. To prevent interference between tests, variable names are generated
+// automatically.
+const id = (() => {
+  let nextId = 0;
+  return () => {
+    return `realmsId${nextId++}`;
+  };
+})();
+
+// Eval string "code" in the content of realm "realm". Evaluation happens
+// asynchronously, meaning it hasn't happened when the function returns.
+function evalInRealm(realm, code) {
+  realm.postMessage(code, window.origin);
+}
+
+// Same as evalInRealm() but returns a Promise which will resolve when the
+// function has actually.
+async function evalInRealmAndWait(realm, code) {
+  const resolve = id();
+  const waitOn = new Promise(r => {
+    realm[resolve] = r;
+  });
+  evalInRealm(realm, code);
+  evalInRealm(realm, `${resolve}();`);
+  await waitOn;
+}
+
+// The same as evalInRealmAndWait but returns the result of evaluating "code" as
+// an expression.
+async function evalInRealmAndReturn(realm, code) {
+  const myId = id();
+  await evalInRealmAndWait(realm, `window.${myId} = ${code};`);
+  return realm[myId];
+}
+
+// Constructs an object in constructedRealm and copies it into readRealm and
+// writeRealm. Returns the id that can be used to access the object in those
+// realms. |what| can contain constructor arguments.
+async function constructAndStore(what) {
+  const objId = id();
+  // Call |constructorRealm|'s constructor from inside |constructedRealm|.
+  writeRealm[objId] = await evalInRealmAndReturn(
+      constructedRealm, `new parent.constructorRealm.${what}`);
+  readRealm[objId] = writeRealm[objId];
+  return objId;
+}
+
+// Calls read() on the readable side of the TransformStream stored in
+// readRealm[objId]. Locks the readable side as a side-effect.
+function readInReadRealm(objId) {
+  return evalInRealmAndReturn(readRealm, `
+parent.readMethod.call(window.${objId}.readable.getReader())`);
+}
+
+// Calls write() on the writable side of the TransformStream stored in
+// writeRealm[objId], passing |value|. Locks the writable side as a
+// side-effect.
+function writeInWriteRealm(objId, value) {
+  const valueId = id();
+  writeRealm[valueId] = value;
+  return evalInRealmAndReturn(writeRealm, `
+parent.writeMethod.call(window.${objId}.writable.getWriter(),
+                        window.${valueId})`);
+}
+
+window.onload = () => {
+  createRealms().then(() => {
+    runGenericTests('TextEncoderStream');
+    runTextEncoderStreamTests();
+    runGenericTests('TextDecoderStream');
+    runTextDecoderStreamTests();
+    done();
+  });
+};
+
+function runGenericTests(classname) {
+  promise_test(async () => {
+    const obj = await evalInRealmAndReturn(
+        constructedRealm, `new parent.constructorRealm.${classname}()`);
+    assert_equals(obj.constructor, constructorRealm[classname],
+                  'obj should be in constructor realm');
+  }, `a ${classname} object should be associated with the realm the ` +
+     'constructor came from');
+
+  promise_test(async () => {
+    const objId = await constructAndStore(classname);
+    const readableGetterId = id();
+    readRealm[readableGetterId] = Object.getOwnPropertyDescriptor(
+        methodRealm[classname].prototype, 'readable').get;
+    const writableGetterId = id();
+    writeRealm[writableGetterId] = Object.getOwnPropertyDescriptor(
+        methodRealm[classname].prototype, 'writable').get;
+    const readable = await evalInRealmAndReturn(
+        readRealm, `${readableGetterId}.call(${objId})`);
+    const writable = await evalInRealmAndReturn(
+        writeRealm, `${writableGetterId}.call(${objId})`);
+    assert_equals(readable.constructor, constructorRealm.ReadableStream,
+                  'readable should be in constructor realm');
+    assert_equals(writable.constructor, constructorRealm.WritableStream,
+                  'writable should be in constructor realm');
+  }, `${classname}'s readable and writable attributes should come from the ` +
+     'same realm as the constructor definition');
+}
+
+function runTextEncoderStreamTests() {
+  promise_test(async () => {
+    const objId = await constructAndStore('TextEncoderStream');
+    const writePromise = writeInWriteRealm(objId, 'A');
+    const result = await readInReadRealm(objId);
+    await writePromise;
+    assert_equals(result.constructor, constructorRealm.Object,
+                  'result should be in constructor realm');
+    assert_equals(result.value.constructor, constructorRealm.Uint8Array,
+                  'chunk should be in constructor realm');
+  }, 'the output chunks when read is called after write should come from the ' +
+     'same realm as the constructor of TextEncoderStream');
+
+  promise_test(async () => {
+    const objId = await constructAndStore('TextEncoderStream');
+    const chunkPromise = readInReadRealm(objId);
+    writeInWriteRealm(objId, 'A');
+    // Now the read() should resolve.
+    const result = await chunkPromise;
+    assert_equals(result.constructor, constructorRealm.Object,
+                  'result should be in constructor realm');
+    assert_equals(result.value.constructor, constructorRealm.Uint8Array,
+                  'chunk should be in constructor realm');
+  }, 'the output chunks when write is called with a pending read should come ' +
+     'from the same realm as the constructor of TextEncoderStream');
+
+  // There is not absolute consensus regarding what realm exceptions should be
+  // created in. Implementations may vary. The expectations in exception-related
+  // tests may change in future once consensus is reached.
+  promise_test(async t => {
+    const objId = await constructAndStore('TextEncoderStream');
+    // Read first to relieve backpressure.
+    const readPromise = readInReadRealm(objId);
+
+    await promise_rejects_js(t, constructorRealm.TypeError,
+                             writeInWriteRealm(objId, {
+                               toString() { return {}; }
+                             }),
+                             'write TypeError should come from constructor realm');
+
+    return promise_rejects_js(t, constructorRealm.TypeError, readPromise,
+                              'read TypeError should come from constructor realm');
+  }, 'TypeError for unconvertable chunk should come from constructor realm ' +
+     'of TextEncoderStream');
+}
+
+function runTextDecoderStreamTests() {
+  promise_test(async () => {
+    const objId = await constructAndStore('TextDecoderStream');
+    const writePromise = writeInWriteRealm(objId, new Uint8Array([65]));
+    const result = await readInReadRealm(objId);
+    await writePromise;
+    assert_equals(result.constructor, constructorRealm.Object,
+                  'result should be in constructor realm');
+    // A string is not an object, so doesn't have an associated realm. Accessing
+    // string properties will create a transient object wrapper belonging to the
+    // current realm. So checking the realm of result.value is not useful.
+  }, 'the result object when read is called after write should come from the ' +
+     'same realm as the constructor of TextDecoderStream');
+
+  promise_test(async () => {
+    const objId = await constructAndStore('TextDecoderStream');
+    const chunkPromise = readInReadRealm(objId);
+    writeInWriteRealm(objId, new Uint8Array([65]));
+    // Now the read() should resolve.
+    const result = await chunkPromise;
+    assert_equals(result.constructor, constructorRealm.Object,
+                  'result should be in constructor realm');
+    // A string is not an object, so doesn't have an associated realm. Accessing
+    // string properties will create a transient object wrapper belonging to the
+    // current realm. So checking the realm of result.value is not useful.
+  }, 'the result object when write is called with a pending ' +
+     'read should come from the same realm as the constructor of TextDecoderStream');
+
+  promise_test(async t => {
+    const objId = await constructAndStore('TextDecoderStream');
+    // Read first to relieve backpressure.
+    const readPromise = readInReadRealm(objId);
+    await promise_rejects_js(
+      t, constructorRealm.TypeError,
+      writeInWriteRealm(objId, {}),
+      'write TypeError should come from constructor realm'
+    );
+
+    return promise_rejects_js(
+      t, constructorRealm.TypeError, readPromise,
+      'read TypeError should come from constructor realm'
+    );
+  }, 'TypeError for chunk with the wrong type should come from constructor ' +
+     'realm of TextDecoderStream');
+
+  promise_test(async t => {
+    const objId =
+          await constructAndStore(`TextDecoderStream('utf-8', {fatal: true})`);
+    // Read first to relieve backpressure.
+    const readPromise = readInReadRealm(objId);
+
+    await promise_rejects_js(
+      t, constructorRealm.TypeError,
+      writeInWriteRealm(objId, new Uint8Array([0xff])),
+      'write TypeError should come from constructor realm'
+    );
+
+    return promise_rejects_js(
+      t, constructorRealm.TypeError, readPromise,
+      'read TypeError should come from constructor realm'
+    );
+  }, 'TypeError for invalid chunk should come from constructor realm ' +
+     'of TextDecoderStream');
+
+  promise_test(async t => {
+    const objId =
+          await constructAndStore(`TextDecoderStream('utf-8', {fatal: true})`);
+    // Read first to relieve backpressure.
+    readInReadRealm(objId);
+    // Write an unfinished sequence of bytes.
+    const incompleteBytesId = id();
+    writeRealm[incompleteBytesId] = new Uint8Array([0xf0]);
+
+    return promise_rejects_js(
+      t, constructorRealm.TypeError,
+      // Can't use writeInWriteRealm() here because it doesn't make it possible
+      // to reuse the writer.
+      evalInRealmAndReturn(writeRealm, `
+(() => {
+  const writer = window.${objId}.writable.getWriter();
+  parent.writeMethod.call(writer, window.${incompleteBytesId});
+  return parent.methodRealm.WritableStreamDefaultWriter.prototype
+    .close.call(writer);
+})();
+`),
+      'close TypeError should come from constructor realm'
+    );
+  }, 'TypeError for incomplete input should come from constructor realm ' +
+     'of TextDecoderStream');
+}
-- 
cgit v1.2.3

