test: rename and split VFS test files into topic-based names

Replaces the -coverage / -branches / -misc suffixes with focused
files named after the API or behaviour they exercise. Splits the
larger multi-topic files into one-topic-per-file.

Renames:
- callbacks.js → callback-api.js
- stats-defaults.js → stats-helpers.js
- file-handle-base.js → virtual-file-handle.js
- provider-base.js → virtual-provider.js
- provider-memory.js → memory-provider.js
- real-provider-async.js → real-provider-promises.js
- mkdir-recursive-return.js → mkdir.js

New files (split out of -coverage/-branches/-misc):
- access-modes, create, link, mkdtemp, rename, symlinks, utimes,
  write-options
- memory-file-handle, memory-provider-dynamic, memory-provider-flags
- real-provider-handle, real-provider-symlinks, real-provider-watch
- stream-errors, stream-explicit-fd
- watch, watch-abort-signal, watch-encoding, watch-promises,
  watch-recursive

Coverage maintained at 97.6% line / 95.2% branch / 95.3% function.

Assisted-by: Claude-Opus4.7

Author: mcollina

test/parallel/test-vfs-access-modes.js

@@ -0,0 +1,40 @@
+'use strict';
+
+// access / accessSync honour the R_OK / W_OK / X_OK / F_OK mode bits and
+// throw EACCES when the file's permission bits don't allow the request.
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const vfs = require('node:vfs');
+
+const { R_OK, W_OK, X_OK } = fs.constants;
+
+const myVfs = vfs.create();
+
+// No read permission (mode 0o222 → owner has W only)
+myVfs.writeFileSync('/no-r.txt', 'x');
+myVfs.chmodSync('/no-r.txt', 0o222);
+assert.throws(() => myVfs.accessSync('/no-r.txt', R_OK), { code: 'EACCES' });
+assert.rejects(myVfs.promises.access('/no-r.txt', R_OK),
+               { code: 'EACCES' }).then(common.mustCall());
+
+// No write permission (mode 0o444 → owner has R only)
+myVfs.writeFileSync('/no-w.txt', 'x');
+myVfs.chmodSync('/no-w.txt', 0o444);
+assert.throws(() => myVfs.accessSync('/no-w.txt', W_OK), { code: 'EACCES' });
+assert.rejects(myVfs.promises.access('/no-w.txt', W_OK),
+               { code: 'EACCES' }).then(common.mustCall());
+
+// No execute permission (mode 0o644)
+myVfs.writeFileSync('/no-x.txt', 'x');
+myVfs.chmodSync('/no-x.txt', 0o644);
+assert.throws(() => myVfs.accessSync('/no-x.txt', X_OK), { code: 'EACCES' });
+assert.rejects(myVfs.promises.access('/no-x.txt', X_OK),
+               { code: 'EACCES' }).then(common.mustCall());
+
+// F_OK (mode 0) is an existence-only check and does not require permission
+myVfs.accessSync('/no-r.txt', 0);
+
+// mode passed as null also exits early (existence-only)
+myVfs.accessSync('/no-r.txt', null);

test/parallel/test-vfs-callbacks.js test/parallel/test-vfs-callback-api.jstest/parallel/test-vfs-callbacks.js renamed to test/parallel/test-vfs-callback-api.js

@@ -0,0 +1,64 @@
+'use strict';
+
+// Constructor variants and option validation for vfs.create() and
+// `new VirtualFileSystem(...)`.
+
+require('../common');
+const assert = require('assert');
+const vfs = require('node:vfs');
+
+// vfs.create() with no arguments uses the default MemoryProvider
+{
+  const myVfs = vfs.create();
+  assert.ok(myVfs.provider instanceof vfs.MemoryProvider);
+}
+
+// vfs.create with first arg as options object (no provider)
+{
+  const myVfs = vfs.create({ emitExperimentalWarning: false });
+  assert.ok(myVfs);
+  assert.ok(myVfs.provider instanceof vfs.MemoryProvider);
+}
+
+// vfs.create with explicit provider
+{
+  const provider = new vfs.MemoryProvider();
+  const myVfs = vfs.create(provider);
+  assert.strictEqual(myVfs.provider, provider);
+}
+
+// new VirtualFileSystem(options) directly
+{
+  const myVfs = new vfs.VirtualFileSystem({ emitExperimentalWarning: false });
+  assert.ok(myVfs);
+}
+
+// emitExperimentalWarning option must be a boolean
+{
+  assert.throws(
+    () => new vfs.VirtualFileSystem({ emitExperimentalWarning: 'not-bool' }),
+    { code: 'ERR_INVALID_ARG_TYPE' });
+}
+
+// existsSync swallows ALL errors from the provider, not just ENOENT
+{
+  class ThrowingProvider extends vfs.VirtualProvider {
+    existsSync() { throw new Error('boom'); }
+  }
+  const myVfs = vfs.create(new ThrowingProvider());
+  assert.strictEqual(myVfs.existsSync('/anything'), false);
+}
+
+// Walking a path through a regular-file parent throws ENOTDIR
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/file.txt', 'x');
+  assert.throws(() => myVfs.writeFileSync('/file.txt/oops', 'y'),
+                { code: 'ENOTDIR' });
+}
+
+// statSync('/') returns the root directory
+{
+  const myVfs = vfs.create();
+  assert.ok(myVfs.statSync('/').isDirectory());
+}

test/parallel/test-vfs-create.js

@@ -71,3 +71,37 @@ myVfs.opendir('/d', common.mustCall((err, dir) => {
   assert.strictEqual(dir.path, '/d');
   dir.closeSync();
 }));
+
+// read() callback on a closed dir delivers ERR_DIR_CLOSED
+{
+  const dir = myVfs.opendirSync('/d');
+  dir.closeSync();
+  dir.read(common.mustCall((err) => {
+    assert.strictEqual(err.code, 'ERR_DIR_CLOSED');
+  }));
+  // entries() iteration on a closed dir rejects with ERR_DIR_CLOSED
+  (async () => {
+    await assert.rejects(
+      (async () => { for await (const _ of dir.entries()) {} })(), // eslint-disable-line no-unused-vars
+      { code: 'ERR_DIR_CLOSED' });
+  })().then(common.mustCall());
+  // [Symbol.dispose] is a no-op on an already-closed dir (must not throw)
+  dir[Symbol.dispose]();
+}
+
+// async dir.close() returns a promise when invoked without a callback
+(async () => {
+  const dir = myVfs.opendirSync('/d');
+  await dir.close();
+})().then(common.mustCall());
+
+// opendirSync without options object
+{
+  const dir = myVfs.opendirSync('/d');
+  dir.closeSync();
+}
+
+// opendir error path (missing directory)
+myVfs.opendir('/missing-dir', common.mustCall((err) => {
+  assert.ok(err);
+}));

test/parallel/test-vfs-dir-handle.js

@@ -121,3 +121,84 @@ myVfs.writeFileSync('/file.txt', 'hello world');
                 { code: 'EBADF' });
   await assert.rejects(handle.stat(), { code: 'EBADF' });
 })().then(common.mustCall());
+
+// readv with a partial read at EOF (second buffer larger than remaining)
+(async () => {
+  const handle = await myVfs.provider.open('/file.txt', 'r');
+  const b1 = Buffer.alloc(5);
+  const b2 = Buffer.alloc(20);
+  const r = await handle.readv([b1, b2], 0);
+  assert.strictEqual(b1.toString(), 'hello');
+  assert.strictEqual(r.bytesRead, 11);
+  await handle.close();
+})().then(common.mustCall());
+
+// writev with explicit position 0
+(async () => {
+  const wh = await myVfs.provider.open('/wv.txt', 'w+');
+  await wh.writev([Buffer.from('AB'), Buffer.from('CD')], 0);
+  await wh.close();
+  assert.strictEqual(myVfs.readFileSync('/wv.txt', 'utf8'), 'ABCD');
+})().then(common.mustCall());
+
+// appendFile with string + encoding option
+(async () => {
+  const ah = await myVfs.provider.open('/ap.txt', 'a+');
+  await ah.appendFile('hello', { encoding: 'utf8' });
+  await ah.close();
+  assert.strictEqual(myVfs.readFileSync('/ap.txt', 'utf8'), 'hello');
+})().then(common.mustCall());
+
+// 'w'-mode handle rejects all read ops with EBADF
+(async () => {
+  const handle = await myVfs.provider.open('/wonly.txt', 'w');
+  assert.throws(() => handle.readSync(Buffer.alloc(1), 0, 1, 0),
+                { code: 'EBADF' });
+  await assert.rejects(handle.read(Buffer.alloc(1), 0, 1, 0),
+                       { code: 'EBADF' });
+  assert.throws(() => handle.readFileSync(), { code: 'EBADF' });
+  await assert.rejects(handle.readFile(), { code: 'EBADF' });
+  await handle.close();
+})().then(common.mustCall());
+
+// 'r'-mode handle rejects all write ops with EBADF
+(async () => {
+  myVfs.writeFileSync('/ronly.txt', 'x');
+  const handle = await myVfs.provider.open('/ronly.txt', 'r');
+  assert.throws(() => handle.writeSync(Buffer.from('y'), 0, 1, 0),
+                { code: 'EBADF' });
+  await assert.rejects(handle.write(Buffer.from('y'), 0, 1, 0),
+                       { code: 'EBADF' });
+  assert.throws(() => handle.writeFileSync('y'), { code: 'EBADF' });
+  await assert.rejects(handle.writeFile('y'), { code: 'EBADF' });
+  assert.throws(() => handle.truncateSync(0), { code: 'EBADF' });
+  await assert.rejects(handle.truncate(0), { code: 'EBADF' });
+  await handle.close();
+})().then(common.mustCall());
+
+// writeFile with string + encoding
+(async () => {
+  const handle = await myVfs.provider.open('/se.txt', 'w+');
+  await handle.writeFile('héllo', { encoding: 'utf8' });
+  assert.strictEqual(await handle.readFile('utf8'), 'héllo');
+  await handle.close();
+})().then(common.mustCall());
+
+// truncate extending past current size zero-fills
+(async () => {
+  const handle = await myVfs.provider.open('/grow.txt', 'w+');
+  await handle.writeFile('abc');
+  await handle.truncate(10);
+  assert.strictEqual((await handle.stat()).size, 10);
+  assert.strictEqual((await handle.readFile()).length, 10);
+  await handle.close();
+})().then(common.mustCall());
+
+// readv / writev / appendFile on a closed handle reject with EBADF
+(async () => {
+  const handle = await myVfs.provider.open('/file.txt', 'r');
+  await handle.close();
+  await assert.rejects(handle.readv([Buffer.alloc(1)], 0), { code: 'EBADF' });
+  await assert.rejects(handle.writev([Buffer.alloc(1)], 0), { code: 'EBADF' });
+  await assert.rejects(handle.appendFile('x'), { code: 'EBADF' });
+})().then(common.mustCall());

test/parallel/test-vfs-file-handle-branches.js

@@ -0,0 +1,23 @@
+'use strict';
+
+// Hard-link error cases: creating a link to a directory or to an
+// already-existing path.
+
+require('../common');
+const assert = require('assert');
+const vfs = require('node:vfs');
+
+// Linking to a directory throws EINVAL
+{
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/d');
+  assert.throws(() => myVfs.linkSync('/d', '/d-link'), { code: 'EINVAL' });
+}
+
+// Linking to an existing target throws EEXIST
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/a.txt', 'x');
+  myVfs.writeFileSync('/b.txt', 'y');
+  assert.throws(() => myVfs.linkSync('/a.txt', '/b.txt'), { code: 'EEXIST' });
+}