From 45e7b64fda6f97b01a886e8d6dbcbdce611f3a16 Mon Sep 17 00:00:00 2001
From: kai zhu <kaizhu256@gmail.com>
Date: Sun, 10 Jan 2021 22:57:02 -0600
Subject: [PATCH] fs: add option `parents` to     - fs.open[Sync],     -
 fs.writeFile[Sync],     - fs.appendFile[Sync]

this feature is intended to improve ergonomics/simplify-scripting when:
- creating build-artifacts/coverage-files during ci
- scaffolding new web-projects
- cloning website with web-crawler

allowing user to lazily create ad-hoc directory-structures as need
during file-creation with ergonomic syntax:
```
fs.writeFileSync(
    "foo/bar/baz/qux.txt",
    "hello world!",
    { parents: true } // will lazily create parent foo/bar/baz/ as needed
);
```

fs: add new signature-form fs.open(path[, options], callback)
fs: add new signature-form fs.openSync(path[, options])

Fixes: https://github.com/nodejs/node/issues/33559
---
 doc/api/fs.md                                 |  64 +++++
 lib/fs.js                                     |  95 ++++++-
 test/parallel/test-fs-open-options.js         | 251 ++++++++++++++++++
 .../test-fs-write-file-with-parents.js        | 199 ++++++++++++++
 4 files changed, 596 insertions(+), 13 deletions(-)
 create mode 100644 test/parallel/test-fs-open-options.js
 create mode 100644 test/parallel/test-fs-write-file-with-parents.js

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 8f896437d7438dd..a775d22255fdcce 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -1354,6 +1354,9 @@ try {
 <!-- YAML
 added: v0.6.7
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
   - version: v10.0.0
     pr-url: https://github.com/nodejs/node/pull/12562
     description: The `callback` parameter is no longer optional. Not passing
@@ -1376,6 +1379,8 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
 * `callback` {Function}
   * `err` {Error}
 
@@ -1415,6 +1420,9 @@ fs.open('message.txt', 'a', (err, fd) => {
 <!-- YAML
 added: v0.6.7
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
   - version: v7.0.0
     pr-url: https://github.com/nodejs/node/pull/7831
     description: The passed `options` object will never be modified.
@@ -1429,6 +1437,8 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'a'`.
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
 
 Synchronously append data to a file, creating the file if it does not yet
 exist. `data` can be a string or a [`Buffer`][].
@@ -2828,6 +2838,28 @@ a colon, Node.js will open a file system stream, as described by
 Functions based on `fs.open()` exhibit this behavior as well:
 `fs.writeFile()`, `fs.readFile()`, etc.
 
+## `fs.open(path[, options], callback)`
+<!-- YAML
+added: REPLACEME
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object|string}
+  * `flags` {string|number} See [support of file system `flags`][].
+    **Default:** `'r'`.
+  * `mode` {string|integer} **Default:** `0o666` (readable and writable)
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
+  * `callback` {Function}
+    * `err` {Error}
+    * `fd` {integer}
+
+Asynchronous file open using `options` signature-form.
+
 ## `fs.opendir(path[, options], callback)`
 <!-- YAML
 added: v12.12.0
@@ -2911,6 +2943,28 @@ Returns an integer representing the file descriptor.
 For detailed information, see the documentation of the asynchronous version of
 this API: [`fs.open()`][].
 
+## `fs.openSync(path[, options])`
+<!-- YAML
+added: REPLACEME
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
+-->
+
+* `path` {string|Buffer|URL}
+* `options` {Object|string}
+  * `flags` {string|number} See [support of file system `flags`][].
+    **Default:** `'r'`.
+  * `mode` {string|integer} **Default:** `0o666` (readable and writable)
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
+  * `callback` {Function}
+    * `err` {Error}
+    * `fd` {integer}
+
+Synchronous file open using `options` signature-form.
+
 ## `fs.read(fd, buffer, offset, length, position, callback)`
 <!-- YAML
 added: v0.0.2
@@ -4415,6 +4469,9 @@ details.
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
   - version: v15.2.0
     pr-url: https://github.com/nodejs/node/pull/35993
     description: The options argument may include an AbortSignal to abort an
@@ -4453,6 +4510,8 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
   * `signal` {AbortSignal} allows aborting an in-progress writeFile
 * `callback` {Function}
   * `err` {Error}
@@ -4537,6 +4596,9 @@ to contain only `', World'`.
 <!-- YAML
 added: v0.1.29
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/35775
+    description: add option `parents`.
   - version: v14.12.0
     pr-url: https://github.com/nodejs/node/pull/34993
     description: The `data` parameter will stringify an object with an
@@ -4563,6 +4625,8 @@ changes:
   * `encoding` {string|null} **Default:** `'utf8'`
   * `mode` {integer} **Default:** `0o666`
   * `flag` {string} See [support of file system `flags`][]. **Default:** `'w'`.
+  * `parents` {boolean} create parent-directories if they do not exist.
+    **Default:** `false`.
 
 Returns `undefined`.
 
diff --git a/lib/fs.js b/lib/fs.js
index a4b38f10899d486..d68f8820c63c6be 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -62,6 +62,7 @@ const {
   R_OK,
   W_OK,
   X_OK,
+  O_CREAT,
   O_WRONLY,
   O_SYMLINK
 } = constants;
@@ -453,42 +454,110 @@ function closeSync(fd) {
   handleErrorFromBinding(ctx);
 }
 
+// This function has two different signatures:
+// fs.open(path[, flags[, mode]], callback)
+// fs.open(path[, options], callback)
 function open(path, flags, mode, callback) {
+  let options;
   path = getValidatedPath(path);
   if (arguments.length < 3) {
     callback = flags;
-    flags = 'r';
-    mode = 0o666;
   } else if (typeof mode === 'function') {
     callback = mode;
-    mode = 0o666;
-  } else {
-    mode = parseFileMode(mode, 'mode', 0o666);
+    // Handle case where 2nd argument is options-bag
+    if (flags && typeof flags === 'object') {
+      options = flags;
+    }
   }
-  const flagsNumber = stringToFlags(flags);
+  options = getOptions(options || {
+    flags,
+    mode
+  }, {
+    flags: 'r',
+    mode: 0o666,
+    parents: false
+  });
+  flags = stringToFlags(options.flags);
+  mode = parseFileMode(options.mode, 'mode', 0o666);
+  const parents = options.parents;
   callback = makeCallback(callback);
 
   const req = new FSReqCallback();
-  req.oncomplete = callback;
+  req.oncomplete = (err, fd) => {
+    // Lazily create parent-subdirectories if they do not exist
+    if (err?.code === 'ENOENT' && parents && (flags & O_CREAT)) {
+      mkdir(pathModule.dirname(path), { recursive: true }, (err) => {
+        // Ignore EEXIST race-condition from multiple, async mkdir()
+        if (err && err.code !== 'EEXIST') {
+          callback(err);
+          return;
+        }
+        // Retry open() after lazily creating parent-subdirectories
+        open(path, {
+          flags,
+          mode
+        }, callback);
+      });
+      return;
+    }
+    callback(err, fd);
+  };
 
   binding.open(pathModule.toNamespacedPath(path),
-               flagsNumber,
+               flags,
                mode,
                req);
 }
 
 
+// This function has two different signatures:
+// fs.openSync(path[, flags[, mode]])
+// fs.openSync(path[, options])
 function openSync(path, flags, mode) {
+  let options;
   path = getValidatedPath(path);
-  const flagsNumber = stringToFlags(flags);
-  mode = parseFileMode(mode, 'mode', 0o666);
+  // Handle case where 2nd argument is options-bag
+  if (flags && typeof flags === 'object') {
+    options = flags;
+  }
+  options = getOptions(options || {
+    flags,
+    mode
+  }, {
+    flags: 'r',
+    mode: 0o666,
+    parents: false
+  });
+  flags = stringToFlags(options.flags);
+  mode = parseFileMode(options.mode, 'mode', 0o666);
+  const parents = options.parents;
 
   const ctx = { path };
   const result = binding.open(pathModule.toNamespacedPath(path),
-                              flagsNumber, mode,
+                              flags, mode,
                               undefined, ctx);
-  handleErrorFromBinding(ctx);
-  return result;
+  try {
+    handleErrorFromBinding(ctx);
+    return result;
+  } catch (err) {
+    // Lazily create parent-subdirectories if they do not exist
+    if (err?.code === 'ENOENT' && parents && (flags & O_CREAT)) {
+      try {
+        mkdirSync(pathModule.dirname(path), { recursive: true });
+      } catch (err2) {
+        // Ignore EEXIST race-condition from multiple, async mkdir()
+        if (err2.code !== 'EEXIST') {
+          throw err2;
+        }
+      }
+      // Retry openSync() after lazily creating parent-subdirectories
+      return openSync(path, {
+        flags,
+        mode
+      });
+    }
+    throw err;
+  }
 }
 
 // usage:
diff --git a/test/parallel/test-fs-open-options.js b/test/parallel/test-fs-open-options.js
new file mode 100644
index 000000000000000..13cf476e91303f1
--- /dev/null
+++ b/test/parallel/test-fs-open-options.js
@@ -0,0 +1,251 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+'use strict';
+
+
+// Copied from /test/parallel/test-fs-open.js using options-signature
+(function() {
+  const common = require('../common');
+  const assert = require('assert');
+  const fs = require('fs');
+
+  let caughtException = false;
+
+  try {
+    // Should throw ENOENT, not EBADF
+    // see https://github.com/joyent/node/pull/1228
+    fs.openSync('/8hvftyuncxrt/path/to/file/that/does/not/exist', {
+      flags: 'r'
+    });
+  } catch (e) {
+    assert.strictEqual(e.code, 'ENOENT');
+    caughtException = true;
+  }
+  assert.strictEqual(caughtException, true);
+
+  fs.openSync(__filename);
+
+  fs.open(__filename, common.mustSucceed());
+
+  fs.open(__filename, { flags: 'r' }, common.mustSucceed());
+
+  fs.open(__filename, { flags: 'rs' }, common.mustSucceed());
+
+  fs.open(__filename, { flags: 'r', mode: 0 }, common.mustSucceed());
+
+  fs.open(__filename, { flags: 'r', mode: null }, common.mustSucceed());
+
+  async function promise() {
+    await fs.promises.open(__filename);
+    await fs.promises.open(__filename, 'r');
+  }
+
+  promise().then(common.mustCall()).catch(common.mustNotCall());
+
+  assert.throws(
+    () => fs.open(__filename, {
+      flags: 'r',
+      mode: 'boom'
+    }, common.mustNotCall()),
+    {
+      code: 'ERR_INVALID_ARG_VALUE',
+      name: 'TypeError'
+    }
+  );
+
+  for (const extra of [[], ['r'], ['r', 0], ['r', 0, 'bad callback']]) {
+    assert.throws(
+      () => fs.open(__filename, ...extra),
+      {
+        code: 'ERR_INVALID_CALLBACK',
+        name: 'TypeError'
+      }
+    );
+  }
+
+  [false, 1, [], {}, null, undefined].forEach((i) => {
+    assert.throws(
+      () => fs.open(i, { flags: 'r' }, common.mustNotCall()),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+    assert.throws(
+      () => fs.openSync(i, { flags: 'r' }, common.mustNotCall()),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+    assert.rejects(
+      fs.promises.open(i, { flags: 'r' }),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError'
+      }
+    );
+  });
+
+  // Check invalid modes.
+  [false, [], {}].forEach((mode) => {
+    assert.throws(
+      () => fs.open(__filename, { flags: 'r', mode }, common.mustNotCall()),
+      {
+        message: /'mode' must be a 32-bit/,
+        code: 'ERR_INVALID_ARG_VALUE'
+      }
+    );
+    assert.throws(
+      () => fs.openSync(__filename, { flags: 'r', mode }, common.mustNotCall()),
+      {
+        message: /'mode' must be a 32-bit/,
+        code: 'ERR_INVALID_ARG_VALUE'
+      }
+    );
+    assert.rejects(
+      fs.promises.open(__filename, { flags: 'r', mode }),
+      {
+        message: /'mode' must be a 32-bit/,
+        code: 'ERR_INVALID_ARG_VALUE'
+      }
+    );
+  });
+}());
+
+
+// Copied from /test/parallel/test-fs-open-flags.js using options-signature
+(function() {
+  // Flags: --expose-internals
+  const common = require('../common');
+
+  const fixtures = require('../common/fixtures');
+
+  // const assert = require('assert');
+  const fs = require('fs');
+  const path = require('path');
+
+  if (common.isLinux || common.isOSX) {
+    const tmpdir = require('../common/tmpdir');
+    tmpdir.refresh();
+    const file = path.join(tmpdir.path, 'a.js');
+    fs.copyFileSync(fixtures.path('a.js'), file);
+    fs.open(file, { flags: fs.constants.O_DSYNC }, common.mustSucceed((fd) => {
+      fs.closeSync(fd);
+    }));
+  }
+}());
+
+
+// Copied from /test/parallel/test-fs-open-mode-mask.js using options-signature
+(function() {
+  // This tests that the lower bits of mode > 0o777 still works in fs.open().
+
+  const common = require('../common');
+  const assert = require('assert');
+  const path = require('path');
+  const fs = require('fs');
+
+  const mode = common.isWindows ? 0o444 : 0o644;
+
+  const maskToIgnore = 0o10000;
+
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+
+  function test(mode, asString) {
+    const suffix = asString ? 'str' : 'num';
+    const input = asString ?
+      (mode | maskToIgnore).toString(8) : (mode | maskToIgnore);
+
+    {
+      const file = path.join(tmpdir.path, `openSync-${suffix}.txt`);
+      const fd = fs.openSync(file, { flags: 'w+', mask: input });
+      assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+      fs.closeSync(fd);
+      assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+    }
+
+    {
+      const file = path.join(tmpdir.path, `open-${suffix}.txt`);
+      fs.open(file, { flags: 'w+', mask: input }, common.mustSucceed((fd) => {
+        assert.strictEqual(fs.fstatSync(fd).mode & 0o777, mode);
+        fs.closeSync(fd);
+        assert.strictEqual(fs.statSync(file).mode & 0o777, mode);
+      }));
+    }
+  }
+
+  test(mode, true);
+  test(mode, false);
+}());
+
+
+// Copied from /test/parallel/test-fs-open-no-close.js using options-signature
+(function() {
+  // Refs: https://github.com/nodejs/node/issues/34266
+  // Failing to close a file should not keep the event loop open.
+
+  const common = require('../common');
+  const assert = require('assert');
+
+  const fs = require('fs');
+
+  const debuglog = (arg) => {
+    console.log(new Date().toLocaleString(), arg);
+  };
+
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+
+  {
+    fs.open(`${tmpdir.path}/dummy`, {
+      flags: 'wx+'
+    }, common.mustCall((err, fd) => {
+      debuglog('fs open() callback');
+      assert.ifError(err);
+    }));
+    debuglog('waiting for callback');
+  }
+}());
+
+
+// Copied from /test/parallel/test-fs-open-numeric-flags.js
+// using options-signature
+(function() {
+  require('../common');
+
+  const assert = require('assert');
+  const fs = require('fs');
+  const path = require('path');
+
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+
+  // O_WRONLY without O_CREAT shall fail with ENOENT
+  const pathNE = path.join(tmpdir.path, 'file-should-not-exist');
+  assert.throws(
+    () => fs.openSync(pathNE, { flags: fs.constants.O_WRONLY }),
+    (e) => e.code === 'ENOENT'
+  );
+}());
diff --git a/test/parallel/test-fs-write-file-with-parents.js b/test/parallel/test-fs-write-file-with-parents.js
new file mode 100644
index 000000000000000..c731694e0db99cb
--- /dev/null
+++ b/test/parallel/test-fs-write-file-with-parents.js
@@ -0,0 +1,199 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+{
+  // Test appendFile, appendFileSync, writeFile, writeFileSync
+  // with lazy-mkdirp.
+  [
+    'appendFile',
+    'writeFile'
+  ].forEach((functionName) => {
+    const functionNameSync = functionName + 'Sync';
+    // Test async lazy-mkdirp multiple times to ensure EEXIST is ignored.
+    [
+      path.join(tmpdir.path, functionName + '/mkdirp/test1.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test2.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test3.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test4.txt')
+    ].forEach((pathname) => {
+      fs[functionName](
+        pathname,
+        'hello world!',
+        { parents: true },
+        common.mustSucceed(() => {
+          fs.readFile(pathname, 'utf8', common.mustSucceed((data) => {
+            // Validate data.
+            assert.strictEqual(data, 'hello world!');
+          }));
+        })
+      );
+    });
+    // Test sync lazy-mkdirp multiple times to ensure EEXIST is ignored.
+    [
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test1.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test2.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test3.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test4.txt')
+    ].forEach((pathname) => {
+      fs[functionNameSync](
+        pathname,
+        'hello world!',
+        { parents: true }
+      );
+      fs.readFile(pathname, 'utf8', common.mustSucceed((data) => {
+        // Validate data.
+        assert.strictEqual(data, 'hello world!');
+      }));
+    });
+  });
+}
+
+{
+  // Test appendFile, appendFileSync, writeFile, writeFileSync
+  // will disables option mkdirp for flags missing O_CREAT.
+  [
+    'appendFile',
+    'writeFile'
+  ].forEach((functionName) => {
+    const functionNameSync = functionName + 'Sync';
+    [
+      'r',   // O_RDONLY
+      'rs',  // Fall through.
+      'sr',  // O_RDONLY | O_SYNC
+      'r+',  // O_RDWR
+      'rs+', // Fall through.
+      'sr+'  // O_RDWR | O_SYNC
+    ].forEach((flag) => {
+      // Test fs.writeFile(..., { flag: 'r', parents: 'true' }, callback)
+      // fails with 'ENOENT'.
+      fs[functionName](
+        path.join(tmpdir.path, 'enoent/enoent/test.txt'),
+        'hello world!',
+        { flag, parents: true },
+        common.mustCall((err) => {
+          // Validate error 'ENOENT'.
+          assert.strictEqual(err.code, 'ENOENT');
+        })
+      );
+      // Test fs.writeFileSync(..., { flag: 'r', parents: 'true' })
+      // fails with 'ENOENT'.
+      try {
+        fs[functionNameSync](
+          path.join(tmpdir.path, 'enoent/enoent/test.txt'),
+          'hello world!',
+          { flag, parents: true }
+        );
+        throw new Error('fs.' + functionNameSync + ' should have failed.');
+      } catch (errCaught) {
+        // Validate error 'ENOENT'.
+        assert.strictEqual(errCaught.code, 'ENOENT');
+      }
+    });
+  });
+}
+
+{
+  // Test open, openSync
+  // with lazy-mkdirp.
+  [
+    'open'
+  ].forEach((functionName) => {
+    const functionNameSync = functionName + 'Sync';
+    // Test async lazy-mkdirp multiple times to ensure EEXIST is ignored.
+    [
+      path.join(tmpdir.path, functionName + '/mkdirp/test1.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test2.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test3.txt'),
+      path.join(tmpdir.path, functionName + '/mkdirp/test4.txt')
+    ].forEach((pathname) => {
+      fs[functionName](pathname, {
+        flags: 'w',
+        parents: true
+      }, common.mustSucceed((fd) => {
+        // cleanup fd
+        fs.close(fd, common.mustSucceed(() => {}));
+      }));
+    });
+    // Test sync lazy-mkdirp multiple times to ensure EEXIST is ignored.
+    [
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test1.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test2.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test3.txt'),
+      path.join(tmpdir.path, functionNameSync + '/mkdirp/test4.txt')
+    ].forEach((pathname) => {
+      const fd = fs[functionNameSync](pathname, {
+        flags: 'w',
+        parents: true
+      });
+      // cleanup fd
+      fs.close(fd, common.mustSucceed(() => {}));
+    });
+  });
+}
+
+{
+  // Test open, openSync
+  // will disable option mkdirp for flags missing O_CREAT.
+  [
+    'open'
+  ].forEach((functionName) => {
+    const functionNameSync = functionName + 'Sync';
+    [
+      'r',   // O_RDONLY
+      'rs',  // Fall through.
+      'sr',  // O_RDONLY | O_SYNC
+      'r+',  // O_RDWR
+      'rs+', // Fall through.
+      'sr+'  // O_RDWR | O_SYNC
+    ].forEach((flags) => {
+      // Test fs.open(..., { flags: 'r', parents: 'true' }, callback)
+      // fails with 'ENOENT'.
+      fs[functionName](
+        path.join(tmpdir.path, 'enoent/enoent/test.txt'),
+        { flags, parents: 'true' },
+        common.mustCall((err) => {
+          // Validate error 'ENOENT'.
+          assert.strictEqual(err.code, 'ENOENT');
+        })
+      );
+      // Test fs.openSync(..., { flags: 'r', parents: 'true' })
+      // fails with 'ENOENT'.
+      try {
+        fs[functionNameSync](
+          path.join(tmpdir.path, 'enoent/enoent/test.txt'),
+          { flags, parents: 'true' },
+        );
+        throw new Error('fs.' + functionNameSync + ' should have failed.');
+      } catch (errCaught) {
+        // Validate error 'ENOENT'.
+        assert.strictEqual(errCaught.code, 'ENOENT');
+      }
+    });
+  });
+}