@gjsify/fs 0.0.1 → 0.0.2

package/test.node.mjs

@@ -0,0 +1,710 @@
+// ../../../node_modules/@girs/gjs/gjs.js
+var imports = globalThis.imports || {};
+
+// ../../gjs/unit/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 {
+  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 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/callback.spec.ts
+import { open, write, close, rm } from "fs";
+import { Buffer } from "buffer";
+var callback_spec_default = async () => {
+  await describe("fs.open", async () => {
+    await it(`should open a file for writing`, () => {
+      const path = "./test/open.txt";
+      open(path, "w+", 438, (err, fd) => {
+        expect(err).toBeNull();
+        console.log("fs.open: file open");
+        let buffWrite = Buffer.from("Hello World", "utf8"), buffStart = 0, buffLength = buffWrite.length, filePos = 0;
+        write(fd, buffWrite, buffStart, buffLength, filePos, (err2, written, buffer) => {
+          expect(err2).toBeNull();
+          console.log("fs.open: file written");
+          expect(written).toBe(buffWrite.length);
+          expect(buffer).toBe(buffWrite);
+          close(fd, (err3) => {
+            expect(err3).toBeNull();
+            console.log("fs.open: file closed");
+            rm(path, (err4) => {
+              expect(err4).toBeNull();
+              console.log("fs.open: file removed");
+            });
+          });
+        });
+      });
+    });
+  });
+};
+
+// src/file-handle.spec.ts
+import { promises } from "fs";
+import { Buffer as Buffer2 } from "buffer";
+var file_handle_spec_default = async () => {
+  await describe("FileHandle", async () => {
+    await it(`should open a file for writing`, async () => {
+      const path = "./test/openP.txt";
+      const fileHandle = await promises.open(path, "w+", 438);
+      console.log("FileHandle: file open");
+      let buffWrite = Buffer2.from("Hello World", "utf8"), buffStart = 0, buffLength = buffWrite.length, filePos = 0;
+      const res = await fileHandle.write(buffWrite, buffStart, buffLength, filePos);
+      console.log("FileHandle: file written");
+      expect(res.bytesWritten).toBe(buffWrite.length);
+      expect(res.buffer).toBe(buffWrite);
+      await fileHandle.close();
+      console.log("FileHandle: file closed");
+      await promises.rm(path);
+      console.log("FileHandle: file removed");
+    });
+  });
+};
+
+// src/promises.spec.ts
+import { promises as promises2, existsSync } from "fs";
+import { mkdir, readdir, mkdtemp, writeFile, rm as rm2, rmdir } from "fs/promises";
+import { join } from "path";
+import { Buffer as Buffer3 } from "buffer";
+var promises_spec_default = async () => {
+  await describe("fs/promises", async () => {
+    await it('import over "fs/should" should be work', async () => {
+      expect(typeof mkdir).toBe("function");
+    });
+  });
+  await describe("fs.promises.readdir", async () => {
+    await it("should return no files for an empty directory", async () => {
+      const dir = await mkdtemp("fs-test-");
+      const files = await readdir(dir);
+      expect(files.length).toBe(0);
+      await rmdir(dir);
+    });
+    await it("should return the files for non-empty directory", async () => {
+      const dir = await mkdtemp("fs-test-");
+      const txt1 = join(dir, "test1.txt");
+      const txt2 = join(dir, "test2.txt");
+      const dir1 = join(dir, "empty-dir");
+      await writeFile(txt1, "");
+      await writeFile(txt2, "");
+      await mkdir(dir1);
+      const files = await readdir(dir);
+      expect(files.length).toEqual(3);
+      await rm2(txt1);
+      await rm2(txt2);
+      await rmdir(dir1);
+      await rmdir(dir);
+    });
+    await it('should return the file with the name "file.txt"', async () => {
+      const dir = await mkdtemp("fs-test-");
+      const expectedFileName = "file.txt";
+      const file = join(dir, expectedFileName);
+      await writeFile(file, "");
+      const files = await readdir(dir);
+      expect(files[0]).toEqual(expectedFileName);
+      await rm2(file);
+      await rmdir(dir);
+    });
+    await it('should return with file types if option "withFileTypes" is `true`', async () => {
+      const dir = await mkdtemp("fs-test-");
+      const expectedFile = "file.txt";
+      const expectedDir = "subdir";
+      const file = join(dir, expectedFile);
+      const subdir = join(dir, expectedDir);
+      await writeFile(file, "");
+      await mkdir(subdir);
+      const files = await readdir(dir, { withFileTypes: true });
+      expect(files.length).toBe(2);
+      const fileWithTypes = files.find((f) => f.name === expectedFile);
+      const dirWithTypes = files.find((f) => f.name === expectedDir);
+      expect(fileWithTypes.isFile()).toBeTruthy();
+      expect(fileWithTypes.isDirectory()).toBeFalsy();
+      expect(dirWithTypes.isFile()).toBeFalsy();
+      expect(dirWithTypes.isDirectory()).toBeTruthy();
+      await rm2(file);
+      await rmdir(subdir);
+      await rmdir(dir);
+    });
+  });
+  await describe("fs.promises.readFile", async () => {
+    await it("should be a function", async () => {
+      expect(typeof promises2.readFile).toBe("function");
+    });
+    await it("should be a promise", async () => {
+      expect(promises2.readFile("./test/file.txt", "utf-8") instanceof Promise).toBeTruthy();
+    });
+    await it("should return a Buffer if no encoding was specified", async () => {
+      const bufferData = await promises2.readFile("package.json");
+      expect(bufferData instanceof Buffer3).toBeTruthy();
+    });
+    await it("should return a string when encoding is utf-8", async () => {
+      const utf8Data = await promises2.readFile("./test/file.txt", "utf-8");
+      expect(typeof utf8Data === "string").toBeTruthy();
+    });
+    await it('should return a string with "Hello World"', async () => {
+      const utf8Data = await promises2.readFile("./test/file.txt", "utf-8");
+      expect(utf8Data).toBe("Hello World");
+    });
+  });
+  await describe("fs.promises.mkdtemp", async () => {
+    await it("should be a function", async () => {
+      expect(typeof promises2.mkdtemp).toBe("function");
+    });
+    await it("should create a new directory", async () => {
+      const directory = await promises2.mkdtemp("fs-test-");
+      expect(existsSync(directory)).toBeTruthy();
+      await promises2.rmdir(directory);
+    });
+  });
+  await describe("fs.promises.rm", async () => {
+    await it("should be a function", async () => {
+      expect(typeof promises2.rm).toBe("function");
+    });
+    await it("should remove an text file", async () => {
+      const dir = await promises2.mkdtemp("fs-test-");
+      const txt1 = join(dir, "file1.txt");
+      await promises2.writeFile(txt1, "");
+      expect(existsSync(txt1)).toBeTruthy();
+      await promises2.rm(txt1);
+      expect(existsSync(txt1)).toBeFalsy();
+      await promises2.rmdir(dir);
+    });
+    await it("should not remove an non-empty folder if recursive option is false and should remove an non-empty folder if recursive option is true", async () => {
+      const dir = await promises2.mkdtemp("fs-test-");
+      await promises2.writeFile(join(dir, "file1.txt"), "");
+      await promises2.writeFile(join(dir, "file2.txt"), "");
+      await promises2.mkdir(join(dir, "some_dir"));
+      await promises2.mkdir(join(dir, "some_dir", "file.txt"));
+      expect(existsSync(dir)).toBeTruthy();
+      try {
+        await promises2.rm(dir, { recursive: false });
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+      expect(existsSync(dir)).toBeTruthy();
+      await promises2.rm(dir, { recursive: true });
+      expect(existsSync(dir)).toBeFalsy();
+    });
+  });
+};
+
+// src/sync.spec.ts
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2, readdirSync, readFileSync, mkdirSync, rmdirSync, writeFileSync, unlinkSync, watch, mkdtempSync, rmSync, realpathSync, symlinkSync } from "fs";
+import { Buffer as Buffer4 } from "buffer";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var sync_spec_default = async () => {
+  await describe("fs.existsSync", async () => {
+    const existingFiles = ["tsconfig.json", "package.json", "README.md"];
+    const nonExistingFiles = ["asdasd", "/asdasd", ""];
+    await it("should return true for existing files", () => {
+      for (const file of existingFiles) {
+        const result = existsSync2(file);
+        expect(result).toBe(true);
+      }
+    });
+    await it("should return false for non existing files", () => {
+      for (const file of nonExistingFiles) {
+        const result = existsSync2(file);
+        expect(result).toBe(false);
+      }
+    });
+  });
+  await describe("fs.readdirSync", async () => {
+    await it("should return no files for an empty directory", () => {
+      const dir = mkdtempSync("fs-test-");
+      const files = readdirSync(dir);
+      expect(files.length).toBe(0);
+      rmdirSync(dir);
+    });
+    await it("should return the files for non-empty directory", () => {
+      const dir = mkdtempSync("fs-test-");
+      const txt1 = join2(dir, "test1.txt");
+      const txt2 = join2(dir, "test2.txt");
+      const dir1 = join2(dir, "empty-dir");
+      writeFileSync(txt1, "");
+      writeFileSync(txt2, "");
+      mkdirSync(dir1);
+      const files = readdirSync(dir);
+      expect(files.length).toEqual(3);
+      rmSync(txt1);
+      rmSync(txt2);
+      rmdirSync(dir1);
+      rmdirSync(dir);
+    });
+    await it('should return the file with the name "file.txt"', () => {
+      const dir = mkdtempSync("fs-test-");
+      const expectedFileName = "file.txt";
+      const file = join2(dir, expectedFileName);
+      writeFileSync(file, "");
+      const files = readdirSync(dir);
+      expect(files[0]).toEqual(expectedFileName);
+      rmSync(file);
+      rmdirSync(dir);
+    });
+    await it('should return with file types if option "withFileTypes" is `true`', () => {
+      const dir = mkdtempSync("fs-test-");
+      const expectedFile = "file.txt";
+      const expectedDir = "subdir";
+      const file = join2(dir, expectedFile);
+      const subdir = join2(dir, expectedDir);
+      writeFileSync(file, "");
+      mkdirSync(subdir);
+      const files = readdirSync(dir, { withFileTypes: true });
+      expect(files.length).toBe(2);
+      const fileWithTypes = files.find((f) => f.name === expectedFile);
+      const dirWithTypes = files.find((f) => f.name === expectedDir);
+      expect(fileWithTypes.isFile()).toBeTruthy();
+      expect(fileWithTypes.isDirectory()).toBeFalsy();
+      expect(dirWithTypes.isFile()).toBeFalsy();
+      expect(dirWithTypes.isDirectory()).toBeTruthy();
+      rmSync(file);
+      rmdirSync(subdir);
+      rmdirSync(dir);
+    });
+  });
+  await describe("fs.readFileSync", async () => {
+    await it("should return a Buffer if no encoding was specified", () => {
+      const bufferData = readFileSync("package.json");
+      expect(bufferData instanceof Buffer4).toBeTruthy();
+    });
+    await it("should return a string when encoding is utf-8", () => {
+      const utf8Data = readFileSync("./test/file.txt", "utf-8");
+      expect(typeof utf8Data === "string").toBeTruthy();
+    });
+    await it('should return a string with "Hello World"', () => {
+      const utf8Data = readFileSync("./test/file.txt", "utf-8");
+      expect(utf8Data).toBe("Hello World");
+    });
+  });
+  await describe("fs.mkdirSync", async () => {
+    const dir = "./foobar";
+    await it(`should create the directory "${dir}" without error`, () => {
+      mkdirSync(dir);
+    });
+    await it(`${dir} should exists`, () => {
+      expect(existsSync2(dir)).toBeTruthy();
+    });
+  });
+  await describe("fs.rmdirSync", async () => {
+    const dir = "./foobar";
+    await it(`should be remove the directory "${dir}" without error`, () => {
+      rmdirSync(dir);
+    });
+    await it(`"${dir}" should not exists (anymore)`, () => {
+      expect(existsSync2(dir)).toBeFalsy();
+    });
+  });
+  await describe("fs.writeFileSync", async () => {
+    const watchMe = join2(__dirname, "test/watch.js");
+    await it(`should be executed without error`, () => {
+      writeFileSync(watchMe, "// test");
+    });
+    await it(`fs.watch should watch ${watchMe} for changes`, () => {
+      const watcher = watch(watchMe, { persistent: true }, console.log);
+      watcher.on("change", console.log).on("rename", console.log);
+      setTimeout(() => {
+        watcher.close();
+      }, 1e3);
+      setTimeout(() => {
+        writeFileSync(watchMe, "// test");
+        setTimeout(() => {
+          unlinkSync(watchMe);
+        }, 100);
+      }, 100);
+    });
+  });
+  await describe("fs.mkdtempSync", async () => {
+    await it("should be a function", () => {
+      expect(typeof mkdtempSync).toBe("function");
+    });
+    await it("should create a new directory", () => {
+      const directory = mkdtempSync("fs-test-");
+      expect(existsSync2(directory)).toBeTruthy();
+      rmdirSync(directory);
+    });
+  });
+  await describe("fs.realpathSync", async () => {
+    await it("should be a function", () => {
+      expect(typeof realpathSync).toBe("function");
+    });
+    await it("should return the real and absolute path", () => {
+      const tsConfig = "./tsconfig.json";
+      const tsConfigSymlink = "./symlink_tsconfig.json";
+      if (!existsSync2(tsConfigSymlink)) {
+        symlinkSync(tsConfig, tsConfigSymlink);
+        const realPath = realpathSync(tsConfig);
+        const realSymLinkPath = realpathSync(tsConfigSymlink);
+        expect(realSymLinkPath).toBe(realPath);
+      }
+      unlinkSync(tsConfigSymlink);
+    });
+  });
+};
+
+// src/symlink.spec.ts
+import { symlink as symlinkCb } from "fs";
+var symlink_spec_default = async () => {
+  await describe("fs.symlink", async () => {
+    await it("ASYNC: no callback function results in Error", () => {
+      expect(() => {
+        symlinkCb("some/path", "some/other/path", "dir");
+      }).toThrow(Error);
+    });
+  });
+};
+
+// src/stat.spec.ts
+import { statSync } from "fs";
+import { stat } from "fs/promises";
+var stat_spec_default = async () => {
+  await describe("fs.statSync", async () => {
+    await it("Should return the file stat", async () => {
+      const s = statSync("tsconfig.json");
+      expect(s.atime instanceof Date).toBeTruthy();
+      expect(s.atimeMs).toBeGreaterThan(0);
+      expect(s.birthtime instanceof Date).toBeTruthy();
+      expect(s.birthtimeMs).toBeGreaterThan(0);
+      expect(s.blksize).toBeGreaterThan(0);
+      expect(s.blocks).toBeGreaterThan(0);
+      expect(s.ctime instanceof Date).toBeTruthy();
+      expect(s.ctimeMs).toBeGreaterThan(0);
+      expect(s.dev).toBeGreaterThan(0);
+      expect(s.gid).toBeGreaterThan(0);
+      expect(s.ino).toBeGreaterThan(0);
+      expect(s.mode).toBeGreaterThan(0);
+      expect(s.mtime instanceof Date).toBeTruthy();
+      expect(s.mtimeMs).toBeGreaterThan(0);
+      expect(s.nlink).toBeGreaterThan(0);
+      expect(s.rdev).toBeGreaterThan(-1);
+      expect(s.size).toBeGreaterThan(0);
+      expect(s.uid).toBeGreaterThan(0);
+      expect(s.isBlockDevice()).toBeFalsy();
+      expect(s.isCharacterDevice()).toBeFalsy();
+      expect(s.isDirectory()).toBeFalsy();
+      expect(s.isFIFO()).toBeFalsy();
+      expect(s.isFile()).toBeTruthy();
+      expect(s.isSocket()).toBeFalsy();
+      expect(s.isSymbolicLink()).toBeFalsy();
+    });
+  });
+  await describe("fs.stat (promise)", async () => {
+    await it("Should return the file stat", async () => {
+      const s = await stat("tsconfig.json");
+      expect(s.atime instanceof Date).toBeTruthy();
+      expect(s.atimeMs).toBeGreaterThan(0);
+      expect(s.birthtime instanceof Date).toBeTruthy();
+      expect(s.birthtimeMs).toBeGreaterThan(0);
+      expect(s.blksize).toBeGreaterThan(0);
+      expect(s.blocks).toBeGreaterThan(0);
+      expect(s.ctime instanceof Date).toBeTruthy();
+      expect(s.ctimeMs).toBeGreaterThan(0);
+      expect(s.dev).toBeGreaterThan(0);
+      expect(s.gid).toBeGreaterThan(0);
+      expect(s.ino).toBeGreaterThan(0);
+      expect(s.mode).toBeGreaterThan(0);
+      expect(s.mtime instanceof Date).toBeTruthy();
+      expect(s.mtimeMs).toBeGreaterThan(0);
+      expect(s.nlink).toBeGreaterThan(0);
+      expect(s.rdev).toBeGreaterThan(-1);
+      expect(s.size).toBeGreaterThan(0);
+      expect(s.uid).toBeGreaterThan(0);
+      expect(s.isBlockDevice()).toBeFalsy();
+      expect(s.isCharacterDevice()).toBeFalsy();
+      expect(s.isDirectory()).toBeFalsy();
+      expect(s.isFIFO()).toBeFalsy();
+      expect(s.isFile()).toBeTruthy();
+      expect(s.isSocket()).toBeFalsy();
+      expect(s.isSymbolicLink()).toBeFalsy();
+    });
+  });
+};
+
+// src/test.mts
+run({ testSuiteCallback: callback_spec_default, testSuiteFileHandle: file_handle_spec_default, testSuitePromise: promises_spec_default, testSuiteSync: sync_spec_default, testSuiteSymlink: symlink_spec_default, testSuiteStat: stat_spec_default });