@zenfs/core 2.5.8 → 2.6.0

package/tests/fs/directory.test.ts

@@ -2,38 +2,38 @@
 import assert from 'node:assert/strict';
 import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const testDir = 'test-dir';
 const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
 const testDirectories = ['subdir1', 'subdir2'];
 
-fs.mkdirSync(testDir);
+await fs.promises.mkdir(testDir);
 for (const file of testFiles) {
-	fs.writeFileSync(`${testDir}/${file}`, 'Sample content');
+	await fs.promises.writeFile(`${testDir}/${file}`, 'Sample content');
 }
 for (const dir of testDirectories) {
-	fs.mkdirSync(`${testDir}/${dir}`);
+	await fs.promises.mkdir(`${testDir}/${dir}`);
 	for (const file of ['file4.txt', 'file5.txt']) {
-		fs.writeFileSync(`${testDir}/${dir}/${file}`, 'Sample content');
+		await fs.promises.writeFile(`${testDir}/${dir}/${file}`, 'Sample content');
 	}
 }
 
-suite('Directories', () => {
-	test('mkdir', async () => {
+suite('Directories', config('directories'), () => {
+	test('mkdir', config('async'), async () => {
 		await fs.promises.mkdir('/one', 0o755);
 		assert(await fs.promises.exists('/one'));
 		await assert.rejects(fs.promises.mkdir('/one', 0o755), { code: 'EEXIST' });
 	});
 
-	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));
+	test('mkdirSync', config('sync'), () => fs.mkdirSync('/two', 0o000));
 
-	test('mkdir, nested', async () => {
+	test('mkdir, nested', config('async'), async () => {
 		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested/dir' });
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
 
-	test('mkdir, recursive', async () => {
+	test('mkdir, recursive', config('async'), async () => {
 		assert.equal(await fs.promises.mkdir('/recursiveP/A/B', { recursive: true, mode: 0o755 }), '/recursiveP');
 		assert.equal(await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveP/A/B/C');
 		assert.equal(await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o700 }), undefined);
@@ -45,7 +45,7 @@ suite('Directories', () => {
 		assert.equal((await fs.promises.stat('/recursiveP/A/B/C/D')).mode, fs.constants.S_IFDIR | 0o777);
 	});
 
-	test('mkdirSync, recursive', () => {
+	test('mkdirSync, recursive', config('sync'), () => {
 		assert.equal(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }), '/recursiveS');
 		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveS/A/B/C');
 		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o700 }), undefined);
@@ -57,30 +57,30 @@ suite('Directories', () => {
 		assert.equal(fs.statSync('/recursiveS/A/B/C/D').mode, fs.constants.S_IFDIR | 0o777);
 	});
 
-	test('rmdir (non-empty)', async () => {
+	test('rmdir (non-empty)', config('async'), async () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
 
 		await assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
 	});
 
-	test('readdirSync on file', () => {
+	test('readdirSync on file', config('sync'), () => {
 		assert.throws(() => fs.readdirSync('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdir on file', async () => {
+	test('readdir on file', config('async'), async () => {
 		await assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdirSync on non-existent directory', () => {
+	test('readdirSync on non-existent directory', config('sync'), () => {
 		assert.throws(() => fs.readdirSync('/does/not/exist'), { code: 'ENOENT' });
 	});
 
-	test('readdir on non-existent directory', async () => {
+	test('readdir on non-existent directory', config('async'), async () => {
 		await assert.rejects(fs.promises.readdir('/does/not/exist'), { code: 'ENOENT' });
 	});
 
-	test('rm recursively', async () => {
+	test('rm recursively', config('async'), async () => {
 		await fs.promises.mkdir('/rmDirRecursively');
 		await fs.promises.mkdir('/rmDirRecursively/rmDirNested');
 		await fs.promises.writeFile('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
@@ -88,7 +88,7 @@ suite('Directories', () => {
 		await fs.promises.rm('/rmDirRecursively', { recursive: true });
 	});
 
-	test('rmSync recursively', () => {
+	test('rmSync recursively', config('sync'), () => {
 		fs.mkdirSync('/rmDirRecursively');
 		fs.mkdirSync('/rmDirRecursively/rmDirNested');
 		fs.writeFileSync('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
@@ -96,7 +96,7 @@ suite('Directories', () => {
 		fs.rmSync('/rmDirRecursively', { recursive: true });
 	});
 
-	test('readdir returns files and directories', async () => {
+	test('readdir returns files and directories', config('async'), async () => {
 		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
 		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
 		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
@@ -105,7 +105,7 @@ suite('Directories', () => {
 		assert(testDirectories.every(dir => dirs.includes(dir)));
 	});
 
-	test('readdirSync returns files and directories', () => {
+	test('readdirSync returns files and directories', config('sync'), () => {
 		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
 		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
 		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
@@ -114,53 +114,54 @@ suite('Directories', () => {
 		assert(testDirectories.every(dir => dirs.includes(dir)));
 	});
 
-	test('readdir returns Dirent objects', async () => {
+	test('readdir returns Dirent objects', config('async'), async () => {
 		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
 		assert(dirents[0] instanceof fs.Dirent);
 	});
 
-	test('readdirSync returns Dirent objects', () => {
+	test('readdirSync returns Dirent objects', config('sync'), () => {
 		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
 		assert(dirents[0] instanceof fs.Dirent);
 	});
 
-	test('readdir works without withFileTypes option', async () => {
+	test('readdir works without withFileTypes option', config('async'), async () => {
 		const files = await fs.promises.readdir(testDir);
 		assert(testFiles.every(entry => files.includes(entry)));
 		assert(testDirectories.every(entry => files.includes(entry)));
 	});
 
-	test('readdirSync works without withFileTypes option', () => {
+	test('readdirSync works without withFileTypes option', config('sync'), () => {
 		const files = fs.readdirSync(testDir);
 		assert(testFiles.every(entry => files.includes(entry)));
 		assert(testDirectories.every(entry => files.includes(entry)));
 	});
 
-	test('readdir returns files recursively', async () => {
+	test('readdir returns files recursively', config('async'), async () => {
 		const entries = await fs.promises.readdir(testDir, { recursive: true });
 		assert(entries.includes('file1.txt'));
 		assert(entries.includes('subdir1/file4.txt'));
 		assert(entries.includes('subdir2/file5.txt'));
 	});
 
-	test('readdir returns Dirent recursively', async () => {
+	test('readdir returns Dirent recursively', config('async'), async () => {
 		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
 		entries.sort((a, b) => join(a.parentPath, a.name).localeCompare(join(b.parentPath, b.name)));
 		const values = entries.map(entry => [entry.parentPath, entry.name]);
 
-		assert.deepEqual(values[0], ['.', 'file1.txt']);
-		assert.deepEqual(values[4], ['subdir1', 'file4.txt']);
-		assert.deepEqual(values[8], ['subdir2', 'file5.txt']);
+		// `parentPath` is resolved against the directory that was read
+		assert.deepEqual(values[0], ['/' + testDir, 'file1.txt']);
+		assert.deepEqual(values[4], ['/' + testDir + '/subdir1', 'file4.txt']);
+		assert.deepEqual(values[8], ['/' + testDir + '/subdir2', 'file5.txt']);
 	});
 
-	test('readdirSync returns files recursively', () => {
+	test('readdirSync returns files recursively', config('sync'), () => {
 		const entries = fs.readdirSync(testDir, { recursive: true }).sort();
 		assert.equal(entries[0], 'file1.txt');
 		assert.equal(entries[4], 'subdir1/file4.txt');
 		assert.equal(entries[8], 'subdir2/file5.txt');
 	});
 
-	test('Cyrillic file names', () => {
+	test('Cyrillic file names', config('sync'), () => {
 		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
 		assert(fs.readdirSync('/').includes('мой-файл.txt'));
 	});

package/tests/fs/errors.test.ts

@@ -1,39 +1,159 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import test, { suite } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const existingFile = '/exit.js';
+const path = '/non-existent';
+
+interface Case {
+	/** The name of the test */
+	name: string;
+	code: string;
+	/** The syscall the error should be attributed to, which is not always the name of the function */
+	syscall: string;
+	path: string;
+	dest?: string;
+	sync: (this: void) => unknown;
+	async: (this: void) => Promise<unknown>;
+}
+
+const cases: Case[] = [
+	{
+		name: 'stat',
+		code: 'ENOENT',
+		syscall: 'stat',
+		path,
+		sync: () => fs.statSync(path),
+		async: () => fs.promises.stat(path),
+	},
+	{
+		name: 'lstat',
+		code: 'ENOENT',
+		syscall: 'lstat',
+		path,
+		sync: () => fs.lstatSync(path),
+		async: () => fs.promises.lstat(path),
+	},
+	{
+		name: 'mkdir',
+		code: 'EEXIST',
+		syscall: 'mkdir',
+		path: existingFile,
+		sync: () => fs.mkdirSync(existingFile, 0o666),
+		async: () => fs.promises.mkdir(existingFile, 0o666),
+	},
+	{
+		name: 'rmdir (missing)',
+		code: 'ENOENT',
+		syscall: 'rmdir',
+		path,
+		sync: () => fs.rmdirSync(path),
+		async: () => fs.promises.rmdir(path),
+	},
+	{
+		name: 'rmdir (not a directory)',
+		code: 'ENOTDIR',
+		syscall: 'rmdir',
+		path: existingFile,
+		sync: () => fs.rmdirSync(existingFile),
+		async: () => fs.promises.rmdir(existingFile),
+	},
+	{
+		name: 'rename',
+		code: 'ENOENT',
+		syscall: 'rename',
+		path,
+		dest: '/foo',
+		sync: () => fs.renameSync(path, 'foo'),
+		async: () => fs.promises.rename(path, 'foo'),
+	},
+	{
+		name: 'open',
+		code: 'ENOENT',
+		syscall: 'open',
+		path,
+		sync: () => fs.openSync(path, 'r'),
+		async: () => fs.promises.open(path, 'r'),
+	},
+	{
+		// Note Node attributes `readdir` failures to `scandir`
+		name: 'readdir',
+		code: 'ENOENT',
+		syscall: 'scandir',
+		path,
+		sync: () => fs.readdirSync(path),
+		async: () => fs.promises.readdir(path),
+	},
+	{
+		name: 'unlink',
+		code: 'ENOENT',
+		syscall: 'unlink',
+		path,
+		sync: () => fs.unlinkSync(path),
+		async: () => fs.promises.unlink(path),
+	},
+	{
+		// Note `path` is the existing file and `dest` is the new link
+		name: 'link',
+		code: 'ENOENT',
+		syscall: 'link',
+		path,
+		dest: '/foo',
+		sync: () => fs.linkSync(path, 'foo'),
+		async: () => fs.promises.link(path, 'foo'),
+	},
+	{
+		name: 'chmod',
+		code: 'ENOENT',
+		syscall: 'chmod',
+		path,
+		sync: () => fs.chmodSync(path, 0o666),
+		async: () => fs.promises.chmod(path, 0o666),
+	},
+	{
+		name: 'readlink',
+		code: 'ENOENT',
+		syscall: 'readlink',
+		path,
+		sync: () => fs.readlinkSync(path),
+		async: () => fs.promises.readlink(path),
+	},
+];
+
+/**
+ * Checks an error against the expected code, syscall, path, and message.
+ *
+ * The message is only matched at the start, since the description text for an errno
+ * is not standardized and implementations may add more information at the end.
+ */
+function check(error: unknown, c: Case): void {
+	const e = error as NodeJS.ErrnoException & { dest?: string };
+
+	assert.equal(e.code, c.code);
+	assert.equal(e.syscall, c.syscall);
+	assert.equal(e.path, c.path);
+	if (c.dest) assert.equal(e.dest, c.dest);
+
+	// e.g. `ENOENT: no such file or directory, stat '/non-existent'`
+	const expected = new RegExp(`^${c.code}: .+, ${c.syscall} '${c.path}'` + (c.dest ? ` -> '${c.dest}'` : ''));
+	assert.match(e.message, expected);
+}
 
 suite('Error messages', () => {
-	const path = '/non-existent';
-
-	const missing = { path, code: 'ENOENT' };
-	const existing = { path: existingFile, code: 'EEXIST' };
-	const notDir = { path: existingFile, code: 'ENOTDIR' };
-
-	test('stat', async () => await assert.rejects(() => fs.promises.stat(path), missing));
-	test('mkdir', async () => await assert.rejects(() => fs.promises.mkdir(existingFile, 0o666), existing));
-	test('rmdir (missing)', async () => await assert.rejects(() => fs.promises.rmdir(path), missing));
-	test('rmdir (existing)', async () => await assert.rejects(() => fs.promises.rmdir(existingFile), notDir));
-	test('rename', async () => await assert.rejects(() => fs.promises.rename(path, 'foo'), missing));
-	test('open', async () => await assert.rejects(() => fs.promises.open(path, 'r'), missing));
-	test('readdir', async () => await assert.rejects(() => fs.promises.readdir(path), missing));
-	test('unlink', async () => await assert.rejects(() => fs.promises.unlink(path), missing));
-	test('link', async () => await assert.rejects(() => fs.promises.link(path, 'foo'), { code: 'ENOENT', path: '/foo' }));
-	test('chmod', async () => await assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
-	test('lstat', async () => await assert.rejects(() => fs.promises.lstat(path), missing));
-	test('readlink', async () => await assert.rejects(() => fs.promises.readlink(path), missing));
-	test('statSync', () => assert.throws(() => fs.statSync(path), missing));
-	test('mkdirSync', () => assert.throws(() => fs.mkdirSync(existingFile, 0o666), existing));
-	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(path), missing));
-	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(existingFile), notDir));
-	test('renameSync', () => assert.throws(() => fs.renameSync(path, 'foo'), missing));
-	test('openSync', () => assert.throws(() => fs.openSync(path, 'r'), missing));
-	test('readdirSync', () => assert.throws(() => fs.readdirSync(path), missing));
-	test('unlinkSync', () => assert.throws(() => fs.unlinkSync(path), missing));
-	test('linkSync', () => assert.throws(() => fs.linkSync(path, 'foo'), { code: 'ENOENT', path: '/foo' }));
-	test('chmodSync', () => assert.throws(() => fs.chmodSync(path, 0o666), missing));
-	test('lstatSync', () => assert.throws(() => fs.lstatSync(path), missing));
-	test('readlinkSync', () => assert.throws(() => fs.readlinkSync(path), missing));
+	for (const c of cases) {
+		test(c.name, config('async'), async () => {
+			await assert.rejects(c.async, (error: unknown) => {
+				check(error, c);
+				return true;
+			});
+		});
+
+		test(c.name + 'Sync', config('sync'), () => {
+			assert.throws(c.sync, (error: unknown) => {
+				check(error, c);
+				return true;
+			});
+		});
+	}
 });

package/tests/fs/exists.test.ts

@@ -1,22 +1,22 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 suite('exists', () => {
 	const f = 'x.txt';
 
-	test('return true for an existing file', async () => {
+	test('return true for an existing file', config('async'), async () => {
 		const exists = await fs.promises.exists(f);
 		assert(exists);
 	});
 
-	test('return false for a non-existent file', async () => {
+	test('return false for a non-existent file', config('async'), async () => {
 		const exists = await fs.promises.exists(f + '-NO');
 		assert(!exists);
 	});
 
-	test('have sync methods that behave the same', () => {
+	test('have sync methods that behave the same', config('sync'), () => {
 		assert(fs.existsSync(f));
 		assert(!fs.existsSync(f + '-NO'));
 	});

package/tests/fs/links.test.ts

@@ -1,11 +1,10 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { join } from '@zenfs/core/path';
-import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
-suite('Links', () => {
+suite('Links', config('symlinks'), () => {
 	const target = '/a1.js',
 		symlink = 'symlink1.js',
 		hardlink = 'link1.js';
@@ -69,14 +68,8 @@ suite('Links', () => {
 		assert(await fs.promises.exists(target));
 	});
 
-	test('link', async t => {
-		const _ = await fs.promises.link(target, hardlink).catch((e: Exception) => {
-			if (e.code == 'ENOSYS') return e;
-			throw e;
-		});
-		if (_) {
-			return t.skip('Backend does not support hard links');
-		}
+	test('link', config('links'), async () => {
+		await fs.promises.link(target, hardlink);
 		const targetContent = await fs.promises.readFile(target, 'utf8');
 		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
 		assert.equal(targetContent, linkContent);

package/tests/fs/open.test.ts

@@ -1,22 +1,22 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 suite('Opening files', () => {
 	const filename = 'a.js';
 
-	test('throw ENOENT when opening non-existent file', async () => {
+	test('throw ENOENT when opening non-existent file', config('sync', 'async'), async () => {
 		assert.throws(() => fs.openSync('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
 		await assert.rejects(fs.promises.open('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
 	});
 
-	test('open file with mode "r"', async () => {
+	test('open file with mode "r"', config('async'), async () => {
 		const { fd } = await fs.promises.open(filename, 'r');
 		assert(fd >= -Infinity);
 	});
 
-	test('open file with mode "rs"', async () => {
+	test('open file with mode "rs"', config('async'), async () => {
 		const { fd } = await fs.promises.open(filename, 'rs');
 		assert(fd >= -Infinity);
 	});

package/tests/fs/permissions.test.ts

@@ -1,19 +1,20 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { Exception } from 'kerium';
+import { R_OK, W_OK, X_OK } from '@zenfs/core/constants';
+import { defaultContext } from '@zenfs/core/internal/contexts.js';
+import { hasAccess } from '@zenfs/core/internal/inode.js';
+import { join } from '@zenfs/core/path';
+import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { encodeUTF8 } from 'utilium';
-import { defaultContext } from '@zenfs/core/internal/contexts.js';
-import { join } from '@zenfs/core/path';
-import { R_OK, W_OK, X_OK } from '@zenfs/core/constants';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const asyncMode = 0o777;
 const syncMode = 0o644;
 const file = 'a.js';
 
-suite('Permissions', () => {
-	test('chmod', async () => {
+suite('Permissions', config('permissions'), () => {
+	test('chmod', config('sync', 'async'), async () => {
 		await fs.promises.chmod(file, asyncMode.toString(8));
 
 		const stats = await fs.promises.stat(file);
@@ -23,7 +24,7 @@ suite('Permissions', () => {
 		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
 	});
 
-	test('fchmod', async () => {
+	test('fchmod', config('sync', 'async'), async () => {
 		const handle = await fs.promises.open(file, 'a', 0o644);
 
 		await handle.chmod(asyncMode);
@@ -35,7 +36,7 @@ suite('Permissions', () => {
 		assert.equal(fs.statSync(file).mode & 0o777, syncMode);
 	});
 
-	test('lchmod', async () => {
+	test('lchmod', config('lchmod', 'async'), async () => {
 		const link = 'symbolic-link';
 
 		await fs.promises.symlink(file, link);
@@ -50,16 +51,15 @@ suite('Permissions', () => {
 
 	async function test_item(path: string): Promise<void> {
 		const stats = await fs.promises.stat(path).catch((error: Exception) => {
-			assert(error instanceof Exception);
 			assert.equal(error.code, 'EACCES');
 		});
 		if (!stats) return;
-		assert(stats.hasAccess(X_OK));
+		assert(hasAccess(defaultContext, stats, X_OK));
 
 		function checkError(access: number) {
 			return function (error: Exception) {
-				assert(error instanceof Exception);
-				assert(!stats!.hasAccess(access));
+				assert(error instanceof Error);
+				assert(!hasAccess(defaultContext, stats!, access));
 			};
 		}
 
@@ -70,7 +70,7 @@ suite('Permissions', () => {
 		} else {
 			await fs.promises.readFile(path).catch(checkError(R_OK));
 		}
-		assert(stats.hasAccess(R_OK));
+		assert(hasAccess(defaultContext, stats, R_OK));
 
 		if (stats.isDirectory()) {
 			const testFile = join(path, '__test_file_plz_ignore.txt');
@@ -81,7 +81,7 @@ suite('Permissions', () => {
 			if (!handle) return;
 			await handle.close();
 		}
-		assert(stats.hasAccess(W_OK));
+		assert(hasAccess(defaultContext, stats, W_OK));
 	}
 
 	const copy = { ...defaultContext.credentials };

package/tests/fs/read.test.ts

@@ -5,21 +5,21 @@ import assert from 'node:assert/strict';
 import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
 import { promisify } from 'node:util';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
 const ellipses = '…'.repeat(10_000);
 
 suite('read', () => {
-	test('read file asynchronously', async () => {
+	test('read file asynchronously', config('async'), async () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 		assert.equal(bytesRead, expected.length);
 		assert.equal(buffer.toString(), expected);
 	});
 
-	test('read file synchronously', () => {
+	test('read file synchronously', config('sync'), () => {
 		const fd = fs.openSync(filepath, 'r');
 		const buffer = Buffer.alloc(expected.length);
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
@@ -28,14 +28,14 @@ suite('read', () => {
 		assert.equal(buffer.toString(), expected);
 	});
 
-	test('Read a file and check its binary bytes asynchronously', async () => {
+	test('Read a file and check its binary bytes asynchronously', config('async'), async () => {
 		const buff = await fs.promises.readFile('elipses.txt');
 		assert.equal(buff.length, 30_000);
 		assert.equal(buff.toString(), ellipses);
 		assert.equal((buff[1] << 8) | buff[0], 32994);
 	});
 
-	test('Read a file and check its binary bytes synchronously', () => {
+	test('Read a file and check its binary bytes synchronously', config('sync'), () => {
 		const buff = fs.readFileSync('elipses.txt');
 		assert.equal(buff.length, 30_000);
 		assert.equal(buff.toString(), ellipses);
@@ -45,7 +45,7 @@ suite('read', () => {
 	const bufferAsync = Buffer.alloc(expected.length);
 	const bufferSync = Buffer.alloc(expected.length);
 
-	test('read file from handle asynchronously', async () => {
+	test('read file from handle asynchronously', config('async'), async () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
@@ -53,7 +53,7 @@ suite('read', () => {
 		assert.equal(bufferAsync.toString(), expected);
 	});
 
-	test('read file from handle synchronously', () => {
+	test('read file from handle synchronously', config('sync'), () => {
 		const fd = fs.openSync(filepath, 'r');
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 
@@ -61,7 +61,7 @@ suite('read', () => {
 		assert.equal(bytesRead, expected.length);
 	});
 
-	test('read file synchronously to non-zero offset', () => {
+	test('read file synchronously to non-zero offset', config('sync'), () => {
 		const fd = fs.openSync(filepath, 'r');
 		const buffer = Buffer.alloc(expected.length + 10);
 		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
@@ -70,7 +70,7 @@ suite('read', () => {
 		assert.equal(bytesRead, expected.length);
 	});
 
-	test('read using callback API #239', async () => {
+	test('read using callback API #239', config('sync', 'write'), async () => {
 		const path = '/text.txt';
 
 		fs.writeFileSync(path, 'hello world');