12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886
// 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("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("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);        },      );    });  });});