summaryrefslogtreecommitdiffstats
path: root/js/src/tests/non262/ReadableStream/readable-stream-globals.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/tests/non262/ReadableStream/readable-stream-globals.js')
-rw-r--r--js/src/tests/non262/ReadableStream/readable-stream-globals.js367
1 files changed, 367 insertions, 0 deletions
diff --git a/js/src/tests/non262/ReadableStream/readable-stream-globals.js b/js/src/tests/non262/ReadableStream/readable-stream-globals.js
new file mode 100644
index 0000000000..37e73d5cbf
--- /dev/null
+++ b/js/src/tests/non262/ReadableStream/readable-stream-globals.js
@@ -0,0 +1,367 @@
+// |reftest| skip-if(!this.hasOwnProperty("ReadableStream"))
+
+if ("ignoreUnhandledRejections" in this) {
+ ignoreUnhandledRejections();
+}
+
+async function test() {
+ if (typeof newGlobal !== 'undefined') {
+ otherGlobal = newGlobal();
+ }
+
+ OtherReadableStream = otherGlobal.ReadableStream;
+
+ ReadableStreamReader = new ReadableStream().getReader().constructor;
+ OtherReadableStreamReader = new otherGlobal.ReadableStream().getReader().constructor;
+
+ let byteStreamsSupported = false;
+ try {
+ let controller;
+ let reader = new ReadableStream({
+ start(c) {
+ ByteStreamController = c.constructor;
+ controller = c;
+ },
+ type: "bytes"
+ }).getReader({ mode: "byob" })
+ ReadableStreamBYOBReader = reader.constructor;
+ reader.read(new Uint8Array(10));
+ BYOBRequest = controller.byobRequest.constructor;
+ reader = new otherGlobal.ReadableStream({
+ start(c) {
+ OtherByteStreamController = c.constructor;
+ controller = c;
+ },
+ type: "bytes"
+ }).getReader({ mode: "byob" });
+ OtherReadableStreamBYOBReader = reader.constructor;
+ reader.read(new Uint8Array(10));
+ OtherBYOBRequest = controller.byobRequest.constructor;
+
+ BYOBRequestGetter = Object.getOwnPropertyDescriptor(ByteStreamController.prototype,
+ "byobRequest").get;
+ OtherBYOBRequestGetter = Object.getOwnPropertyDescriptor(OtherByteStreamController.prototype,
+ "byobRequest").get;
+
+ byteStreamsSupported = true;
+ } catch (e) {
+ }
+
+ let chunk = { name: "chunk" };
+ let enqueuedError = { name: "enqueuedError" };
+
+ let controller;
+ let stream;
+ let otherStream;
+ let otherController;
+ let reader;
+ let otherReader;
+
+ function getFreshInstances(type, otherType = type) {
+ stream = new ReadableStream({ start(c) { controller = c; }, type });
+
+ otherStream = new OtherReadableStream({ start(c) { otherController = c; }, type: otherType });
+ }
+
+ getFreshInstances();
+
+ Controller = controller.constructor;
+ OtherController = otherController.constructor;
+
+
+ otherReader = OtherReadableStream.prototype.getReader.call(stream);
+ assertEq(otherReader instanceof ReadableStreamReader, false);
+ assertEq(otherReader instanceof OtherReadableStreamReader, true);
+ assertEq(otherController instanceof Controller, false);
+
+ assertEq(stream.locked, true);
+ Object.defineProperty(stream, "locked",
+ Object.getOwnPropertyDescriptor(OtherReadableStream.prototype, "locked"));
+ assertEq(stream.locked, true);
+
+
+ request = otherReader.read();
+ assertEq(request instanceof otherGlobal.Promise, true);
+ controller.close();
+ assertEq(await request instanceof Object, true);
+
+ getFreshInstances();
+ otherReader = new OtherReadableStreamReader(stream);
+
+ getFreshInstances();
+ otherReader = new OtherReadableStreamReader(stream);
+ let cancelSucceeded = false;
+ let cancelPromise = ReadableStreamReader.prototype.cancel.call(otherReader);
+ assertEq(cancelPromise instanceof Promise, true);
+ assertEq(await cancelPromise, undefined);
+
+ getFreshInstances();
+ otherReader = new OtherReadableStreamReader(stream);
+ let closeSucceeded = false;
+ Object.defineProperty(otherReader, "closed",
+ Object.getOwnPropertyDescriptor(ReadableStreamReader.prototype, "closed"));
+ let closedPromise = otherReader.closed;
+ assertEq(closedPromise instanceof otherGlobal.Promise, true);
+ controller.close();
+ assertEq(await closedPromise, undefined);
+
+ getFreshInstances();
+
+ otherReader = OtherReadableStream.prototype.getReader.call(stream);
+ request = otherReader.read();
+ assertEq(request instanceof otherGlobal.Promise, true);
+ otherController.close.call(controller);
+ assertEq(await request instanceof otherGlobal.Object, true);
+
+ getFreshInstances();
+
+ assertEq(controller.desiredSize, 1);
+ Object.defineProperty(controller, "desiredSize",
+ Object.getOwnPropertyDescriptor(OtherController.prototype, "desiredSize"));
+ assertEq(controller.desiredSize, 1);
+
+
+ request = otherReader.read();
+
+ controller.error(enqueuedError);
+
+ expectException(() => controller.close(), TypeError);
+ expectException(() => otherController.close.call(controller), otherGlobal.TypeError);
+
+ otherReader.releaseLock();
+
+ reader = stream.getReader();
+ assertEq(await expectAsyncException(async () => reader.read(), enqueuedError.constructor),
+ enqueuedError);
+
+ otherReader.releaseLock.call(reader);
+ assertEq(reader.closed instanceof otherGlobal.Promise, true);
+
+ // getFreshInstances();
+
+ // reader = stream.getReader();
+ // request = otherReader.read.call(reader);
+ // assertEq(request instanceof otherGlobal.Promise, true);
+ // controller.enqueue(chunk);
+ // assertEq((await request).value, chunk);
+
+ // reader.releaseLock();
+
+ // getFreshInstances();
+
+ // reader = stream.getReader();
+ // request = otherReader.read.call(reader);
+ // otherController.enqueue.call(controller, chunk);
+ // otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10));
+ // controller.enqueue(new otherGlobal.Uint8Array(10));
+ // request = otherReader.read.call(reader);
+
+ getFreshInstances();
+
+ stream = new ReadableStream({ start(c) { controller = c; } }, { size() {return 1} });
+ otherController.enqueue.call(controller, chunk);
+ otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10));
+ controller.enqueue(new otherGlobal.Uint8Array(10));
+
+ getFreshInstances();
+
+ controller.close();
+ expectException(() => controller.enqueue(new otherGlobal.Uint8Array(10)), TypeError);
+ expectException(() => otherController.enqueue.call(controller, chunk), otherGlobal.TypeError);
+ expectException(() => otherController.enqueue.call(controller, new otherGlobal.Uint8Array(10)),
+ otherGlobal.TypeError);
+
+ getFreshInstances();
+
+ let [branch1, branch2] = otherGlobal.ReadableStream.prototype.tee.call(stream);
+ assertEq(branch1 instanceof otherGlobal.ReadableStream, true);
+ assertEq(branch2 instanceof otherGlobal.ReadableStream, true);
+
+ controller.enqueue(chunk);
+ reader = branch1.getReader();
+ result = await reader.read();
+ reader.releaseLock();
+ let subPromiseCreated = false;
+ let speciesInvoked = false;
+ class SubPromise extends Promise {
+ constructor(executor) {
+ super(executor);
+ subPromiseCreated = true;
+ }
+ }
+ Object.defineProperty(Promise, Symbol.species, {get: function() {
+ speciesInvoked = true;
+ return SubPromise;
+ }
+ });
+
+ otherGlobal.eval(`
+ subPromiseCreated = false;
+ speciesInvoked = false;
+ class OtherSubPromise extends Promise {
+ constructor(executor) {
+ super(executor);
+ subPromiseCreated = true;
+ }
+ }
+ Object.defineProperty(Promise, Symbol.species, {get: function() {
+ speciesInvoked = true;
+ return OtherSubPromise;
+ }
+ });`);
+
+ controller.error(enqueuedError);
+ subPromiseCreated = false;
+ speciesInvoked = false;
+ otherGlobal.subPromiseCreated = false;
+ otherGlobal.speciesInvoked = false;
+ let cancelPromise1 = branch1.cancel({ name: "cancel 1" });
+ assertEq(cancelPromise1 instanceof otherGlobal.Promise, true);
+ assertEq(subPromiseCreated, false);
+ assertEq(speciesInvoked, false);
+ assertEq(otherGlobal.subPromiseCreated, false);
+ assertEq(otherGlobal.speciesInvoked, false);
+ subPromiseCreated = false;
+ speciesInvoked = false;
+ otherGlobal.subPromiseCreated = false;
+ otherGlobal.speciesInvoked = false;
+ let cancelPromise2 = branch2.cancel({ name: "cancel 2" });
+ assertEq(cancelPromise2 instanceof otherGlobal.Promise, true);
+ assertEq(subPromiseCreated, false);
+ assertEq(speciesInvoked, false);
+ assertEq(otherGlobal.subPromiseCreated, false);
+ assertEq(otherGlobal.speciesInvoked, false);
+ await 1;
+
+
+ getFreshInstances();
+
+ [branch1, branch2] = otherGlobal.ReadableStream.prototype.tee.call(stream);
+ assertEq(branch1 instanceof otherGlobal.ReadableStream, true);
+ assertEq(branch2 instanceof otherGlobal.ReadableStream, true);
+
+ controller.enqueue(chunk);
+ reader = branch1.getReader();
+ result = await reader.read();
+ reader.releaseLock();
+
+
+ assertEq(result.value, chunk);
+
+ controller.error(enqueuedError);
+ subPromiseCreated = false;
+ speciesInvoked = false;
+ otherGlobal.subPromiseCreated = false;
+ otherGlobal.speciesInvoked = false;
+ cancelPromise1 = ReadableStream.prototype.cancel.call(branch1, { name: "cancel 1" });
+ assertEq(cancelPromise1 instanceof Promise, true);
+ assertEq(subPromiseCreated, false);
+ assertEq(speciesInvoked, false);
+ assertEq(otherGlobal.subPromiseCreated, false);
+ assertEq(otherGlobal.speciesInvoked, false);
+ subPromiseCreated = false;
+ speciesInvoked = false;
+ otherGlobal.subPromiseCreated = false;
+ otherGlobal.speciesInvoked = false;
+ cancelPromise2 = ReadableStream.prototype.cancel.call(branch2, { name: "cancel 2" });
+ assertEq(cancelPromise2 instanceof Promise, true);
+ assertEq(subPromiseCreated, false);
+ assertEq(speciesInvoked, false);
+ assertEq(otherGlobal.subPromiseCreated, false);
+ assertEq(otherGlobal.speciesInvoked, false);
+
+ if (!byteStreamsSupported) {
+ return;
+ }
+
+ if (typeof nukeCCW === 'function') {
+ getFreshInstances("bytes");
+ assertEq(otherController instanceof OtherByteStreamController, true);
+ reader = ReadableStream.prototype.getReader.call(otherStream);
+ otherGlobal.reader = reader;
+ otherGlobal.nukeCCW(otherGlobal.reader);
+ let chunk = new Uint8Array(10);
+ expectException(() => otherController.enqueue(chunk), otherGlobal.TypeError);
+ // otherController.error();
+ expectException(() => reader.read(), TypeError);
+ }
+
+ function testBYOBRequest(controller, view) {
+ const request = new BYOBRequest(controller, view);
+ let storedView = request.view;
+ assertEq(storedView, view);
+ storedView = Object.getOwnPropertyDescriptor(OtherBYOBRequest.prototype, "view").get.call(request);
+ assertEq(storedView, view);
+ request.respond(10);
+ OtherBYOBRequest.prototype.respond.call(request, 10);
+ request.respondWithNewView(new view.constructor(10));
+ OtherBYOBRequest.prototype.respondWithNewView.call(request, new view.constructor(10));
+ }
+
+ expectException(() => new BYOBRequest(), TypeError);
+ getFreshInstances("bytes");
+ expectException(() => new BYOBRequest(controller, new Uint8Array(10)), TypeError);
+ expectException(() => new BYOBRequest(otherController, new Uint8Array(10)), TypeError);
+ expectException(() => new BYOBRequest(otherController, new Uint8Array(10)), TypeError);
+ expectException(() => new BYOBRequest(otherController, new otherGlobal.Uint8Array(10)), TypeError);
+
+ getFreshInstances("bytes");
+
+ reader = stream.getReader({ mode: "byob" });
+ request = OtherReadableStreamBYOBReader.prototype.read.call(reader, new Uint8Array(10));
+ assertEq(request instanceof otherGlobal.Promise, true);
+ controller.enqueue(new Uint8Array([1, 2, 3, 4]));
+ result = await request;
+
+ getFreshInstances("bytes");
+
+ reader = stream.getReader({ mode: "byob" });
+ request = OtherReadableStreamBYOBReader.prototype.read.call(reader, new Uint8Array(10));
+ assertEq(request instanceof otherGlobal.Promise, true);
+ try {
+ let byobRequest = OtherBYOBRequestGetter.call(controller);
+ } catch (e) {
+ print(e, '\n', e.stack);
+ }
+ controller.enqueue(new Uint8Array([1, 2, 3, 4]));
+ result = await request;
+
+ await 1;
+}
+
+function expectException(closure, errorType) {
+ let error;
+ try {
+ closure();
+ } catch (e) {
+ error = e;
+ }
+ assertEq(error !== undefined, true);
+ assertEq(error.constructor, errorType);
+ return error;
+}
+
+async function expectAsyncException(closure, errorType) {
+ let error;
+ try {
+ await closure();
+ } catch (e) {
+ error = e;
+ }
+ assertEq(error !== undefined, true);
+ assertEq(error.constructor, errorType);
+ return error;
+}
+
+async function runTest() {
+ try {
+ await test();
+ } catch (e) {
+ assertEq(false, true, `Unexpected exception ${e}\n${e.stack}`);
+ }
+ console.log("done");
+ if (typeof reportCompare === "function")
+ reportCompare(true, true);
+}
+
+runTest();