uncomment

1 files changed, 211 insertions, 212 deletions

diff --git a/test/bun.js/streams.test.js b/test/bun.js/streams.test.js
index 0e28e512a..4e70409a6 100644
--- a/test/bun.js/streams.test.js
+++ b/test/bun.js/streams.test.js
@@ -7,236 +7,236 @@ new Uint8Array();
 beforeEach(() => gc());
 afterEach(() => gc());
 
-// it("exists globally", () => {
-//   expect(typeof ReadableStream).toBe("function");
-//   expect(typeof ReadableStreamBYOBReader).toBe("function");
-//   expect(typeof ReadableStreamBYOBRequest).toBe("function");
-//   expect(typeof ReadableStreamDefaultController).toBe("function");
-//   expect(typeof ReadableStreamDefaultReader).toBe("function");
-//   expect(typeof TransformStream).toBe("function");
-//   expect(typeof TransformStreamDefaultController).toBe("function");
-//   expect(typeof WritableStream).toBe("function");
-//   expect(typeof WritableStreamDefaultController).toBe("function");
-//   expect(typeof WritableStreamDefaultWriter).toBe("function");
-//   expect(typeof ByteLengthQueuingStrategy).toBe("function");
-//   expect(typeof CountQueuingStrategy).toBe("function");
-// });
+it("exists globally", () => {
+  expect(typeof ReadableStream).toBe("function");
+  expect(typeof ReadableStreamBYOBReader).toBe("function");
+  expect(typeof ReadableStreamBYOBRequest).toBe("function");
+  expect(typeof ReadableStreamDefaultController).toBe("function");
+  expect(typeof ReadableStreamDefaultReader).toBe("function");
+  expect(typeof TransformStream).toBe("function");
+  expect(typeof TransformStreamDefaultController).toBe("function");
+  expect(typeof WritableStream).toBe("function");
+  expect(typeof WritableStreamDefaultController).toBe("function");
+  expect(typeof WritableStreamDefaultWriter).toBe("function");
+  expect(typeof ByteLengthQueuingStrategy).toBe("function");
+  expect(typeof CountQueuingStrategy).toBe("function");
+});
 
-// it("ReadableStream (readMany)", async () => {
-//   var stream = new ReadableStream({
-//     pull(controller) {
-//       controller.enqueue("hello");
-//       controller.enqueue("world");
-//       controller.close();
-//     },
-//     cancel() {},
-//   });
-//   var reader = stream.getReader();
-//   const chunk = await reader.readMany();
-//   expect(chunk.value.join("")).toBe("helloworld");
-//   expect((await reader.read()).done).toBe(true);
-// });
+it("ReadableStream (readMany)", async () => {
+  var stream = new ReadableStream({
+    pull(controller) {
+      controller.enqueue("hello");
+      controller.enqueue("world");
+      controller.close();
+    },
+    cancel() {},
+  });
+  var reader = stream.getReader();
+  const chunk = await reader.readMany();
+  expect(chunk.value.join("")).toBe("helloworld");
+  expect((await reader.read()).done).toBe(true);
+});
 
-// it("ReadableStream (direct)", async () => {
-//   var stream = new ReadableStream({
-//     pull(controller) {
-//       controller.write("hello");
-//       controller.write("world");
-//       controller.close();
-//     },
-//     cancel() {},
-//     type: "direct",
-//   });
-//   var reader = stream.getReader();
-//   const chunk = await reader.read();
-//   expect(chunk.value.join("")).toBe(Buffer.from("helloworld").join(""));
-//   expect((await reader.read()).done).toBe(true);
-//   expect((await reader.read()).done).toBe(true);
-// });
+it("ReadableStream (direct)", async () => {
+  var stream = new ReadableStream({
+    pull(controller) {
+      controller.write("hello");
+      controller.write("world");
+      controller.close();
+    },
+    cancel() {},
+    type: "direct",
+  });
+  var reader = stream.getReader();
+  const chunk = await reader.read();
+  expect(chunk.value.join("")).toBe(Buffer.from("helloworld").join(""));
+  expect((await reader.read()).done).toBe(true);
+  expect((await reader.read()).done).toBe(true);
+});
 
-// it("ReadableStream (bytes)", async () => {
-//   var stream = new ReadableStream({
-//     start(controller) {
-//       controller.enqueue(Buffer.from("abdefgh"));
-//     },
-//     pull(controller) {},
-//     cancel() {},
-//     type: "bytes",
-//   });
-//   const chunks = [];
-//   const chunk = await stream.getReader().read();
-//   chunks.push(chunk.value);
-//   expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
-// });
+it("ReadableStream (bytes)", async () => {
+  var stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(Buffer.from("abdefgh"));
+    },
+    pull(controller) {},
+    cancel() {},
+    type: "bytes",
+  });
+  const chunks = [];
+  const chunk = await stream.getReader().read();
+  chunks.push(chunk.value);
+  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
+});
 
-// it("ReadableStream (default)", async () => {
-//   var stream = new ReadableStream({
-//     start(controller) {
-//       controller.enqueue(Buffer.from("abdefgh"));
-//       controller.close();
-//     },
-//     pull(controller) {},
-//     cancel() {},
-//   });
-//   const chunks = [];
-//   const chunk = await stream.getReader().read();
-//   chunks.push(chunk.value);
-//   expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
-// });
+it("ReadableStream (default)", async () => {
+  var stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(Buffer.from("abdefgh"));
+      controller.close();
+    },
+    pull(controller) {},
+    cancel() {},
+  });
+  const chunks = [];
+  const chunk = await stream.getReader().read();
+  chunks.push(chunk.value);
+  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
+});
 
-// it("readableStreamToArray", async () => {
-//   var queue = [Buffer.from("abdefgh")];
-//   var stream = new ReadableStream({
-//     pull(controller) {
-//       var chunk = queue.shift();
-//       if (chunk) {
-//         controller.enqueue(chunk);
-//       } else {
-//         controller.close();
-//       }
-//     },
-//     cancel() {},
-//     type: "bytes",
-//   });
+it("readableStreamToArray", async () => {
+  var queue = [Buffer.from("abdefgh")];
+  var stream = new ReadableStream({
+    pull(controller) {
+      var chunk = queue.shift();
+      if (chunk) {
+        controller.enqueue(chunk);
+      } else {
+        controller.close();
+      }
+    },
+    cancel() {},
+    type: "bytes",
+  });
 
-//   const chunks = await readableStreamToArray(stream);
+  const chunks = await readableStreamToArray(stream);
 
-//   expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
-// });
+  expect(chunks[0].join("")).toBe(Buffer.from("abdefgh").join(""));
+});
 
-// it("readableStreamToArrayBuffer (bytes)", async () => {
-//   var queue = [Buffer.from("abdefgh")];
-//   var stream = new ReadableStream({
-//     pull(controller) {
-//       var chunk = queue.shift();
-//       if (chunk) {
-//         controller.enqueue(chunk);
-//       } else {
-//         controller.close();
-//       }
-//     },
-//     cancel() {},
-//     type: "bytes",
-//   });
-//   const buffer = await readableStreamToArrayBuffer(stream);
-//   expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
-// });
+it("readableStreamToArrayBuffer (bytes)", async () => {
+  var queue = [Buffer.from("abdefgh")];
+  var stream = new ReadableStream({
+    pull(controller) {
+      var chunk = queue.shift();
+      if (chunk) {
+        controller.enqueue(chunk);
+      } else {
+        controller.close();
+      }
+    },
+    cancel() {},
+    type: "bytes",
+  });
+  const buffer = await readableStreamToArrayBuffer(stream);
+  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
+});
 
-// it("readableStreamToArrayBuffer (default)", async () => {
-//   var queue = [Buffer.from("abdefgh")];
-//   var stream = new ReadableStream({
-//     pull(controller) {
-//       var chunk = queue.shift();
-//       if (chunk) {
-//         controller.enqueue(chunk);
-//       } else {
-//         controller.close();
-//       }
-//     },
-//     cancel() {},
-//   });
+it("readableStreamToArrayBuffer (default)", async () => {
+  var queue = [Buffer.from("abdefgh")];
+  var stream = new ReadableStream({
+    pull(controller) {
+      var chunk = queue.shift();
+      if (chunk) {
+        controller.enqueue(chunk);
+      } else {
+        controller.close();
+      }
+    },
+    cancel() {},
+  });
 
-//   const buffer = await readableStreamToArrayBuffer(stream);
-//   expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
-// });
+  const buffer = await readableStreamToArrayBuffer(stream);
+  expect(new TextDecoder().decode(new Uint8Array(buffer))).toBe("abdefgh");
+});
 
-// it("ReadableStream for Blob", async () => {
-//   var blob = new Blob(["abdefgh", "ijklmnop"]);
-//   expect(await blob.text()).toBe("abdefghijklmnop");
-//   var stream;
-//   try {
-//     stream = blob.stream();
-//     stream = blob.stream();
-//   } catch (e) {
-//     console.error(e);
-//     console.error(e.stack);
-//   }
-//   const chunks = [];
-//   var reader;
-//   reader = stream.getReader();
+it("ReadableStream for Blob", async () => {
+  var blob = new Blob(["abdefgh", "ijklmnop"]);
+  expect(await blob.text()).toBe("abdefghijklmnop");
+  var stream;
+  try {
+    stream = blob.stream();
+    stream = blob.stream();
+  } catch (e) {
+    console.error(e);
+    console.error(e.stack);
+  }
+  const chunks = [];
+  var reader;
+  reader = stream.getReader();
 
-//   while (true) {
-//     var chunk;
-//     try {
-//       chunk = await reader.read();
-//     } catch (e) {
-//       console.error(e);
-//       console.error(e.stack);
-//     }
+  while (true) {
+    var chunk;
+    try {
+      chunk = await reader.read();
+    } catch (e) {
+      console.error(e);
+      console.error(e.stack);
+    }
 
-//     if (chunk.done) break;
-//     chunks.push(new TextDecoder().decode(chunk.value));
-//   }
-//   expect(chunks.join("")).toBe(
-//     new TextDecoder().decode(Buffer.from("abdefghijklmnop"))
-//   );
-// });
+    if (chunk.done) break;
+    chunks.push(new TextDecoder().decode(chunk.value));
+  }
+  expect(chunks.join("")).toBe(
+    new TextDecoder().decode(Buffer.from("abdefghijklmnop"))
+  );
+});
 
-// it("ReadableStream for File", async () => {
-//   var blob = file(import.meta.dir + "/fetch.js.txt");
-//   var stream = blob.stream(24);
-//   const chunks = [];
-//   var reader = stream.getReader();
-//   stream = undefined;
-//   while (true) {
-//     const chunk = await reader.read();
-//     gc(true);
-//     if (chunk.done) break;
-//     chunks.push(chunk.value);
-//     expect(chunk.value.byteLength <= 24).toBe(true);
-//     gc(true);
-//   }
-//   reader = undefined;
-//   const output = new Uint8Array(await blob.arrayBuffer()).join("");
-//   const input = chunks.map((a) => a.join("")).join("");
-//   expect(output).toBe(input);
-//   gc(true);
-// });
+it("ReadableStream for File", async () => {
+  var blob = file(import.meta.dir + "/fetch.js.txt");
+  var stream = blob.stream(24);
+  const chunks = [];
+  var reader = stream.getReader();
+  stream = undefined;
+  while (true) {
+    const chunk = await reader.read();
+    gc(true);
+    if (chunk.done) break;
+    chunks.push(chunk.value);
+    expect(chunk.value.byteLength <= 24).toBe(true);
+    gc(true);
+  }
+  reader = undefined;
+  const output = new Uint8Array(await blob.arrayBuffer()).join("");
+  const input = chunks.map((a) => a.join("")).join("");
+  expect(output).toBe(input);
+  gc(true);
+});
 
-// it("ReadableStream for File errors", async () => {
-//   try {
-//     var blob = file(import.meta.dir + "/fetch.js.txt.notfound");
-//     blob.stream().getReader();
-//     throw new Error("should not reach here");
-//   } catch (e) {
-//     expect(e.code).toBe("ENOENT");
-//     expect(e.syscall).toBe("open");
-//   }
-// });
+it("ReadableStream for File errors", async () => {
+  try {
+    var blob = file(import.meta.dir + "/fetch.js.txt.notfound");
+    blob.stream().getReader();
+    throw new Error("should not reach here");
+  } catch (e) {
+    expect(e.code).toBe("ENOENT");
+    expect(e.syscall).toBe("open");
+  }
+});
 
-// it("ReadableStream for empty blob closes immediately", async () => {
-//   var blob = new Blob([]);
-//   var stream = blob.stream();
-//   const chunks = [];
-//   var reader = stream.getReader();
-//   while (true) {
-//     const chunk = await reader.read();
-//     if (chunk.done) break;
-//     chunks.push(chunk.value);
-//   }
+it("ReadableStream for empty blob closes immediately", async () => {
+  var blob = new Blob([]);
+  var stream = blob.stream();
+  const chunks = [];
+  var reader = stream.getReader();
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    chunks.push(chunk.value);
+  }
 
-//   expect(chunks.length).toBe(0);
-// });
+  expect(chunks.length).toBe(0);
+});
 
-// it("ReadableStream for empty file closes immediately", async () => {
-//   writeFileSync("/tmp/bun-empty-file-123456", "");
-//   var blob = file("/tmp/bun-empty-file-123456");
-//   var stream;
-//   try {
-//     stream = blob.stream();
-//   } catch (e) {
-//     console.error(e.stack);
-//   }
-//   const chunks = [];
-//   var reader = stream.getReader();
-//   while (true) {
-//     const chunk = await reader.read();
-//     if (chunk.done) break;
-//     chunks.push(chunk.value);
-//   }
+it("ReadableStream for empty file closes immediately", async () => {
+  writeFileSync("/tmp/bun-empty-file-123456", "");
+  var blob = file("/tmp/bun-empty-file-123456");
+  var stream;
+  try {
+    stream = blob.stream();
+  } catch (e) {
+    console.error(e.stack);
+  }
+  const chunks = [];
+  var reader = stream.getReader();
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    chunks.push(chunk.value);
+  }
 
-//   expect(chunks.length).toBe(0);
-// });
+  expect(chunks.length).toBe(0);
+});
 
 it("new Response(stream).arrayBuffer() (bytes)", async () => {
   var queue = [Buffer.from("abdefgh")];
@@ -322,7 +322,6 @@ it("new Response(stream).blob() (default)", async () => {
   });
   const response = new Response(stream);
   const blob = await response.blob();
-  console.log(blob.size);
   expect(await blob.text()).toBe('{"hello":true}');
 });