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, 927 deletions

diff --git a/std/testing/asserts_test.ts b/std/testing/asserts_test.ts
deleted file mode 100644
index 14ffd2962..000000000
--- a/std/testing/asserts_test.ts
+++ /dev/null
@@ -1,927 +0,0 @@
-// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
-import {
-  _format,
-  assert,
-  assertArrayIncludes,
-  assertEquals,
-  assertExists,
-  AssertionError,
-  assertMatch,
-  assertNotEquals,
-  assertNotMatch,
-  assertNotStrictEquals,
-  assertObjectMatch,
-  assertStrictEquals,
-  assertStringIncludes,
-  assertThrows,
-  assertThrowsAsync,
-  equal,
-  fail,
-  unimplemented,
-  unreachable,
-} from "./asserts.ts";
-import { bold, gray, green, red, stripColor, yellow } from "../fmt/colors.ts";
-
-Deno.test("testingEqual", function (): void {
-  assert(equal("world", "world"));
-  assert(!equal("hello", "world"));
-  assert(equal(5, 5));
-  assert(!equal(5, 6));
-  assert(equal(NaN, NaN));
-  assert(equal({ hello: "world" }, { hello: "world" }));
-  assert(!equal({ world: "hello" }, { hello: "world" }));
-  assert(
-    equal(
-      { hello: "world", hi: { there: "everyone" } },
-      { hello: "world", hi: { there: "everyone" } },
-    ),
-  );
-  assert(
-    !equal(
-      { hello: "world", hi: { there: "everyone" } },
-      { hello: "world", hi: { there: "everyone else" } },
-    ),
-  );
-  assert(equal(/deno/, /deno/));
-  assert(!equal(/deno/, /node/));
-  assert(equal(new Date(2019, 0, 3), new Date(2019, 0, 3)));
-  assert(!equal(new Date(2019, 0, 3), new Date(2019, 1, 3)));
-  assert(
-    !equal(
-      new Date(2019, 0, 3, 4, 20, 1, 10),
-      new Date(2019, 0, 3, 4, 20, 1, 20),
-    ),
-  );
-  assert(equal(new Date("Invalid"), new Date("Invalid")));
-  assert(!equal(new Date("Invalid"), new Date(2019, 0, 3)));
-  assert(!equal(new Date("Invalid"), new Date(2019, 0, 3, 4, 20, 1, 10)));
-  assert(equal(new Set([1]), new Set([1])));
-  assert(!equal(new Set([1]), new Set([2])));
-  assert(equal(new Set([1, 2, 3]), new Set([3, 2, 1])));
-  assert(equal(new Set([1, new Set([2, 3])]), new Set([new Set([3, 2]), 1])));
-  assert(!equal(new Set([1, 2]), new Set([3, 2, 1])));
-  assert(!equal(new Set([1, 2, 3]), new Set([4, 5, 6])));
-  assert(equal(new Set("denosaurus"), new Set("denosaurussss")));
-  assert(equal(new Map(), new Map()));
-  assert(
-    equal(
-      new Map([
-        ["foo", "bar"],
-        ["baz", "baz"],
-      ]),
-      new Map([
-        ["foo", "bar"],
-        ["baz", "baz"],
-      ]),
-    ),
-  );
-  assert(
-    equal(
-      new Map([["foo", new Map([["bar", "baz"]])]]),
-      new Map([["foo", new Map([["bar", "baz"]])]]),
-    ),
-  );
-  assert(
-    equal(
-      new Map([["foo", { bar: "baz" }]]),
-      new Map([["foo", { bar: "baz" }]]),
-    ),
-  );
-  assert(
-    equal(
-      new Map([
-        ["foo", "bar"],
-        ["baz", "qux"],
-      ]),
-      new Map([
-        ["baz", "qux"],
-        ["foo", "bar"],
-      ]),
-    ),
-  );
-  assert(equal(new Map([["foo", ["bar"]]]), new Map([["foo", ["bar"]]])));
-  assert(!equal(new Map([["foo", "bar"]]), new Map([["bar", "baz"]])));
-  assert(
-    !equal(
-      new Map([["foo", "bar"]]),
-      new Map([
-        ["foo", "bar"],
-        ["bar", "baz"],
-      ]),
-    ),
-  );
-  assert(
-    !equal(
-      new Map([["foo", new Map([["bar", "baz"]])]]),
-      new Map([["foo", new Map([["bar", "qux"]])]]),
-    ),
-  );
-  assert(equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 1 }, true]])));
-  assert(!equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 1 }, false]])));
-  assert(!equal(new Map([[{ x: 1 }, true]]), new Map([[{ x: 2 }, true]])));
-  assert(equal([1, 2, 3], [1, 2, 3]));
-  assert(equal([1, [2, 3]], [1, [2, 3]]));
-  assert(!equal([1, 2, 3, 4], [1, 2, 3]));
-  assert(!equal([1, 2, 3, 4], [1, 2, 3]));
-  assert(!equal([1, 2, 3, 4], [1, 4, 2, 3]));
-  assert(equal(new Uint8Array([1, 2, 3, 4]), new Uint8Array([1, 2, 3, 4])));
-  assert(!equal(new Uint8Array([1, 2, 3, 4]), new Uint8Array([2, 1, 4, 3])));
-  assert(
-    equal(new URL("https://example.test"), new URL("https://example.test")),
-  );
-  assert(
-    !equal(
-      new URL("https://example.test"),
-      new URL("https://example.test/with-path"),
-    ),
-  );
-});
-
-Deno.test("testingNotEquals", function (): void {
-  const a = { foo: "bar" };
-  const b = { bar: "foo" };
-  assertNotEquals(a, b);
-  assertNotEquals("Denosaurus", "Tyrannosaurus");
-  assertNotEquals(
-    new Date(2019, 0, 3, 4, 20, 1, 10),
-    new Date(2019, 0, 3, 4, 20, 1, 20),
-  );
-  assertNotEquals(
-    new Date("invalid"),
-    new Date(2019, 0, 3, 4, 20, 1, 20),
-  );
-  let didThrow;
-  try {
-    assertNotEquals("Raptor", "Raptor");
-    didThrow = false;
-  } catch (e) {
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assertEquals(didThrow, true);
-});
-
-Deno.test("testingAssertExists", function (): void {
-  assertExists("Denosaurus");
-  assertExists(false);
-  assertExists(0);
-  assertExists("");
-  assertExists(-0);
-  assertExists(0);
-  assertExists(NaN);
-  let didThrow;
-  try {
-    assertExists(undefined);
-    didThrow = false;
-  } catch (e) {
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assertEquals(didThrow, true);
-  didThrow = false;
-  try {
-    assertExists(null);
-    didThrow = false;
-  } catch (e) {
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assertEquals(didThrow, true);
-});
-
-Deno.test("testingAssertStringContains", function (): void {
-  assertStringIncludes("Denosaurus", "saur");
-  assertStringIncludes("Denosaurus", "Deno");
-  assertStringIncludes("Denosaurus", "rus");
-  let didThrow;
-  try {
-    assertStringIncludes("Denosaurus", "Raptor");
-    didThrow = false;
-  } catch (e) {
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assertEquals(didThrow, true);
-});
-
-Deno.test("testingArrayContains", function (): void {
-  const fixture = ["deno", "iz", "luv"];
-  const fixtureObject = [{ deno: "luv" }, { deno: "Js" }];
-  assertArrayIncludes(fixture, ["deno"]);
-  assertArrayIncludes(fixtureObject, [{ deno: "luv" }]);
-  assertArrayIncludes(
-    Uint8Array.from([1, 2, 3, 4]),
-    Uint8Array.from([1, 2, 3]),
-  );
-  assertThrows(
-    (): void => assertArrayIncludes(fixtureObject, [{ deno: "node" }]),
-    AssertionError,
-    `actual: "[
-  {
-    deno: "luv",
-  },
-  {
-    deno: "Js",
-  },
-]" expected to include: "[
-  {
-    deno: "node",
-  },
-]"
-missing: [
-  {
-    deno: "node",
-  },
-]`,
-  );
-});
-
-Deno.test("testingAssertStringContainsThrow", function (): void {
-  let didThrow = false;
-  try {
-    assertStringIncludes("Denosaurus from Jurassic", "Raptor");
-  } catch (e) {
-    assert(
-      e.message ===
-        `actual: "Denosaurus from Jurassic" expected to contain: "Raptor"`,
-    );
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assert(didThrow);
-});
-
-Deno.test("testingAssertStringMatching", function (): void {
-  assertMatch("foobar@deno.com", RegExp(/[a-zA-Z]+@[a-zA-Z]+.com/));
-});
-
-Deno.test("testingAssertStringMatchingThrows", function (): void {
-  let didThrow = false;
-  try {
-    assertMatch("Denosaurus from Jurassic", RegExp(/Raptor/));
-  } catch (e) {
-    assert(
-      e.message ===
-        `actual: "Denosaurus from Jurassic" expected to match: "/Raptor/"`,
-    );
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assert(didThrow);
-});
-
-Deno.test("testingAssertStringNotMatching", function (): void {
-  assertNotMatch("foobar.deno.com", RegExp(/[a-zA-Z]+@[a-zA-Z]+.com/));
-});
-
-Deno.test("testingAssertStringNotMatchingThrows", function (): void {
-  let didThrow = false;
-  try {
-    assertNotMatch("Denosaurus from Jurassic", RegExp(/from/));
-  } catch (e) {
-    assert(
-      e.message ===
-        `actual: "Denosaurus from Jurassic" expected to not match: "/from/"`,
-    );
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assert(didThrow);
-});
-
-Deno.test("testingAssertObjectMatching", function (): void {
-  const sym = Symbol("foo");
-  const a = { foo: true, bar: false };
-  const b = { ...a, baz: a };
-  const c = { ...b, qux: b };
-  const d = { corge: c, grault: c };
-  const e = { foo: true } as { [key: string]: unknown };
-  e.bar = e;
-  const f = { [sym]: true, bar: false };
-  // Simple subset
-  assertObjectMatch(a, {
-    foo: true,
-  });
-  // Subset with another subset
-  assertObjectMatch(b, {
-    foo: true,
-    baz: { bar: false },
-  });
-  // Subset with multiple subsets
-  assertObjectMatch(c, {
-    foo: true,
-    baz: { bar: false },
-    qux: {
-      baz: { foo: true },
-    },
-  });
-  // Subset with same object reference as subset
-  assertObjectMatch(d, {
-    corge: {
-      foo: true,
-      qux: { bar: false },
-    },
-    grault: {
-      bar: false,
-      qux: { foo: true },
-    },
-  });
-  // Subset with circular reference
-  assertObjectMatch(e, {
-    foo: true,
-    bar: {
-      bar: {
-        bar: {
-          foo: true,
-        },
-      },
-    },
-  });
-  // Subset with same symbol
-  assertObjectMatch(f, {
-    [sym]: true,
-  });
-  // Missing key
-  {
-    let didThrow;
-    try {
-      assertObjectMatch({
-        foo: true,
-      }, {
-        foo: true,
-        bar: false,
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Simple subset
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(a, {
-        foo: false,
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Subset with another subset
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(b, {
-        foo: true,
-        baz: { bar: true },
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Subset with multiple subsets
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(c, {
-        foo: true,
-        baz: { bar: false },
-        qux: {
-          baz: { foo: false },
-        },
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Subset with same object reference as subset
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(d, {
-        corge: {
-          foo: true,
-          qux: { bar: true },
-        },
-        grault: {
-          bar: false,
-          qux: { foo: false },
-        },
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Subset with circular reference
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(e, {
-        foo: true,
-        bar: {
-          bar: {
-            bar: {
-              foo: false,
-            },
-          },
-        },
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-  // Subset with symbol key but with string key subset
-  {
-    let didThrow;
-    try {
-      assertObjectMatch(f, {
-        foo: true,
-      });
-      didThrow = false;
-    } catch (e) {
-      assert(e instanceof AssertionError);
-      didThrow = true;
-    }
-    assertEquals(didThrow, true);
-  }
-});
-
-Deno.test("testingAssertsUnimplemented", function (): void {
-  let didThrow = false;
-  try {
-    unimplemented();
-  } catch (e) {
-    assert(e.message === "unimplemented");
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assert(didThrow);
-});
-
-Deno.test("testingAssertsUnreachable", function (): void {
-  let didThrow = false;
-  try {
-    unreachable();
-  } catch (e) {
-    assert(e.message === "unreachable");
-    assert(e instanceof AssertionError);
-    didThrow = true;
-  }
-  assert(didThrow);
-});
-
-Deno.test("testingAssertFail", function (): void {
-  assertThrows(fail, AssertionError, "Failed assertion.");
-  assertThrows(
-    (): void => {
-      fail("foo");
-    },
-    AssertionError,
-    "Failed assertion: foo",
-  );
-});
-
-Deno.test("testingAssertFailWithWrongErrorClass", function (): void {
-  assertThrows(
-    (): void => {
-      //This next assertThrows will throw an AssertionError due to the wrong
-      //expected error class
-      assertThrows(
-        (): void => {
-          fail("foo");
-        },
-        TypeError,
-        "Failed assertion: foo",
-      );
-    },
-    AssertionError,
-    `Expected error to be instance of "TypeError", but was "AssertionError"`,
-  );
-});
-
-Deno.test("testingAssertThrowsWithReturnType", () => {
-  assertThrows(() => {
-    throw new Error();
-  });
-});
-
-Deno.test("testingAssertThrowsAsyncWithReturnType", () => {
-  assertThrowsAsync(() => {
-    throw new Error();
-  });
-});
-
-const createHeader = (): string[] => [
-  "",
-  "",
-  `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${
-    green(
-      bold("Expected"),
-    )
-  }`,
-  "",
-  "",
-];
-
-const added: (s: string) => string = (s: string): string =>
-  green(bold(stripColor(s)));
-const removed: (s: string) => string = (s: string): string =>
-  red(bold(stripColor(s)));
-
-Deno.test({
-  name: "pass case",
-  fn(): void {
-    assertEquals({ a: 10 }, { a: 10 });
-    assertEquals(true, true);
-    assertEquals(10, 10);
-    assertEquals("abc", "abc");
-    assertEquals({ a: 10, b: { c: "1" } }, { a: 10, b: { c: "1" } });
-    assertEquals(new Date("invalid"), new Date("invalid"));
-  },
-});
-
-Deno.test({
-  name: "failed with number",
-  fn(): void {
-    assertThrows(
-      (): void => assertEquals(1, 2),
-      AssertionError,
-      [
-        "Values are not equal:",
-        ...createHeader(),
-        removed(`-   ${yellow("1")}`),
-        added(`+   ${yellow("2")}`),
-        "",
-      ].join("\n"),
-    );
-  },
-});
-
-Deno.test({
-  name: "failed with number vs string",
-  fn(): void {
-    assertThrows(
-      (): void => assertEquals(1, "1"),
-      AssertionError,
-      [
-        "Values are not equal:",
-        ...createHeader(),
-        removed(`-   ${yellow("1")}`),
-        added(`+   "1"`),
-      ].join("\n"),
-    );
-  },
-});
-
-Deno.test({
-  name: "failed with array",
-  fn(): void {
-    assertThrows(
-      (): void => assertEquals([1, "2", 3], ["1", "2", 3]),
-      AssertionError,
-      `
-    [
--     1,
-+     "1",
-      "2",
-      3,
-    ]`,
-    );
-  },
-});
-
-Deno.test({
-  name: "failed with object",
-  fn(): void {
-    assertThrows(
-      (): void => assertEquals({ a: 1, b: "2", c: 3 }, { a: 1, b: 2, c: [3] }),
-      AssertionError,
-      `
-    {
-      a: 1,
-+     b: 2,
-+     c: [
-+       3,
-+     ],
--     b: "2",
--     c: 3,
-    }`,
-    );
-  },
-});
-
-Deno.test({
-  name: "failed with date",
-  fn(): void {
-    assertThrows(
-      (): void =>
-        assertEquals(
-          new Date(2019, 0, 3, 4, 20, 1, 10),
-          new Date(2019, 0, 3, 4, 20, 1, 20),
-        ),
-      AssertionError,
-      [
-        "Values are not equal:",
-        ...createHeader(),
-        removed(`-   ${new Date(2019, 0, 3, 4, 20, 1, 10).toISOString()}`),
-        added(`+   ${new Date(2019, 0, 3, 4, 20, 1, 20).toISOString()}`),
-        "",
-      ].join("\n"),
-    );
-    assertThrows(
-      (): void =>
-        assertEquals(
-          new Date("invalid"),
-          new Date(2019, 0, 3, 4, 20, 1, 20),
-        ),
-      AssertionError,
-      [
-        "Values are not equal:",
-        ...createHeader(),
-        removed(`-   ${new Date("invalid")}`),
-        added(`+   ${new Date(2019, 0, 3, 4, 20, 1, 20).toISOString()}`),
-        "",
-      ].join("\n"),
-    );
-  },
-});
-
-Deno.test({
-  name: "strict pass case",
-  fn(): void {
-    assertStrictEquals(true, true);
-    assertStrictEquals(10, 10);
-    assertStrictEquals("abc", "abc");
-
-    const xs = [1, false, "foo"];
-    const ys = xs;
-    assertStrictEquals(xs, ys);
-
-    const x = { a: 1 };
-    const y = x;
-    assertStrictEquals(x, y);
-  },
-});
-
-Deno.test({
-  name: "strict failed with structure diff",
-  fn(): void {
-    assertThrows(
-      (): void => assertStrictEquals({ a: 1, b: 2 }, { a: 1, c: [3] }),
-      AssertionError,
-      `
-    {
-      a: 1,
-+     c: [
-+       3,
-+     ],
--     b: 2,
-    }`,
-    );
-  },
-});
-
-Deno.test({
-  name: "strict failed with reference diff",
-  fn(): void {
-    assertThrows(
-      (): void => assertStrictEquals({ a: 1, b: 2 }, { a: 1, b: 2 }),
-      AssertionError,
-      `Values have the same structure but are not reference-equal:
-
-    {
-      a: 1,
-      b: 2,
-    }`,
-    );
-  },
-});
-
-Deno.test({
-  name: "strictly unequal pass case",
-  fn(): void {
-    assertNotStrictEquals(true, false);
-    assertNotStrictEquals(10, 11);
-    assertNotStrictEquals("abc", "xyz");
-    assertNotStrictEquals(1, "1");
-
-    const xs = [1, false, "foo"];
-    const ys = [1, true, "bar"];
-    assertNotStrictEquals(xs, ys);
-
-    const x = { a: 1 };
-    const y = { a: 2 };
-    assertNotStrictEquals(x, y);
-  },
-});
-
-Deno.test({
-  name: "strictly unequal fail case",
-  fn(): void {
-    assertThrows(() => assertNotStrictEquals(1, 1), AssertionError);
-  },
-});
-
-Deno.test({
-  name: "assert* functions with specified type parameter",
-  fn(): void {
-    assertEquals<string>("hello", "hello");
-    assertNotEquals<number>(1, 2);
-    assertArrayIncludes<boolean>([true, false], [true]);
-    const value = { x: 1 };
-    assertStrictEquals<typeof value>(value, value);
-    // deno-lint-ignore ban-types
-    assertNotStrictEquals<object>(value, { x: 1 });
-  },
-});
-
-Deno.test("Assert Throws Non-Error Fail", () => {
-  assertThrows(
-    () => {
-      assertThrows(
-        () => {
-          throw "Panic!";
-        },
-        String,
-        "Panic!",
-      );
-    },
-    AssertionError,
-    "A non-Error object was thrown.",
-  );
-
-  assertThrows(
-    () => {
-      assertThrows(() => {
-        throw null;
-      });
-    },
-    AssertionError,
-    "A non-Error object was thrown.",
-  );
-
-  assertThrows(
-    () => {
-      assertThrows(() => {
-        throw undefined;
-      });
-    },
-    AssertionError,
-    "A non-Error object was thrown.",
-  );
-});
-
-Deno.test("Assert Throws Async Non-Error Fail", () => {
-  assertThrowsAsync(
-    () => {
-      return assertThrowsAsync(
-        () => {
-          return Promise.reject("Panic!");
-        },
-        String,
-        "Panic!",
-      );
-    },
-    AssertionError,
-    "A non-Error object was thrown or rejected.",
-  );
-
-  assertThrowsAsync(
-    () => {
-      return assertThrowsAsync(() => {
-        return Promise.reject(null);
-      });
-    },
-    AssertionError,
-    "A non-Error object was thrown or rejected.",
-  );
-
-  assertThrowsAsync(
-    () => {
-      return assertThrowsAsync(() => {
-        return Promise.reject(undefined);
-      });
-    },
-    AssertionError,
-    "A non-Error object was thrown or rejected.",
-  );
-
-  assertThrowsAsync(
-    () => {
-      return assertThrowsAsync(() => {
-        throw undefined;
-      });
-    },
-    AssertionError,
-    "A non-Error object was thrown or rejected.",
-  );
-});
-
-Deno.test("assertEquals diff for differently ordered objects", () => {
-  assertThrows(
-    () => {
-      assertEquals(
-        {
-          aaaaaaaaaaaaaaaaaaaaaaaa: 0,
-          bbbbbbbbbbbbbbbbbbbbbbbb: 0,
-          ccccccccccccccccccccccc: 0,
-        },
-        {
-          ccccccccccccccccccccccc: 1,
-          aaaaaaaaaaaaaaaaaaaaaaaa: 0,
-          bbbbbbbbbbbbbbbbbbbbbbbb: 0,
-        },
-      );
-    },
-    AssertionError,
-    `
-    {
-      aaaaaaaaaaaaaaaaaaaaaaaa: 0,
-      bbbbbbbbbbbbbbbbbbbbbbbb: 0,
--     ccccccccccccccccccccccc: 0,
-+     ccccccccccccccccccccccc: 1,
-    }`,
-  );
-});
-
-// Check that the diff formatter overrides some default behaviours of
-// `Deno.inspect()` which are problematic for diffing.
-Deno.test("assert diff formatting", () => {
-  // Wraps objects into multiple lines even when they are small. Prints trailing
-  // commas.
-  assertEquals(
-    stripColor(_format({ a: 1, b: 2 })),
-    `{
-  a: 1,
-  b: 2,
-}`,
-  );
-
-  // Same for nested small objects.
-  assertEquals(
-    stripColor(_format([{ x: { a: 1, b: 2 }, y: ["a", "b"] }])),
-    `[
-  {
-    x: {
-      a: 1,
-      b: 2,
-    },
-    y: [
-      "a",
-      "b",
-    ],
-  },
-]`,
-  );
-
-  // Grouping is disabled.
-  assertEquals(
-    stripColor(_format(["i", "i", "i", "i", "i", "i", "i"])),
-    `[
-  "i",
-  "i",
-  "i",
-  "i",
-  "i",
-  "i",
-  "i",
-]`,
-  );
-});
-
-Deno.test("Assert Throws Parent Error", () => {
-  assertThrows(
-    () => {
-      throw new AssertionError("Fail!");
-    },
-    Error,
-    "Fail!",
-  );
-});
-
-Deno.test("Assert Throws Async Parent Error", () => {
-  assertThrowsAsync(
-    () => {
-      throw new AssertionError("Fail!");
-    },
-    Error,
-    "Fail!",
-  );
-});