From 878b5aee0777c47cd886748310dd0d96f140ee6e Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sat, 22 Apr 2017 09:17:04 +0100
Subject: [PATCH 01/14] fs: add fs.copy, fs.copySync, fs.delete and
 fs.deleteSync with docs and tests.

So I and many other often need to recursively copy or delete
directory's with node and copy file that keep their permissions and
properties etc. Many use an external library or write their own and
that takes up a lot of time and adds deps to your project which you
might not want.

I have added fs.copy and fs.copySync to recursively copy directory's or
just copy files, all files/directory's copied with fs.copy and
fs.copySync retain they owners, mode and times.

fs.delete and fs.deleteSync either delete a file (basically an alias
for fs.unlink) or of a directory is passed into the path recursively
remove the content of the directory and remove the directory itself.

There are however a few notes, this is writen in JavaScript only and
thus calls other functions in the fs module, I have placed the code at
the bottom of lib/fs.js however there may be a better place to put the
code.

I also change open the directory's for copying in different modes
dependent on the platform, I use 'process.platform==="win32"?"r+":"r"'
to determine the mode to open the directory in, I have done this
because I found during testing that on Windows, you need to have the
directory open in r+ mode to modify it's properties whereas on Linux it
throws when you attempt to open a directory in r+ mode & you can open
it in r mode and still change the properties. I don't have a Mac OS
computer & thus cannot test it on Mac so this mode could be wrong on
Mac.

I also use read streams and write streams in fs.copy however I use
fs.readFileSync to read the file in fs.copySync, I know that this could
load the entire file into the main memory and thus not be a great way
of doing it however I am not sure how to do this better. So advise on
this would be helpful.

I have also used readable.on('end') to determine when the copying of
the file contents has ended, however I have seen the finish event used
in some other cases, the end event seems to work to I haven't changed
it but again that is something that might need changing.

My tests are relatively simplistic however they do test the copying. I
haven't got a test for the overwrite mode being a function however I
can write that if it is needed.

Hope this is OK,
Jacob
---
 doc/api/fs.md                            |  64 ++
 lib/fs.js                                | 854 +++++++++++++++++++++++
 test/parallel/test-fs-copy-and-delete.js | 118 ++++
 3 files changed, 1036 insertions(+)
 create mode 100644 test/parallel/test-fs-copy-and-delete.js

diff --git a/doc/api/fs.md b/doc/api/fs.md
index f3828f15e70baa..7089c42f68802e 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -599,6 +599,48 @@ 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.
+
+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 +766,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` us 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..0e37a399fb5a87 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2171,3 +2171,857 @@ 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 "First 2 arguments must be strings." ;
+		
+	}
+	let file1 = args[0] ;
+	let 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.
+	let 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)=>{
+								
+								let 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.
+										fs.futimes(fd2,stats1.atime,stats1.mtime,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 {
+																		
+																		//Recursivly go through directory.
+																		fs.readdir(file1,(err,dir)=>{
+																			
+																			if (err) {
+																				
+																				reject(err) ;
+																				
+																			}
+																			
+																			else {
+																				
+																				let doing = -1 ;
+																				let next =_=> {
+																					
+																					doing++ ;
+																					
+																					if (doing >= dir.length) {
+																						
+																						resolve() ;
+																						
+																					}
+																					
+																					else {
+																						
+																						fs.copy(pathModule.join(file1,dir[doing]),pathModule.join(file2,dir[doing]),overwrite).then(next).catch(reject) ;
+																						
+																					}
+																					
+																				} ;
+																				next() ;
+																				
+																			}
+																			
+																		}) ;
+																		
+																	}
+																	
+																}) ;
+																
+															}
+															
+														}) ;
+														
+													}
+													
+												}) ;
+												
+											}
+											
+										}) ;
+										
+									}) ;
+									
+								} ;
+								
+								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)=>{
+						
+						let go =_=> {
+							
+							let write = fs.createWriteStream(file2,{
+								
+								fd:fd2,
+								autoClose:false
+								
+							}) ;
+							
+							let 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 {
+										
+										fs.futimes(fd2,stats1.atime,stats1.mtime,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() ;
+																		
+																	}
+																	
+																}) ;
+																
+															}
+															
+														}) ;
+														
+													}
+													
+												}) ;
+												
+											}
+											
+										}) ;
+										
+									}
+									
+								}) ;
+								
+							}) ;
+							
+							read.pipe(write) ;
+							
+						} ;
+						
+						if (err) {
+							
+							//If the file already exists, we need to check the overwrite mode.
+							if (err.code === "EEXIST") {
+								
+								let 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() ;
+											
+										}
+										
+									}) ;
+									
+								} ;
+								
+								let 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) {
+											
+											fd2 = fd ;
+											go() ;
+											
+										}
+										
+										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,file1,overwrite=2) {
+	
+	//Check arguments.
+	if (typeof file1 !== "string" || typeof file2 !== "string") {
+		
+		throw "First 2 arguments must be strings." ;
+		
+	}
+	if (typeof overwrite !== "number" && typeof overwrite !== "boolean" && typeof overwrite !== "function") {
+		
+		throw "Overwrite mode must be number, boolean or function." ;
+		
+	}
+	
+	let fd2 = null ;
+	
+	try {
+		
+		let stats1 = fs.statSync(file1) ;
+		
+		//Different behavior for files or directories.
+		if (stats1.isDirectory()) {
+			
+			let go = (checkDir=true) => {
+				
+				let stats2 = fs.fstatSync(fd2,"w") ;
+				if (checkDir) {
+					
+					if (stats2.isFile()) {
+						
+						throw {
+							
+							code:"ENOTDIR",
+							errno:-4052,
+							path:p
+							
+						} ;
+						
+					}
+					
+				}
+				//Get properties from origional file.
+				fs.futimesSync(fd2,stats1.atime,stats1.mtime) ;
+				fs.fchmodSync(fd2,stats1.mode) ;
+				fs.fchownSync(fd2,stats1.uid,stats1.gid) ;
+				fs.closeSync(fd2) ;
+				fd2 = null ;
+				
+				//Recursivaly act on the directory.
+				let dir = fs.readdirSync(file1) ;
+				for (let doing in dir) {
+					
+					fs.copySync(pathModule.join(file1,dir[doing]),pathModule.join(file2,dir[doing]),overwrite) ;
+					
+				}
+				
+			} ;
+			
+			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") {
+						
+						let 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.futimesSync(fd2,stats1.atime,stats1.mtime) ;
+			fs.fchmodSync(fd2,stats1.mode) ;
+			fs.fchownSync(fd2,stats1.uid,stats1.gid) ; 
+			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) {
+	
+	//Set up resolve and reject.
+	let resolve =_=> callback(null) ;
+	let 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 ;
+						let 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])).then(next).catch(reject) ;
+								
+							}
+							
+						} ;
+						
+						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) {
+	
+	let stats = fs.statSync(toDel) ;
+	
+	//Different behavior for file or directory.
+	if (stats.isDirectory()) {
+		
+		//Recussivly call fs.deleteSync for all directory contents.
+		let dir = fs.readdirSync(toDel) ;
+		for (let 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) ;
+		
+	}
+	
+} ;
\ No newline at end of file
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..c8007eaeb293ad
--- /dev/null
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -0,0 +1,118 @@
+'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();
+let testDir = common.tmpDir + "/copyanddeletetest" ;
+
+function setUpDir(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") ;
+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) ;
+	assert.strictEqual(fs.statSync(p1).mtime,fs.statSync(p2).mtime) ;
+
+}
+
+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) {
+		
+		throw 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) {
+				
+				throw 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) ;
+				
+			}
+			
+		}) ;
+		
+	}
+	
+}) ;
\ No newline at end of file

From 3a2ef1d35b6f92f26110a3a9ab68f18d95ba4ec5 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sat, 22 Apr 2017 11:39:46 +0100
Subject: [PATCH 02/14] Ammended docs: enclosed overwrite_mode in square
 brackets, corrected spelling from us to is and included the default value for
 overwrite_mode.

---
 doc/api/fs.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/doc/api/fs.md b/doc/api/fs.md
index 7089c42f68802e..47609351e33cf5 100644
--- a/doc/api/fs.md
+++ b/doc/api/fs.md
@@ -599,7 +599,7 @@ 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)
+## fs.copy(path1, path2[, overwrite_mode], callback)
 
 * `path1` {string}
 * `path2` {string}
@@ -612,6 +612,8 @@ 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,
@@ -631,7 +633,7 @@ 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)
+## fs.copySync(path1, path2[, overwrite_mode])
 
 * `path1` {string}
 * `path2` {string}
@@ -771,7 +773,7 @@ If `options` is a string, then it specifies the encoding.
 * `path` {string|Buffer}
 * `callback` {function}
 
-If `path` us a file, it is the equivalent of [`fs.unlink()`][], however if `path`
+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.

From 4482021448a31d36b7fad054410df21627878b0a Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 09:11:41 +0100
Subject: [PATCH 03/14] Replaced tabs with spaces and fixed linting issues.

---
 lib/fs.js                                | 1617 +++++++++++-----------
 test/parallel/test-fs-copy-and-delete.js |  265 ++--
 2 files changed, 920 insertions(+), 962 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index 0e37a399fb5a87..645ac86e8791d2 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2174,854 +2174,783 @@ Object.defineProperty(fs, 'SyncWriteStream', {
 
 //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 "First 2 arguments must be strings." ;
-		
-	}
-	let file1 = args[0] ;
-	let 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.
-	let 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)=>{
-								
-								let 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.
-										fs.futimes(fd2,stats1.atime,stats1.mtime,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 {
-																		
-																		//Recursivly go through directory.
-																		fs.readdir(file1,(err,dir)=>{
-																			
-																			if (err) {
-																				
-																				reject(err) ;
-																				
-																			}
-																			
-																			else {
-																				
-																				let doing = -1 ;
-																				let next =_=> {
-																					
-																					doing++ ;
-																					
-																					if (doing >= dir.length) {
-																						
-																						resolve() ;
-																						
-																					}
-																					
-																					else {
-																						
-																						fs.copy(pathModule.join(file1,dir[doing]),pathModule.join(file2,dir[doing]),overwrite).then(next).catch(reject) ;
-																						
-																					}
-																					
-																				} ;
-																				next() ;
-																				
-																			}
-																			
-																		}) ;
-																		
-																	}
-																	
-																}) ;
-																
-															}
-															
-														}) ;
-														
-													}
-													
-												}) ;
-												
-											}
-											
-										}) ;
-										
-									}) ;
-									
-								} ;
-								
-								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)=>{
-						
-						let go =_=> {
-							
-							let write = fs.createWriteStream(file2,{
-								
-								fd:fd2,
-								autoClose:false
-								
-							}) ;
-							
-							let 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 {
-										
-										fs.futimes(fd2,stats1.atime,stats1.mtime,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() ;
-																		
-																	}
-																	
-																}) ;
-																
-															}
-															
-														}) ;
-														
-													}
-													
-												}) ;
-												
-											}
-											
-										}) ;
-										
-									}
-									
-								}) ;
-								
-							}) ;
-							
-							read.pipe(write) ;
-							
-						} ;
-						
-						if (err) {
-							
-							//If the file already exists, we need to check the overwrite mode.
-							if (err.code === "EEXIST") {
-								
-								let 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() ;
-											
-										}
-										
-									}) ;
-									
-								} ;
-								
-								let 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) {
-											
-											fd2 = fd ;
-											go() ;
-											
-										}
-										
-										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.
+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.
+                            fs.futimes(fd2, stats1.atime, stats1.mtime,
+                                       (err) => {
+
+                                         if (err) {
+
+                                           reject(err, fd2);
+
+                                         } else {
+
+                                           const nextstep = (err) => {
+
+                                             if (err) {
+
+                                               reject(err, fd2);
+
+                                             } else {
+
+                                               fs.fchown(fd2,
+                                                         stats1.uid,
+                                                         stats1.gid,
+                                                         nextstep2);
+
+                                             }
+
+                                           };
+                                           const nextstep2 = (err) => {
+
+                                             if (err) {
+
+                                               reject(err, fd2);
+
+                                             } else {
+
+                                               fs.close(fd2,
+                                                        (err) => {
+
+                                                          if (err) {
+
+                                                            reject(err);
+
+                                                          } else {
+
+                                    //Recursivly go through directory.
+                                                            const r = fs
+                                                                      .readdir;
+                                                            r(file1,
+                                                              nextstep3);
+
+                                                          }
+
+                                                        });
+
+                                             }
+
+                                           };
+                                           const nextstep3 = (err, dir) => {
+
+                                             if (err) {
+
+                                               reject(err);
+
+                                             } else {
+
+                                               let doing = -1;
+                                               const next = () => {
+
+                                                 doing++;
+
+                                                 if (doing >= dir.length) {
+
+                                                   resolve();
+
+                                                 } else {
+
+                                                   const j = pathModule.join;
+                                                   fs.copy(j(file1, dir[doing])
+                                                           , j(file2,
+                                                               dir[doing]),
+                                                           overwrite)
+                                                     .then(next).catch(reject);
+
+                                                 }
+
+                                               };
+                                               next();
+
+                                             }
+
+                                           };
+                                           fs.fchmod(fd2, stats1.mode,
+                                                     nextstep);
+
+
+                                         }
+
+                                       });
+
+                          });
+
+                        };
+
+                        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 {
+
+                    fs.futimes(fd2, stats1.atime, stats1.mtime, (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();
+
+                                  }
+
+                                });
+
+                              }
+
+                            });
+
+                          }
+
+                        });
+
+                      }
+
+                    });
+
+                  }
+
+                });
+
+              });
+
+              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,file1,overwrite=2) {
-	
-	//Check arguments.
-	if (typeof file1 !== "string" || typeof file2 !== "string") {
-		
-		throw "First 2 arguments must be strings." ;
-		
-	}
-	if (typeof overwrite !== "number" && typeof overwrite !== "boolean" && typeof overwrite !== "function") {
-		
-		throw "Overwrite mode must be number, boolean or function." ;
-		
-	}
-	
-	let fd2 = null ;
-	
-	try {
-		
-		let stats1 = fs.statSync(file1) ;
-		
-		//Different behavior for files or directories.
-		if (stats1.isDirectory()) {
-			
-			let go = (checkDir=true) => {
-				
-				let stats2 = fs.fstatSync(fd2,"w") ;
-				if (checkDir) {
-					
-					if (stats2.isFile()) {
-						
-						throw {
-							
-							code:"ENOTDIR",
-							errno:-4052,
-							path:p
-							
-						} ;
-						
-					}
-					
-				}
-				//Get properties from origional file.
-				fs.futimesSync(fd2,stats1.atime,stats1.mtime) ;
-				fs.fchmodSync(fd2,stats1.mode) ;
-				fs.fchownSync(fd2,stats1.uid,stats1.gid) ;
-				fs.closeSync(fd2) ;
-				fd2 = null ;
-				
-				//Recursivaly act on the directory.
-				let dir = fs.readdirSync(file1) ;
-				for (let doing in dir) {
-					
-					fs.copySync(pathModule.join(file1,dir[doing]),pathModule.join(file2,dir[doing]),overwrite) ;
-					
-				}
-				
-			} ;
-			
-			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") {
-						
-						let 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.futimesSync(fd2,stats1.atime,stats1.mtime) ;
-			fs.fchmodSync(fd2,stats1.mode) ;
-			fs.fchownSync(fd2,stats1.uid,stats1.gid) ; 
-			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 ;
-		
-	}
-	
-} ;
+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.futimesSync(fd2, stats1.atime, stats1.mtime);
+        fs.fchmodSync(fd2, stats1.mode);
+        fs.fchownSync(fd2, stats1.uid, stats1.gid);
+        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);
+
+        }
+
+      };
+
+      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.futimesSync(fd2, stats1.atime, stats1.mtime);
+      fs.fchmodSync(fd2, stats1.mode);
+      fs.fchownSync(fd2, stats1.uid, stats1.gid);
+      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) {
-	
-	//Set up resolve and reject.
-	let resolve =_=> callback(null) ;
-	let 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 ;
-						let 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])).then(next).catch(reject) ;
-								
-							}
-							
-						} ;
-						
-						next() ;
-						
-					}
-					
-				}) ;
-				
-			}
-			
-			else {
-				
-				//Delete the file and resolve.
-				fs.unlink(toDel,err=>{
-					
-					if (err) {
-						
-						reject(err) ;
-						
-					}
-					else {
-						
-						resolve() ;
-						
-					}
-					
-				}) ;
-				
-			}
-			
-		}
-		
-	}) ;
-	
-} ;
+fs.delete = function(toDel, 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]))
+                  .then(next)
+                  .catch(reject);
+
+              }
+
+            };
+
+            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) {
-	
-	let stats = fs.statSync(toDel) ;
-	
-	//Different behavior for file or directory.
-	if (stats.isDirectory()) {
-		
-		//Recussivly call fs.deleteSync for all directory contents.
-		let dir = fs.readdirSync(toDel) ;
-		for (let 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) ;
-		
-	}
-	
-} ;
\ No newline at end of file
+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 (let 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
index c8007eaeb293ad..60e0c4e0d6e46d 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -1,118 +1,147 @@
-'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();
-let testDir = common.tmpDir + "/copyanddeletetest" ;
-
-function setUpDir(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") ;
-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) ;
-	assert.strictEqual(fs.statSync(p1).mtime,fs.statSync(p2).mtime) ;
-
-}
-
-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) {
-		
-		throw 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) {
-				
-				throw 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) ;
-				
-			}
-			
-		}) ;
-		
-	}
-	
-}) ;
\ No newline at end of file
+'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';
+
+function setUpDir(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');
+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);
+  assert.strictEqual(fs.statSync(p1).mtime, fs.statSync(p2).mtime);
+
+}
+
+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) {
+
+    throw 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) {
+
+        throw 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);
+
+      }
+
+    });
+
+  }
+
+});

From 39b0e12f8028b48d198732e14aa428459259131f Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 09:30:12 +0100
Subject: [PATCH 04/14] Remove directory after test

---
 test/parallel/test-fs-copy-and-delete.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index 60e0c4e0d6e46d..5348fc058436f2 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -138,6 +138,8 @@ fs.copy(testDir + '/test1', testDir + '/test1-copied', (err) => {
         assert.strictEqual(common
           .fileExists(`${testDir}/test1-copied/test3/file5`), false);
 
+        fs.deleteSync(`${testDir}/test1`);
+
       }
 
     });

From 45296d632d1836c28591ac7cf91472ca8d6c1786 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 10:11:59 +0100
Subject: [PATCH 05/14] Use var instead of let in for loop in fs.js and use
 assert.ifError instead of throw in test-fs-copy-and-delete.js

---
 lib/fs.js                                | 2 +-
 test/parallel/test-fs-copy-and-delete.js | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index 645ac86e8791d2..586290b023e718 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2938,7 +2938,7 @@ fs.deleteSync = function(toDel) {
 
     //Recussivly call fs.deleteSync for all directory contents.
     const dir = fs.readdirSync(toDel);
-    for (let doing = 0; doing < dir.length; doing++) {
+    for (var doing = 0; doing < dir.length; doing++) {
 
       fs.deleteSync(pathModule.join(toDel, dir[doing]));
 
diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index 5348fc058436f2..ffa14d66d5d583 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -79,7 +79,7 @@ fs.copy(testDir + '/test1', testDir + '/test1-copied', (err) => {
 
   if (err) {
 
-    throw err;
+    assert.ifError(err);
 
   } else {
 
@@ -116,7 +116,7 @@ fs.copy(testDir + '/test1', testDir + '/test1-copied', (err) => {
 
       if (err) {
 
-        throw err;
+        assert.ifError(err);
 
       } else {
 

From 050a6ee741da56b60c85d11a7fb1d76725b3e009 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 10:34:13 +0100
Subject: [PATCH 06/14] Make the test dir if it doesn't already exist.

---
 test/parallel/test-fs-copy-and-delete.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index ffa14d66d5d583..ea5be0c51ed4cf 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -8,6 +8,9 @@ const testDir = common.tmpDir + '/copyanddeletetest';
 
 function setUpDir(path) {
 
+  if (!fs.existsSync(path)) {
+    fs.mkdirSync(path);
+  }
   fs.mkdirSync(path + '/test1');
   fs.mkdirSync(path + '/test2');
   fs.mkdirSync(path + '/test3');

From 89627742709fbf5427f317e03e4b7d0e2ff3c13a Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 10:49:01 +0100
Subject: [PATCH 07/14] Create the test directory if it doesn't exist.

---
 test/parallel/test-fs-copy-and-delete.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index ea5be0c51ed4cf..0d6ddabacb0b52 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -5,6 +5,9 @@ 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) {
 

From 5c75683f9f604431ff923bb8e4718478b6a8c13f Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 11:50:53 +0100
Subject: [PATCH 08/14] Modify times after writing in fs.copy and fs.copySync,
 in all async functions use a callback instead of promise when recursivaly
 calling. Modify tests to check times better.

---
 lib/fs.js                                | 151 ++++++++++++++---------
 test/parallel/test-fs-copy-and-delete.js |  18 ++-
 2 files changed, 107 insertions(+), 62 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index 586290b023e718..807238dc29bdf9 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2312,62 +2312,71 @@ fs.copy = function(...args) {
                             }
 
                             //Set the propeties to that of the origional file.
-                            fs.futimes(fd2, stats1.atime, stats1.mtime,
-                                       (err) => {
 
-                                         if (err) {
+                            if (err) {
 
-                                           reject(err, fd2);
+                              reject(err, fd2);
 
-                                         } else {
+                            } else {
 
-                                           const nextstep = (err) => {
+                              const nextstep1 = (err, dir) => {
 
-                                             if (err) {
+                                if (err) {
 
-                                               reject(err, fd2);
+                                  reject(err);
 
-                                             } else {
+                                } else {
 
-                                               fs.fchown(fd2,
-                                                         stats1.uid,
-                                                         stats1.gid,
-                                                         nextstep2);
+                                  let doing = -1;
+                                  const next = () => {
 
-                                             }
+                                    doing++;
 
-                                           };
-                                           const nextstep2 = (err) => {
+                                    if (doing >= dir.length) {
 
-                                             if (err) {
+                                      fs.futimes(fd2,
+                                                 stats1.atime,
+                                                 stats1.mtime,
+                                                 nextstep2);
 
-                                               reject(err, fd2);
+                                    } else {
 
-                                             } else {
+                                      const j = pathModule.join;
+                                      fs.copy(j(file1, dir[doing]),
+                                              j(file2, dir[doing]),
+                                              overwrite,
+                                              (err) => {
 
-                                               fs.close(fd2,
-                                                        (err) => {
+                                                if (err) {
 
-                                                          if (err) {
+                                                  reject(err, fd2);
 
-                                                            reject(err);
+                                                } else {
 
-                                                          } else {
+                                                  next();
 
-                                    //Recursivly go through directory.
-                                                            const r = fs
-                                                                      .readdir;
-                                                            r(file1,
-                                                              nextstep3);
+                                                }
 
-                                                          }
+                                              });
 
-                                                        });
+                                    }
 
-                                             }
+                                  };
+                                  next();
+
+                                }
+
+                              };
+                              const nextstep2 = (err) => {
+
+                                if (err) {
 
-                                           };
-                                           const nextstep3 = (err, dir) => {
+                                  reject(err, fd2);
+
+                                } else {
+
+                                  fs.close(fd2,
+                                           (err) => {
 
                                              if (err) {
 
@@ -2375,39 +2384,49 @@ fs.copy = function(...args) {
 
                                              } else {
 
-                                               let doing = -1;
-                                               const next = () => {
+                                               resolve();
 
-                                                 doing++;
+                                             }
 
-                                                 if (doing >= dir.length) {
+                                           });
 
-                                                   resolve();
+                                }
 
-                                                 } else {
+                              };
+                              fs.fchmod(fd2, stats1.mode,
+                                        (err) => {
 
-                                                   const j = pathModule.join;
-                                                   fs.copy(j(file1, dir[doing])
-                                                           , j(file2,
-                                                               dir[doing]),
-                                                           overwrite)
-                                                     .then(next).catch(reject);
+                                          if (err) {
 
-                                                 }
+                                            reject(err, fd2);
 
-                                               };
-                                               next();
+                                          } else {
 
-                                             }
+                                            fs.fchown(fd2,
+                                                      stats1.uid,
+                                                      stats1.gid,
+                                                      (err) => {
 
-                                           };
-                                           fs.fchmod(fd2, stats1.mode,
-                                                     nextstep);
+                                                        if (err) {
 
+                                                          reject(err, fd2);
 
-                                         }
+                                                        } else {
 
-                                       });
+                                                          fs.readdir(file1,
+                                                                     nextstep1
+                                                          );
+
+                                                        }
+
+                                                      });
+
+                                          }
+
+                                        });
+
+
+                            }
 
                           });
 
@@ -2707,11 +2726,8 @@ fs.copySync = function(file1, file2, overwrite = 2) {
 
         }
         //Get properties from origional file.
-        fs.futimesSync(fd2, stats1.atime, stats1.mtime);
         fs.fchmodSync(fd2, stats1.mode);
         fs.fchownSync(fd2, stats1.uid, stats1.gid);
-        fs.closeSync(fd2);
-        fd2 = null;
 
         //Recursivaly act on the directory.
         const dir = fs.readdirSync(file1);
@@ -2721,6 +2737,9 @@ fs.copySync = function(file1, file2, overwrite = 2) {
                       pathModule.join(file2, dir[doing]), overwrite);
 
         }
+        fs.futimesSync(fd2, stats1.atime, stats1.mtime);
+        fs.closeSync(fd2);
+        fd2 = null;
 
       };
 
@@ -2888,9 +2907,19 @@ fs.delete = function(toDel, callback) {
                 });
               } else {
 
-                fs.delete(pathModule.join(toDel, dir[doing]))
-                  .then(next)
-                  .catch(reject);
+                fs.delete(pathModule.join(toDel, dir[doing]), (err) => {
+
+                  if (err) {
+
+                    reject(err);
+
+                  } else {
+
+                    next();
+
+                  }
+
+                });
 
               }
 
diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index 0d6ddabacb0b52..26cf4c7b8cf34d 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -50,7 +50,23 @@ function checkProps(p1, p2) {
   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);
-  assert.strictEqual(fs.statSync(p1).mtime, fs.statSync(p2).mtime);
+  if (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.',
+                '<');
+
+  } if (Math.abs(fs.statSync(p1).atime.getTime() -
+               fs.statSync(p2).atime.getTime()) > 1000) {
+
+    assert.fail(Math.abs(fs.statSync(p1).atime.getTime() -
+                         fs.statSync(p2).atime.getTime()), 1000,
+                'atimes are not correct.',
+                '<');
+
+  }
 
 }
 

From 2b15b181e30489324947a175ef1f0fdf45f0f4c5 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 11:56:43 +0100
Subject: [PATCH 09/14] Don't fail on fs.delete when callback isn't a function.

---
 lib/fs.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/fs.js b/lib/fs.js
index 807238dc29bdf9..ac9798460c9abf 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2860,6 +2860,12 @@ fs.copySync = function(file1, file2, overwrite = 2) {
 //(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);

From acbe41c0e0bf340100aab741dcba088a3813f7b8 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 15:55:00 +0100
Subject: [PATCH 10/14] Don't test atimes as they will be modified when we run
 the read tests.

---
 test/parallel/test-fs-copy-and-delete.js | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index 26cf4c7b8cf34d..eddd55080c2deb 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -58,14 +58,6 @@ function checkProps(p1, p2) {
                 'mtimes are not correct.',
                 '<');
 
-  } if (Math.abs(fs.statSync(p1).atime.getTime() -
-               fs.statSync(p2).atime.getTime()) > 1000) {
-
-    assert.fail(Math.abs(fs.statSync(p1).atime.getTime() -
-                         fs.statSync(p2).atime.getTime()), 1000,
-                'atimes are not correct.',
-                '<');
-
   }
 
 }

From 3f6306aea723e177198d7fe1481fdedbd92dab1e Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 16:14:09 +0100
Subject: [PATCH 11/14] Log process.platform and os.platform() in test scripts
 to determine what they are on aix.

---
 test/parallel/test-fs-copy-and-delete.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index eddd55080c2deb..26e65df2b65cf5 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -5,6 +5,10 @@ const fs = require('fs');
 const assert = require('assert');
 common.refreshTmpDir();
 const testDir = common.tmpDir + '/copyanddeletetest';
+
+console.log('process.platform =', process.platform);
+console.log('os.platform() =', require('os').platform());
+
 if (!fs.existsSync(testDir)) {
   fs.mkdirSync(testDir);
 }

From a2a66486c955cd62f43d8d4e550d9f71a0391a34 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 16:17:40 +0100
Subject: [PATCH 12/14] Don't call fs.futimes on aix platform.

---
 lib/fs.js                                | 55 +++++++++++++++++++-----
 test/parallel/test-fs-copy-and-delete.js |  3 --
 2 files changed, 45 insertions(+), 13 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index ac9798460c9abf..dcbad3de9222f9 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2334,10 +2334,18 @@ fs.copy = function(...args) {
 
                                     if (doing >= dir.length) {
 
-                                      fs.futimes(fd2,
-                                                 stats1.atime,
-                                                 stats1.mtime,
-                                                 nextstep2);
+                                      if (process.platform !== 'aix') {
+
+                                        fs.futimes(fd2,
+                                                   stats1.atime,
+                                                   stats1.mtime,
+                                                   nextstep2);
+
+                                      } else {
+
+                                        nextstep2();
+
+                                      }
 
                                     } else {
 
@@ -2519,7 +2527,7 @@ fs.copy = function(...args) {
 
                   } else {
 
-                    fs.futimes(fd2, stats1.atime, stats1.mtime, (err) => {
+                    const nextstep = (err) => {
 
                       if (err) {
 
@@ -2567,7 +2575,17 @@ fs.copy = function(...args) {
 
                       }
 
-                    });
+                    };
+
+                    if (process.platform !== 'aix') {
+
+                      fs.futimes(fd2, stats1.atime, stats1.mtime, nextstep);
+
+                    } else {
+
+                      nextstep();
+
+                    }
 
                   }
 
@@ -2728,6 +2746,12 @@ fs.copySync = function(file1, file2, overwrite = 2) {
         //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);
@@ -2737,9 +2761,14 @@ fs.copySync = function(file1, file2, overwrite = 2) {
                       pathModule.join(file2, dir[doing]), overwrite);
 
         }
-        fs.futimesSync(fd2, stats1.atime, stats1.mtime);
-        fs.closeSync(fd2);
-        fd2 = null;
+
+        if (process.platform === 'aix') {
+
+          fs.futimesSync(fd2, stats1.atime, stats1.mtime);
+          fs.closeSync(fd2);
+          fd2 = null;
+
+        }
 
       };
 
@@ -2824,9 +2853,15 @@ fs.copySync = function(file1, file2, overwrite = 2) {
       fs.writeSync(fd2, fs.readFileSync(file1));
 
       //Now properties.
-      fs.futimesSync(fd2, stats1.atime, stats1.mtime);
       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;
 
diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index 26e65df2b65cf5..fc24b59098af41 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -6,9 +6,6 @@ const assert = require('assert');
 common.refreshTmpDir();
 const testDir = common.tmpDir + '/copyanddeletetest';
 
-console.log('process.platform =', process.platform);
-console.log('os.platform() =', require('os').platform());
-
 if (!fs.existsSync(testDir)) {
   fs.mkdirSync(testDir);
 }

From ea1db2d6823160e1ace34826168920bd03a9df01 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 16:45:57 +0100
Subject: [PATCH 13/14] I made a stupid mistake and triggered fs.futimesSync
 for AIX and not for any other platform when it should have been the other way
 round.

---
 lib/fs.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/fs.js b/lib/fs.js
index dcbad3de9222f9..01d72649d75d90 100644
--- a/lib/fs.js
+++ b/lib/fs.js
@@ -2746,7 +2746,7 @@ fs.copySync = function(file1, file2, overwrite = 2) {
         //Get properties from origional file.
         fs.fchmodSync(fd2, stats1.mode);
         fs.fchownSync(fd2, stats1.uid, stats1.gid);
-        if (process.platform !== 'aix') {
+        if (process.platform === 'aix') {
 
           fs.closeSync(fd2);
           fd2 = null;
@@ -2762,7 +2762,7 @@ fs.copySync = function(file1, file2, overwrite = 2) {
 
         }
 
-        if (process.platform === 'aix') {
+        if (process.platform !== 'aix') {
 
           fs.futimesSync(fd2, stats1.atime, stats1.mtime);
           fs.closeSync(fd2);

From bad81e79fd77a2298814e6c2a5f168c92859f499 Mon Sep 17 00:00:00 2001
From: Jacob O'Toole <jacob.otoole1@gmail.com>
Date: Sun, 23 Apr 2017 18:16:58 +0100
Subject: [PATCH 14/14] Made sure that the test cannot fluke with timings.

---
 test/parallel/test-fs-copy-and-delete.js | 266 ++++++++++++-----------
 1 file changed, 135 insertions(+), 131 deletions(-)

diff --git a/test/parallel/test-fs-copy-and-delete.js b/test/parallel/test-fs-copy-and-delete.js
index fc24b59098af41..0dc7ff60bf5464 100644
--- a/test/parallel/test-fs-copy-and-delete.js
+++ b/test/parallel/test-fs-copy-and-delete.js
@@ -27,138 +27,142 @@ function setUpDir(path) {
 }
 
 setUpDir(testDir + '/test1');
-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 (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`);
-
-      }
-
-    });
+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);