123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406
// Based on https://github.com/golang/go/blob/891682/src/bufio/bufio_test.go// Copyright 2009 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.
const { Buffer } = Deno;type Reader = Deno.Reader;import {  assert,  assertEquals,  fail,  assertNotEOF,} from "../testing/asserts.ts";import {  BufReader,  BufWriter,  BufferFullError,  PartialReadError,  readStringDelim,  readLines,} from "./bufio.ts";import * as iotest from "./iotest.ts";import { charCode, copyBytes, stringsReader } from "./util.ts";
const encoder = new TextEncoder();
async function readBytes(buf: BufReader): Promise<string> {  const b = new Uint8Array(1000);  let nb = 0;  while (true) {    const c = await buf.readByte();    if (c === Deno.EOF) {      break; // EOF    }    b[nb] = c;    nb++;  }  const decoder = new TextDecoder();  return decoder.decode(b.subarray(0, nb));}
Deno.test(async function bufioReaderSimple(): Promise<void> {  const data = "hello world";  const b = new BufReader(stringsReader(data));  const s = await readBytes(b);  assertEquals(s, data);});
interface ReadMaker {  name: string;  fn: (r: Reader) => Reader;}
const readMakers: ReadMaker[] = [  { name: "full", fn: (r): Reader => r },  {    name: "byte",    fn: (r): iotest.OneByteReader => new iotest.OneByteReader(r),  },  { name: "half", fn: (r): iotest.HalfReader => new iotest.HalfReader(r) },  // TODO { name: "data+err", r => new iotest.DataErrReader(r) },  // { name: "timeout", fn: r => new iotest.TimeoutReader(r) },];
// Call read to accumulate the text of a fileasync function reads(buf: BufReader, m: number): Promise<string> {  const b = new Uint8Array(1000);  let nb = 0;  while (true) {    const result = await buf.read(b.subarray(nb, nb + m));    if (result === Deno.EOF) {      break;    }    nb += result;  }  const decoder = new TextDecoder();  return decoder.decode(b.subarray(0, nb));}
interface NamedBufReader {  name: string;  fn: (r: BufReader) => Promise<string>;}
const bufreaders: NamedBufReader[] = [  { name: "1", fn: (b: BufReader): Promise<string> => reads(b, 1) },  { name: "2", fn: (b: BufReader): Promise<string> => reads(b, 2) },  { name: "3", fn: (b: BufReader): Promise<string> => reads(b, 3) },  { name: "4", fn: (b: BufReader): Promise<string> => reads(b, 4) },  { name: "5", fn: (b: BufReader): Promise<string> => reads(b, 5) },  { name: "7", fn: (b: BufReader): Promise<string> => reads(b, 7) },  { name: "bytes", fn: readBytes },  // { name: "lines", fn: readLines },];
const MIN_READ_BUFFER_SIZE = 16;const bufsizes: number[] = [  0,  MIN_READ_BUFFER_SIZE,  23,  32,  46,  64,  93,  128,  1024,  4096,];
Deno.test(async function bufioBufReader(): Promise<void> {  const texts = new Array<string>(31);  let str = "";  let all = "";  for (let i = 0; i < texts.length - 1; i++) {    texts[i] = str + "\n";    all += texts[i];    str += String.fromCharCode((i % 26) + 97);  }  texts[texts.length - 1] = all;
  for (const text of texts) {    for (const readmaker of readMakers) {      for (const bufreader of bufreaders) {        for (const bufsize of bufsizes) {          const read = readmaker.fn(stringsReader(text));          const buf = new BufReader(read, bufsize);          const s = await bufreader.fn(buf);          const debugStr =            `reader=${readmaker.name} ` +            `fn=${bufreader.name} bufsize=${bufsize} want=${text} got=${s}`;          assertEquals(s, text, debugStr);        }      }    }  }});
Deno.test(async function bufioBufferFull(): Promise<void> {  const longString =    "And now, hello, world! It is the time for all good men to come to the" +    " aid of their party";  const buf = new BufReader(stringsReader(longString), MIN_READ_BUFFER_SIZE);  const decoder = new TextDecoder();
  try {    await buf.readSlice(charCode("!"));    fail("readSlice should throw");  } catch (err) {    assert(err instanceof BufferFullError);    assert(err.partial instanceof Uint8Array);    assertEquals(decoder.decode(err.partial), "And now, hello, ");  }
  const line = assertNotEOF(await buf.readSlice(charCode("!")));  const actual = decoder.decode(line);  assertEquals(actual, "world!");});
Deno.test(async function bufioReadString(): Promise<void> {  const string = "And now, hello world!";  const buf = new BufReader(stringsReader(string), MIN_READ_BUFFER_SIZE);
  const line = assertNotEOF(await buf.readString(","));  assertEquals(line, "And now,");  assertEquals(line.length, 8);
  const line2 = assertNotEOF(await buf.readString(","));  assertEquals(line2, " hello world!");
  assertEquals(await buf.readString(","), Deno.EOF);
  try {    await buf.readString("deno");
    fail("should throw");  } catch (err) {    assert(err.message, "Delimiter should be a single character");  }});
const testInput = encoder.encode(  "012\n345\n678\n9ab\ncde\nfgh\nijk\nlmn\nopq\nrst\nuvw\nxy");const testInputrn = encoder.encode(  "012\r\n345\r\n678\r\n9ab\r\ncde\r\nfgh\r\nijk\r\nlmn\r\nopq\r\nrst\r\n" +    "uvw\r\nxy\r\n\n\r\n");const testOutput = encoder.encode("0123456789abcdefghijklmnopqrstuvwxy");
// TestReader wraps a Uint8Array and returns reads of a specific length.class TestReader implements Reader {  constructor(private data: Uint8Array, private stride: number) {}
  read(buf: Uint8Array): Promise<number | Deno.EOF> {    let nread = this.stride;    if (nread > this.data.byteLength) {      nread = this.data.byteLength;    }    if (nread > buf.byteLength) {      nread = buf.byteLength;    }    if (nread === 0) {      return Promise.resolve(Deno.EOF);    }    copyBytes(buf as Uint8Array, this.data);    this.data = this.data.subarray(nread);    return Promise.resolve(nread);  }}
async function testReadLine(input: Uint8Array): Promise<void> {  for (let stride = 1; stride < 2; stride++) {    let done = 0;    const reader = new TestReader(input, stride);    const l = new BufReader(reader, input.byteLength + 1);    while (true) {      const r = await l.readLine();      if (r === Deno.EOF) {        break;      }      const { line, more } = r;      assertEquals(more, false);      // eslint-disable-next-line @typescript-eslint/restrict-plus-operands      const want = testOutput.subarray(done, done + line.byteLength);      assertEquals(        line,        want,        `Bad line at stride ${stride}: want: ${want} got: ${line}`      );      done += line.byteLength;    }    assertEquals(      done,      testOutput.byteLength,      `readLine didn't return everything: got: ${done}, ` +        `want: ${testOutput} (stride: ${stride})`    );  }}
Deno.test(async function bufioReadLine(): Promise<void> {  await testReadLine(testInput);  await testReadLine(testInputrn);});
Deno.test(async function bufioPeek(): Promise<void> {  const decoder = new TextDecoder();  const p = new Uint8Array(10);  // string is 16 (minReadBufferSize) long.  const buf = new BufReader(    stringsReader("abcdefghijklmnop"),    MIN_READ_BUFFER_SIZE  );
  let actual = assertNotEOF(await buf.peek(1));  assertEquals(decoder.decode(actual), "a");
  actual = assertNotEOF(await buf.peek(4));  assertEquals(decoder.decode(actual), "abcd");
  try {    await buf.peek(32);    fail("peek() should throw");  } catch (err) {    assert(err instanceof BufferFullError);    assert(err.partial instanceof Uint8Array);    assertEquals(decoder.decode(err.partial), "abcdefghijklmnop");  }
  await buf.read(p.subarray(0, 3));  assertEquals(decoder.decode(p.subarray(0, 3)), "abc");
  actual = assertNotEOF(await buf.peek(1));  assertEquals(decoder.decode(actual), "d");
  actual = assertNotEOF(await buf.peek(1));  assertEquals(decoder.decode(actual), "d");
  actual = assertNotEOF(await buf.peek(1));  assertEquals(decoder.decode(actual), "d");
  actual = assertNotEOF(await buf.peek(2));  assertEquals(decoder.decode(actual), "de");
  const res = await buf.read(p.subarray(0, 3));  assertEquals(decoder.decode(p.subarray(0, 3)), "def");  assert(res !== Deno.EOF);
  actual = assertNotEOF(await buf.peek(4));  assertEquals(decoder.decode(actual), "ghij");
  await buf.read(p);  assertEquals(decoder.decode(p), "ghijklmnop");
  actual = assertNotEOF(await buf.peek(0));  assertEquals(decoder.decode(actual), "");
  const r = await buf.peek(1);  assert(r === Deno.EOF);  /* TODO	Test for issue 3022, not exposing a reader's error on a successful Peek.	buf = NewReaderSize(dataAndEOFReader("abcd"), 32)	if s, err := buf.Peek(2); string(s) != "ab" || err != nil {		t.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s), err)	}	if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {		t.Errorf(      `Peek(4) on "abcd", EOF = %q, %v; want "abcd", nil`,      string(s),      err    )	}	if n, err := buf.Read(p[0:5]); string(p[0:n]) != "abcd" || err != nil {		t.Fatalf("Read after peek = %q, %v; want abcd, EOF", p[0:n], err)	}	if n, err := buf.Read(p[0:1]); string(p[0:n]) != "" || err != io.EOF {		t.Fatalf(`second Read after peek = %q, %v; want "", EOF`, p[0:n], err)	}  */});
Deno.test(async function bufioWriter(): Promise<void> {  const data = new Uint8Array(8192);
  for (let i = 0; i < data.byteLength; i++) {    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands    data[i] = charCode(" ") + (i % (charCode("~") - charCode(" ")));  }
  const w = new Buffer();  for (const nwrite of bufsizes) {    for (const bs of bufsizes) {      // Write nwrite bytes using buffer size bs.      // Check that the right amount makes it out      // and that the data is correct.
      w.reset();      const buf = new BufWriter(w, bs);
      const context = `nwrite=${nwrite} bufsize=${bs}`;      const n = await buf.write(data.subarray(0, nwrite));      assertEquals(n, nwrite, context);
      await buf.flush();
      const written = w.bytes();      assertEquals(written.byteLength, nwrite);
      for (let l = 0; l < written.byteLength; l++) {        assertEquals(written[l], data[l]);      }    }  }});
Deno.test(async function bufReaderReadFull(): Promise<void> {  const enc = new TextEncoder();  const dec = new TextDecoder();  const text = "Hello World";  const data = new Buffer(enc.encode(text));  const bufr = new BufReader(data, 3);  {    const buf = new Uint8Array(6);    const r = assertNotEOF(await bufr.readFull(buf));    assertEquals(r, buf);    assertEquals(dec.decode(buf), "Hello ");  }  {    const buf = new Uint8Array(6);    try {      await bufr.readFull(buf);      fail("readFull() should throw PartialReadError");    } catch (err) {      assert(err instanceof PartialReadError);      assert(err.partial instanceof Uint8Array);      assertEquals(err.partial.length, 5);      assertEquals(dec.decode(buf.subarray(0, 5)), "World");    }  }});
Deno.test(async function readStringDelimAndLines(): Promise<void> {  const enc = new TextEncoder();  const data = new Buffer(    enc.encode("Hello World\tHello World 2\tHello World 3")  );  const chunks_ = [];
  for await (const c of readStringDelim(data, "\t")) {    chunks_.push(c);  }
  assertEquals(chunks_.length, 3);  assertEquals(chunks_, ["Hello World", "Hello World 2", "Hello World 3"]);
  const linesData = new Buffer(enc.encode("0\n1\n2\n3\n4\n5\n6\n7\n8\n9"));  const lines_ = [];
  for await (const l of readLines(linesData)) {    lines_.push(l);  }
  assertEquals(lines_.length, 10);  assertEquals(lines_, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);});