1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.import {  assert,  assertEquals,  assertObjectMatch,  assertStrictEquals,} from "./asserts.ts";import {  afterAll,  afterEach,  beforeAll,  beforeEach,  describe,  it,} from "./bdd.ts";import { TestSuiteInternal } from "./_test_suite.ts";import { assertSpyCall, assertSpyCalls, Spy, spy, stub } from "./mock.ts";
Deno.test("global", async (t) => {  class TestContext implements Deno.TestContext {    name: string;    origin: string;    steps: TestContext[];    spies: {      step: Spy;    };
    constructor(name: string) {      this.name = name;      this.origin = "origin";      this.spies = {        step: spy(this, "step"),      };      this.steps = [];    }
    async step(t: Deno.TestStepDefinition): Promise<boolean>;    async step(      name: string,      fn: (t: Deno.TestContext) => void | Promise<void>,    ): Promise<boolean>;    async step(      fn: (t: Deno.TestContext) => void | Promise<void>,    ): Promise<boolean>;    async step(      tOrNameOrFn:        | Deno.TestStepDefinition        | string        | ((t: Deno.TestContext) => void | Promise<void>),      fn?: (t: Deno.TestContext) => void | Promise<void>,    ): Promise<boolean> {      let ignore = false;      if (typeof tOrNameOrFn === "function") {        ignore = false;        fn = tOrNameOrFn;      } else if (typeof tOrNameOrFn === "object") {        ignore = tOrNameOrFn.ignore ?? false;        fn = tOrNameOrFn.fn;      }
      const name = typeof tOrNameOrFn === "string"        ? tOrNameOrFn        : tOrNameOrFn.name;      const context = new TestContext(name);      this.steps.push(context);      if (!ignore) {        await fn!(context);      }      return !ignore;    }  }
  const baseStepOptions: Omit<Deno.TestStepDefinition, "name" | "fn"> = {    ignore: false,    sanitizeExit: true,    sanitizeOps: true,    sanitizeResources: true,  };
  const baseOptions: Omit<Deno.TestDefinition, "name" | "fn"> = {    ...baseStepOptions,    only: false,    permissions: "inherit",  };
  interface GlobalContext {    allTimer: number;    eachTimer: number;    x?: number;    y?: number;  }
  let timerIdx = 1;  const timers = new Map<number, number>();  function hookFns() {    timerIdx = 1;    timers.clear();    return {      beforeAllFn: spy(async function (this: GlobalContext) {        await Promise.resolve();        this.allTimer = timerIdx++;        timers.set(this.allTimer, setTimeout(() => {}, 10000));      }),      afterAllFn: spy(async function (this: GlobalContext) {        await Promise.resolve();        clearTimeout(timers.get(this.allTimer));      }),      beforeEachFn: spy(async function (this: GlobalContext) {        await Promise.resolve();        this.eachTimer = timerIdx++;        timers.set(this.eachTimer, setTimeout(() => {}, 10000));      }),      afterEachFn: spy(async function (this: GlobalContext) {        await Promise.resolve();        clearTimeout(timers.get(this.eachTimer));      }),    };  }
  await t.step("global hooks", async () => {    const test = stub(Deno, "test"),      fns = [spy(), spy()],      { beforeAllFn, afterAllFn, beforeEachFn, afterEachFn } = hookFns();
    const context = new TestContext("global");    try {      beforeAll(beforeAllFn);      afterAll(afterAllFn);
      beforeEach(beforeEachFn);      afterEach(afterEachFn);
      assertEquals(it({ name: "example 1", fn: fns[0] }), undefined);      assertEquals(it({ name: "example 2", fn: fns[1] }), undefined);
      assertSpyCalls(fns[0], 0);      assertSpyCalls(fns[1], 0);
      assertSpyCall(test, 0);      const call = test.calls[0];      const options = call.args[0] as Deno.TestDefinition;      assertEquals(Object.keys(options).sort(), ["fn", "name"]);      assertEquals(options.name, "global");
      const result = options.fn(context);      assertStrictEquals(Promise.resolve(result), result);      assertEquals(await result, undefined);      assertSpyCalls(context.spies.step, 2);    } finally {      TestSuiteInternal.reset();      test.restore();    }
    let fn = fns[0];    assertSpyCall(fn, 0, {      self: { allTimer: 1, eachTimer: 2 },      args: [context.steps[0]],      returned: undefined,    });    assertSpyCalls(fn, 1);
    fn = fns[1];    assertSpyCall(fn, 0, {      self: { allTimer: 1, eachTimer: 3 },      args: [context.steps[1]],      returned: undefined,    });    assertSpyCalls(fn, 1);
    assertSpyCalls(beforeAllFn, 1);    assertSpyCalls(afterAllFn, 1);    assertSpyCalls(beforeEachFn, 2);    assertSpyCalls(afterEachFn, 2);  });
  await t.step("it", async (t) => {    /**     * Asserts that `Deno.test` is called with the correct options for the `it` call in the callback function.     * This is used to reduce code duplication when testing calling `it` with different call signatures.     */    async function assertOptions<T>(      expectedOptions: Omit<Deno.TestDefinition, "name" | "fn">,      cb: (fn: Spy) => void,    ) {      const test = stub(Deno, "test");      const fn = spy();      try {        cb(fn);
        assertSpyCalls(fn, 0);        assertSpyCall(test, 0);        const call = test.calls[0];        const options = call.args[0] as Deno.TestDefinition;        assertEquals(          Object.keys(options).sort(),          ["name", "fn", ...Object.keys(expectedOptions)].sort(),        );        assertObjectMatch(options, {          name: "example",          ...expectedOptions,        });
        const context = new TestContext("example");        const result = options.fn(context);        assertStrictEquals(Promise.resolve(result), result);        assertEquals(await result, undefined);        assertSpyCalls(context.spies.step, 0);        assertSpyCall(fn, 0, {          self: {},          args: [context],          returned: undefined,        });      } finally {        TestSuiteInternal.reset();        test.restore();      }    }
    /**     * Asserts that `Deno.test` is called with just the name and function for the `it` call in the callback function.     * This is used to reduce code duplication when testing calling `it` with different call signatures.     */    async function assertMinimumOptions(      cb: (fn: Spy) => void,    ) {      await assertOptions({}, cb);    }
    /**     * Asserts that `Deno.test` is called with all of the options for the `it` call in the callback function.     * This is used to reduce code duplication when testing calling `it` with different call signatures.     */    async function assertAllOptions(      cb: (fn: Spy) => void,    ) {      await assertOptions(baseOptions, cb);    }
    await t.step("signature 1", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it({ name: "example", fn }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fn) => {          assertEquals(            it({              name: "example",              fn,              ...baseOptions,            }),            undefined,          );        }));    });
    await t.step("signature 2", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it("example", { fn }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fn) => {          assertEquals(            it("example", {              fn,              ...baseOptions,            }),            undefined,          );        }));    });
    await t.step("signature 3", async () =>      await assertMinimumOptions((fn) => {        assertEquals(it("example", fn), undefined);      }));
    await t.step("signature 4", async () =>      await assertMinimumOptions((fn) => {        assertEquals(          it(function example(this: void, ...args) {            fn.apply(this, args);          }),          undefined,        );      }));
    await t.step("signature 5", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it("example", {}, fn), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fn) => {          assertEquals(            it("example", {              ...baseOptions,            }, fn),            undefined,          );        }));    });
    await t.step("signature 6", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it({ name: "example" }, fn), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fn) => {          assertEquals(            it({              name: "example",              ...baseOptions,            }, fn),            undefined,          );        }));    });
    await t.step("signature 7", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(              it({}, function example(this: void, ...args) {                fn.apply(this, args);              }),              undefined,            );          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fn) => {          assertEquals(            it({              ...baseOptions,            }, function example(this: void, ...args) {              fn.apply(this, args);            }),            undefined,          );        }));    });
    await t.step("only", async (t) => {      /**       * Asserts that `Deno.test` is called with just the name, only, and function for the `it.only` call in the callback function.       * This is used to reduce code duplication when testing calling `it.only` with different call signatures.       */      async function assertMinimumOptions(        cb: (fn: Spy) => void,      ) {        await assertOptions({ only: true }, cb);      }
      /**       * Asserts that `Deno.test` is called with all of the options for the `it.only` call in the callback function.       * This is used to reduce code duplication when testing calling `it.only` with different call signatures.       */      async function assertAllOptions(        cb: (fn: Spy) => void,      ) {        await assertOptions({ ...baseOptions, only: true }, cb);      }
      await t.step("signature 1", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.only({ name: "example", fn }), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.only({                name: "example",                fn,                ...baseOptions,              }),              undefined,            );          }));      });
      await t.step("signature 2", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.only("example", { fn }), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.only("example", {                fn,                ...baseOptions,              }),              undefined,            );          }));      });
      await t.step(        "signature 3",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it.only("example", fn), undefined);          }),      );
      await t.step(        "signature 4",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(              it.only(function example(this: void, ...args) {                fn.apply(this, args);              }),              undefined,            );          }),      );
      await t.step("signature 5", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.only("example", {}, fn), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.only("example", {                ...baseOptions,              }, fn),              undefined,            );          }));      });
      await t.step("signature 6", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.only({ name: "example" }, fn), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.only({                name: "example",                ...baseOptions,              }, fn),              undefined,            );          }));      });
      await t.step("signature 7", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(                it.only({}, function example(this: void, ...args) {                  fn.apply(this, args);                }),                undefined,              );            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.only({                ...baseOptions,              }, function example(this: void, ...args) {                fn.apply(this, args);              }),              undefined,            );          }));      });    });
    await t.step("ignore", async (t) => {      /**       * Asserts that `Deno.test` is called with just the name, ignore, and function for the `it.ignore` call in the callback function.       * This is used to reduce code duplication when testing calling `it.ignore` with different call signatures.       */      async function assertMinimumOptions(        cb: (fn: Spy) => void,      ) {        await assertOptions({ ignore: true }, cb);      }
      /**       * Asserts that `Deno.test` is called with all of the options for the `it.ignore` call in the callback function.       * This is used to reduce code duplication when testing calling `it.ignore` with different call signatures.       */      async function assertAllOptions(        cb: (fn: Spy) => void,      ) {        await assertOptions({ ...baseOptions, ignore: true }, cb);      }
      await t.step("signature 1", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.ignore({ name: "example", fn }), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.ignore({                name: "example",                fn,                ...baseOptions,              }),              undefined,            );          }));      });
      await t.step("signature 2", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.ignore("example", { fn }), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.ignore("example", {                fn,                ...baseOptions,              }),              undefined,            );          }));      });
      await t.step(        "signature 3",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(it.ignore("example", fn), undefined);          }),      );
      await t.step(        "signature 4",        async () =>          await assertMinimumOptions((fn) => {            assertEquals(              it.ignore(function example(this: void, ...args) {                fn.apply(this, args);              }),              undefined,            );          }),      );
      await t.step("signature 5", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.ignore("example", {}, fn), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.ignore("example", {                ...baseOptions,              }, fn),              undefined,            );          }));      });
      await t.step("signature 6", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(it.ignore({ name: "example" }, fn), undefined);            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.ignore({                name: "example",                ...baseOptions,              }, fn),              undefined,            );          }));      });
      await t.step("signature 7", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fn) => {              assertEquals(                it.ignore({}, function example(this: void, ...args) {                  fn.apply(this, args);                }),                undefined,              );            }),        );
        await t.step("all options", async () =>          await assertAllOptions((fn) => {            assertEquals(              it.ignore({                ...baseOptions,              }, function example(this: void, ...args) {                fn.apply(this, args);              }),              undefined,            );          }));      });
      await t.step(".skip is an alias of .ignore", () => {        assertEquals(it.ignore, it.skip);      });    });  });
  await t.step("describe", async (t) => {    /**     * Asserts that `Deno.test` is called with the correct options for the `describe` call in the callback function.     * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.     * This is used to reduce code duplication when testing calling `describe` with different call signatures.     */    async function assertOptions(      expectedOptions: Omit<Deno.TestDefinition, "name" | "fn">,      cb: (fns: Spy[]) => void,    ) {      const test = stub(Deno, "test");      const fns = [spy(), spy()];      try {        cb(fns);
        assertSpyCall(test, 0);        const call = test.calls[0];        const options = call.args[0] as Deno.TestDefinition;        assertEquals(          Object.keys(options).sort(),          ["name", "fn", ...Object.keys(expectedOptions)].sort(),        );        assertObjectMatch(options, {          name: "example",          ...expectedOptions,        });
        assertSpyCalls(fns[0], 0);        assertSpyCalls(fns[1], 0);
        const context = new TestContext("example");        const result = options.fn(context);        assertStrictEquals(Promise.resolve(result), result);        assertEquals(await result, undefined);        assertSpyCalls(context.spies.step, 2);
        let fn = fns[0];        assertSpyCall(fn, 0, {          self: {},          args: [context.steps[0]],          returned: undefined,        });
        fn = fns[1];        assertSpyCall(fn, 0, {          self: {},          args: [context.steps[1]],          returned: undefined,        });        assertSpyCalls(fn, 1);      } finally {        TestSuiteInternal.reset();        test.restore();      }    }
    /**     * Asserts that `Deno.test` is called with just the name and function for the `describe` call in the callback function.     * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.     * This is used to reduce code duplication when testing calling `describe` with different call signatures.     */    async function assertMinimumOptions(      cb: (fns: Spy[]) => void,    ) {      await assertOptions({}, cb);    }
    /**     * Asserts that `Deno.test` is called with all of the options for the `describe` call in the callback function.     * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.     * This is used to reduce code duplication when testing calling `describe` with different call signatures.     */    async function assertAllOptions(      cb: (fns: Spy[]) => void,    ) {      await assertOptions({ ...baseOptions }, cb);    }
    await t.step("signature 1", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe({ name: "example" });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fns) => {          const suite = describe({            name: "example",            fn: () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            },            ...baseOptions,          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }));    });
    await t.step(      "signature 2",      async () =>        await assertMinimumOptions((fns) => {          const suite = describe("example");          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }),    );
    await t.step("signature 3", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe("example", {});            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fns) => {          const suite = describe("example", {            fn: () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            },            ...baseOptions,          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }));    });
    await t.step(      "signature 4",      async () =>        await assertMinimumOptions((fns) => {          const suite = describe("example", () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }),    );
    await t.step(      "signature 5",      async () =>        await assertMinimumOptions((fns) => {          const suite = describe(function example() {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }),    );
    await t.step("signature 6", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe("example", {}, () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fns) => {          const suite = describe("example", {            ...baseOptions,          }, () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }));    });
    await t.step("signature 7", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe({ name: "example" }, () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fns) => {          const suite = describe({            name: "example",            ...baseOptions,          }, () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }));    });
    await t.step("signature 8", async (t) => {      await t.step(        "minimum options",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe({}, function example() {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("all options", async () =>        await assertAllOptions((fns) => {          const suite = describe({            ...baseOptions,          }, function example() {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);          });          assert(suite && typeof suite.symbol === "symbol");          assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);        }));    });
    await t.step("only", async (t) => {      /**       * Asserts that `Deno.test` is called with just the name, only, and function for the `describe.only` call in the callback function.       * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.       * This is used to reduce code duplication when testing calling `describe.only` with different call signatures.       */      async function assertMinimumOptions(        cb: (fns: Spy[]) => void,      ) {        await assertOptions({ only: true }, cb);      }
      /**       * Asserts that `Deno.test` is called with all of the options for the `describe.only` call in the callback function.       * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.       * This is used to reduce code duplication when testing calling `describe.only` with different call signatures.       */      async function assertAllOptions(        cb: (fns: Spy[]) => void,      ) {        await assertOptions({ ...baseOptions, only: true }, cb);      }
      await t.step("signature 1", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.only({ name: "example" });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.only({                name: "example",                fn: () => {                  assertEquals(it({ name: "a", fn: fns[0] }), undefined);                },                ...baseOptions,              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step(        "signature 2",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.only("example");            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("signature 3", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.only("example", {});              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.only("example", {                fn: () => {                  assertEquals(it({ name: "a", fn: fns[0] }), undefined);                },                ...baseOptions,              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step(        "signature 4",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.only("example", () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step(        "signature 5",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.only(function example() {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("signature 6", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.only("example", {}, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.only("example", {                ...baseOptions,              }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step("signature 7", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.only({ name: "example" }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.only({                name: "example",                ...baseOptions,              }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step("signature 8", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.only({}, function example() {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.only({                ...baseOptions,              }, function example() {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });    });
    await t.step("ignore", async (t) => {      /**       * Asserts that `Deno.test` is called with just the name, ignore, and function for the `describe.ignore` call in the callback function.       * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.       * This is used to reduce code duplication when testing calling `describe.ignore` with different call signatures.       */      async function assertMinimumOptions(        cb: (fns: Spy[]) => void,      ) {        await assertOptions({ ignore: true }, cb);      }
      /**       * Asserts that `Deno.test` is called with all of the options for the `describe.ignore` call in the callback function.       * In addition to that, it asserts that the individual test cases registered with `it` use the test step API correctly.       * This is used to reduce code duplication when testing calling `describe.ignore` with different call signatures.       */      async function assertAllOptions(        cb: (fns: Spy[]) => void,      ) {        await assertOptions({ ...baseOptions, ignore: true }, cb);      }
      await t.step("signature 1", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.ignore({ name: "example" });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.ignore({                name: "example",                fn: () => {                  assertEquals(it({ name: "a", fn: fns[0] }), undefined);                },                ...baseOptions,              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step(        "signature 2",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.ignore("example");            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("signature 3", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.ignore("example", {});              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "a", fn: fns[0] }), undefined);              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.ignore("example", {                fn: () => {                  assertEquals(it({ name: "a", fn: fns[0] }), undefined);                },                ...baseOptions,              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step(        "signature 4",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.ignore("example", () => {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step(        "signature 5",        async () =>          await assertMinimumOptions((fns) => {            const suite = describe.ignore(function example() {              assertEquals(it({ name: "a", fn: fns[0] }), undefined);            });            assert(suite && typeof suite.symbol === "symbol");            assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);          }),      );
      await t.step("signature 6", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.ignore("example", {}, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.ignore("example", {                ...baseOptions,              }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step("signature 7", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.ignore({ name: "example" }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.ignore({                name: "example",                ...baseOptions,              }, () => {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step("signature 8", async (t) => {        await t.step(          "minimum options",          async () =>            await assertMinimumOptions((fns) => {              const suite = describe.ignore({}, function example() {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );
        await t.step(          "all options",          async () =>            await assertAllOptions((fns) => {              const suite = describe.ignore({                ...baseOptions,              }, function example() {                assertEquals(it({ name: "a", fn: fns[0] }), undefined);              });              assert(suite && typeof suite.symbol === "symbol");              assertEquals(it({ suite, name: "b", fn: fns[1] }), undefined);            }),        );      });
      await t.step(".skip is an alias of .ignore", () => {        assertEquals(describe.ignore, describe.skip);      });    });
    await t.step("nested only", async (t) => {      /**       * Asserts that when only is used on a nested `describe` or `it` call, it will be the only test case or suite that runs in the file.       * This is used to reduce code duplication when testing calling `describe.ignore` with different call signatures.       */      async function assertOnly(        cb: (fns: Spy[]) => void,      ) {        const test = stub(Deno, "test");        const fns = [spy(), spy(), spy()];        try {          cb(fns);
          assertSpyCall(test, 0);          const call = test.calls[0];          const options = call.args[0] as Deno.TestDefinition;          assertEquals(            Object.keys(options).sort(),            ["name", "only", "fn"].sort(),          );          assertObjectMatch(options, {            name: "example",            only: true,          });
          assertSpyCalls(fns[0], 0);          assertSpyCalls(fns[1], 0);
          const context = new TestContext("example");          const result = options.fn(context);          assertStrictEquals(Promise.resolve(result), result);          assertEquals(await result, undefined);          assertSpyCalls(context.spies.step, 1);
          let fn = fns[0];          assertSpyCalls(fn, 0);
          fn = fns[1];          assertSpyCall(fn, 0, {            self: {},            returned: undefined,          });          assertSpyCalls(fn, 1);
          fn = fns[2];          assertSpyCalls(fn, 0);        } finally {          TestSuiteInternal.reset();          test.restore();        }      }
      await t.step("it", async () =>        await assertOnly((fns) => {          describe("example", () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);            assertEquals(it.only({ name: "b", fn: fns[1] }), undefined);            assertEquals(it({ name: "c", fn: fns[2] }), undefined);          });        }));
      await t.step("nested it", async () =>        await assertOnly((fns) => {          describe("example", () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);            describe("nested", () => {              assertEquals(it.only({ name: "b", fn: fns[1] }), undefined);            });            assertEquals(it({ name: "c", fn: fns[2] }), undefined);          });        }));
      await t.step("describe", async () =>        await assertOnly((fns) => {          describe("example", () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);            describe.only("nested", () => {              assertEquals(it({ name: "b", fn: fns[1] }), undefined);            });            assertEquals(it({ name: "c", fn: fns[2] }), undefined);          });        }));
      await t.step("nested describe", async () =>        await assertOnly((fns) => {          describe("example", () => {            assertEquals(it({ name: "a", fn: fns[0] }), undefined);            describe("nested", () => {              describe.only("nested 2", () => {                assertEquals(it({ name: "b", fn: fns[1] }), undefined);              });            });            assertEquals(it({ name: "c", fn: fns[2] }), undefined);          });        }));    });
    await t.step("flat child only", async (t) => {      /**       * Asserts that when only is used on a child `describe` or `it` call, it will be the only test case or suite that runs within the top test suite.       * This demonstrates the issue where `Deno.test` is called without `only` even though one of it's child steps are focused.       * This is used to reduce code duplication when testing calling `describe.ignore` with different call signatures.       */      async function assertOnly(        cb: (fns: Spy[]) => void,      ) {        const test = stub(Deno, "test");        const fns = [spy(), spy(), spy()];        try {          cb(fns);
          assertSpyCall(test, 0);          const call = test.calls[0];          const options = call.args[0] as Deno.TestDefinition;          assertEquals(            Object.keys(options).sort(),            ["name", "fn"].sort(),          );          assertObjectMatch(options, {            name: "example",          });
          assertSpyCalls(fns[0], 0);          assertSpyCalls(fns[1], 0);
          const context = new TestContext("example");          const result = options.fn(context);          assertStrictEquals(Promise.resolve(result), result);          assertEquals(await result, undefined);          assertSpyCalls(context.spies.step, 1);
          let fn = fns[0];          assertSpyCalls(fn, 0);
          fn = fns[1];          assertSpyCall(fn, 0, {            self: {},            returned: undefined,          });          assertSpyCalls(fn, 1);
          fn = fns[2];          assertSpyCalls(fn, 0);        } finally {          TestSuiteInternal.reset();          test.restore();        }      }
      await t.step("it", async () =>        await assertOnly((fns) => {          const suite = describe("example");          assertEquals(it({ name: "a", suite, fn: fns[0] }), undefined);          assertEquals(it.only({ name: "b", suite, fn: fns[1] }), undefined);          assertEquals(it({ name: "c", suite, fn: fns[2] }), undefined);        }));
      await t.step("deep child it", async () =>        await assertOnly((fns) => {          const suite = describe("example");          assertEquals(it({ name: "a", suite, fn: fns[0] }), undefined);          const childSuite = describe(suite, "child");          assertEquals(            it.only({ name: "b", suite: childSuite, fn: fns[1] }),            undefined,          );          assertEquals(it({ name: "c", suite, fn: fns[2] }), undefined);        }));
      await t.step("describe", async () =>        await assertOnly((fns) => {          const suite = describe("example");          assertEquals(it({ name: "a", suite, fn: fns[0] }), undefined);          const childSuite = describe.only(suite, "child");          assertEquals(            it({ name: "b", suite: childSuite, fn: fns[1] }),            undefined,          );          assertEquals(it({ name: "c", suite, fn: fns[2] }), undefined);        }));
      await t.step(        "deep child describe",        async () =>          await assertOnly((fns) => {            const suite = describe("example");            assertEquals(it({ name: "a", suite, fn: fns[0] }), undefined);            const childSuite = describe(suite, "child");            const child2Suite = describe.only(childSuite, "child 2");            assertEquals(              it({ name: "b", suite: child2Suite, fn: fns[1] }),              undefined,            );            assertEquals(it({ name: "c", suite, fn: fns[2] }), undefined);          }),      );    });
    await t.step("with hooks", async (t) => {      /**       * Asserts that all the different hook types are called in the correct order when the tests run.       * This is used to reduce code duplication when testing calling `describe` with different call signatures.       */      async function assertHooks(        cb: (          options: {            beforeAllFn: Spy;            afterAllFn: Spy;            beforeEachFn: Spy;            afterEachFn: Spy;            fns: Spy[];          },        ) => void,      ) {        const test = stub(Deno, "test"),          fns = [spy(), spy()],          { beforeAllFn, afterAllFn, beforeEachFn, afterEachFn } = hookFns();
        const context = new TestContext("example");        try {          cb({ beforeAllFn, afterAllFn, beforeEachFn, afterEachFn, fns });
          assertSpyCalls(fns[0], 0);          assertSpyCalls(fns[1], 0);
          assertSpyCall(test, 0);          const call = test.calls[0];          const options = call.args[0] as Deno.TestDefinition;          assertEquals(Object.keys(options).sort(), ["fn", "name"]);          assertEquals(options.name, "example");
          const result = options.fn(context);          assertStrictEquals(Promise.resolve(result), result);          assertEquals(await result, undefined);          assertSpyCalls(context.spies.step, 2);        } finally {          TestSuiteInternal.reset();          test.restore();        }
        let fn = fns[0];        assertSpyCall(fn, 0, {          self: { allTimer: 1, eachTimer: 2 },          args: [context.steps[0]],          returned: undefined,        });        assertSpyCalls(fn, 1);
        fn = fns[1];        assertSpyCall(fn, 0, {          self: { allTimer: 1, eachTimer: 3 },          args: [context.steps[1]],          returned: undefined,        });        assertSpyCalls(fn, 1);
        assertSpyCalls(beforeAllFn, 1);        assertSpyCalls(afterAllFn, 1);        assertSpyCalls(beforeEachFn, 2);        assertSpyCalls(afterEachFn, 2);      }
      await t.step(        "in callback",        async () =>          await assertHooks(            ({ beforeAllFn, afterAllFn, beforeEachFn, afterEachFn, fns }) => {              describe("example", () => {                beforeAll(beforeAllFn);                afterAll(afterAllFn);
                beforeEach(beforeEachFn);                afterEach(afterEachFn);
                assertEquals(it({ name: "example 1", fn: fns[0] }), undefined);                assertEquals(it({ name: "example 2", fn: fns[1] }), undefined);              });            },          ),      );
      await t.step(        "in options",        async () =>          await assertHooks(            ({ beforeAllFn, afterAllFn, beforeEachFn, afterEachFn, fns }) => {              describe({                name: "example",                beforeAll: beforeAllFn,                afterAll: afterAllFn,                beforeEach: beforeEachFn,                afterEach: afterEachFn,                fn: () => {                  assertEquals(                    it({ name: "example 1", fn: fns[0] }),                    undefined,                  );                  assertEquals(                    it({ name: "example 2", fn: fns[1] }),                    undefined,                  );                },              });            },          ),      );
      await t.step(        "nested",        async () => {          const test = stub(Deno, "test"),            fns = [spy(), spy()],            { beforeAllFn, afterAllFn, beforeEachFn, afterEachFn } = hookFns();
          const context = new TestContext("example");          try {            describe("example", () => {              beforeAll(beforeAllFn);              afterAll(afterAllFn);
              beforeEach(beforeEachFn);              afterEach(afterEachFn);
              describe("nested", () => {                assertEquals(it({ name: "example 1", fn: fns[0] }), undefined);                assertEquals(it({ name: "example 2", fn: fns[1] }), undefined);              });            });
            assertSpyCalls(fns[0], 0);            assertSpyCalls(fns[1], 0);
            assertSpyCall(test, 0);            const call = test.calls[0];            const options = call.args[0] as Deno.TestDefinition;            assertEquals(Object.keys(options).sort(), ["fn", "name"]);            assertEquals(options.name, "example");
            const result = options.fn(context);            assertStrictEquals(Promise.resolve(result), result);            assertEquals(await result, undefined);            assertSpyCalls(context.spies.step, 1);
            assertStrictEquals(Promise.resolve(result), result);            assertEquals(await result, undefined);            assertSpyCalls(context.steps[0].spies.step, 2);          } finally {            TestSuiteInternal.reset();            test.restore();          }
          let fn = fns[0];          assertSpyCall(fn, 0, {            self: { allTimer: 1, eachTimer: 2 },            args: [context.steps[0].steps[0]],            returned: undefined,          });          assertSpyCalls(fn, 1);
          fn = fns[1];          assertSpyCall(fn, 0, {            self: { allTimer: 1, eachTimer: 3 },            args: [context.steps[0].steps[1]],            returned: undefined,          });          assertSpyCalls(fn, 1);
          assertSpyCalls(beforeAllFn, 1);          assertSpyCalls(afterAllFn, 1);          assertSpyCalls(beforeEachFn, 2);          assertSpyCalls(afterEachFn, 2);        },      );
      interface NestedContext extends GlobalContext {        allTimerNested: number;        eachTimerNested: number;        x: number;        y: number;      }
      await t.step(        "nested with hooks",        async () => {          const test = stub(Deno, "test"),            fns = [              spy(function (this: NestedContext) {                this.x = 2;              }),              spy(function (this: NestedContext) {                this.y = 3;              }),            ],            { beforeAllFn, afterAllFn, beforeEachFn, afterEachFn } = hookFns(),            beforeAllFnNested = spy(async function (this: NestedContext) {              await Promise.resolve();              this.x = 1;              this.allTimerNested = timerIdx++;              timers.set(                this.allTimerNested,                setTimeout(() => {}, 10000),              );            }),            afterAllFnNested = spy(              async function (this: NestedContext) {                await Promise.resolve();                clearTimeout(timers.get(this.allTimerNested));              },            ),            beforeEachFnNested = spy(async function (this: NestedContext) {              await Promise.resolve();              this.y = 2;              this.eachTimerNested = timerIdx++;              timers.set(                this.eachTimerNested,                setTimeout(() => {}, 10000),              );            }),            afterEachFnNested = spy(              async function (this: NestedContext) {                await Promise.resolve();                clearTimeout(timers.get(this.eachTimerNested));              },            );
          const context = new TestContext("example");          try {            describe("example", () => {              beforeAll(beforeAllFn);              afterAll(afterAllFn);
              beforeEach(beforeEachFn);              afterEach(afterEachFn);
              describe("nested", () => {                beforeAll(beforeAllFnNested);                afterAll(afterAllFnNested);
                beforeEach(beforeEachFnNested);                afterEach(afterEachFnNested);
                assertEquals(it({ name: "example 1", fn: fns[0] }), undefined);                assertEquals(it({ name: "example 2", fn: fns[1] }), undefined);              });            });
            assertSpyCalls(fns[0], 0);            assertSpyCalls(fns[1], 0);
            assertSpyCall(test, 0);            const call = test.calls[0];            const options = call.args[0] as Deno.TestDefinition;            assertEquals(Object.keys(options).sort(), ["fn", "name"]);            assertEquals(options.name, "example");
            const result = options.fn(context);            assertStrictEquals(Promise.resolve(result), result);            assertEquals(await result, undefined);            assertSpyCalls(context.spies.step, 1);
            assertStrictEquals(Promise.resolve(result), result);            assertEquals(await result, undefined);            assertSpyCalls(context.steps[0].spies.step, 2);          } finally {            TestSuiteInternal.reset();            test.restore();          }
          let fn = fns[0];          assertSpyCall(fn, 0, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 3,              eachTimerNested: 4,              x: 2,              y: 2,            },            args: [context.steps[0].steps[0]],            returned: undefined,          });          assertSpyCalls(fn, 1);
          fn = fns[1];          assertSpyCall(fn, 0, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 5,              eachTimerNested: 6,              x: 1,              y: 3,            },            args: [context.steps[0].steps[1]],            returned: undefined,          });          assertSpyCalls(fn, 1);
          assertSpyCalls(beforeAllFn, 1);
          assertSpyCall(afterAllFn, 0, {            self: {              allTimer: 1,            } as GlobalContext,          });          assertSpyCalls(afterAllFn, 1);
          assertSpyCalls(beforeEachFn, 2);
          assertSpyCall(afterEachFn, 0, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 3,              eachTimerNested: 4,              x: 2,              y: 2,            } as NestedContext,          });          assertSpyCall(afterEachFn, 1, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 5,              eachTimerNested: 6,              x: 1,              y: 3,            } as NestedContext,          });          assertSpyCalls(afterEachFn, 2);
          assertSpyCalls(beforeAllFnNested, 1);
          assertSpyCall(afterAllFnNested, 0, {            self: {              allTimer: 1,              allTimerNested: 2,              x: 1,            } as NestedContext,          });          assertSpyCalls(afterAllFnNested, 1);
          assertSpyCalls(beforeEachFnNested, 2);
          assertSpyCall(afterEachFnNested, 0, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 3,              eachTimerNested: 4,              x: 2,              y: 2,            },          });          assertSpyCall(afterEachFnNested, 1, {            self: {              allTimer: 1,              allTimerNested: 2,              eachTimer: 5,              eachTimerNested: 6,              x: 1,              y: 3,            },          });          assertSpyCalls(afterEachFnNested, 2);        },      );    });  });});