@zenfs/core 1.11.4 → 2.1.0

package/tests/common/context.test.ts

@@ -1,11 +1,11 @@
-import { suite, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { canary } from 'utilium';
 import { bindContext } from '../../dist/context.js';
 import * as fs from '../../dist/vfs/index.js';
-import { canary } from 'utilium';
 
 fs.mkdirSync('/ctx');
-const { fs: ctx } = bindContext('/ctx');
+const { fs: ctx } = bindContext({ root: '/ctx' });
 
 suite('Context', () => {
 	test('create a file', () => {

package/tests/common/handle.test.ts

@@ -1,25 +1,21 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
+import { wait } from 'utilium';
 import { constants, type FileHandle, open } from '../../dist/vfs/promises.js';
 
 const content = 'The cake is a lie',
 	appended = '\nAnother lie';
 
-await suite('FileHandle', () => {
-	let handle: FileHandle;
-	const filePath = './test.txt';
-
-	test('open', async () => {
-		handle = await open(filePath, 'w+');
-	});
+await using handle: FileHandle = await open('./test.txt', 'ws+');
 
+await suite('FileHandle', () => {
 	test('writeFile', async () => {
 		await handle.writeFile(content);
 		await handle.sync();
 	});
 
 	test('readFile', async () => {
-		assert((await handle.readFile('utf8')) === content);
+		assert.equal(await handle.readFile('utf8'), content);
 	});
 
 	test('appendFile', async () => {
@@ -27,12 +23,12 @@ await suite('FileHandle', () => {
 	});
 
 	test('readFile after appendFile', async () => {
-		assert((await handle.readFile({ encoding: 'utf8' })) === content + appended);
+		assert.equal(await handle.readFile({ encoding: 'utf8' }), content + appended);
 	});
 
 	test('truncate', async () => {
 		await handle.truncate(5);
-		assert((await handle.readFile({ encoding: 'utf8' })) === content.slice(0, 5));
+		assert.equal(await handle.readFile({ encoding: 'utf8' }), content.slice(0, 5));
 	});
 
 	test('stat', async () => {
@@ -54,7 +50,16 @@ await suite('FileHandle', () => {
 		assert.equal(stats.gid, 5678);
 	});
 
-	test('close', async () => {
-		await handle.close();
+	test('readLines', async () => {
+		await handle.writeFile('first line\nsecond line\nthird line');
+
+		await using rl = handle.readLines();
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		await wait(50);
+
+		assert.deepEqual(lines, ['first line', 'second line', 'third line']);
 	});
 });

package/tests/common/mutex.test.ts

@@ -1,16 +1,16 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { Mutexed } from '../../dist/mixins/mutexed.js';
-import { StoreFS } from '../../dist/backends/store/fs.js';
 import { InMemoryStore } from '../../dist/backends/memory.js';
-import { suite, test } from 'node:test';
-import assert from 'node:assert/strict';
+import { StoreFS } from '../../dist/backends/store/fs.js';
+import { Mutexed } from '../../dist/mixins/mutexed.js';
 
-suite('LockFS mutex', () => {
+suite('Mutexed FS', () => {
 	const fs = new (Mutexed(StoreFS))(new InMemoryStore(0x10000, 'test'));
 	fs._fs.checkRootSync();
 
 	test('lock/unlock', () => {
-		const lock = fs.lockSync('/test', 'lock');
+		const lock = fs.lockSync();
 		assert(fs.isLocked);
 		lock.unlock();
 		assert(!fs.isLocked);
@@ -20,11 +20,11 @@ suite('LockFS mutex', () => {
 		let lock1Resolved = false;
 		let lock2Resolved = false;
 
-		const lock1 = fs.lock('/queued', 'test').then(lock => {
+		const lock1 = fs.lock().then(lock => {
 			lock1Resolved = true;
 			lock.unlock();
 		});
-		const lock2 = fs.lock('/queued', 'test').then(lock => {
+		const lock2 = fs.lock().then(lock => {
 			lock2Resolved = true;
 			lock.unlock();
 		});
@@ -50,7 +50,7 @@ suite('LockFS mutex', () => {
 		let x = 1;
 
 		async function foo() {
-			const lock = await fs.lock('raceConditions', 'test');
+			const lock = await fs.lock();
 			await wait(25);
 			x++;
 			lock.unlock();

package/tests/common/path.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { basename, dirname, extname, join, normalize, resolve } from '../../dist/vfs/path.js';
+import { basename, dirname, extname, join, normalize, resolve } from '../../dist/path.js';
 import * as fs from '../../dist/vfs/index.js';
 
 suite('Path emulation', () => {

package/tests/common/readline.test.ts

@@ -0,0 +1,104 @@
+import assert from 'node:assert/strict';
+import { PassThrough } from 'node:stream';
+import { suite, test } from 'node:test';
+import { wait } from 'utilium';
+import { createInterface, Interface } from '../../dist/readline.js';
+
+suite('Readline interface', { skip: true }, () => {
+	test('creates interface with readable stream', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		assert.ok(rl instanceof Interface);
+		assert.equal(rl.input, input);
+	});
+
+	test('emits line events when receiving data', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('first line\n');
+		input.write('second line\r\n');
+		input.write('third line\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['first line', 'second line', 'third line']);
+	});
+
+	test('handles partial lines correctly', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('partial ');
+		input.write('line\n');
+		input.write('another ');
+		input.write('partial line\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['partial line', 'another partial line']);
+	});
+
+	test('emits remaining buffer on close', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		input.write('line with newline\n');
+		input.write('line without newline');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['line with newline']);
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['line with newline', 'line without newline']);
+	});
+
+	test('tracks history correctly', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		let history: string[] = [];
+		rl.on('history', (h: string[]) => (history = h));
+
+		input.write('first command\n');
+		input.write('second command\n');
+
+		await wait(10);
+
+		assert.deepEqual(history, ['first command', 'second command']);
+	});
+
+	test('pause and resume functionality', async () => {
+		const input = new PassThrough();
+		await using rl = createInterface({ input });
+
+		const lines: string[] = [];
+		rl.on('line', (line: string) => lines.push(line));
+
+		rl.pause();
+		input.write('should not be processed\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, []);
+
+		rl.resume();
+		input.write('should be processed\n');
+
+		await wait(10);
+
+		assert.deepEqual(lines, ['should be processed']);
+	});
+});

package/tests/common.ts

@@ -1,26 +1,11 @@
 import { join, resolve } from 'node:path';
-import { fs as defaultFS, log } from '../dist/index.js';
+import { fs as defaultFS } from '../dist/index.js';
+import { setupLogs } from './logs.js';
 export type * from '../dist/index.js';
 
-const { ZENFS_LOG_LEVEL, SETUP } = process.env;
+setupLogs();
 
-let level: log.Level | (typeof log.levels)[log.Level] = log.Level.CRIT;
-
-if (ZENFS_LOG_LEVEL) {
-	const tmp = parseInt(ZENFS_LOG_LEVEL);
-	if (Number.isSafeInteger(tmp)) level = tmp;
-	else level = ZENFS_LOG_LEVEL as (typeof log.levels)[log.Level];
-}
-
-log.configure({
-	enabled: true,
-	format: log.formats.ansi_message,
-	dumpBacklog: true,
-	level,
-	output: console.error,
-});
-
-const setupPath = resolve(SETUP || join(import.meta.dirname, 'setup/memory.ts'));
+const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 
 const setup = await import(setupPath).catch(error => {
 	console.log('Failed to import test setup:');

package/tests/fetch/fetch.ts

@@ -1,6 +1,6 @@
+import { log } from 'kerium';
 import { configure, Fetch } from '../../dist/index.js';
 import { baseUrl } from './config.js';
-import * as log from '../../dist/internal/log.js';
 
 await configure({
 	mounts: {
@@ -13,7 +13,7 @@ await configure({
 	log: {
 		enabled: true,
 		output: console.error,
-		format: log.formats.ansi_message,
+		format: log.fancy({ style: 'ansi', colorize: 'message' }),
 		level: log.Level.INFO,
 		dumpBacklog: true,
 	},

package/tests/fs/append.test.ts

@@ -5,15 +5,15 @@ import { fs } from '../common.js';
 const content = 'Sample content',
 	original = 'ABCD';
 
-suite('appendFile', () => {
-	test('create an empty file and add content', async () => {
+suite('Appends', () => {
+	test('Create an empty file and add content', async () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
 		assert.equal(data, content);
 	});
 
-	test('append data to a non-empty file', async () => {
+	test('Append data to a non-empty file', async () => {
 		const filename = 'append2.txt';
 
 		await fs.promises.writeFile(filename, original);
@@ -22,7 +22,7 @@ suite('appendFile', () => {
 		assert.equal(data, original + content);
 	});
 
-	test('append a buffer to the file', async () => {
+	test('Append a buffer to the file', async () => {
 		const filename = 'append3.txt';
 
 		await fs.promises.writeFile(filename, original);

package/tests/fs/directory.test.ts

@@ -27,7 +27,7 @@ suite('Directories', () => {
 	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));
 
 	test('mkdir, nested', async () => {
-		assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
+		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
 
@@ -59,39 +59,39 @@ suite('Directories', () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
 
-		assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
+		await assert.rejects(fs.promises.rmdir('/rmdirTest'), { code: 'ENOTEMPTY' });
 	});
 
 	test('readdirSync on file', () => {
 		assert.throws(() => fs.readdirSync('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdir on file', () => {
-		assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
+	test('readdir on file', async () => {
+		await assert.rejects(fs.promises.readdir('a.js'), { code: 'ENOTDIR' });
 	});
 
-	test('readdirSync on non-existant directory', () => {
+	test('readdirSync on non-existent directory', () => {
 		assert.throws(() => fs.readdirSync('/does/not/exist'), { code: 'ENOENT' });
 	});
 
-	test('readdir on non-existant directory', () => {
-		assert.rejects(fs.promises.readdir('/does/not/exist'), { code: 'ENOENT' });
+	test('readdir on non-existent directory', async () => {
+		await assert.rejects(fs.promises.readdir('/does/not/exist'), { code: 'ENOENT' });
 	});
 
-	test('rm recursively asynchronously', async () => {
-		await fs.promises.mkdir('/rmDirRecusrively');
-		await fs.promises.mkdir('/rmDirRecusrively/rmDirNested');
-		await fs.promises.writeFile('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+	test('rm recursively', async () => {
+		await fs.promises.mkdir('/rmDirRecursively');
+		await fs.promises.mkdir('/rmDirRecursively/rmDirNested');
+		await fs.promises.writeFile('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
 
-		await fs.promises.rm('/rmDirRecusrively', { recursive: true });
+		await fs.promises.rm('/rmDirRecursively', { recursive: true });
 	});
 
-	test('rm recursively synchronously', () => {
-		fs.mkdirSync('/rmDirRecusrively');
-		fs.mkdirSync('/rmDirRecusrively/rmDirNested');
-		fs.writeFileSync('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+	test('rmSync recursively', () => {
+		fs.mkdirSync('/rmDirRecursively');
+		fs.mkdirSync('/rmDirRecursively/rmDirNested');
+		fs.writeFileSync('/rmDirRecursively/rmDirNested/test.txt', 'hello world!');
 
-		fs.rmSync('/rmDirRecusrively', { recursive: true });
+		fs.rmSync('/rmDirRecursively', { recursive: true });
 	});
 
 	test('readdir returns files and directories', async () => {
@@ -143,17 +143,17 @@ suite('Directories', () => {
 
 	test('readdir returns Dirent recursively', async () => {
 		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
-		assert(entries.find(entry => entry.path === 'file1.txt'));
-		assert(entries.find(entry => entry.path === 'subdir1/file4.txt'));
-		assert(entries.find(entry => entry.path === 'subdir2/file5.txt'));
+		const paths = entries.map(entry => entry.path).sort();
+		assert.equal(paths[0], 'file1.txt');
+		assert.equal(paths[4], 'subdir1/file4.txt');
+		assert.equal(paths[8], 'subdir2/file5.txt');
 	});
 
-	// New test for readdirSync with recursive: true
 	test('readdirSync returns files recursively', () => {
-		const entries = fs.readdirSync(testDir, { recursive: true });
-		assert(entries.includes('file1.txt'));
-		assert(entries.includes('subdir1/file4.txt'));
-		assert(entries.includes('subdir2/file5.txt'));
+		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', () => {

package/tests/fs/errors.test.ts

@@ -1,36 +1,32 @@
 import assert from 'node:assert/strict';
 import test, { suite } from 'node:test';
 import { fs } from '../common.js';
-import type { ErrnoError } from '../../dist/index.js';
 
 const existingFile = '/exit.js';
 
 suite('Error messages', () => {
 	const path = '/non-existent';
 
-	fs.promises.stat(path).catch((error: ErrnoError) => {
-		assert.equal(error.bufferSize(), 4 + JSON.stringify(error.toJSON()).length);
-	});
-
 	const missing = { path, code: 'ENOENT' };
-	const existing = { path: existingFile };
+	const existing = { path: existingFile, code: 'EEXIST' };
+	const notDir = { path: existingFile, code: 'ENOTDIR' };
 
-	test('stat', () => assert.rejects(() => fs.promises.stat(path), missing));
-	test('mkdir', () => assert.rejects(() => fs.promises.mkdir(existingFile, 0o666), existing));
-	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(path), missing));
-	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(existingFile), existing));
-	test('rename', () => assert.rejects(() => fs.promises.rename(path, 'foo'), missing));
-	test('open', () => assert.rejects(() => fs.promises.open(path, 'r'), missing));
-	test('readdir', () => assert.rejects(() => fs.promises.readdir(path), missing));
-	test('unlink', () => assert.rejects(() => fs.promises.unlink(path), missing));
-	test('link', () => assert.rejects(() => fs.promises.link(path, 'foo'), missing));
-	test('chmod', () => assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
-	test('lstat', () => assert.rejects(() => fs.promises.lstat(path), missing));
-	test('readlink', () => assert.rejects(() => fs.promises.readlink(path), missing));
+	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'), missing));
+	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), existing));
+	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));

package/tests/fs/links.test.ts

@@ -1,8 +1,8 @@
+import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { join } from '../../dist/vfs/path.js';
+import { join } from '../../dist/path.js';
 import { fs } from '../common.js';
-import type { ErrnoError } from '../../dist/index.js';
 
 suite('Links', () => {
 	const target = '/a1.js',
@@ -21,6 +21,7 @@ suite('Links', () => {
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
 		assert.equal(destination, target);
+		assert.throws(() => fs.readlinkSync(destination));
 	});
 
 	test('read target contents', async () => {
@@ -59,7 +60,7 @@ suite('Links', () => {
 	});
 
 	test('link', async t => {
-		const _ = await fs.promises.link(target, hardlink).catch((e: ErrnoError) => {
+		const _ = await fs.promises.link(target, hardlink).catch((e: Exception) => {
 			if (e.code == 'ENOSYS') return e;
 			throw e;
 		});

package/tests/fs/open.test.ts

@@ -1,30 +1,13 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
-suite('fs file opening', () => {
+suite('Opening files', () => {
 	const filename = 'a.js';
 
-	test('throw ENOENT when opening non-existent file (sync)', () => {
-		let caughtException = false;
-		try {
-			fs.openSync('/path/to/file/that/does/not/exist', 'r');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error?.code, 'ENOENT');
-			caughtException = true;
-		}
-		assert(caughtException);
-	});
-
-	test('throw ENOENT when opening non-existent file (async)', async () => {
-		try {
-			await fs.promises.open('/path/to/file/that/does/not/exist', 'r');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error?.code, 'ENOENT');
-		}
+	test('throw ENOENT when opening non-existent file', 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 () => {

package/tests/fs/permissions.test.ts

@@ -1,9 +1,10 @@
+import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { credentials, ErrnoError } from '../../dist/index.js';
-import { encodeUTF8 } from '../../dist/utils.js';
+import { encodeUTF8 } from 'utilium';
+import { defaultContext } from '../../dist/internal/contexts.js';
+import { join } from '../../dist/path.js';
 import { R_OK, W_OK, X_OK } from '../../dist/vfs/constants.js';
-import { join } from '../../dist/vfs/path.js';
 import { fs } from '../common.js';
 
 const asyncMode = 0o777;
@@ -47,19 +48,16 @@ suite('Permissions', () => {
 	});
 
 	async function test_item(path: string): Promise<void> {
-		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
+		const stats = await fs.promises.stat(path).catch((error: Exception) => {
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'EACCES');
 		});
-		if (!stats) {
-			return;
-		}
+		if (!stats) return;
 		assert(stats.hasAccess(X_OK));
 
 		function checkError(access: number) {
-			return function (error: ErrnoError) {
-				assert(error instanceof ErrnoError);
-				assert(error);
+			return function (error: Exception) {
+				assert(error instanceof Exception);
 				assert(!stats!.hasAccess(access));
 			};
 		}
@@ -79,16 +77,14 @@ suite('Permissions', () => {
 			await fs.promises.unlink(testFile).catch(checkError(W_OK));
 		} else {
 			const handle = await fs.promises.open(path, 'a').catch(checkError(W_OK));
-			if (!handle) {
-				return;
-			}
+			if (!handle) return;
 			await handle.close();
 		}
-		assert(stats.hasAccess(R_OK));
+		assert(stats.hasAccess(W_OK));
 	}
 
-	const copy = { ...credentials };
-	Object.assign(credentials, { uid: 1000, gid: 1000, euid: 1000, egid: 1000 });
+	const copy = { ...defaultContext.credentials };
+	Object.assign(defaultContext.credentials, { uid: 1000, gid: 1000, euid: 1000, egid: 1000 });
 	test('Access controls: /', () => test_item('/'));
-	Object.assign(credentials, copy);
+	Object.assign(defaultContext.credentials, copy);
 });

package/tests/fs/read.test.ts

@@ -1,10 +1,11 @@
+import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-import { Buffer } from 'buffer';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
+const ellipses = '…'.repeat(10_000);
 
 suite('read', () => {
 	test('read file asynchronously', async () => {
@@ -22,25 +23,25 @@ suite('read', () => {
 		assert.equal(bytesRead, expected.length);
 		assert.equal(buffer.toString(), expected);
 	});
-});
 
-suite('read binary', () => {
-	test('Read a file and check its binary bytes (asynchronous)', async () => {
+	test('Read a file and check its binary bytes asynchronously', 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 (synchronous)', () => {
+	test('Read a file and check its binary bytes synchronously', () => {
 		const buff = fs.readFileSync('elipses.txt');
+		assert.equal(buff.length, 30_000);
+		assert.equal(buff.toString(), ellipses);
 		assert.equal((buff[1] << 8) | buff[0], 32994);
 	});
-});
 
-suite('read buffer', () => {
 	const bufferAsync = Buffer.alloc(expected.length);
 	const bufferSync = Buffer.alloc(expected.length);
 
-	test('read file asynchronously', async () => {
+	test('read file from handle asynchronously', async () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
@@ -48,7 +49,7 @@ suite('read buffer', () => {
 		assert.equal(bufferAsync.toString(), expected);
 	});
 
-	test('read file synchronously', () => {
+	test('read file from handle synchronously', () => {
 		const fd = fs.openSync(filepath, 'r');
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);