chore: remove std directory (#9361)

This removes the std folder from the tree.

Various parts of the tests are pretty tightly dependent 
on std (47 direct imports and 75 indirect imports, not 
counting the cli tests that use them as fixtures) so I've 
added std as a submodule for now.

1 files changed, 0 insertions, 566 deletions

diff --git a/std/io/bufio_test.ts b/std/io/bufio_test.ts
deleted file mode 100644
index d6a0856de..000000000
--- a/std/io/bufio_test.ts
+++ /dev/null
@@ -1,566 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-// 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.
-import { assert, assertEquals, fail } from "../testing/asserts.ts";
-import {
-  BufferFullError,
-  BufReader,
-  BufWriter,
-  BufWriterSync,
-  PartialReadError,
-  ReadLineResult,
-  readLines,
-  readStringDelim,
-} from "./bufio.ts";
-import * as iotest from "./_iotest.ts";
-import { StringReader } from "./readers.ts";
-import { StringWriter } from "./writers.ts";
-import { copy } from "../bytes/mod.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 === null) {
-      break; // EOF
-    }
-    b[nb] = c;
-    nb++;
-  }
-  const decoder = new TextDecoder();
-  return decoder.decode(b.subarray(0, nb));
-}
-
-Deno.test("bufioReaderSimple", async function (): Promise<void> {
-  const data = "hello world";
-  const b = new BufReader(new StringReader(data));
-  const s = await readBytes(b);
-  assertEquals(s, data);
-});
-
-interface ReadMaker {
-  name: string;
-  fn: (r: Deno.Reader) => Deno.Reader;
-}
-
-const readMakers: ReadMaker[] = [
-  { name: "full", fn: (r): Deno.Reader => r },
-  {
-    name: "byte",
-    fn: (r): iotest.OneByteReader => new iotest.OneByteReader(r),
-  },
-  { name: "half", fn: (r): iotest.HalfReader => new iotest.HalfReader(r) },
-  // TODO(bartlomieju): { name: "data+err", r => new iotest.DataErrReader(r) },
-  // { name: "timeout", fn: r => new iotest.TimeoutReader(r) },
-];
-
-// Call read to accumulate the text of a file
-async 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 === null) {
-      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("bufioBufReader", async function (): 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(new StringReader(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("bufioBufferFull", async function (): 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(new StringReader(longString), MIN_READ_BUFFER_SIZE);
-  const decoder = new TextDecoder();
-
-  try {
-    await buf.readSlice("!".charCodeAt(0));
-    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 = await buf.readSlice("!".charCodeAt(0));
-  assert(line !== null);
-  const actual = decoder.decode(line);
-  assertEquals(actual, "world!");
-});
-
-Deno.test("bufioReadString", async function (): Promise<void> {
-  const string = "And now, hello world!";
-  const buf = new BufReader(new StringReader(string), MIN_READ_BUFFER_SIZE);
-
-  const line = await buf.readString(",");
-  assert(line !== null);
-  assertEquals(line, "And now,");
-  assertEquals(line.length, 8);
-
-  const line2 = await buf.readString(",");
-  assert(line2 !== null);
-  assertEquals(line2, " hello world!");
-
-  assertEquals(await buf.readString(","), null);
-
-  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 Deno.Reader {
-  constructor(private data: Uint8Array, private stride: number) {}
-
-  read(buf: Uint8Array): Promise<number | null> {
-    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(null);
-    }
-    copy(this.data, buf as Uint8Array);
-    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 === null) {
-        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("bufioReadLine", async function (): Promise<void> {
-  await testReadLine(testInput);
-  await testReadLine(testInputrn);
-});
-
-Deno.test("bufioPeek", async function (): Promise<void> {
-  const decoder = new TextDecoder();
-  const p = new Uint8Array(10);
-  // string is 16 (minReadBufferSize) long.
-  const buf = new BufReader(
-    new StringReader("abcdefghijklmnop"),
-    MIN_READ_BUFFER_SIZE,
-  );
-
-  let actual = await buf.peek(1);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "a");
-
-  actual = await buf.peek(4);
-  assert(actual !== null);
-  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 = await buf.peek(1);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "d");
-
-  actual = await buf.peek(1);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "d");
-
-  actual = await buf.peek(1);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "d");
-
-  actual = await buf.peek(2);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "de");
-
-  const res = await buf.read(p.subarray(0, 3));
-  assertEquals(decoder.decode(p.subarray(0, 3)), "def");
-  assert(res !== null);
-
-  actual = await buf.peek(4);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "ghij");
-
-  await buf.read(p);
-  assertEquals(decoder.decode(p), "ghijklmnop");
-
-  actual = await buf.peek(0);
-  assert(actual !== null);
-  assertEquals(decoder.decode(actual), "");
-
-  const r = await buf.peek(1);
-  assert(r === null);
-  /* 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("bufioWriter", async function (): 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] = " ".charCodeAt(0) + (i % ("~".charCodeAt(0) - " ".charCodeAt(0)));
-  }
-
-  const w = new Deno.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("bufioWriterSync", function (): 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] = " ".charCodeAt(0) + (i % ("~".charCodeAt(0) - " ".charCodeAt(0)));
-  }
-
-  const w = new Deno.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 BufWriterSync(w, bs);
-
-      const context = `nwrite=${nwrite} bufsize=${bs}`;
-      const n = buf.writeSync(data.subarray(0, nwrite));
-      assertEquals(n, nwrite, context);
-
-      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("bufReaderReadFull", async function (): Promise<void> {
-  const enc = new TextEncoder();
-  const dec = new TextDecoder();
-  const text = "Hello World";
-  const data = new Deno.Buffer(enc.encode(text));
-  const bufr = new BufReader(data, 3);
-  {
-    const buf = new Uint8Array(6);
-    const r = await bufr.readFull(buf);
-    assert(r !== null);
-    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("readStringDelimAndLines", async function (): Promise<void> {
-  const enc = new TextEncoder();
-  const data = new Deno.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 Deno.Buffer(enc.encode("0\n1\n2\n3\n4\n5\n6\n7\n8\n9"));
-  // consider data with windows newlines too
-  const linesDataWindows = new Deno.Buffer(
-    enc.encode("0\r\n1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\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"]);
-
-  // Now test for "windows" lines
-  lines_.length = 0;
-  for await (const l of readLines(linesDataWindows)) {
-    lines_.push(l);
-  }
-  assertEquals(lines_.length, 10);
-  assertEquals(lines_, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
-});
-
-Deno.test(
-  "bufReaderShouldNotShareArrayBufferAcrossReads",
-  async function (): Promise<void> {
-    const decoder = new TextDecoder();
-    const data = "abcdefghijklmnopqrstuvwxyz";
-    const bufSize = 25;
-    const b = new BufReader(new StringReader(data), bufSize);
-
-    const r1 = (await b.readLine()) as ReadLineResult;
-    assert(r1 !== null);
-    assertEquals(decoder.decode(r1.line), "abcdefghijklmnopqrstuvwxy");
-
-    const r2 = (await b.readLine()) as ReadLineResult;
-    assert(r2 !== null);
-    assertEquals(decoder.decode(r2.line), "z");
-    assert(
-      r1.line.buffer !== r2.line.buffer,
-      "array buffer should not be shared across reads",
-    );
-  },
-);
-
-Deno.test({
-  name: "Reset buffer after flush",
-  async fn(): Promise<void> {
-    const stringWriter = new StringWriter();
-    const bufWriter = new BufWriter(stringWriter);
-    const encoder = new TextEncoder();
-    await bufWriter.write(encoder.encode("hello\nworld\nhow\nare\nyou?\n\n"));
-    await bufWriter.flush();
-    await bufWriter.write(encoder.encode("foobar\n\n"));
-    await bufWriter.flush();
-    const actual = stringWriter.toString();
-    assertEquals(actual, "hello\nworld\nhow\nare\nyou?\n\nfoobar\n\n");
-  },
-});
-
-Deno.test({
-  name: "Reset buffer after flush sync",
-  fn(): void {
-    const stringWriter = new StringWriter();
-    const bufWriter = new BufWriterSync(stringWriter);
-    const encoder = new TextEncoder();
-    bufWriter.writeSync(encoder.encode("hello\nworld\nhow\nare\nyou?\n\n"));
-    bufWriter.flush();
-    bufWriter.writeSync(encoder.encode("foobar\n\n"));
-    bufWriter.flush();
-    const actual = stringWriter.toString();
-    assertEquals(actual, "hello\nworld\nhow\nare\nyou?\n\nfoobar\n\n");
-  },
-});
-
-Deno.test({
-  name: "BufWriter.flush should write all bytes",
-  async fn(): Promise<void> {
-    const bufSize = 16 * 1024;
-    const data = new Uint8Array(bufSize);
-    data.fill("a".charCodeAt(0));
-
-    const cache: Uint8Array[] = [];
-    const writer: Deno.Writer = {
-      write(p: Uint8Array): Promise<number> {
-        cache.push(p.subarray(0, 1));
-
-        // Writer that only writes 1 byte at a time
-        return Promise.resolve(1);
-      },
-    };
-
-    const bufWriter = new BufWriter(writer);
-    await bufWriter.write(data);
-
-    await bufWriter.flush();
-    const buf = new Uint8Array(cache.length);
-    for (let i = 0; i < cache.length; i++) buf.set(cache[i], i);
-
-    assertEquals(data, buf);
-  },
-});
-
-Deno.test({
-  name: "BufWriterSync.flush should write all bytes",
-  fn(): void {
-    const bufSize = 16 * 1024;
-    const data = new Uint8Array(bufSize);
-    data.fill("a".charCodeAt(0));
-
-    const cache: Uint8Array[] = [];
-    const writer: Deno.WriterSync = {
-      writeSync(p: Uint8Array): number {
-        cache.push(p.subarray(0, 1));
-        // Writer that only writes 1 byte at a time
-        return 1;
-      },
-    };
-
-    const bufWriter = new BufWriterSync(writer);
-    bufWriter.writeSync(data);
-
-    bufWriter.flush();
-    const buf = new Uint8Array(cache.length);
-    for (let i = 0; i < cache.length; i++) buf.set(cache[i], i);
-
-    assertEquals(data, buf);
-  },
-});