@zenfs/core 1.2.1 → 1.2.3

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.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -387,7 +387,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -460,8 +460,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
-		cache.setStats(path, stats);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+		cache.setStatsSync(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -488,8 +488,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.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.setStats(join(path, entry), entryStat);
+		const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.setStatsSync(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -513,7 +513,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -671,7 +671,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.getStats(path) || statSync(path);
+		stats = cache.getStatsSync(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -680,7 +680,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.setStats(path, stats);
+	cache.setStatsSync(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -701,12 +701,12 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStats();
+			cache.clearStatsSync();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 }
 rmSync satisfies typeof fs.rmSync;

package/src/mixins/async.ts

@@ -1,3 +1,5 @@
+import { StoreFS } from '../backends/store/fs.js';
+import type { Store } from '../backends/store/store.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile, type File } from '../file.js';
@@ -72,6 +74,22 @@ export function Async<T extends typeof FileSystem>(
 
 			await this._sync.ready();
 
+			// optimization: for 2 storeFS', we copy at a lower abstraction level.
+			if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+				const sync = (this._sync as StoreFS<Store>)['store'].transaction();
+				const async = (this as StoreFS<Store>)['store'].transaction();
+
+				const promises = [];
+				for (const key of sync.keysSync()) {
+					promises.push(async.set(key, sync.getSync(key)));
+				}
+
+				await Promise.all(promises);
+
+				this._isInitialized = true;
+				return;
+			}
+
 			try {
 				await this.crossCopy('/');
 				this._isInitialized = true;
@@ -175,10 +193,11 @@ export function Async<T extends typeof FileSystem>(
 				const stats = await this.stat(path);
 				this._sync.mkdirSync(path, stats.mode);
 			}
-			const files = await this.readdir(path);
-			for (const file of files) {
-				await this.crossCopy(join(path, file));
+			const promises = [];
+			for (const file of await this.readdir(path)) {
+				promises.push(this.crossCopy(join(path, file)));
 			}
+			await Promise.all(promises);
 		}
 
 		/**

package/tests/fs/appendFile.test.ts

@@ -10,7 +10,7 @@ suite('appendFile', () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == content);
+		assert.equal(data, content);
 	});
 
 	test('append data to a non-empty file', async () => {
@@ -19,7 +19,7 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 
 	test('append a buffer to the file', async () => {
@@ -28,6 +28,6 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 });

package/tests/fs/dir.test.ts

@@ -18,8 +18,8 @@ suite('Dirent', () => {
 		const stats = await fs.promises.lstat(testFile);
 		const dirent = new fs.Dirent(testFile, stats);
 
-		assert(dirent.name === testFile);
-		assert(dirent.parentPath === testFile);
+		assert.equal(dirent.name, testFile);
+		assert.equal(dirent.parentPath, testFile);
 	});
 
 	test('Dirent.isFile', async () => {
@@ -68,7 +68,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = await dir.read();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		await dir.close();
 	});
@@ -76,8 +76,8 @@ suite('Dir', () => {
 	test('Dir read() method (Callback varient)', (_, done) => {
 		const dir = new fs.Dir(testDirPath);
 		dir.read((err, dirent) => {
-			assert(err === undefined);
-			assert(dirent != undefined);
+			assert.strictEqual(err, undefined);
+			assert.notEqual(dirent, undefined);
 			assert(dirent instanceof fs.Dirent);
 			assert(testFiles.includes(dirent?.name));
 			dir.closeSync();
@@ -97,7 +97,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = dir.readSync();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		dir.closeSync();
 	});
@@ -122,7 +122,7 @@ suite('Dir', () => {
 			dirents.push(dirent);
 		}
 
-		assert(dirents.length === 2);
+		assert.strictEqual(dirents.length, 2);
 		assert(dirents[0] instanceof fs.Dirent);
 		assert(testFiles.includes(dirents[0].name));
 		assert(testFiles.includes(dirents[1].name));

package/tests/fs/directory.test.ts

@@ -17,7 +17,7 @@ suite('Directory', () => {
 			await fs.promises.mkdir('/nested/dir');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
@@ -51,7 +51,7 @@ suite('Directory', () => {
 			fs.readdirSync('/two');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		}
 	});
 
@@ -63,7 +63,7 @@ suite('Directory', () => {
 			await fs.promises.rmdir('/rmdirTest');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTEMPTY');
+			assert.strictEqual(error.code, 'ENOTEMPTY');
 		}
 	});
 
@@ -75,7 +75,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 		assert(wasThrown);
 	});
@@ -85,7 +85,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('a.js');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 	});
 
@@ -97,7 +97,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(wasThrown);
 	});
@@ -107,7 +107,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('/does/not/exist');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/links.test.ts

@@ -19,7 +19,7 @@ suite('Links', () => {
 
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
-		assert(destination === target);
+		assert.strictEqual(destination, target);
 	});
 
 	test('unlink', async () => {
@@ -32,7 +32,7 @@ suite('Links', () => {
 		await fs.promises.link(target, hardlink);
 		const targetContent = await fs.promises.readFile(target, 'utf8');
 		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 
 	test('file inside symlinked directory', async () => {
@@ -41,6 +41,6 @@ suite('Links', () => {
 		const link = join('link', target);
 		assert((await fs.promises.realpath(link)) === target);
 		const linkContent = await fs.promises.readFile(link, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 });

package/tests/fs/open.test.ts

@@ -12,7 +12,7 @@ suite('fs file opening', () => {
 			fs.openSync('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 			caughtException = true;
 		}
 		assert(caughtException);
@@ -23,7 +23,7 @@ suite('fs file opening', () => {
 			await fs.promises.open('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/permissions.test.ts

@@ -10,7 +10,7 @@ suite('Permissions', () => {
 	async function test_item(path: string): Promise<void> {
 		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		});
 		if (!stats) {
 			return;

package/tests/fs/read.test.ts

@@ -10,7 +10,7 @@ suite('read', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 
@@ -19,7 +19,7 @@ suite('read', () => {
 		const buffer = Buffer.alloc(expected.length);
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 });
@@ -44,7 +44,7 @@ suite('read buffer', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 		assert(bufferAsync.toString() === expected);
 	});
 
@@ -53,7 +53,7 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 
 		assert(bufferSync.toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 
 	test('read file synchronously to non-zero offset', () => {
@@ -62,6 +62,6 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
 
 		assert(buffer.subarray(10, buffer.length).toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 });

package/tests/fs/readFile.test.ts

@@ -65,9 +65,9 @@ suite('fs file reading', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
 		for (let i = 0; i < content.length; i++) {
-			assert(content[i] === '…');
+			assert.strictEqual(content[i], '…');
 		}
 
-		assert(content.length === 10000);
+		assert.strictEqual(content.length, 10000);
 	});
 });

package/tests/fs/rename.test.ts

@@ -21,10 +21,10 @@ suite('Rename', () => {
 	 */
 	async function check_directory(dir: string) {
 		const contents = await fs.promises.readdir(dir);
-		assert(contents.length === 2);
+		assert.strictEqual(contents.length, 2);
 
 		const subContents = await fs.promises.readdir(dir + '/_rename_me');
-		assert(subContents.length === 1);
+		assert.strictEqual(subContents.length, 1);
 
 		assert(await fs.promises.exists(dir + '/file.dat'));
 		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
@@ -88,7 +88,7 @@ suite('Rename', () => {
 		  if (e == null) {
 			throw new Error("Failed invariant: Cannot rename a directory over a file.");
 		  } else {
-			assert(e.code === 'ENOTDIR');
+			assert.strictEqual(e.code, 'ENOTDIR');
 		  }
 		});*/
 	});
@@ -101,7 +101,7 @@ suite('Rename', () => {
 
 		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EBUSY');
+			assert.strictEqual(error.code, 'EBUSY');
 		});
 	});
 });

package/tests/fs/streams.test.ts

@@ -18,7 +18,7 @@ suite('ReadStream', () => {
 			data += chunk;
 		});
 		readStream.on('end', () => {
-			assert(data == testData);
+			assert.equal(data, testData);
 			done();
 		});
 		readStream.on('error', err => {
@@ -33,7 +33,7 @@ suite('ReadStream', () => {
 			closed = true;
 		});
 		readStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -41,27 +41,27 @@ suite('ReadStream', () => {
 
 	test('ReadStream declared properties', () => {
 		const readStream = new fs.ReadStream();
-		assert(readStream.bytesRead === undefined);
-		assert(readStream.path === undefined);
-		assert(readStream.pending === undefined);
+		assert.strictEqual(readStream.bytesRead, undefined);
+		assert.strictEqual(readStream.path, undefined);
+		assert.strictEqual(readStream.pending, undefined);
 
 		// Assign values
 		readStream.bytesRead = 10;
 		readStream.path = testFilePath;
 		readStream.pending = false;
 
-		assert(readStream.bytesRead === 10);
-		assert(readStream.path === testFilePath);
+		assert.strictEqual(readStream.bytesRead, 10);
+		assert.strictEqual(readStream.path, testFilePath);
 		assert(!readStream.pending);
 	});
 
 	test('ReadStream close method can be called multiple times', (_, done) => {
 		const readStream = new fs.ReadStream();
 		readStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			readStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -94,7 +94,7 @@ suite('WriteStream', () => {
 			closed = true;
 		});
 		writeStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -102,27 +102,27 @@ suite('WriteStream', () => {
 
 	test('WriteStream declared properties', () => {
 		const writeStream = new fs.WriteStream();
-		assert(writeStream.bytesWritten === undefined);
-		assert(writeStream.path === undefined);
-		assert(writeStream.pending === undefined);
+		assert.strictEqual(writeStream.bytesWritten, undefined);
+		assert.strictEqual(writeStream.path, undefined);
+		assert.strictEqual(writeStream.pending, undefined);
 
 		// Assign values
 		writeStream.bytesWritten = 20;
 		writeStream.path = testFilePathWrite;
 		writeStream.pending = true;
 
-		assert(writeStream.bytesWritten === 20);
-		assert(writeStream.path === testFilePathWrite);
+		assert.strictEqual(writeStream.bytesWritten, 20);
+		assert.strictEqual(writeStream.path, testFilePathWrite);
 		assert(writeStream.pending);
 	});
 
 	test('WriteStream close method can be called multiple times', (_, done) => {
 		const writeStream = new fs.WriteStream();
 		writeStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			writeStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -139,7 +139,7 @@ suite('FileHandle', () => {
 				data += chunk;
 			});
 			readStream.on('end', () => {
-				assert(data == testData);
+				assert.equal(data, testData);
 				resolve();
 			});
 			readStream.on('error', reject);
@@ -159,7 +159,7 @@ suite('FileHandle', () => {
 			writeStream.on('error', reject);
 		});
 		const data = await fs.promises.readFile(testFilePathWrite, 'utf8');
-		assert(data == testData);
+		assert.equal(data, testData);
 		await fileHandle.close();
 	});
 

package/tests/fs/times.test.ts

@@ -21,7 +21,7 @@ suite('times', () => {
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		});
 
 		// don't close this fd
@@ -40,21 +40,21 @@ suite('times', () => {
 			expect_assert(handle.fd, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOSYS');
+			assert.strictEqual(error.code, 'ENOSYS');
 		}
 
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code == 'EBADF');
+			assert.equal(error.code, 'EBADF');
 		}
 	}
 

package/tests/fs/watch.test.ts

@@ -14,8 +14,8 @@ await fs.promises.writeFile(testFile, 'Initial content');
 suite('Watch Features', () => {
 	test('fs.watch should emit events on file change', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
-			assert(eventType === 'change');
-			assert(filename === 'test.txt');
+			assert.strictEqual(eventType, 'change');
+			assert.strictEqual(filename, 'test.txt');
 		});
 
 		// Modify the file to trigger the event
@@ -24,8 +24,8 @@ suite('Watch Features', () => {
 
 	test('fs.watch should emit events on file rename (delete)', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'test.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'test.txt');
 		});
 
 		// Delete the file to trigger the event
@@ -63,8 +63,8 @@ suite('Watch Features', () => {
 
 	test('fs.watch should work with directories', async () => {
 		using watcher = fs.watch(testDir, (eventType, filename) => {
-			assert(eventType === 'change');
-			assert(filename === 'newFile.txt');
+			assert.strictEqual(eventType, 'change');
+			assert.strictEqual(filename, 'newFile.txt');
 		});
 
 		await fs.promises.writeFile(`${testDir}/newFile.txt`, 'Content');
@@ -77,8 +77,8 @@ suite('Watch Features', () => {
 		await fs.promises.writeFile(oldFile, 'Some content');
 
 		using watcher = fs.watch(testDir, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'oldFile.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'oldFile.txt');
 		});
 
 		// Rename the file to trigger the event
@@ -91,8 +91,8 @@ suite('Watch Features', () => {
 		await fs.promises.writeFile(tempFile, 'Temporary content');
 
 		using watcher = fs.watch(tempFile, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'tempFile.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'tempFile.txt');
 		});
 
 		await fs.promises.unlink(tempFile);

package/tests/fs/write.test.ts

@@ -10,11 +10,11 @@ suite('write', () => {
 		const handle = await fs.promises.open(fn, 'w', 0o644);
 		await handle.write('', 0, 'utf8');
 		const { bytesWritten } = await handle.write(expected, 0, 'utf8');
-		assert(bytesWritten === Buffer.from(expected).length);
+		assert.strictEqual(bytesWritten, Buffer.from(expected).length);
 		await handle.close();
 
 		const data = await fs.promises.readFile(fn, 'utf8');
-		assert(data === expected);
+		assert.strictEqual(data, expected);
 
 		await fs.promises.unlink(fn);
 	});
@@ -27,7 +27,7 @@ suite('write', () => {
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
-		assert(expected.length === written.bytesWritten);
+		assert.strictEqual(expected.length, written.bytesWritten);
 
 		await handle.close();
 
@@ -43,13 +43,13 @@ suite('writeSync', () => {
 		const fd = fs.openSync(fn, 'w');
 
 		let written = fs.writeSync(fd, '');
-		assert(written === 0);
+		assert.strictEqual(written, 0);
 
 		fs.writeSync(fd, 'foo');
 
 		const data = Buffer.from('bár');
 		written = fs.writeSync(fd, data, 0, data.length);
-		assert(written === 4);
+		assert.strictEqual(written, 4);
 
 		fs.closeSync(fd);