squash: improve tests

test/parallel/test-fs-read-offset-null.js

@@ -47,10 +47,7 @@ let filehandle = null;
   );
 })()
 .then(common.mustCall())
-.finally(async () => {
-  if (filehandle)
-    await filehandle.close();
-});
+.finally(() => filehandle?.close());
 
 (async () => {
   filehandle = await fsPromises.open(filepath, 'r');
@@ -61,7 +58,4 @@ let filehandle = null;
   assert.strictEqual(readObject.buffer[0], 120);
 })()
 .then(common.mustCall())
-.finally(async () => {
-  if (filehandle)
-    await filehandle.close();
-});
+.finally(() => filehandle?.close());

test/parallel/test-fs-read-optional-params.js

@@ -5,49 +5,36 @@ const fixtures = require('../common/fixtures');
 const fs = require('fs');
 const assert = require('assert');
 const filepath = fixtures.path('x.txt');
-const fd = fs.openSync(filepath, 'r');
 
 const expected = Buffer.from('xyz\n');
 const defaultBufferAsync = Buffer.alloc(16384);
 const bufferAsOption = Buffer.allocUnsafe(expected.byteLength);
 
-// Test not passing in any options object
-fs.read(fd, common.mustCall((err, bytesRead, buffer) => {
-  assert.strictEqual(bytesRead, expected.byteLength);
-  assert.deepStrictEqual(defaultBufferAsync.byteLength, buffer.byteLength);
-}));
-fs.read(fd, bufferAsOption, { position: 0 }, common.mustCall((err, bytesRead, buffer) => {
-  assert.strictEqual(bytesRead, expected.byteLength);
-  assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength);
-}));
+function testValid(message, ...options) {
+  const paramsMsg = `${message} (as params)`;
+  const paramsFilehandle = fs.openSync(filepath, 'r');
+  fs.read(paramsFilehandle, ...options, common.mustCall((err, bytesRead, buffer) => {
+    if (err) throw err;
+    assert.strictEqual(bytesRead, expected.byteLength, paramsMsg);
+    assert.deepStrictEqual(defaultBufferAsync.byteLength, buffer.byteLength, paramsMsg);
+    fs.closeSync(paramsFilehandle);
+  }));
 
-// Test passing in an empty options object
-fs.read(fd, { position: 0 }, common.mustCall((err, bytesRead, buffer) => {
-  assert.strictEqual(bytesRead, expected.byteLength);
-  assert.deepStrictEqual(defaultBufferAsync.byteLength, buffer.byteLength);
-}));
-fs.read(fd, bufferAsOption, { position: 0 }, common.mustCall((err, bytesRead, buffer) => {
-  assert.strictEqual(bytesRead, expected.byteLength);
-  assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength);
-}));
+  const optionsMsg = `${message} (as options)`;
+  const optionsFilehandle = fs.openSync(filepath, 'r');
+  fs.read(optionsFilehandle, bufferAsOption, ...options, common.mustCall((err, bytesRead, buffer) => {
+    if (err) throw err;
+    assert.strictEqual(bytesRead, expected.byteLength, optionsMsg);
+    assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength, optionsMsg);
+    fs.closeSync(optionsFilehandle);
+  }));
+}
 
-// Test passing in options
-fs.read(fd, {
-  buffer: bufferAsOption,
+testValid('Not passing in any object');
+testValid('Passing in a null', null);
+testValid('Passing in an empty object', {});
+testValid('Passing in an object', {
   offset: 0,
   length: bufferAsOption.byteLength,
   position: 0
-},
-        common.mustCall((err, bytesRead, buffer) => {
-          assert.strictEqual(bytesRead, expected.byteLength);
-          assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength);
-        }));
-fs.read(fd, bufferAsOption, {
-  offset: 0,
-  length: bufferAsOption.byteLength,
-  position: 0
-},
-        common.mustCall((err, bytesRead, buffer) => {
-          assert.strictEqual(bytesRead, expected.byteLength);
-          assert.deepStrictEqual(bufferAsOption.byteLength, buffer.byteLength);
-        }));
+});