diff --git a/doc/api/fs.md b/doc/api/fs.md
index f3828f15e70baa..47609351e33cf5 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -599,6 +599,50 @@ Returns an object containing commonly used constants for file system
 operations. The specific constants currently defined are described in
 [FS Constants][].
 
+## fs.copy(path1, path2[, overwrite_mode], callback)
+
+* `path1` {string}
+* `path2` {string}
+* `overwrite_mode` {string|Boolean|function}
+* `callback` {function}
+
+Asynchronous copying of file or recursively copying directory's, including
+ownership, permissions and times. If `path1` is a file, it will be copied
+to `path2`, if `path1` is a directory it will be recursively copied
+retaining it's file structure with the root of the `path1` directory
+being the root of the `path2` directory.
+
+`overwrite_mode` defaults to 2.
+
+If `overwrite_mode` is a function, any time a file in `path2` already
+exists it will be called with the arguments (`file1`,`file2`,`callback`)
+where `file1` and `file2` are full paths of the files being copied,
+`file1` being the source and `file2` being the destination that already
+exists. The callback will take 1 argument, which is the mode to be used
+for this file only. This can be used for prompting the user whether or
+not they want to overwrite specific files etc.
+
+If `overwrite_mode` (this also can be the value passed via the
+callback of `overwrite_mode`) is a number greater than 1 or true,
+any files that already exist within `path2` will be overwritten, if
+`overwrite_mode` is 1 or false, existing file will not be
+overwritten however if it is acting recursively, it will continue
+copying. If `overwrite_mode` is a number less than 1 it will throw
+an error if a file already exists.
+
+No arguments other than a possible exception are given to the completion
+callback.
+
+## fs.copySync(path1, path2[, overwrite_mode])
+
+* `path1` {string}
+* `path2` {string}
+* `overwrite_mode` {string|Boolean|function}
+
+Synchronous version of [`fs.copy()`][]. However if `overwrite_mode` is
+a function, it should return the mode rather then pass it to a callback.
+`overwrite_mode` will not be called with a callback.
+
 ## fs.createReadStream(path[, options])
 <!-- YAML
 added: v0.1.31
@@ -724,6 +768,28 @@ Like [`ReadStream`][], if `fd` is specified, `WriteStream` will ignore the
 
 If `options` is a string, then it specifies the encoding.
 
+## fs.delete(path, callback)
+
+* `path` {string|Buffer}
+* `callback` {function}
+
+If `path` is a file, it is the equivalent of [`fs.unlink()`][], however if `path`
+is a directory, it will recursively delete it, it does this be recursively
+calling [`fs.delete()`][] on all the directory contents and after all of them
+have completed call [`fs.rmdir()`][] on the directory.
+
+You should use [`fs.unlink()`][] any time you know you are going to be deleting
+a file.
+
+No arguments other than a possible exception are given to the completion
+callback.
+
+## fs.deleteSync(path)
+
+* `path` {string|Buffer}
+
+Synchronous version of [`fs.delete()`][].
+
 ## fs.exists(path, callback)
 <!-- YAML
 added: v0.0.2
diff --git a/lib/fs.js b/lib/fs.js
index 83c0d8085de3d0..01d72649d75d90 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2171,3 +2171,856 @@ Object.defineProperty(fs, 'SyncWriteStream', {
     SyncWriteStream = val;
   }, 'fs.SyncWriteStream is deprecated.', 'DEP0061')
 });
+
+//Recursivly copy directorys or copy a sungle file.
+//path1,path2,overwrite=2,callback
+fs.copy = function(...args) {
+
+  //Parse arguments
+  if (typeof args[0] !== 'string' || typeof args[1] !== 'string') {
+
+    throw new Error('First 2 arguments must be strings.');
+
+  }
+  const file1 = args[0];
+  const file2 = args[1];
+
+  let callback, overwrite;
+  if (typeof args[3] === 'function') {
+
+    overwrite = args[2];
+    callback = args[3];
+
+  } else if (typeof args[3] !== 'undefined' && (typeof args[2] === 'number' ||
+   typeof args[2] === 'boolean' || typeof args[2] === 'function')) {
+
+    overwrite = args[2];
+    callback = () => {};
+
+  } else if (typeof args[2] === 'function') {
+
+    overwrite = 2;
+    callback = args[2];
+
+  } else if (typeof args[2] === 'number' || typeof args[2] === 'boolean') {
+
+    overwrite = args[2];
+    callback = () => {};
+
+  } else {
+
+    overwrite = 2;
+    callback = () => {};
+
+  }
+
+  //Set resolve and reject funftions, easy to port to promise and easy to catch
+  //errors and close fd's etc.
+  const resolve = () => callback(null);
+  function reject(err, ...fds) {
+
+    //Rejct will close any fd's passed to it to eliminate leaks before calling
+    // the callback with the error.
+    let doing = -1;
+    function next() {
+
+      doing++;
+      if (doing >= fds.length) {
+
+        callback(err);
+
+      } else {
+
+        fs.close(fds[doing], next);
+
+      }
+
+    }
+    next();
+
+  }
+
+  fs.open(file1, 'r', (err, fd1) => {
+
+    if (err) {
+
+      reject(err, fd1);
+
+    } else {
+
+      fs.fstat(fd1, (err, stats1) => {
+
+        if (err) {
+
+          reject(err, fd1);
+
+          //Different behavior for files or directorys.
+        } else if (stats1.isDirectory()) {
+
+          //We no longer need the fd1, so close it as soon as possible.
+          fs.close(fd1, (err) => {
+
+            if (err) {
+
+              reject(err);
+
+            } else {
+
+              //Modes are different depending on platform, r+ needed on windows
+              // for modifiying propities.
+              fs.open(file2, process.platform === 'win32' ? 'r+' : 'r',
+                      (err, fd2) => {
+
+                        const go = (check = true) => {
+
+                          fs.fstat(fd2, (err, stats2) => {
+
+                            if (err) {
+
+                              reject(err, fd2);
+                              return;
+
+                            } else if (check) {
+
+                              if (stats2.isFile()) {
+
+                                fs.realpath(file2, (err, p) => {
+
+                                  if (err) {
+
+                                    reject(err, fd2);
+
+                                  } else {
+
+                                    //Try to keep it the same as other errors.
+                                    //I know this is bad :(
+                                    reject({
+
+                                      code: 'ENOTDIR',
+                                      errno: -4052,
+                                      path: p
+
+                                    }, fd2);
+
+                                  }
+
+                                });
+                                return;
+
+                              }
+
+                            }
+
+                            //Set the propeties to that of the origional file.
+
+                            if (err) {
+
+                              reject(err, fd2);
+
+                            } else {
+
+                              const nextstep1 = (err, dir) => {
+
+                                if (err) {
+
+                                  reject(err);
+
+                                } else {
+
+                                  let doing = -1;
+                                  const next = () => {
+
+                                    doing++;
+
+                                    if (doing >= dir.length) {
+
+                                      if (process.platform !== 'aix') {
+
+                                        fs.futimes(fd2,
+                                                   stats1.atime,
+                                                   stats1.mtime,
+                                                   nextstep2);
+
+                                      } else {
+
+                                        nextstep2();
+
+                                      }
+
+                                    } else {
+
+                                      const j = pathModule.join;
+                                      fs.copy(j(file1, dir[doing]),
+                                              j(file2, dir[doing]),
+                                              overwrite,
+                                              (err) => {
+
+                                                if (err) {
+
+                                                  reject(err, fd2);
+
+                                                } else {
+
+                                                  next();
+
+                                                }
+
+                                              });
+
+                                    }
+
+                                  };
+                                  next();
+
+                                }
+
+                              };
+                              const nextstep2 = (err) => {
+
+                                if (err) {
+
+                                  reject(err, fd2);
+
+                                } else {
+
+                                  fs.close(fd2,
+                                           (err) => {
+
+                                             if (err) {
+
+                                               reject(err);
+
+                                             } else {
+
+                                               resolve();
+
+                                             }
+
+                                           });
+
+                                }
+
+                              };
+                              fs.fchmod(fd2, stats1.mode,
+                                        (err) => {
+
+                                          if (err) {
+
+                                            reject(err, fd2);
+
+                                          } else {
+
+                                            fs.fchown(fd2,
+                                                      stats1.uid,
+                                                      stats1.gid,
+                                                      (err) => {
+
+                                                        if (err) {
+
+                                                          reject(err, fd2);
+
+                                                        } else {
+
+                                                          fs.readdir(file1,
+                                                                     nextstep1
+                                                          );
+
+                                                        }
+
+                                                      });
+
+                                          }
+
+                                        });
+
+
+                            }
+
+                          });
+
+                        };
+
+                        if (err) {
+
+                          //If the target doesn't exist, we need to create one.
+                          if (err.code === 'ENOENT') {
+
+                            fs.mkdir(file2, (err) => {
+
+                              if (err) {
+
+                                reject(err);
+
+                              } else {
+
+                                fs.open(file2,
+                                        process.platform === 'win32' ?
+                                        'r+' : 'r',
+                                        (err, fd) => {
+
+                                          if (err) {
+
+                                            reject(err);
+
+                                          } else {
+
+                                            fd2 = fd;
+                                            go();
+
+                                          }
+
+                                        });
+
+                              }
+
+                            });
+
+                          } else {
+
+                            reject(err);
+
+                          }
+
+                        } else {
+
+                          go();
+
+                        }
+
+                      });
+
+            }
+
+          });
+
+        } else {
+
+          //wx mode so we can fail if it already exists.
+          fs.open(file2, 'wx', (err, fd2) => {
+
+            const go = () => {
+
+              const write = fs.createWriteStream(file2, {
+
+                fd: fd2,
+                autoClose: false
+
+              });
+
+              const read = fs.createReadStream(file1, {
+
+                fd: fd1,
+                autoClose: false
+
+              });
+
+              write.on('error', (err) => reject(err, fd1, fd2));
+              read.on('error', (err) => reject(err, fd1, fd2));
+
+              read.on('end', () => {
+
+                fs.close(fd1, (err) => {
+
+                  if (err) {
+
+                    reject(err, fd2);
+
+                  } else {
+
+                    const nextstep = (err) => {
+
+                      if (err) {
+
+                        reject(err, fd2);
+
+                      } else {
+
+                        fs.fchmod(fd2, stats1.mode, (err) => {
+
+                          if (err) {
+
+                            reject(err, fd2);
+
+                          } else {
+
+                            fs.fchown(fd2, stats1.uid, stats1.gid, (err) => {
+
+                              if (err) {
+
+                                reject(err, fd2);
+
+                              } else {
+
+                                fs.close(fd2, (err) => {
+
+                                  if (err) {
+
+                                    reject(err);
+
+                                  } else {
+
+                                    resolve();
+
+                                  }
+
+                                });
+
+                              }
+
+                            });
+
+                          }
+
+                        });
+
+                      }
+
+                    };
+
+                    if (process.platform !== 'aix') {
+
+                      fs.futimes(fd2, stats1.atime, stats1.mtime, nextstep);
+
+                    } else {
+
+                      nextstep();
+
+                    }
+
+                  }
+
+                });
+
+              });
+
+              read.pipe(write);
+
+            };
+
+            if (err) {
+
+              //If the file already exists, we need to check the overwrite mode.
+              if (err.code === 'EEXIST') {
+
+                const getFDAndGo = () => {
+
+                  //We are overwriting now, wo w mode is fine.
+                  fs.open(file2, 'w', (err, fd) => {
+
+                    if (err) {
+
+                      reject(err, fd1);
+
+                    } else {
+
+                      fd2 = fd;
+                      go();
+
+                    }
+
+                  });
+
+                };
+
+                const closeFDAndGo = () => {
+
+                  //Close fd1 and continue.
+                  fs.close(fd1, (err) => {
+
+                    if (err) {
+
+                      reject(err);
+
+                    } else {
+
+                      resolve();
+
+                    }
+
+                  });
+
+                };
+
+                if (overwrite > 1 || overwrite === true) {
+
+                  getFDAndGo();
+
+                } else if (overwrite === 1 || overwrite === false) {
+
+                  closeFDAndGo();
+
+                } else if (typeof overwrite === 'function') {
+
+                  overwrite(file1, file2, (mode) => {
+
+                    if (mode > 1 || mode === true) {
+
+                      getFDAndGo();
+
+                    } else if (mode === 1 || mode === false) {
+
+                      closeFDAndGo();
+
+                    } else {
+
+                      reject(err, fd1);
+
+                    }
+
+                  });
+
+                } else {
+
+                  reject(err, fd1);
+
+                }
+
+              } else {
+
+                reject(err, fd1);
+
+              }
+
+            } else {
+
+              go();
+
+            }
+
+          });
+
+        }
+
+      });
+
+    }
+
+  });
+
+};
+
+//Sync version of fs.copy, copy file from path1 to path2 or recursivly copy
+// directory on path1 to path2.
+//path1,path2,overwrite=2
+fs.copySync = function(file1, file2, overwrite = 2) {
+
+  //Check arguments.
+  if (typeof file1 !== 'string' || typeof file2 !== 'string') {
+
+    throw new Error('First 2 arguments must be strings.');
+
+  } if (typeof overwrite !== 'number' && typeof overwrite !== 'boolean' &&
+        typeof overwrite !== 'function') {
+
+    throw new Error('Overwrite mode must be number, boolean or function.');
+
+  }
+
+  let fd2 = null;
+
+  try {
+
+    const stats1 = fs.statSync(file1);
+
+    //Different behavior for files or directories.
+    if (stats1.isDirectory()) {
+
+      const go = (checkDir = true) => {
+
+        const stats2 = fs.fstatSync(fd2, 'w');
+        if (checkDir) {
+
+          if (stats2.isFile()) {
+
+            throw new Error({
+
+              code: 'ENOTDIR',
+              errno: -4052,
+              path: fs.realpathSync(file2)
+
+            });
+
+          }
+
+        }
+        //Get properties from origional file.
+        fs.fchmodSync(fd2, stats1.mode);
+        fs.fchownSync(fd2, stats1.uid, stats1.gid);
+        if (process.platform === 'aix') {
+
+          fs.closeSync(fd2);
+          fd2 = null;
+
+        }
+
+        //Recursivaly act on the directory.
+        const dir = fs.readdirSync(file1);
+        for (const doing in dir) {
+
+          fs.copySync(pathModule.join(file1, dir[doing]),
+                      pathModule.join(file2, dir[doing]), overwrite);
+
+        }
+
+        if (process.platform !== 'aix') {
+
+          fs.futimesSync(fd2, stats1.atime, stats1.mtime);
+          fs.closeSync(fd2);
+          fd2 = null;
+
+        }
+
+      };
+
+      try {
+
+        //Different modes for different platforms.
+        fd2 = fs.openSync(file2, process.platform === 'win32' ? 'r+' : 'r');
+        go();
+
+      } catch (err) {
+
+        //If it doesn't exist we need to create it.
+        if (err.code === 'ENOENT') {
+
+          fs.mkdirSync(file2);
+          fd2 = fs.openSync(file2, process.platform === 'win32' ? 'r+' : 'r');
+          go(false);
+          return;
+
+        } else {
+
+          throw err;
+
+        }
+
+      }
+
+    } else {
+
+      try {
+
+        //It needs to fail if it already exists.
+        fd2 = fs.openSync(file2, 'wx');
+
+      } catch (err) {
+
+        fd2 = null;
+        //If it already exists, we need to check the overwrite mode.
+        if (err.code === 'EEXIST') {
+
+          if (overwrite > 1 || overwrite === true) {
+
+            fd2 = fs.openSync(file2, 'w');
+
+          } else if (overwrite === 1 || overwrite === false) {
+
+            return;
+
+          } else if (typeof overwrite === 'function') {
+
+            const mode = overwrite(file1, file2);
+
+            if (mode > 1 || mode === true) {
+
+              fd2 = fs.openSync(file2, 'w');
+
+            } else if (mode === 1 || mode === false) {
+
+              return;
+
+            } else {
+
+              throw err;
+
+            }
+
+          } else {
+
+            throw err;
+
+          }
+
+        } else {
+
+          throw err;
+
+        }
+
+      }
+
+      //Copy the file contents.
+      fs.writeSync(fd2, fs.readFileSync(file1));
+
+      //Now properties.
+      fs.fchmodSync(fd2, stats1.mode);
+      fs.fchownSync(fd2, stats1.uid, stats1.gid);
+
+      if (process.platform !== 'aix') {
+
+        fs.futimesSync(fd2, stats1.atime, stats1.mtime);
+
+      }
+
+      fs.closeSync(fd2);
+      return;
+
+    }
+
+  } catch (err) {
+
+    //If it errord and fd2 is open, close it before throwing.
+    if (fd2 !== null) {
+
+      try {
+
+        fs.closeSync(fd2);
+
+      } catch (e) {
+
+        //Warn, not throw if fd fails to close, we need to throw the error that
+        // origionaly occured.
+        console.warn(new Error(`Failed to close fd in error handler: ${e}`));
+
+      }
+
+    }
+    throw err;
+
+  }
+
+};
+
+//Delete file or recursivaly delete directory.
+//(path)
+fs.delete = function(toDel, callback) {
+
+  if (typeof callback !== 'function') {
+
+    callback = () => {};
+
+  }
+
+  //Set up resolve and reject.
+  const resolve = () => callback(null);
+  const reject = (err) => callback(err);
+
+  fs.stat(toDel, (err, stats) => {
+
+    if (err) {
+
+      reject(err);
+
+    } else {
+
+      //Differnt behavior for files or directories.
+      if (stats.isDirectory()) {
+
+        fs.readdir(toDel, (err, dir) => {
+
+          if (err) {
+
+            reject(err);
+
+          } else {
+
+            //Recursivaly go through the directory contents, calling fs.delete
+            // on all of them.
+            let doing = -1;
+            const next = () => {
+
+              doing++;
+              if (doing >= dir.length) {
+
+                //Finally delete the empty directory.
+                fs.rmdir(toDel, (err) => {
+
+                  if (err) {
+
+                    reject(err);
+
+                  } else {
+
+                    resolve();
+
+                  }
+
+                });
+              } else {
+
+                fs.delete(pathModule.join(toDel, dir[doing]), (err) => {
+
+                  if (err) {
+
+                    reject(err);
+
+                  } else {
+
+                    next();
+
+                  }
+
+                });
+
+              }
+
+            };
+
+            next();
+
+          }
+
+        });
+
+      } else {
+
+        //Delete the file and resolve.
+        fs.unlink(toDel, (err) => {
+
+          if (err) {
+
+            reject(err);
+
+          } else {
+
+            resolve();
+
+          }
+
+        });
+
+      }
+
+    }
+
+  });
+
+};
+
+//Sync version of fs.delete
+//(path)
+fs.deleteSync = function(toDel) {
+
+  const stats = fs.statSync(toDel);
+
+  //Different behavior for file or directory.
+  if (stats.isDirectory()) {
+
+    //Recussivly call fs.deleteSync for all directory contents.
+    const dir = fs.readdirSync(toDel);
+    for (var doing = 0; doing < dir.length; doing++) {
+
+      fs.deleteSync(pathModule.join(toDel, dir[doing]));
+
+    }
+    //Finally now delete the empty directory.
+    fs.rmdirSync(toDel);
+
+  } else {
+
+    //Delete the file
+    fs.unlinkSync(toDel);
+
+  }
+
+};
diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
new file mode 100644
index 00000000000000..0dc7ff60bf5464
--- /dev/null
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -0,0 +1,168 @@
+'use strict';
+const common = require('../common');
+//This test tests fs.copy,  fs.copySync,  fs.delete and fs.deleteSync
+const fs = require('fs');
+const assert = require('assert');
+common.refreshTmpDir();
+const testDir = common.tmpDir + '/copyanddeletetest';
+
+if (!fs.existsSync(testDir)) {
+  fs.mkdirSync(testDir);
+}
+
+function setUpDir(path) {
+
+  if (!fs.existsSync(path)) {
+    fs.mkdirSync(path);
+  }
+  fs.mkdirSync(path + '/test1');
+  fs.mkdirSync(path + '/test2');
+  fs.mkdirSync(path + '/test3');
+  fs.writeFileSync(path + '/file1', 'Contents of file\r\n1');
+  fs.writeFileSync(path + '/file2', 'Contents of file 2');
+  fs.writeFileSync(path + '/test1/file3', 'Contents of file\r\n3');
+  fs.writeFileSync(path + '/test3/file4', 'Contents of file 4');
+  fs.writeFileSync(path + '/test3/file5', 'Contents of file 5');
+
+}
+
+setUpDir(testDir + '/test1');
+
+setTimeout(() => {
+
+  fs.copySync(testDir + '/test1', testDir + '/test1-copied');
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test1`), true);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test2`), true);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3`), true);
+  assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/file1`)
+    .toString(), 'Contents of file\r\n1');
+  assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/file2`)
+    .toString(), 'Contents of file 2');
+  assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test1/file3`)
+    .toString(), 'Contents of file\r\n3');
+  assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test3/file4`)
+    .toString(), 'Contents of file 4');
+  assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test3/file5`)
+    .toString(), 'Contents of file 5');
+
+  function checkProps(p1, p2) {
+
+    assert.strictEqual(fs.statSync(p1).mode, fs.statSync(p2).mode);
+    assert.strictEqual(fs.statSync(p1).uid, fs.statSync(p2).uid);
+    assert.strictEqual(fs.statSync(p1).gid, fs.statSync(p2).gid);
+    assert.strictEqual(fs.statSync(p1).size, fs.statSync(p2).size);
+    if (process.platform !== 'aix' &&
+    Math.abs(fs.statSync(p1).mtime.getTime() -
+    fs.statSync(p2).mtime.getTime()) > 1000) {
+
+      assert.fail(Math.abs(fs.statSync(p1).mtime.getTime() -
+                          fs.statSync(p2).mtime.getTime()), 1000,
+                  'mtimes are not correct.',
+                  '<');
+
+    }
+
+  }
+
+  checkProps(`${testDir}/test1/test1`, `${testDir}/test1-copied/test1`);
+  checkProps(`${testDir}/test1/test2`, `${testDir}/test1-copied/test2`);
+  checkProps(`${testDir}/test1/test3`, `${testDir}/test1-copied/test3`);
+  checkProps(`${testDir}/test1/file1`, `${testDir}/test1-copied/file1`);
+  checkProps(`${testDir}/test1/file2`, `${testDir}/test1-copied/file2`);
+  checkProps(`${testDir}/test1/test1/file3`,
+             `${testDir}/test1-copied/test1/file3`);
+  checkProps(`${testDir}/test1/test3/file4`,
+             `${testDir}/test1-copied/test3/file4`);
+  checkProps(`${testDir}/test1/test3/file5`,
+             `${testDir}/test1-copied/test3/file5`);
+
+  fs.deleteSync(testDir + '/test1-copied');
+
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test1`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test2`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/file1`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/file2`), false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test1/file3`),
+                     false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3/file4`),
+                     false);
+  assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3/file5`),
+                     false);
+
+  fs.copy(testDir + '/test1', testDir + '/test1-copied', (err) => {
+
+    if (err) {
+
+      assert.ifError(err);
+
+    } else {
+
+      assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test1`),
+                         true);
+      assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test2`),
+                         true);
+      assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3`),
+                         true);
+      assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/file1`)
+        .toString(), 'Contents of file\r\n1');
+      assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/file2`)
+        .toString(), 'Contents of file 2');
+      assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test1/file3`)
+        .toString(), 'Contents of file\r\n3');
+      assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test3/file4`)
+        .toString(), 'Contents of file 4');
+      assert.strictEqual(fs.readFileSync(`${testDir}/test1-copied/test3/file5`)
+        .toString(), 'Contents of file 5');
+
+      checkProps(`${testDir}/test1/test1`, `${testDir}/test1-copied/test1`);
+      checkProps(`${testDir}/test1/test2`, `${testDir}/test1-copied/test2`);
+      checkProps(`${testDir}/test1/test3`, `${testDir}/test1-copied/test3`);
+      checkProps(`${testDir}/test1/file1`, `${testDir}/test1-copied/file1`);
+      checkProps(`${testDir}/test1/file2`, `${testDir}/test1-copied/file2`);
+      checkProps(`${testDir}/test1/test1/file3`,
+                 `${testDir}/test1-copied/test1/file3`);
+      checkProps(`${testDir}/test1/test3/file4`,
+                 `${testDir}/test1-copied/test3/file4`);
+      checkProps(`${testDir}/test1/test3/file5`,
+                 `${testDir}/test1-copied/test3/file5`);
+
+      fs.delete(testDir + '/test1-copied', (err) => {
+
+        if (err) {
+
+          assert.ifError(err);
+
+        } else {
+
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied`),
+                             false);
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test1`)
+                             , false);
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test2`)
+                             , false);
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied/test3`)
+                             , false);
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied/file1`)
+                             , false);
+          assert.strictEqual(common.fileExists(`${testDir}/test1-copied/file2`)
+                             , false);
+          assert.strictEqual(common
+            .fileExists(`${testDir}/test1-copied/test1/file3`), false);
+          assert.strictEqual(common
+            .fileExists(`${testDir}/test1-copied/test3/file4`), false);
+          assert.strictEqual(common
+            .fileExists(`${testDir}/test1-copied/test3/file5`), false);
+
+          fs.deleteSync(`${testDir}/test1`);
+
+        }
+
+      });
+
+    }
+
+  });
+
+}, 1500);