@zenfs/core 1.2.10 → 1.3.1

package/src/emulation/sync.ts

@@ -106,7 +106,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -386,7 +386,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -459,8 +459,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
-		cache.setStatsSync(path, stats);
+		const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+		cache.stats.setSync(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -475,8 +475,8 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.setStatsSync(join(path, entry), entryStat);
+		const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.stats.setSync(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -500,7 +500,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStatsSync();
+		cache.stats.clearSync();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -622,7 +622,7 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption): st
 export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs.BufferEncodingOption): string | Buffer {
 	path = normalizePath(path);
 	const { base, dir } = parse(path);
-	const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
+	const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
 	const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
 
 	try {
@@ -631,7 +631,8 @@ export function realpathSync(path: fs.PathLike, options?: fs.EncodingOption | fs
 			return lpath;
 		}
 
-		return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
+		const target = mountPoint + readlinkSync(lpath, options).toString();
+		return cache.paths.getSync(target) || realpathSync(target);
 	} catch (e) {
 		if ((e as ErrnoError).code == 'ENOENT') {
 			return path;
@@ -658,7 +659,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.getStatsSync(path) || statSync(path);
+		stats = cache.stats.getSync(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -667,7 +668,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.setStatsSync(path, stats);
+	cache.stats.setSync(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -688,12 +689,12 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStatsSync();
+			cache.stats.clearSync();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStatsSync();
+		cache.stats.clearSync();
 	}
 }
 rmSync satisfies typeof fs.rmSync;

package/src/file.ts

@@ -145,7 +145,7 @@ export function isExclusive(flag: string): boolean {
 	return flag.indexOf('x') !== -1;
 }
 
-export abstract class File {
+export abstract class File<FS extends FileSystem = FileSystem> {
 	public constructor(
 		/**
 		 * @internal
@@ -166,12 +166,12 @@ export abstract class File {
 	public abstract close(): Promise<void>;
 	public abstract closeSync(): void;
 
-	public [Symbol.asyncDispose](): Promise<void> {
-		return this.close();
+	public async [Symbol.asyncDispose](): Promise<void> {
+		await this.close();
 	}
 
 	public [Symbol.dispose](): void {
-		return this.closeSync();
+		this.closeSync();
 	}
 
 	public abstract truncate(len: number): Promise<void>;
@@ -269,7 +269,7 @@ export abstract class File {
  * An implementation of `File` that operates completely in-memory.
  * `PreloadFile`s are backed by a `Uint8Array`.
  */
-export class PreloadFile<FS extends FileSystem> extends File {
+export class PreloadFile<FS extends FileSystem> extends File<FS> {
 	/**
 	 * Current position
 	 */
@@ -290,11 +290,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 * Note that, if contents is specified, it will be mutated by the file.
 	 */
 	public constructor(
-		/**
-		 * The file system that created the file.
-		 * @internal
-		 */
-		public fs: FS,
+		fs: FS,
 		path: string,
 		public readonly flag: string,
 		public readonly stats: Stats,
@@ -431,12 +427,12 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		if (length > this._buffer.length) {
 			const data = new Uint8Array(length - this._buffer.length);
 			// Write will set stats.size and handle syncing.
-			this.writeSync(data, 0, data.length, this._buffer.length);
+			this._write(data, 0, data.length, this._buffer.length);
 			return;
 		}
 		this.stats.size = length;
 		// Truncate.
-		this._buffer = this._buffer.slice(0, length);
+		this._buffer = length ? this._buffer.slice(0, length) : new Uint8Array();
 	}
 
 	public async truncate(length: number): Promise<void> {
@@ -645,14 +641,6 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
 		this.syncSync();
 	}
-
-	public async [Symbol.asyncDispose]() {
-		await this.close();
-	}
-
-	public [Symbol.dispose]() {
-		this.closeSync();
-	}
 }
 
 /**

package/src/index.ts

@@ -23,3 +23,13 @@ export * from './emulation/index.js';
 import * as fs from './emulation/index.js';
 export { fs };
 export default fs;
+
+declare global {
+	/**
+	 * Global FS emulation. Do not use unless absolutely needed.
+	 * @hidden
+	 */
+	// eslint-disable-next-line no-var
+	var __zenfs__: typeof fs;
+}
+globalThis.__zenfs__ = fs;

package/src/inode.ts

@@ -1,11 +1,6 @@
-import { deserialize, serialize, sizeof, struct, types as t } from 'utilium';
+import { deserialize, sizeof, struct, types as t } from 'utilium';
 import { Stats, type StatsLike } from './stats.js';
-
-/**
- * Alias for an ino.
- * This will be helpful if in the future inode numbers/IDs are changed to strings or numbers.
- */
-export type Ino = bigint;
+import { randomBigInt } from './utils.js';
 
 /**
  * Room inode
@@ -13,34 +8,33 @@ export type Ino = bigint;
  */
 export const rootIno = 0n;
 
-/**
- * Generates a random 32 bit integer, then converts to a hex string
- */
-function _random() {
-	return Math.round(Math.random() * 2 ** 32).toString(16);
-}
-
-/**
- * Generate a random ino
- * @internal
- */
-export function randomIno(): Ino {
-	return BigInt('0x' + _random() + _random());
-}
-
 /**
  * Generic inode definition that can easily be serialized.
+ * @internal
+ * @todo [BREAKING]
  */
 @struct()
 export class Inode implements StatsLike {
-	public get data(): Uint8Array {
-		return serialize(this);
-	}
-
-	public constructor(buffer?: ArrayBufferLike) {
+	public constructor(buffer?: ArrayBufferLike | ArrayBufferView) {
 		if (buffer) {
-			if (buffer.byteLength < sizeof(Inode)) {
-				throw new RangeError(`Can not create an inode from a buffer less than ${sizeof(Inode)} bytes`);
+			const sz_inode = sizeof(Inode);
+			const oldSize = sz_inode - sizeof('uint64');
+			if (buffer.byteLength < oldSize) {
+				throw new RangeError(`Can not create an inode from a buffer less than ${oldSize} bytes`);
+			}
+
+			// Expand the buffer so it is the right size
+			if (buffer.byteLength < sz_inode) {
+				const newBuffer = new Uint32Array(sz_inode);
+				// Fill the new buffer with current data
+				newBuffer.set(new Uint32Array(ArrayBuffer.isView(buffer) ? buffer.buffer : buffer));
+				/* 	Add a random ino. 
+					This will be different from the actual one,
+					but `ino` isn't used anywhere so it should be fine.
+				*/
+				const randomIno = crypto.getRandomValues(new Uint32Array(2));
+				newBuffer.set(randomIno, sz_inode - 2);
+				buffer = newBuffer;
 			}
 
 			deserialize(this, buffer);
@@ -48,7 +42,8 @@ export class Inode implements StatsLike {
 		}
 
 		// set defaults on a fresh inode
-		this.ino = randomIno();
+		this.ino = randomBigInt();
+		this.data = randomBigInt();
 		this.nlink = 1;
 		this.size = 4096;
 		const now = Date.now();
@@ -58,7 +53,7 @@ export class Inode implements StatsLike {
 		this.birthtimeMs = now;
 	}
 
-	@t.uint64 public ino!: Ino;
+	@t.uint64 public data!: bigint;
 	@t.uint32 public size!: number;
 	@t.uint16 public mode!: number;
 	@t.uint32 public nlink!: number;
@@ -68,6 +63,7 @@ export class Inode implements StatsLike {
 	@t.float64 public birthtimeMs!: number;
 	@t.float64 public mtimeMs!: number;
 	@t.float64 public ctimeMs!: number;
+	@t.uint64 public ino!: bigint;
 
 	/**
 	 * Handy function that converts the Inode to a Node Stats object.

package/src/mixins/async.ts

@@ -12,6 +12,28 @@ export type AsyncOperation = {
 	[K in keyof AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
 }[keyof AsyncFSMethods];
 
+/**
+ * @internal
+ */
+export interface Async {
+	/**
+	 * @internal @protected
+	 */
+	_sync?: FileSystem;
+	queueDone(): Promise<void>;
+	ready(): Promise<void>;
+	renameSync(oldPath: string, newPath: string): void;
+	statSync(path: string): Stats;
+	createFileSync(path: string, flag: string, mode: number): File;
+	openFileSync(path: string, flag: string): File;
+	unlinkSync(path: string): void;
+	rmdirSync(path: string): void;
+	mkdirSync(path: string, mode: number): void;
+	readdirSync(path: string): string[];
+	linkSync(srcpath: string, dstpath: string): void;
+	syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+}
+
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -22,29 +44,7 @@ export type AsyncOperation = {
  * During loading, the contents of the async file system are preloaded into the synchronous store.
  *
  */
-export function Async<T extends typeof FileSystem>(
-	FS: T
-): Mixin<
-	T,
-	{
-		/**
-		 * @internal @protected
-		 */
-		_sync?: FileSystem;
-		queueDone(): Promise<void>;
-		ready(): Promise<void>;
-		renameSync(oldPath: string, newPath: string): void;
-		statSync(path: string): Stats;
-		createFileSync(path: string, flag: string, mode: number): File;
-		openFileSync(path: string, flag: string): File;
-		unlinkSync(path: string): void;
-		rmdirSync(path: string): void;
-		mkdirSync(path: string, mode: number): void;
-		readdirSync(path: string): string[];
-		linkSync(srcpath: string, dstpath: string): void;
-		syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-	}
-> {
+export function Async<const T extends typeof FileSystem>(FS: T): Mixin<T, Async> {
 	abstract class AsyncFS extends FS {
 		/**
 		 * Queue of pending asynchronous operations.
@@ -67,6 +67,7 @@ export function Async<T extends typeof FileSystem>(
 
 		public async ready(): Promise<void> {
 			await super.ready();
+			await this.queueDone();
 			if (this._isInitialized || this._disableSync) {
 				return;
 			}
@@ -128,7 +129,7 @@ export function Async<T extends typeof FileSystem>(
 
 		public openFileSync(path: string, flag: string): PreloadFile<this> {
 			this.checkSync(path, 'openFile');
-			const file = this._sync.openFileSync(path, flag);
+			const file = this._sync.openFileSync(path, flag + '+');
 			const stats = file.statSync();
 			const buffer = new Uint8Array(stats.size);
 			file.readSync(buffer);
@@ -225,3 +226,5 @@ export function Async<T extends typeof FileSystem>(
 
 	return AsyncFS;
 }
+
+export function asyncPatch<T extends typeof FileSystem>(fs: Mixin<T, Async>) {}

package/src/utils.ts

@@ -182,22 +182,6 @@ export function encodeDirListing(data: Record<string, bigint>): Uint8Array {
 
 export type Callback<Args extends unknown[] = []> = (e?: ErrnoError, ...args: OptionalTuple<Args>) => unknown;
 
-/**
- * converts Date or number to a integer UNIX timestamp
- * Grabbed from NodeJS sources (lib/fs.js)
- *
- * @internal
- */
-export function _toUnixTimestamp(time: Date | number): number {
-	if (typeof time === 'number') {
-		return Math.floor(time);
-	}
-	if (time instanceof Date) {
-		return Math.floor(time.getTime() / 1000);
-	}
-	throw new Error('Cannot parse time');
-}
-
 /**
  * Normalizes a mode
  * @internal
@@ -230,15 +214,11 @@ export function normalizeTime(time: string | number | Date): Date {
 		return time;
 	}
 
-	if (typeof time == 'number') {
-		return new Date(time * 1000);
-	}
-
-	if (typeof time == 'string') {
+	try {
 		return new Date(time);
+	} catch {
+		throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
 	}
-
-	throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
 }
 
 /**
@@ -286,3 +266,11 @@ export function normalizeOptions(
 }
 
 export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: any[]) => InstanceType<T>);
+
+/**
+ * Generate a random ino
+ * @internal
+ */
+export function randomBigInt(): bigint {
+	return crypto.getRandomValues(new BigUint64Array(1))[0];
+}

package/tests/fs/dir.test.ts

@@ -3,18 +3,20 @@ import { suite, test } from 'node:test';
 import { fs } from '../common.js';
 
 const testFile = 'test-file.txt';
-await fs.promises.writeFile(testFile, 'Sample content');
-await fs.promises.mkdir('test-directory');
-await fs.promises.symlink(testFile, 'test-symlink');
+fs.writeFileSync(testFile, 'Sample content');
+fs.mkdirSync('test-directory');
+fs.symlinkSync(testFile, 'test-symlink');
 const testDirPath = 'test-dir';
 const testFiles = ['file1.txt', 'file2.txt'];
-await fs.promises.mkdir(testDirPath);
+fs.mkdirSync(testDirPath);
 for (const file of testFiles) {
-	await fs.promises.writeFile(`${testDirPath}/${file}`, 'Sample content');
+	fs.writeFileSync(`${testDirPath}/${file}`, 'Sample content');
 }
 
+await fs._synced();
+
 suite('Dirent', () => {
-	test('Dirent name and parentPath getters', async () => {
+	test('name and parentPath getters', async () => {
 		const stats = await fs.promises.lstat(testFile);
 		const dirent = new fs.Dirent(testFile, stats);
 
@@ -22,7 +24,7 @@ suite('Dirent', () => {
 		assert.equal(dirent.parentPath, testFile);
 	});
 
-	test('Dirent.isFile', async () => {
+	test('isFile', async () => {
 		const fileStats = await fs.promises.lstat(testFile);
 		const fileDirent = new fs.Dirent(testFile, fileStats);
 
@@ -30,7 +32,7 @@ suite('Dirent', () => {
 		assert(!fileDirent.isDirectory());
 	});
 
-	test('Dirent.isDirectory', async () => {
+	test('isDirectory', async () => {
 		const dirStats = await fs.promises.lstat('test-directory');
 		const dirDirent = new fs.Dirent('test-directory', dirStats);
 
@@ -38,14 +40,14 @@ suite('Dirent', () => {
 		assert(dirDirent.isDirectory());
 	});
 
-	test('Dirent.isSymbolicLink', async () => {
+	test('isSymbolicLink', async () => {
 		const symlinkStats = await fs.promises.lstat('test-symlink');
 		const symlinkDirent = new fs.Dirent('test-symlink', symlinkStats);
 
 		assert(symlinkDirent.isSymbolicLink());
 	});
 
-	test('Dirent other methods return false', async () => {
+	test('other methods return false', async () => {
 		const fileStats = await fs.promises.lstat(testFile);
 		const fileDirent = new fs.Dirent(testFile, fileStats);
 
@@ -56,7 +58,7 @@ suite('Dirent', () => {
 });
 
 suite('Dir', () => {
-	test('Dir read() method (Promise varient)', async () => {
+	test('read()', async () => {
 		const dir = new fs.Dir(testDirPath);
 
 		const dirent1 = await dir.read();
@@ -73,19 +75,7 @@ suite('Dir', () => {
 		await dir.close();
 	});
 
-	test('Dir read() method (Callback varient)', (_, done) => {
-		const dir = new fs.Dir(testDirPath);
-		dir.read((err, dirent) => {
-			assert.strictEqual(err, undefined);
-			assert.notEqual(dirent, undefined);
-			assert(dirent instanceof fs.Dirent);
-			assert(testFiles.includes(dirent?.name));
-			dir.closeSync();
-			done();
-		});
-	});
-
-	test('Dir readSync() method', () => {
+	test('readSync()', () => {
 		const dir = new fs.Dir(testDirPath);
 
 		const dirent1 = dir.readSync();
@@ -102,19 +92,19 @@ suite('Dir', () => {
 		dir.closeSync();
 	});
 
-	test('Dir close() method (Promise version)', async () => {
+	test('close()', async () => {
 		const dir = new fs.Dir(testDirPath);
 		await dir.close();
 		rejects(dir.read(), 'Can not use closed Dir');
 	});
 
-	test('Dir closeSync() method', () => {
+	test('closeSync()', () => {
 		const dir = new fs.Dir(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
 	});
 
-	test('Dir asynchronous iteration', async () => {
+	test('asynchronous iteration', async () => {
 		const dir = new fs.Dir(testDirPath);
 		const dirents: fs.Dirent[] = [];
 
@@ -128,26 +118,26 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirents[1].name));
 	});
 
-	test('Dir read after directory is closed', async () => {
+	test('read after directory is closed', async () => {
 		const dir = new fs.Dir(testDirPath);
 		await dir.close();
 		await assert.rejects(dir.read(), 'Can not use closed Dir');
 	});
 
-	test('Dir readSync after directory is closed', () => {
+	test('readSync after directory is closed', () => {
 		const dir = new fs.Dir(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
 	});
 
-	test('Dir close multiple times', async () => {
+	test('close multiple times', async () => {
 		const dir = new fs.Dir(testDirPath);
 		await dir.close();
 		await dir.close(); // Should not throw an error
 		assert(dir['closed']);
 	});
 
-	test('Dir closeSync multiple times', () => {
+	test('closeSync multiple times', () => {
 		const dir = new fs.Dir(testDirPath);
 		dir.closeSync();
 		dir.closeSync(); // Should not throw an error

package/tests/fs/directory.test.ts

@@ -7,17 +7,19 @@ const testDir = 'test-dir';
 const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
 const testDirectories = ['subdir1', 'subdir2'];
 
-await fs.promises.mkdir(testDir);
+fs.mkdirSync(testDir);
 for (const file of testFiles) {
-	await fs.promises.writeFile(`${testDir}/${file}`, 'Sample content');
+	fs.writeFileSync(`${testDir}/${file}`, 'Sample content');
 }
 for (const dir of testDirectories) {
-	await fs.promises.mkdir(`${testDir}/${dir}`);
+	fs.mkdirSync(`${testDir}/${dir}`);
 	for (const file of ['file4.txt', 'file5.txt']) {
-		await fs.promises.writeFile(`${testDir}/${dir}/${file}`, 'Sample content');
+		fs.writeFileSync(`${testDir}/${dir}/${file}`, 'Sample content');
 	}
 }
 
+await fs._synced();
+
 suite('Directories', () => {
 	test('mkdir', async () => {
 		await fs.promises.mkdir('/one', 0o755);

package/tests/fs/links.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { join } from '../../dist/emulation/path.js';
 import { fs } from '../common.js';
+import type { ErrnoError } from '../../dist/error.js';
 
 suite('Links', () => {
 	const target = '/a1.js',
@@ -28,8 +29,14 @@ suite('Links', () => {
 		assert(await fs.promises.exists(target));
 	});
 
-	test('link', async () => {
-		await fs.promises.link(target, hardlink);
+	test('link', async t => {
+		const _ = await fs.promises.link(target, hardlink).catch((e: ErrnoError) => {
+			if (e.code == 'ENOSYS') return e;
+			throw e;
+		});
+		if (_) {
+			return t.skip('Backend does not support hard links');
+		}
 		const targetContent = await fs.promises.readFile(target, 'utf8');
 		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
 		assert.strictEqual(targetContent, linkContent);

package/tests/fs/permissions.test.ts

@@ -43,8 +43,8 @@ suite('Permissions', () => {
 		const stats = await fs.promises.lstat(link);
 		assert.equal(stats.mode & 0o777, asyncMode);
 
-		fs.lchmodSync(link, syncMode);
-		assert.equal(fs.lstatSync(link).mode & 0o777, syncMode);
+		await fs.promises.lchmod(link, syncMode);
+		assert.equal((await fs.promises.lstat(link)).mode & 0o777, syncMode);
 	});
 
 	async function test_item(path: string): Promise<void> {

package/tests/fs/times.test.ts

@@ -2,22 +2,33 @@ import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
 import { ErrnoError } from '../../dist/error.js';
-import { _toUnixTimestamp } from '../../dist/utils.js';
+import type { StatsLike } from '../../dist/stats.js';
 import { fs } from '../common.js';
 
 const path = 'x.txt';
 
-suite('times', () => {
-	function expect_assert(resource: string | number, atime: Date | number, mtime: Date | number) {
-		const stats = typeof resource == 'string' ? fs.statSync(resource) : fs.fstatSync(resource);
-		// check up to single-second precision since sub-second precision is OS and fs dependent
-		assert.equal(_toUnixTimestamp(atime), _toUnixTimestamp(stats.atime));
-		assert.equal(_toUnixTimestamp(mtime), _toUnixTimestamp(stats.mtime));
-	}
+/**
+ * Gets unix timestamps from stats
+ *
+ * @internal
+ */
+export function unixTimestamps(stats: StatsLike<number>): Record<'atime' | 'mtime', number> {
+	return {
+		atime: Math.floor(stats.atimeMs),
+		mtime: Math.floor(stats.mtimeMs),
+	};
+}
 
+suite('times', () => {
 	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
+		const times = {
+			atime: typeof atime == 'number' ? Math.floor(atime) : atime.getTime(),
+			mtime: typeof mtime == 'number' ? Math.floor(mtime) : mtime.getTime(),
+		};
+
 		await fs.promises.utimes(path, atime, mtime);
-		expect_assert(path, atime, mtime);
+
+		assert.deepStrictEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
@@ -27,10 +38,10 @@ suite('times', () => {
 		await using handle = await fs.promises.open(path, 'r');
 
 		await handle.utimes(atime, mtime);
-		expect_assert(handle.fd, atime, mtime);
+		assert.deepStrictEqual(unixTimestamps(await handle.stat()), times);
 
 		fs.utimesSync(path, atime, mtime);
-		expect_assert(path, atime, mtime);
+		assert.deepStrictEqual(unixTimestamps(fs.statSync(path)), times);
 
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);