diff --git a/doc/api/path.md b/doc/api/path.md
index a5c5af6d068704..049d31a4708049 100644
--- a/doc/api/path.md
+++ b/doc/api/path.md
@@ -431,6 +431,39 @@ added: v0.11.15
 The `path.posix` property provides access to POSIX specific implementations
 of the `path` methods.
 
+*Note*: Be careful when using the following functions directly on Windows.
+
+### path.posix.resolve([...path])
+If after processing all given `path` segments an absolute path has not yet
+been generated, `path.posix.resolve` will throw [`UNSUPPORTED_PLATFORM`] error.
+
+### path.posix.relative(from, to)
+If `from` and `to` are both relative path, `path.posix.relative` will use the
+path `/fakepath/` as the current working path to generate the result.
+
+For example
+
+```
+path.posix.relative('a/b/c', '../../x');
+
+// 'from' will be '/fakepath/a/b/c'
+// 'to' will be '/fakepath/../../x', then will be normalized to '/x'
+// Returns: '../../../../x'
+```
+
+If one of `from` and `to` is relative path, `path.posix.relative` will use the
+other absolute path as the current working path to generate the result.
+
+For example
+
+```
+path.posix.relative('/a/b/c', '../../x');
+
+// 'from' will be '/a/b/c'
+// 'to' will be '/a/b/c/../../x', then will be normalized to '/a/x'
+// Returns: '../../x'
+```
+
 ## path.relative(from, to)
 <!-- YAML
 added: v0.5.0
@@ -551,6 +584,39 @@ added: v0.11.15
 The `path.win32` property provides access to Windows-specific implementations
 of the `path` methods.
 
+*Note*: Be careful when using the following functions directly on POSIX.
+
+### path.win32.resolve([...path])
+If after processing all given `path` segments an absolute path has not yet
+been generated, `path.win32.resolve` will throw [`UNSUPPORTED_PLATFORM`] error.
+
+### path.win32.relative(from, to)
+If `from` and `to` are both relative path, `path.win32.relative` will use the
+path `c:\\fakepath\\` as the current working path to generate the result.
+
+For example
+
+```
+path.win32.relative('a\\b\\c', '..\\..\\x');
+
+// 'from' will be 'c:\\fakepath\\a\\b\\c'
+// 'to' will be 'c:\\fakepath\\..\\..\\x', then will be normalized to 'c:\\x'
+// Returns: '..\\..\\..\\..\\x'
+```
+
+If one of `from` and `to` is relative path, `path.win32.relative` will use the
+other absolute path as the current working path to generate the result.
+
+For example
+
+```
+path.win32.relative('c:\\a\\b\\c', '..\\..\\x');
+
+// 'from' will be 'c:\\a\\b\\c'
+// 'to' will be 'c:\\a\\b\\c\\..\\..\\x', then will be normalized to 'c:\\a\\x'
+// Returns: '..\\..\\x'
+```
+
 [`TypeError`]: errors.html#errors_class_typeerror
 [`path.parse()`]: #path_path_parse_path
 [`path.posix`]: #path_path_posix
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index dd30097c43cd15..48898a0c10db5a 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -179,6 +179,7 @@ E('ERR_UNKNOWN_BUILTIN_MODULE', (id) => `No such built-in module: ${id}`);
 E('ERR_UNKNOWN_SIGNAL', (signal) => `Unknown signal: ${signal}`);
 E('ERR_UNKNOWN_STDIN_TYPE', 'Unknown stdin file type');
 E('ERR_UNKNOWN_STREAM_TYPE', 'Unknown stream file type');
+E('ERR_UNSUPPORTED_PLATFORM', 'Unsupported platform');
 E('ERR_SOCKET_ALREADY_BOUND', 'Socket is already bound');
 E('ERR_SOCKET_BAD_TYPE',
   'Bad socket type specified. Valid types are: udp4, udp6');
diff --git a/lib/path.js b/lib/path.js
index f8d0e822bf1d9b..0d6db42e40bab9 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -29,6 +29,18 @@ function assertPath(path) {
   }
 }
 
+function assertWindowsPlatform(platform) {
+  // throw an error if direct use the function on *nix platform
+  if (platform !== 'win32')
+    throw new errors.Error('ERR_UNSUPPORTED_PLATFORM');
+}
+
+function assertPosixPlatform(platform) {
+  // throw an error if direct use the function on windows platform
+  if (platform === 'win32')
+    throw new errors.Error('ERR_UNSUPPORTED_PLATFORM');
+}
+
 // Resolves . and .. elements in a path with directory names
 function normalizeStringWin32(path, allowAboveRoot) {
   var res = '';
@@ -187,6 +199,10 @@ const win32 = {
         path = arguments[i];
       } else if (!resolvedDevice) {
         path = process.cwd();
+
+        // If you use the current working directory,
+        // it is necessary to check whether the current platform support.
+        assertWindowsPlatform(process.platform);
       } else {
         // Windows has the concept of drive-specific current working
         // directories. If we've resolved a drive letter but not yet an
@@ -201,6 +217,10 @@ const win32 = {
             path.slice(0, 3).toLowerCase() !==
               resolvedDevice.toLowerCase() + '\\') {
           path = resolvedDevice + '\\';
+        } else {
+          // If you use the current working directory,
+          // it is necessary to check whether the current platform support.
+          assertWindowsPlatform(process.platform);
         }
       }
 
@@ -562,8 +582,38 @@ const win32 = {
     if (from === to)
       return '';
 
-    var fromOrig = win32.resolve(from);
-    var toOrig = win32.resolve(to);
+    var fromOrig;
+    var toOrig;
+    var isFromAbsolute = true;
+    var isToAbsolute = true;
+
+    try {
+      fromOrig = win32.resolve(from);
+    } catch (err) {
+      if (err.code === 'ERR_UNSUPPORTED_PLATFORM')
+        isFromAbsolute = false;
+    }
+    try {
+      toOrig = win32.resolve(to);
+    } catch (err) {
+      if (err.code === 'ERR_UNSUPPORTED_PLATFORM')
+        isToAbsolute = false;
+    }
+
+    if (process.platform !== 'win32') {
+      if (!isFromAbsolute && !isToAbsolute) {
+        from = 'c:\\fakepath\\' + from;
+        to = 'c:\\fakepath\\' + to;
+        fromOrig = win32.resolve(from);
+        toOrig = win32.resolve(to);
+      } else if (isFromAbsolute && !isToAbsolute) {
+        to = from + '\\' + to;
+        toOrig = win32.resolve(to);
+      } else if (!isFromAbsolute && isToAbsolute) {
+        from = to + '\\' + from;
+        fromOrig = win32.resolve(from);
+      }
+    }
 
     if (fromOrig === toOrig)
       return '';
@@ -1174,6 +1224,11 @@ const posix = {
       resolvedAbsolute = path.charCodeAt(0) === 47/*/*/;
     }
 
+    // If you use the current working directory,
+    // it is necessary to check whether the current platform support.
+    if (cwd)
+      assertPosixPlatform(process.platform);
+
     // At this point the path should be resolved to a full absolute path, but
     // handle relative paths to be safe (might happen when process.cwd() fails)
 
@@ -1249,8 +1304,35 @@ const posix = {
     if (from === to)
       return '';
 
-    from = posix.resolve(from);
-    to = posix.resolve(to);
+    var isFromAbsolute = true;
+    var isToAbsolute = true;
+    try {
+      from = posix.resolve(from);
+    } catch (err) {
+      if (err.code === 'ERR_UNSUPPORTED_PLATFORM')
+        isFromAbsolute = false;
+    }
+    try {
+      to = posix.resolve(to);
+    } catch (err) {
+      if (err.code === 'ERR_UNSUPPORTED_PLATFORM')
+        isToAbsolute = false;
+    }
+
+    if (process.platform === 'win32') {
+      if (!isFromAbsolute && !isToAbsolute) {
+        from = '/fakepath/' + from;
+        to = '/fakepath/' + to;
+        from = posix.resolve(from);
+        to = posix.resolve(to);
+      } else if (isFromAbsolute && !isToAbsolute) {
+        to = from + '/' + to;
+        to = posix.resolve(to);
+      } else if (!isFromAbsolute && isToAbsolute) {
+        from = to + '/' + from;
+        from = posix.resolve(from);
+      }
+    }
 
     if (from === to)
       return '';
diff --git a/test/parallel/test-path.js b/test/parallel/test-path.js
index 4ee3740038b321..cd16e015abca9a 100644
--- a/test/parallel/test-path.js
+++ b/test/parallel/test-path.js
@@ -418,54 +418,82 @@ assert.strictEqual(path.posix.normalize('///..//./foo/.//bar'), '/foo/bar');
 
 
 // path.resolve tests
-const resolveTests = [
-  [ path.win32.resolve,
-    // arguments                               result
-    [[['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
-     [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
-     [['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
-     [['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
-     [['.'], process.cwd()],
-     [['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],
-     [['c:/', '//'], 'c:\\'],
-     [['c:/', '//dir'], 'c:\\dir'],
-     [['c:/', '//server/share'], '\\\\server\\share\\'],
-     [['c:/', '//server//share'], '\\\\server\\share\\'],
-     [['c:/', '///some//dir'], 'c:\\some\\dir'],
-     [['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
-      'C:\\foo\\tmp.3\\cycles\\root.js']
+const resolveTest = {
+  win32: [
+    [ path.win32.resolve,
+      // arguments                               result
+      [[['c:/blah\\blah', 'd:/games', 'c:../a'], 'c:\\blah\\a'],
+       [['c:/ignore', 'd:\\a/b\\c/d', '\\e.exe'], 'd:\\e.exe'],
+       [['c:/ignore', 'c:/some/file'], 'c:\\some\\file'],
+       [['d:/ignore', 'd:some/dir//'], 'd:\\ignore\\some\\dir'],
+       [['.'], process.cwd()],
+       [['//server/share', '..', 'relative\\'], '\\\\server\\share\\relative'],
+       [['c:/', '//'], 'c:\\'],
+       [['c:/', '//dir'], 'c:\\dir'],
+       [['c:/', '//server/share'], '\\\\server\\share\\'],
+       [['c:/', '//server//share'], '\\\\server\\share\\'],
+       [['c:/', '///some//dir'], 'c:\\some\\dir'],
+       [['C:\\foo\\tmp.3\\', '..\\tmp.3\\cycles\\root.js'],
+        'C:\\foo\\tmp.3\\cycles\\root.js']
+      ]
     ]
   ],
-  [ path.posix.resolve,
-    // arguments                    result
-    [[['/var/lib', '../', 'file/'], '/var/file'],
-     [['/var/lib', '/../', 'file/'], '/file'],
-     [['a/b/c/', '../../..'], process.cwd()],
-     [['.'], process.cwd()],
-     [['/some/dir', '.', '/absolute/'], '/absolute'],
-     [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
+  posix: [
+    [ path.posix.resolve,
+      // arguments                    result
+      [[['/var/lib', '../', 'file/'], '/var/file'],
+       [['/var/lib', '/../', 'file/'], '/file'],
+       [['a/b/c/', '../../..'], process.cwd()],
+       [['.'], process.cwd()],
+       [['/some/dir', '.', '/absolute/'], '/absolute'],
+       [['/foo/tmp.3/', '../tmp.3/cycles/root.js'], '/foo/tmp.3/cycles/root.js']
+      ]
     ]
   ]
-];
-resolveTests.forEach((test) => {
-  const resolve = test[0];
-  test[1].forEach((test) => {
-    const actual = resolve.apply(null, test[0]);
-    let actualAlt;
-    const os = resolve === path.win32.resolve ? 'win32' : 'posix';
-    if (resolve === path.win32.resolve && !common.isWindows)
-      actualAlt = actual.replace(backslashRE, '/');
-    else if (resolve !== path.win32.resolve && common.isWindows)
-      actualAlt = actual.replace(slashRE, '\\');
+};
+
+{
+  let tests;
+
+  if (common.isWindows) {
+    tests = resolveTest.win32;
+
+    // direct use path.posix.resolve with relative path param
+    // on windows will throw error
+    assert.throws(() => {
+      path.posix.resolve('foo/bar');
+    }, common.expectsError({code: 'ERR_UNSUPPORTED_PLATFORM', type: Error}));
+  } else {
+    tests = resolveTest.posix;
+
+    // direct use path.win32.resolve with relative path param
+    // on *nix will throw error
+    assert.throws(() => {
+      path.win32.resolve('foo\\bar');
+    }, common.expectsError({code: 'ERR_UNSUPPORTED_PLATFORM', type: Error}));
+  }
+
+  tests.forEach((test) => {
+    const resolve = test[0];
+    test[1].forEach((test) => {
+      const actual = resolve.apply(null, test[0]);
+      let actualAlt;
+      const os = resolve === path.win32.resolve ? 'win32' : 'posix';
+      if (resolve === path.win32.resolve && !common.isWindows)
+        actualAlt = actual.replace(backslashRE, '/');
+      else if (resolve !== path.win32.resolve && common.isWindows)
+        actualAlt = actual.replace(slashRE, '\\');
 
-    const expected = test[1];
-    const message =
-      `path.${os}.resolve(${test[0].map(JSON.stringify).join(',')})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
-    if (actual !== expected && actualAlt !== expected)
-      failures.push(`\n${message}`);
+      const expected = test[1];
+      const message =
+        `path.${os}.resolve(${test[0].map(JSON.stringify).join(',')})
+          \n  expect=${JSON.stringify(expected)}
+          \n  actual=${JSON.stringify(actual)}`;
+      if (actual !== expected && actualAlt !== expected)
+        failures.push(`\n${message}`);
+    });
   });
-});
+}
 assert.strictEqual(failures.length, 0, failures.join(''));
 
 if (common.isWindows) {
@@ -507,65 +535,100 @@ assert.strictEqual(path.posix.isAbsolute('./baz'), false);
 
 
 // path.relative tests
-const relativeTests = [
-  [ path.win32.relative,
-    // arguments                     result
-    [['c:/blah\\blah', 'd:/games', 'd:\\games'],
-     ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
-     ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
-     ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
-     ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
-     ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
-     ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
-     ['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
-     ['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
-     ['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
-     ['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
-     ['C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json', 'bar\\package.json'],
-     ['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
-     ['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
-     ['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
-     ['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
-     ['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
-     ['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
-     ['C:\\baz-quux', 'C:\\baz', '..\\baz'],
-     ['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
-     ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
-     ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
-     ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
-     ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
+const relativeTest = {
+  win32: [
+    [ path.win32.relative,
+      // arguments                     result
+      [['c:/blah\\blah', 'd:/games', 'd:\\games'],
+       ['c:/aaaa/bbbb', 'c:/aaaa', '..'],
+       ['c:/aaaa/bbbb', 'c:/cccc', '..\\..\\cccc'],
+       ['c:/aaaa/bbbb', 'c:/aaaa/bbbb', ''],
+       ['c:/aaaa/bbbb', 'c:/aaaa/cccc', '..\\cccc'],
+       ['c:/aaaa/', 'c:/aaaa/cccc', 'cccc'],
+       ['c:/', 'c:\\aaaa\\bbbb', 'aaaa\\bbbb'],
+       ['c:/aaaa/bbbb', 'd:\\', 'd:\\'],
+       ['c:/AaAa/bbbb', 'c:/aaaa/bbbb', ''],
+       ['c:/aaaaa/', 'c:/aaaa/cccc', '..\\aaaa\\cccc'],
+       ['C:\\foo\\bar\\baz\\quux', 'C:\\', '..\\..\\..\\..'],
+       [
+         'C:\\foo\\test', 'C:\\foo\\test\\bar\\package.json',
+         'bar\\package.json'
+       ],
+       ['C:\\foo\\bar\\baz-quux', 'C:\\foo\\bar\\baz', '..\\baz'],
+       ['C:\\foo\\bar\\baz', 'C:\\foo\\bar\\baz-quux', '..\\baz-quux'],
+       ['\\\\foo\\bar', '\\\\foo\\bar\\baz', 'baz'],
+       ['\\\\foo\\bar\\baz', '\\\\foo\\bar', '..'],
+       ['\\\\foo\\bar\\baz-quux', '\\\\foo\\bar\\baz', '..\\baz'],
+       ['\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz-quux', '..\\baz-quux'],
+       ['C:\\baz-quux', 'C:\\baz', '..\\baz'],
+       ['C:\\baz', 'C:\\baz-quux', '..\\baz-quux'],
+       ['\\\\foo\\baz-quux', '\\\\foo\\baz', '..\\baz'],
+       ['\\\\foo\\baz', '\\\\foo\\baz-quux', '..\\baz-quux'],
+       ['C:\\baz', '\\\\foo\\bar\\baz', '\\\\foo\\bar\\baz'],
+       ['\\\\foo\\bar\\baz', 'C:\\baz', 'C:\\baz']
+      ]
+    ],
+    [ path.posix.relative,
+      // arguments          result
+      [['a/b/c', '../../x', '../../../../x'],
+       ['../../x', 'a/b/c', '../fakepath/a/b/c'],
+       ['/a/b/c', '../../x', '../../x'],
+       ['../../x', '/a/b/c', '../b/c'],
+       ['/a/b/c', '/d/e/f', '../../../d/e/f']
+      ]
     ]
   ],
-  [ path.posix.relative,
-    // arguments          result
-    [['/var/lib', '/var', '..'],
-     ['/var/lib', '/bin', '../../bin'],
-     ['/var/lib', '/var/lib', ''],
-     ['/var/lib', '/var/apache', '../apache'],
-     ['/var/', '/var/lib', 'lib'],
-     ['/', '/var/lib', 'var/lib'],
-     ['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
-     ['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
-     ['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
-     ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
-     ['/baz-quux', '/baz', '../baz'],
-     ['/baz', '/baz-quux', '../baz-quux']
+  posix: [
+    [ path.posix.relative,
+      // arguments          result
+      [['/var/lib', '/var', '..'],
+       ['/var/lib', '/bin', '../../bin'],
+       ['/var/lib', '/var/lib', ''],
+       ['/var/lib', '/var/apache', '../apache'],
+       ['/var/', '/var/lib', 'lib'],
+       ['/', '/var/lib', 'var/lib'],
+       ['/foo/test', '/foo/test/bar/package.json', 'bar/package.json'],
+       ['/Users/a/web/b/test/mails', '/Users/a/web/b', '../..'],
+       ['/foo/bar/baz-quux', '/foo/bar/baz', '../baz'],
+       ['/foo/bar/baz', '/foo/bar/baz-quux', '../baz-quux'],
+       ['/baz-quux', '/baz', '../baz'],
+       ['/baz', '/baz-quux', '../baz-quux']
+      ]
+    ],
+    [ path.win32.relative,
+      // arguments              result
+      [['a\\b\\c', '..\\..\\x', '..\\..\\..\\..\\x'],
+       ['..\\..\\x', 'a\\b\\c', '..\\fakepath\\a\\b\\c'],
+       ['c:\\a\\b\\c', '..\\..\\x', '..\\..\\x'],
+       ['..\\..\\x', 'c:\\a\\b\\c', '..\\b\\c'],
+       ['c:\\a\\b\\c', 'c:\\d\\e\\f', '..\\..\\..\\d\\e\\f']
+      ]
     ]
   ]
-];
-relativeTests.forEach((test) => {
-  const relative = test[0];
-  test[1].forEach((test) => {
-    const actual = relative(test[0], test[1]);
-    const expected = test[2];
-    const os = relative === path.win32.relative ? 'win32' : 'posix';
-    const message = `path.${os}.relative(${
-      test.slice(0, 2).map(JSON.stringify).join(',')})\n  expect=${
-      JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
-    if (actual !== expected)
-      failures.push(`\n${message}`);
+};
+{
+  let tests;
+
+  if (common.isWindows) {
+    tests = relativeTest.win32;
+  } else {
+    tests = relativeTest.posix;
+  }
+
+  tests.forEach((test) => {
+    const relative = test[0];
+    test[1].forEach((test) => {
+      const actual = relative(test[0], test[1]);
+      const expected = test[2];
+      const os = relative === path.win32.relative ? 'win32' : 'posix';
+      const message = `path.${os}.relative(${
+        test.slice(0, 2).map(JSON.stringify).join(',')})\n  expect=${
+        JSON.stringify(expected)}\n  actual=${JSON.stringify(actual)}`;
+      if (actual !== expected)
+        failures.push(`\n${message}`);
+    });
   });
-});
+}
 assert.strictEqual(failures.length, 0, failures.join(''));