From f6b9bdd49f892ff87a6f086a2059243a95922a7b Mon Sep 17 00:00:00 2001
From: Marcos Casagrande <marcoscvp90@gmail.com>
Date: Mon, 29 Jun 2020 02:51:23 +0200
Subject: [PATCH] allow buffer to store MAX_VALUE bytes

---
 cli/js/buffer.ts              | 22 +++++++++-------------
 cli/tests/unit/buffer_test.ts | 23 +++++++++++++++++++----
 2 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/cli/js/buffer.ts b/cli/js/buffer.ts
index 6a5105908e194..82bbc220c63da 100644
--- a/cli/js/buffer.ts
+++ b/cli/js/buffer.ts
@@ -133,17 +133,17 @@ export class Buffer implements Reader, ReaderSync, Writer, WriterSync {
       // we instead let capacity get twice as large so we
       // don't spend all our time copying.
       copyBytes(this.#buf.subarray(this.#off), this.#buf);
-    } else if (c > MAX_SIZE - c - n) {
+    } else if (c + n > MAX_SIZE) {
       throw new Error("The buffer cannot be grown beyond the maximum size.");
     } else {
       // Not enough space anywhere, we need to allocate.
-      const buf = new Uint8Array(2 * c + n);
+      const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
       copyBytes(this.#buf.subarray(this.#off), buf);
       this.#buf = buf;
     }
     // Restore this.#off and len(this.#buf).
     this.#off = 0;
-    this.#reslice(m + n);
+    this.#reslice(Math.min(m + n, MAX_SIZE));
     return m;
   };
 
@@ -157,31 +157,27 @@ export class Buffer implements Reader, ReaderSync, Writer, WriterSync {
 
   async readFrom(r: Reader): Promise<number> {
     let n = 0;
+    const buf = new Uint8Array(32 * 1024);
     while (true) {
-      const i = this.#grow(MIN_READ);
-      this.#reslice(i);
-      const fub = new Uint8Array(this.#buf.buffer, i);
-      const nread = await r.read(fub);
+      const nread = await r.read(buf);
       if (nread === null) {
         return n;
       }
-      this.#reslice(i + nread);
       n += nread;
+      this.writeSync(buf.subarray(0, nread));
     }
   }
 
   readFromSync(r: ReaderSync): number {
     let n = 0;
+    const buf = new Uint8Array(32 * 1024);
     while (true) {
-      const i = this.#grow(MIN_READ);
-      this.#reslice(i);
-      const fub = new Uint8Array(this.#buf.buffer, i);
-      const nread = r.readSync(fub);
+      const nread = r.readSync(buf);
       if (nread === null) {
         return n;
       }
-      this.#reslice(i + nread);
       n += nread;
+      this.writeSync(buf.subarray(0, nread));
     }
   }
 }
diff --git a/cli/tests/unit/buffer_test.ts b/cli/tests/unit/buffer_test.ts
index 36340b53fbbad..cd13bfd2554e8 100644
--- a/cli/tests/unit/buffer_test.ts
+++ b/cli/tests/unit/buffer_test.ts
@@ -11,8 +11,8 @@ import {
   unitTest,
 } from "./test_util.ts";
 
-// N controls how many iterations of certain checks are performed.
 const MAX_SIZE = 2 ** 32 - 2;
+// N controls how many iterations of certain checks are performed.
 const N = 100;
 let testBytes: Uint8Array | null;
 let testString: string | null;
@@ -170,7 +170,7 @@ unitTest(async function bufferTooLargeByteWrites(): Promise<void> {
 
 unitTest(function bufferGrowWriteMaxBuffer(): void {
   const bufSize = 16 * 1024;
-  const capacities = [MAX_SIZE, MAX_SIZE - 1, MAX_SIZE - 512];
+  const capacities = [MAX_SIZE, MAX_SIZE - 1];
   for (const capacity of capacities) {
     let written = 0;
     const buf = new Deno.Buffer();
@@ -178,7 +178,6 @@ unitTest(function bufferGrowWriteMaxBuffer(): void {
     for (let i = 0; i < writes; i++)
       written += buf.writeSync(repeat("x", bufSize));
 
-    console.log(written, capacity, capacity - written);
     if (written < capacity) {
       written += buf.writeSync(repeat("x", capacity - written));
     }
@@ -188,20 +187,36 @@ unitTest(function bufferGrowWriteMaxBuffer(): void {
 });
 
 unitTest(function bufferGrowReadSyncCloseToMaxBuffer(): void {
-  const capacities = [MAX_SIZE, MAX_SIZE - 1, MAX_SIZE - 512];
+  const capacities = [MAX_SIZE, MAX_SIZE - 1];
   for (const capacity of capacities) {
     const reader = new Deno.Buffer(new ArrayBuffer(capacity));
     const buf = new Deno.Buffer();
     buf.readFromSync(reader);
+
+    assertEquals(buf.length, capacity);
   }
 });
 
 unitTest(async function bufferGrowReadCloseToMaxBuffer(): Promise<void> {
+  const capacities = [MAX_SIZE, MAX_SIZE - 1];
+  for (const capacity of capacities) {
+    const reader = new Deno.Buffer(new ArrayBuffer(capacity));
+    const buf = new Deno.Buffer();
+    await buf.readFrom(reader);
+    assertEquals(buf.length, capacity);
+  }
+});
+
+unitTest(async function bufferReadCloseToMaxBufferWithInitialGrow(): Promise<
+  void
+> {
   const capacities = [MAX_SIZE, MAX_SIZE - 1, MAX_SIZE - 512];
   for (const capacity of capacities) {
     const reader = new Deno.Buffer(new ArrayBuffer(capacity));
     const buf = new Deno.Buffer();
+    buf.grow(MAX_SIZE);
     await buf.readFrom(reader);
+    assertEquals(buf.length, capacity);
   }
 });