@gjsify/unit 0.0.4 → 0.1.0

package/test.node.mjs

@@ -1,1219 +0,0 @@
-// ../../../node_modules/@girs/gjs/gjs.js
-var imports = globalThis.imports || {};
-
-// lib/esm/spy.js
-function spy(f) {
-  const calls = [];
-  function spy2(...args) {
-    let retv;
-    try {
-      retv = f ? f.apply(this, args) : void 0;
-    } catch (error) {
-      calls.push({
-        type: "throw",
-        this: this,
-        arguments: args,
-        throw: error
-      });
-      throw error;
-    }
-    calls.push({
-      type: "return",
-      this: this,
-      arguments: args,
-      return: retv
-    });
-    return retv;
-  }
-  Object.defineProperties(spy2, {
-    calls: descriptors.calls(calls),
-    returnedCalls: descriptors.returnedCalls,
-    thrownCalls: descriptors.thrownCalls,
-    firstCall: descriptors.firstCall,
-    lastCall: descriptors.lastCall,
-    firstReturnedCall: descriptors.firstReturnedCall,
-    lastReturnedCall: descriptors.lastReturnedCall,
-    firstThrownCall: descriptors.firstThrownCall,
-    lastThrownCall: descriptors.lastThrownCall,
-    reset: descriptors.reset,
-    toString: descriptors.toString(f)
-  });
-  return spy2;
-}
-var descriptors = {
-  calls(value) {
-    return { value, configurable: true };
-  },
-  returnedCalls: {
-    get: function returnedCalls() {
-      return this.calls.filter(isReturned);
-    },
-    configurable: true
-  },
-  thrownCalls: {
-    get: function thrownCalls() {
-      return this.calls.filter(isThrown);
-    },
-    configurable: true
-  },
-  firstCall: {
-    get: function firstCall() {
-      return this.calls[0] || null;
-    },
-    configurable: true
-  },
-  lastCall: {
-    get: function lastCall() {
-      return this.calls[this.calls.length - 1] || null;
-    },
-    configurable: true
-  },
-  firstReturnedCall: {
-    get: function firstReturnedCall() {
-      for (let i = 0; i < this.calls.length; ++i) {
-        const call = this.calls[i];
-        if (isReturned(call)) {
-          return call;
-        }
-      }
-      return null;
-    },
-    configurable: true
-  },
-  lastReturnedCall: {
-    get: function lastReturnedCall() {
-      for (let i = this.calls.length - 1; i >= 0; --i) {
-        const call = this.calls[i];
-        if (isReturned(call)) {
-          return call;
-        }
-      }
-      return null;
-    },
-    configurable: true
-  },
-  firstThrownCall: {
-    get: function firstThrownCall() {
-      for (let i = 0; i < this.calls.length; ++i) {
-        const call = this.calls[i];
-        if (isThrown(call)) {
-          return call;
-        }
-      }
-      return null;
-    },
-    configurable: true
-  },
-  lastThrownCall: {
-    get: function lastThrownCall() {
-      for (let i = this.calls.length - 1; i >= 0; --i) {
-        const call = this.calls[i];
-        if (isThrown(call)) {
-          return call;
-        }
-      }
-      return null;
-    },
-    configurable: true
-  },
-  reset: {
-    value: function reset() {
-      ;
-      this.calls.length = 0;
-    },
-    configurable: true
-  },
-  toString(f) {
-    return {
-      value: function toString() {
-        return `/* The spy of */ ${f ? f.toString() : "function(){}"}`;
-      },
-      configurable: true
-    };
-  }
-};
-function isReturned(call) {
-  return call.type === "return";
-}
-function isThrown(call) {
-  return call.type === "throw";
-}
-
-// lib/esm/index.js
-import nodeAssert from "assert";
-var mainloop = globalThis?.imports?.mainloop;
-var countTestsOverall = 0;
-var countTestsFailed = 0;
-var countTestsIgnored = 0;
-var runtime = "";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var BLUE = "\x1B[34m";
-var GRAY = "\x1B[90m";
-var RESET = "\x1B[39m";
-var print = globalThis.print || console.log;
-var MatcherFactory = class _MatcherFactory {
-  constructor(actualValue, positive, negated) {
-    this.actualValue = actualValue;
-    this.positive = positive;
-    if (negated) {
-      this.not = negated;
-    } else {
-      this.not = new _MatcherFactory(actualValue, !positive, this);
-    }
-  }
-  not;
-  triggerResult(success, msg) {
-    if (success && !this.positive || !success && this.positive) {
-      ++countTestsFailed;
-      throw new Error(msg);
-    }
-  }
-  to(callback) {
-    this.triggerResult(
-      callback(this.actualValue),
-      `      Expected callback to validate`
-    );
-  }
-  toBe(expectedValue) {
-    this.triggerResult(
-      this.actualValue === expectedValue,
-      `      Expected values to match using ===
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toEqual(expectedValue) {
-    this.triggerResult(
-      this.actualValue == expectedValue,
-      `      Expected values to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toEqualArray(expectedValue) {
-    let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
-    for (let i = 0; i < this.actualValue.length; i++) {
-      const actualVal = this.actualValue[i];
-      const expectedVal = expectedValue[i];
-      success = actualVal == expectedVal;
-      if (!success)
-        break;
-    }
-    this.triggerResult(
-      success,
-      `      Expected array items to match using ==
-      Expected: ${expectedValue} (${typeof expectedValue})
-      Actual: ${this.actualValue} (${typeof this.actualValue})`
-    );
-  }
-  toMatch(expectedValue) {
-    if (typeof this.actualValue.match !== "function") {
-      throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
-    }
-    this.triggerResult(
-      !!this.actualValue.match(expectedValue),
-      "      Expected values to match using regular expression\n      Expression: " + expectedValue + "\n      Actual: " + this.actualValue
-    );
-  }
-  toBeDefined() {
-    this.triggerResult(
-      typeof this.actualValue !== "undefined",
-      `      Expected value to be defined`
-    );
-  }
-  toBeUndefined() {
-    this.triggerResult(
-      typeof this.actualValue === "undefined",
-      `      Expected value to be undefined`
-    );
-  }
-  toBeNull() {
-    this.triggerResult(
-      this.actualValue === null,
-      `      Expected value to be null`
-    );
-  }
-  toBeTruthy() {
-    this.triggerResult(
-      this.actualValue,
-      `      Expected value to be truthy`
-    );
-  }
-  toBeFalsy() {
-    this.triggerResult(
-      !this.actualValue,
-      `      Expected value to be falsy`
-    );
-  }
-  toContain(needle) {
-    this.triggerResult(
-      this.actualValue instanceof Array && this.actualValue.indexOf(needle) !== -1,
-      `      Expected ` + this.actualValue + ` to contain ` + needle
-    );
-  }
-  toBeLessThan(greaterValue) {
-    this.triggerResult(
-      this.actualValue < greaterValue,
-      `      Expected ` + this.actualValue + ` to be less than ` + greaterValue
-    );
-  }
-  toBeGreaterThan(smallerValue) {
-    this.triggerResult(
-      this.actualValue > smallerValue,
-      `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
-    );
-  }
-  toBeCloseTo(expectedValue, precision) {
-    const shiftHelper = Math.pow(10, precision);
-    this.triggerResult(
-      Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
-      `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
-    );
-  }
-  toThrow(ErrorType) {
-    let errorMessage = "";
-    let didThrow = false;
-    let typeMatch = true;
-    try {
-      this.actualValue();
-      didThrow = false;
-    } catch (e) {
-      errorMessage = e.message || "";
-      didThrow = true;
-      if (ErrorType) {
-        typeMatch = e instanceof ErrorType;
-      }
-    }
-    const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
-    this.triggerResult(
-      didThrow,
-      `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`
-    );
-    if (ErrorType) {
-      this.triggerResult(
-        typeMatch,
-        `      Expected Error type '${ErrorType.name}', but the error is not an instance of it`
-      );
-    }
-  }
-};
-var describe = async function(moduleName, callback) {
-  print("\n" + moduleName);
-  await callback();
-  beforeEachCb = null;
-  afterEachCb = null;
-};
-var beforeEachCb;
-var afterEachCb;
-var beforeEach = function(callback) {
-  beforeEachCb = callback;
-};
-var afterEach = function(callback) {
-  afterEachCb = callback;
-};
-var it = async function(expectation, callback) {
-  try {
-    if (typeof beforeEachCb === "function") {
-      await beforeEachCb();
-    }
-    await callback();
-    if (typeof afterEachCb === "function") {
-      await afterEachCb();
-    }
-    print(`  ${GREEN}\u2714${RESET} ${GRAY}${expectation}${RESET}`);
-  } catch (e) {
-    print(`  ${RED}\u274C${RESET} ${GRAY}${expectation}${RESET}`);
-    print(`${RED}${e.message}${RESET}`);
-    if (e.stack)
-      print(e.stack);
-  }
-};
-var expect = function(actualValue) {
-  ++countTestsOverall;
-  const expecter = new MatcherFactory(actualValue, true);
-  return expecter;
-};
-var assert = function(success, message) {
-  ++countTestsOverall;
-  if (!success) {
-    ++countTestsFailed;
-  }
-  nodeAssert(success, message);
-};
-assert.strictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.strictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    throw error;
-  }
-};
-assert.throws = function(promiseFn, ...args) {
-  ++countTestsOverall;
-  let error;
-  try {
-    promiseFn();
-  } catch (e) {
-    error = e;
-  }
-  if (!error)
-    ++countTestsFailed;
-  nodeAssert.throws(() => {
-    if (error)
-      throw error;
-  }, args[0], args[1]);
-};
-assert.deepStrictEqual = function(actual, expected, message) {
-  ++countTestsOverall;
-  try {
-    nodeAssert.deepStrictEqual(actual, expected, message);
-  } catch (error) {
-    ++countTestsFailed;
-    throw error;
-  }
-};
-var runTests = async function(namespaces) {
-  for (const subNamespace in namespaces) {
-    const namespace = namespaces[subNamespace];
-    if (typeof namespace === "function") {
-      await namespace();
-    } else if (typeof namespace === "object") {
-      await runTests(namespace);
-    }
-  }
-};
-var printResult = () => {
-  if (countTestsIgnored) {
-    print(`
-${BLUE}\u2714 ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
-  }
-  if (countTestsFailed) {
-    print(`
-${RED}\u274C ${countTestsFailed} of ${countTestsOverall} tests failed${RESET}`);
-  } else {
-    print(`
-${GREEN}\u2714 ${countTestsOverall} completed${RESET}`);
-  }
-};
-var getRuntime = async () => {
-  if (runtime && runtime !== "Unknown") {
-    return runtime;
-  }
-  if (globalThis.Deno?.version?.deno) {
-    return "Deno " + globalThis.Deno?.version?.deno;
-  } else {
-    let process = globalThis.process;
-    if (!process) {
-      try {
-        process = await import("process");
-      } catch (error) {
-        console.error(error);
-        console.warn(error.message);
-        runtime = "Unknown";
-      }
-    }
-    if (process?.versions?.gjs) {
-      runtime = "Gjs " + process.versions.gjs;
-    } else if (process?.versions?.node) {
-      runtime = "Node.js " + process.versions.node;
-    }
-  }
-  return runtime || "Unknown";
-};
-var printRuntime = async () => {
-  const runtime2 = await getRuntime();
-  print(`
-Running on ${runtime2}`);
-};
-var run = async (namespaces) => {
-  printRuntime().then(async () => {
-    return runTests(namespaces).then(() => {
-      printResult();
-      print();
-      mainloop?.quit();
-    });
-  });
-  mainloop?.run();
-};
-
-// src/index.spec.ts
-var index_spec_default = async () => {
-  await describe("assert", async () => {
-    await it("should consider truthy values as valid", async () => {
-      assert(true);
-      assert(1);
-      assert({});
-      assert([]);
-    });
-  });
-  await describe("beforeEach", async () => {
-    let foo = "";
-    let count = 0;
-    let countAfter = 0;
-    beforeEach(async () => {
-      console.log("beforeEach");
-      foo = "bar";
-      ++count;
-    });
-    afterEach(async () => {
-      console.log("afterEach");
-      --countAfter;
-    });
-    await it('foo should be "bar"', async () => {
-      expect(foo).toBe("bar");
-      foo = "override me again";
-    });
-    await it('foo should be "bar" again', async () => {
-      expect(foo).toBe("bar");
-    });
-    await it("count should be 3 again", async () => {
-      expect(count).toBe(3);
-    });
-    await it("countAfter should be -3", async () => {
-      expect(countAfter).toBe(-3);
-    });
-  });
-  await describe("expect::to", async () => {
-    await it("should be possible to validate expectations by callback", async () => {
-      expect(3).to(function(actualValue) {
-        return actualValue === 3;
-      });
-    });
-    await it("should be possible to invalidate expectations by callback", async () => {
-      expect(3).not.to(function(actualValue) {
-        return actualValue === 5;
-      });
-    });
-  });
-  await describe("expect::toBe", async () => {
-    var obj = {};
-    var obj2 = {};
-    await it("should compare using ===", async () => {
-      expect(true).toBe(true);
-      expect(false).toBe(false);
-      expect("test").toBe("test");
-      expect(obj).toBe(obj);
-    });
-    await it("should compare using !==", async () => {
-      expect(true).not.toBe(false);
-      expect(true).not.toBe(1);
-      expect(false).not.toBe(true);
-      expect(false).not.toBe(0);
-      expect("test").not.toBe("test2");
-      expect(obj).not.toBe(obj2);
-    });
-  });
-  await describe("expect::toEqual", async () => {
-    var obj = {};
-    var obj2 = {};
-    await it("should compare using ==", async () => {
-      expect(true).toEqual(true);
-      expect(true).toEqual(1);
-      expect(false).toEqual(false);
-      expect(false).toEqual(0);
-      expect("test").toEqual("test");
-      expect(obj).toEqual(obj);
-    });
-    await it("should compare using !=", async () => {
-      expect(true).not.toEqual(false);
-      expect(false).not.toEqual(true);
-      expect("test").not.toEqual("test2");
-      expect(obj).not.toEqual(obj2);
-    });
-  });
-  await describe("expect::toMatch", async () => {
-    await it("should consider matching regular expressions as valid", async () => {
-      expect("test").toMatch(/test/);
-      expect("test").toMatch(/est/);
-      expect("test").toMatch("test");
-    });
-    await it("should consider non matching regular expressions as invalid", async () => {
-      expect("test").not.toMatch(/tester/);
-    });
-  });
-  await describe("expect::toBeDefined", async () => {
-    var obj = { key: "value" };
-    await it("should consider defined values as valid", async () => {
-      expect(obj.key).toBeDefined();
-    });
-    await it("should consider undefined values as invalid", async () => {
-      expect(obj.invalidKey).not.toBeDefined();
-    });
-  });
-  await describe("expect::toBeUndefined", async () => {
-    var obj = { key: "value" };
-    await it("should consider undefined values as valid", async () => {
-      expect(obj.invalidKey).toBeUndefined();
-    });
-    await it("should consider defined values as invalid", async () => {
-      expect(obj.key).not.toBeUndefined();
-    });
-  });
-  await describe("expect::toBeNull", async () => {
-    await it("should consider null values as valid", async () => {
-      expect(null).toBeNull();
-    });
-    await it("should consider non null values as invalid", async () => {
-      expect(0).not.toBeNull();
-      expect(false).not.toBeNull();
-      expect("").not.toBeNull();
-      expect("null").not.toBeNull();
-      expect(void 0).not.toBeNull();
-      expect({}).not.toBeNull();
-    });
-  });
-  await describe("expect::toBeTruthy", async () => {
-    await it("should consider truthy values as valid", async () => {
-      expect(true).toBeTruthy();
-      expect(1).toBeTruthy();
-      expect({}).toBeTruthy();
-      expect([]).toBeTruthy();
-    });
-    await it("should consider non truthy values as invalid", async () => {
-      expect(false).not.toBeTruthy();
-      expect(0).not.toBeTruthy();
-      expect("").not.toBeTruthy();
-      expect(null).not.toBeTruthy();
-      expect(void 0).not.toBeTruthy();
-    });
-  });
-  await describe("expect::toBeFalsy", async () => {
-    await it("should consider truthy values as valid", async () => {
-      expect(false).toBeFalsy();
-      expect(0).toBeFalsy();
-      expect("").toBeFalsy();
-      expect(null).toBeFalsy();
-      expect(void 0).toBeFalsy();
-    });
-    await it("should consider non truthy values as invalid", async () => {
-      expect(true).not.toBeFalsy();
-      expect(1).not.toBeFalsy();
-      expect({}).not.toBeFalsy();
-      expect([]).not.toBeFalsy();
-    });
-  });
-  await describe("expect::toContain", async () => {
-    var testArray = [1, "a"];
-    await it("should consider array containing a value as valid", async () => {
-      expect(testArray).toContain(1);
-      expect(testArray).toContain("a");
-    });
-    await it("should consider arrays not containing a value as invalid", async () => {
-      expect(testArray).not.toContain(0);
-      expect(testArray).not.toContain("b");
-    });
-  });
-  await describe("expect::toBeLessThan", async () => {
-    await it("should consider greater values as valid", async () => {
-      expect(1).toBeLessThan(2);
-      expect(1).toBeLessThan(200);
-    });
-    await it("should consider equal values as invalid", async () => {
-      expect(1).not.toBeLessThan(1);
-    });
-    await it("should consider smaller values as invalid", async () => {
-      expect(1).not.toBeLessThan(0);
-      expect(1).not.toBeLessThan(-5);
-    });
-  });
-  await describe("expect::toBeGreaterThan", async () => {
-    await it("should consider smaller values as valid", async () => {
-      expect(2).toBeGreaterThan(1);
-      expect(2).toBeGreaterThan(0);
-      expect(2).toBeGreaterThan(-5);
-    });
-    await it("should consider equal values as invalid", async () => {
-      expect(1).not.toBeGreaterThan(1);
-    });
-    await it("should consider greater values as invalid", async () => {
-      expect(1).not.toBeGreaterThan(2);
-      expect(1).not.toBeGreaterThan(200);
-    });
-  });
-  await describe("expect::toBeCloseTo", async () => {
-    var pi = 3.1415926, e = 2.78;
-    await it("should consider close numbers as valid", async () => {
-      expect(pi).toBeCloseTo(e, 0);
-    });
-    await it("should consider non close numbers as invalid", async () => {
-      expect(pi).not.toBeCloseTo(e, 2);
-    });
-  });
-  await describe("expect::toBeCloseTo", async () => {
-    function throwException() {
-      throw {};
-    }
-    function dontThrowException() {
-    }
-    await it("should consider functions throwing an exception as valid", async () => {
-      expect(throwException).toThrow();
-    });
-    await it("should consider functions not throwing an exception as invalid", async () => {
-      expect(dontThrowException).not.toThrow();
-    });
-  });
-};
-
-// src/spy.spec.ts
-var spy_spec_default = async () => {
-  await describe("'spy' function", async () => {
-    await it("should return a function.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(typeof f, "function");
-    });
-    await it("should return a function which calls the given function.", async () => {
-      let called = false;
-      const f = spy(() => {
-        called = true;
-      });
-      f();
-      assert.strictEqual(called, true);
-    });
-    await it("should return a function which calls the given method.", async () => {
-      const box = {
-        value: 0,
-        set(value) {
-          this.value = value;
-        }
-      };
-      box.set = spy(box.set);
-      box.set(1);
-      assert.strictEqual(box.value, 1);
-    });
-    await it("should return a function which return the return value of the given function.", async () => {
-      const f = spy(() => 777);
-      const retv = f();
-      assert.strictEqual(retv, 777);
-    });
-    await it("should return a function which throw the thrown error of the given function.", async () => {
-      const f = spy(() => {
-        throw 666;
-      });
-      let error = void 0;
-      try {
-        f();
-      } catch (e) {
-        error = e;
-      }
-      assert.strictEqual(error, 666);
-    });
-  });
-  await describe("Spy.calls property", async () => {
-    await it("should be an array.", async () => {
-      const f = spy();
-      assert(Array.isArray(f.calls));
-    });
-    await it("should be empty before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.calls.length, 0);
-    });
-    await it("should contain call information after called one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.calls.length, 1);
-      assert.deepStrictEqual(f.calls[0], {
-        type: "return",
-        this: void 0,
-        arguments: [],
-        return: void 0
-      });
-    });
-    await it("should contain call information after called one time -- with args.", async () => {
-      const f = spy();
-      f.call(1, 2, 3);
-      assert.strictEqual(f.calls.length, 1);
-      assert.deepStrictEqual(f.calls[0], {
-        type: "return",
-        this: 1,
-        arguments: [2, 3],
-        return: void 0
-      });
-    });
-    await it("should contain call information after called one time -- with args and return value.", async () => {
-      const f = spy(() => -1);
-      f.call(1, 2, 3);
-      assert.strictEqual(f.calls.length, 1);
-      assert.deepStrictEqual(f.calls[0], {
-        type: "return",
-        this: 1,
-        arguments: [2, 3],
-        return: -1
-      });
-    });
-    await it("should contain call information after called two times -- with args and return value.", async () => {
-      const f = spy(() => -1);
-      f.call(1, 2, 3);
-      f.call(4, 5);
-      assert.strictEqual(f.calls.length, 2);
-      assert.deepStrictEqual(f.calls[0], {
-        type: "return",
-        this: 1,
-        arguments: [2, 3],
-        return: -1
-      });
-      assert.deepStrictEqual(f.calls[1], {
-        type: "return",
-        this: 4,
-        arguments: [5],
-        return: -1
-      });
-    });
-    await it("should contain call information regardless returned or thrown.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.calls.length, 2);
-      assert.deepStrictEqual(f.calls[0], {
-        type: "return",
-        this: void 0,
-        arguments: [false],
-        return: 1
-      });
-      assert.deepStrictEqual(f.calls[1], {
-        type: "throw",
-        this: void 0,
-        arguments: [true],
-        throw: -1
-      });
-    });
-  });
-  await describe("Spy.firstCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.firstCall, null);
-    });
-    await it("should be 'f.calls[0]' after calling the spy one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.firstCall, f.calls[0]);
-    });
-    await it("should be 'f.calls[0]' after calling the spy two times.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.firstCall, f.calls[0]);
-    });
-  });
-  await describe("Spy.lastCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.lastCall, null);
-    });
-    await it("should be 'f.calls[f.calls.length - 1]' after calling the spy one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.lastCall, f.calls[f.calls.length - 1]);
-    });
-    await it("should be 'f.calls[f.calls.length - 1]' after calling the spy two times.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.lastCall, f.calls[f.calls.length - 1]);
-    });
-  });
-  await describe("Spy.returnedCalls property", async () => {
-    await it("should be an array.", async () => {
-      const f = spy();
-      assert(Array.isArray(f.returnedCalls));
-    });
-    await it("should be empty before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.returnedCalls.length, 0);
-    });
-    await it("should contain call information that `call.type === 'return'` in `f.calls` after calling the spy one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.returnedCalls.length, 1);
-      assert.strictEqual(f.returnedCalls[0], f.calls[0]);
-    });
-    await it("should contain call information that `call.type === 'return'` in `f.calls` after calling the spy two times.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.returnedCalls.length, 2);
-      assert.strictEqual(f.returnedCalls[0], f.calls[0]);
-      assert.strictEqual(f.returnedCalls[1], f.calls[1]);
-    });
-    await it("should not contain call information that `call.type === 'throw'`.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      assert.strictEqual(f.calls.length, 3);
-      assert.strictEqual(f.returnedCalls.length, 2);
-      assert.strictEqual(f.returnedCalls[0], f.calls[0]);
-      assert.strictEqual(f.returnedCalls[1], f.calls[2]);
-    });
-    await it("should not contain call information that `call.type === 'throw'`. (2)", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.calls.length, 3);
-      assert.strictEqual(f.returnedCalls.length, 1);
-      assert.strictEqual(f.returnedCalls[0], f.calls[1]);
-    });
-  });
-  await describe("Spy.firstReturnedCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.firstReturnedCall, null);
-    });
-    await it("should be 'f.returnedCalls[0]' after calling the spy one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.firstReturnedCall, f.returnedCalls[0]);
-    });
-    await it("should be 'f.returnedCalls[0]' after calling the spy two times.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.firstReturnedCall, f.returnedCalls[0]);
-    });
-    await it("should be 'f.returnedCalls[0]' after calling the spy even if `f.calls[0]` was thrown.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      assert.strictEqual(f.firstReturnedCall, f.returnedCalls[0]);
-    });
-    await it("should be null after calling the spy even if all calls were thrown.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.firstReturnedCall, null);
-    });
-  });
-  await describe("Spy.lastReturnedCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.lastReturnedCall, null);
-    });
-    await it("should be 'f.returnedCalls[f.returnedCalls.length - 1]' after calling the spy one time.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(
-        f.lastReturnedCall,
-        f.returnedCalls[f.returnedCalls.length - 1]
-      );
-    });
-    await it("should be 'f.returnedCalls[f.returnedCalls.length - 1]' after calling the spy two times.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(
-        f.lastReturnedCall,
-        f.returnedCalls[f.returnedCalls.length - 1]
-      );
-    });
-    await it("should be 'f.returnedCalls[f.returnedCalls.length - 1]' after calling the spy even if `f.calls[f.calls.length - 1]` was thrown.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(
-        f.lastReturnedCall,
-        f.returnedCalls[f.returnedCalls.length - 1]
-      );
-    });
-    await it("should be null after calling the spy even if all calls were thrown.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.lastReturnedCall, null);
-    });
-  });
-  await describe("Spy.thrownCalls property", async () => {
-    await it("should be an array.", async () => {
-      const f = spy();
-      assert(Array.isArray(f.thrownCalls));
-    });
-    await it("should be empty before calling the spy.", async () => {
-      const f = spy();
-      assert.strictEqual(f.thrownCalls.length, 0);
-    });
-    await it("should contain call information that `call.type === 'throw'` in `f.calls` after calling the spy one time.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(f.thrownCalls.length, 1);
-      assert.strictEqual(f.thrownCalls[0], f.calls[0]);
-    });
-    await it("should contain call information that `call.type === 'throw'` in `f.calls` after calling the spy two times.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(f.thrownCalls.length, 2);
-      assert.strictEqual(f.thrownCalls[0], f.calls[0]);
-      assert.strictEqual(f.thrownCalls[1], f.calls[1]);
-    });
-    await it("should not contain call information that `call.type === 'return'`.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.calls.length, 3);
-      assert.strictEqual(f.thrownCalls.length, 2);
-      assert.strictEqual(f.thrownCalls[0], f.calls[0]);
-      assert.strictEqual(f.thrownCalls[1], f.calls[2]);
-    });
-    await it("should not contain call information that `call.type === 'return'`. (2)", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      assert.strictEqual(f.calls.length, 3);
-      assert.strictEqual(f.thrownCalls.length, 1);
-      assert.strictEqual(f.thrownCalls[0], f.calls[1]);
-    });
-  });
-  await describe("Spy.firstThrownCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      assert.strictEqual(f.firstThrownCall, null);
-    });
-    await it("should be 'f.thrownCalls[0]' after calling the spy one time.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(f.firstThrownCall, f.thrownCalls[0]);
-    });
-    await it("should be 'f.thrownCalls[0]' after calling the spy two times.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(f.firstThrownCall, f.thrownCalls[0]);
-    });
-    await it("should be 'f.thrownCalls[0]' after calling the spy even if `f.calls[0]` was returned.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      f(false);
-      try {
-        f(true);
-      } catch {
-      }
-      assert.strictEqual(f.firstThrownCall, f.thrownCalls[0]);
-    });
-    await it("should be null after calling the spy even if all calls were returned.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.firstThrownCall, null);
-    });
-  });
-  await describe("Spy.lastThrownCall property", async () => {
-    await it("should be null before calling the spy.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      assert.strictEqual(f.lastThrownCall, null);
-    });
-    await it("should be 'f.thrownCalls[f.thrownCalls.length - 1]' after calling the spy one time.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(
-        f.lastThrownCall,
-        f.thrownCalls[f.thrownCalls.length - 1]
-      );
-    });
-    await it("should be 'f.thrownCalls[f.thrownCalls.length - 1]' after calling the spy two times.", async () => {
-      const f = spy(() => {
-        throw new Error();
-      });
-      try {
-        f();
-      } catch {
-      }
-      try {
-        f();
-      } catch {
-      }
-      assert.strictEqual(
-        f.lastThrownCall,
-        f.thrownCalls[f.thrownCalls.length - 1]
-      );
-    });
-    await it("should be 'f.thrownCalls[f.thrownCalls.length - 1]' after calling the spy even if `f.calls[f.calls.length - 1]` was returned.", async () => {
-      const f = spy((toThrow) => {
-        if (toThrow) {
-          throw -1;
-        }
-        return 1;
-      });
-      try {
-        f(true);
-      } catch {
-      }
-      f(false);
-      assert.strictEqual(
-        f.lastThrownCall,
-        f.thrownCalls[f.thrownCalls.length - 1]
-      );
-    });
-    await it("should be null after calling the spy even if all calls were returned.", async () => {
-      const f = spy();
-      f();
-      f();
-      assert.strictEqual(f.lastThrownCall, null);
-    });
-  });
-  await describe("Spy.reset method", async () => {
-    await it("should be a function.", async () => {
-      const f = spy();
-      assert.strictEqual(typeof f.reset, "function");
-    });
-    await it("should do nothing before calling the spy.", async () => {
-      const f = spy();
-      f.reset();
-      assert.strictEqual(f.calls.length, 0);
-    });
-    await it("should clear `f.calls`.", async () => {
-      const f = spy();
-      f();
-      assert.strictEqual(f.calls.length, 1);
-      f.reset();
-      assert.strictEqual(f.calls.length, 0);
-      assert.strictEqual(f.calls[0], void 0);
-    });
-  });
-  await describe("Spy.toString method", async () => {
-    await it("should be a function.", async () => {
-      const f = spy();
-      assert.strictEqual(typeof f.toString, "function");
-    });
-    await it("should return the original function with a comment. (noop)", async () => {
-      const f = spy();
-      assert.strictEqual(f.toString(), "/* The spy of */ function(){}");
-    });
-    await it("should return the original function with a comment. (with f)", async () => {
-      const f0 = function original() {
-        return 777;
-      };
-      const f = spy(f0);
-      assert.strictEqual(f.toString(), `/* The spy of */ ${f0}`);
-    });
-  });
-};
-
-// src/test.mts
-run({ indexTestSuite: index_spec_default, spyTestSuite: spy_spec_default });