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();