summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/encoding/streams/realms.window.js
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /testing/web-platform/tests/encoding/streams/realms.window.js
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'testing/web-platform/tests/encoding/streams/realms.window.js')
-rw-r--r--testing/web-platform/tests/encoding/streams/realms.window.js304
1 files changed, 304 insertions, 0 deletions
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');
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-15 06:55:00 +0000