Fix tests for sdist

We now create the necessary directories and files
for the tests on-the-fly.

hpath.cabal

@@ -74,21 +74,6 @@ test-suite spec
   Main-Is:              Main.hs
   other-modules:
                         Spec
-                        HPath.IO.CopyDirRecursiveSpec
-                        HPath.IO.CopyDirRecursiveOverwriteSpec
-                        HPath.IO.CopyFileSpec
-                        HPath.IO.CopyFileOverwriteSpec
-                        HPath.IO.CreateDirSpec
-                        HPath.IO.CreateRegularFileSpec
-                        HPath.IO.DeleteDirRecursiveSpec
-                        HPath.IO.DeleteDirSpec
-                        HPath.IO.DeleteFileSpec
-                        HPath.IO.GetDirsFilesSpec
-                        HPath.IO.GetFileTypeSpec
-                        HPath.IO.MoveFileSpec
-                        HPath.IO.MoveFileOverwriteSpec
-                        HPath.IO.RecreateSymlinkSpec
-                        HPath.IO.RenameFileSpec
                         Utils
   GHC-Options:          -Wall
   Build-Depends:        base
@@ -98,6 +83,7 @@ test-suite spec
                       , hspec >= 1.3
                       , process
                       , unix
+                      , unix-bytestring
                       , utf8-string
 
 benchmark bench.hs

test/HPath/IO/CanonicalizePathSpec.hs

@@ -17,50 +17,59 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
-ba = BS.append
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/canonicalizePathSpec/"
 
-specDir' :: String
+setupFiles :: IO ()
-specDir' = toString specDir
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createSymlink' "dirSym" "dir/"
+  createSymlink' "brokenSym" "nothing"
+  createSymlink' "fileSym" "file"
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  deleteFile' "file"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "brokenSym"
+  deleteFile' "fileSym"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.canonicalizePath" $ do
 
     -- successes --
     it "canonicalizePath, all fine" $ do
-      path <- withPwd (specDir `ba` "file") return
+      path <- withTmpDir "file" return
-      canonicalizePath' (specDir `ba` "file")
+      canonicalizePath' "file"
         `shouldReturn` path
 
     it "canonicalizePath, all fine" $ do
-      path <- withPwd (specDir `ba` "dir") return
+      path <- withTmpDir "dir" return
-      canonicalizePath' (specDir `ba` "dir")
+      canonicalizePath' "dir"
         `shouldReturn` path
 
     it "canonicalizePath, all fine" $ do
-      path <- withPwd (specDir `ba` "file") return
+      path <- withTmpDir "file" return
-      canonicalizePath' (specDir `ba` "fileSym")
+      canonicalizePath' "fileSym"
         `shouldReturn` path
 
     it "canonicalizePath, all fine" $ do
-      path <- withPwd (specDir `ba` "dir") return
+      path <- withTmpDir "dir" return
-      canonicalizePath' (specDir `ba` "dirSym")
+      canonicalizePath' "dirSym"
         `shouldReturn` path
 
 
     -- posix failures --
     it "canonicalizePath, broken symlink" $
-      canonicalizePath' (specDir `ba` "brokenSym")
+      canonicalizePath' "brokenSym"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "canonicalizePath, file does not exist" $
-      canonicalizePath' (specDir `ba` "nothingBlah")
+      canonicalizePath' "nothingBlah"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 

test/HPath/IO/CopyDirRecursiveOverwriteSpec.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
+
 module HPath.IO.CopyDirRecursiveOverwriteSpec where
 
 
@@ -20,91 +21,149 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
-ba = BS.append
 
-specDir :: BS.ByteString
+setupFiles :: IO ()
-specDir = "test/HPath/IO/copyDirRecursiveOverwriteSpec/"
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createRegularFile' "wrongInput"
+  createSymlink' "wrongInputSymL" "inputDir/"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+
+  createDir' "inputDir"
+  createDir' "inputDir/bar"
+  createDir' "inputDir/foo"
+  createRegularFile' "inputDir/foo/inputFile1"
+  createRegularFile' "inputDir/inputFile2"
+  createRegularFile' "inputDir/bar/inputFile3"
+  writeFile' "inputDir/foo/inputFile1" "SDAADSdsada"
+  writeFile' "inputDir/inputFile2" "Blahfaselgagaga"
+  writeFile' "inputDir/bar/inputFile3"
+    "fdfdssdffsd3223sasdasdasdadasasddasdasdasasd4"
+
+  createDir' "alreadyExistsD"
+  createDir' "alreadyExistsD/bar"
+  createDir' "alreadyExistsD/foo"
+  createRegularFile' "alreadyExistsD/foo/inputFile1"
+  createRegularFile' "alreadyExistsD/inputFile2"
+  createRegularFile' "alreadyExistsD/bar/inputFile3"
+  writeFile' "alreadyExistsD/foo/inputFile1" "DAAsada"
+  writeFile' "alreadyExistsD/inputFile2" "ahfaagaga"
+  writeFile' "alreadyExistsD/bar/inputFile3"
+    "f3223sasdasdaasdasdasasd4"
+
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "alreadyExists"
+  deleteFile' "wrongInput"
+  deleteFile' "wrongInputSymL"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+  deleteFile' "inputDir/foo/inputFile1"
+  deleteFile' "inputDir/inputFile2"
+  deleteFile' "inputDir/bar/inputFile3"
+  deleteDir' "inputDir/foo"
+  deleteDir' "inputDir/bar"
+  deleteDir' "inputDir"
+  deleteFile' "alreadyExistsD/foo/inputFile1"
+  deleteFile' "alreadyExistsD/inputFile2"
+  deleteFile' "alreadyExistsD/bar/inputFile3"
+  deleteDir' "alreadyExistsD/foo"
+  deleteDir' "alreadyExistsD/bar"
+  deleteDir' "alreadyExistsD"
 
-specDir' :: String
-specDir' = toString specDir
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.copyDirRecursiveOverwrite" $ do
 
     -- successes --
     it "copyDirRecursiveOverwrite, all fine" $ do
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "outputDir")
+                                 "outputDir"
-      removeDirIfExists $ specDir `ba` "outputDir"
+      removeDirIfExists "outputDir"
 
     it "copyDirRecursiveOverwrite, all fine and compare" $ do
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "outputDir")
+                                 "outputDir"
       (system $ "diff -r --no-dereference "
-                          ++ specDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ specDir' ++ "outputDir")
+                          ++ toString tmpDir ++ "outputDir")
         `shouldReturn` ExitSuccess
-      removeDirIfExists $ specDir `ba` "outputDir"
+      removeDirIfExists "outputDir"
 
-    it "copyDirRecursiveOverwrite, destination dir already exists" $
+    it "copyDirRecursiveOverwrite, destination dir already exists" $ do
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      (system $ "diff -r --no-dereference "
-                                 (specDir `ba` "alreadyExistsD")
+                          ++ toString tmpDir ++ "inputDir" ++ " "
+                          ++ toString tmpDir ++ "alreadyExistsD")
+        `shouldReturn` (ExitFailure 1)
+      copyDirRecursiveOverwrite' "inputDir"
+                                 "alreadyExistsD"
+      (system $ "diff -r --no-dereference "
+                          ++ toString tmpDir ++ "inputDir" ++ " "
+                          ++ toString tmpDir ++ "alreadyExistsD")
+        `shouldReturn` ExitSuccess
+      removeDirIfExists "outputDir"
 
     -- posix failures --
     it "copyDirRecursiveOverwrite, source directory does not exist" $
-      copyDirRecursiveOverwrite' (specDir `ba` "doesNotExist")
+      copyDirRecursiveOverwrite' "doesNotExist"
-                                 (specDir `ba` "outputDir")
+                                 "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "copyDirRecursiveOverwrite, no write permission on output dir" $
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "noWritePerm/foo")
+                                 "noWritePerm/foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursiveOverwrite, cannot open output dir" $
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "noPerms/foo")
+                                 "noPerms/foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursiveOverwrite, cannot open source dir" $
-      copyDirRecursiveOverwrite' (specDir `ba` "noPerms/inputDir")
+      copyDirRecursiveOverwrite' "noPerms/inputDir"
-                                 (specDir `ba` "foo")
+                                 "foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursiveOverwrite, destination already exists and is a file" $
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "alreadyExists")
+                                 "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "copyDirRecursiveOverwrite, wrong input (regular file)" $
-      copyDirRecursiveOverwrite' (specDir `ba` "wrongInput")
+      copyDirRecursiveOverwrite' "wrongInput"
-                                 (specDir `ba` "outputDir")
+                                 "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "copyDirRecursiveOverwrite, wrong input (symlink to directory)" $
-      copyDirRecursiveOverwrite' (specDir `ba` "wrongInputSymL")
+      copyDirRecursiveOverwrite' "wrongInputSymL"
-                                 (specDir `ba` "outputDir")
+                                 "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     -- custom failures
     it "copyDirRecursiveOverwrite, destination in source" $
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "inputDir/foo")
+                                 "inputDir/foo"
         `shouldThrow`
         isDestinationInSource
 
     it "copyDirRecursiveOverwrite, destination and source same directory" $
-      copyDirRecursiveOverwrite' (specDir `ba` "inputDir")
+      copyDirRecursiveOverwrite' "inputDir"
-                                 (specDir `ba` "inputDir")
+                                 "inputDir"
         `shouldThrow`
         isSameFile

test/HPath/IO/CopyDirRecursiveSpec.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
+
 module HPath.IO.CopyDirRecursiveSpec where
 
 
@@ -20,93 +21,130 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
-ba = BS.append
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/copyDirRecursiveSpec/"
 
-specDir' :: String
+
-specDir' = toString specDir
+setupFiles :: IO ()
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createRegularFile' "wrongInput"
+  createSymlink' "wrongInputSymL" "inputDir/"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+
+  createDir' "inputDir"
+  createDir' "inputDir/bar"
+  createDir' "inputDir/foo"
+  createRegularFile' "inputDir/foo/inputFile1"
+  createRegularFile' "inputDir/inputFile2"
+  createRegularFile' "inputDir/bar/inputFile3"
+  writeFile' "inputDir/foo/inputFile1" "SDAADSdsada"
+  writeFile' "inputDir/inputFile2" "Blahfaselgagaga"
+  writeFile' "inputDir/bar/inputFile3"
+    "fdfdssdffsd3223sasdasdasdadasasddasdasdasasd4"
+
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+
+
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "alreadyExists"
+  deleteFile' "wrongInput"
+  deleteFile' "wrongInputSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+  deleteFile' "inputDir/foo/inputFile1"
+  deleteFile' "inputDir/inputFile2"
+  deleteFile' "inputDir/bar/inputFile3"
+  deleteDir' "inputDir/foo"
+  deleteDir' "inputDir/bar"
+  deleteDir' "inputDir"
+
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.copyDirRecursive" $ do
 
     -- successes --
     it "copyDirRecursive, all fine" $ do
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "outputDir")
+                        "outputDir"
-      removeDirIfExists (specDir `ba` "outputDir")
+      removeDirIfExists "outputDir"
 
     it "copyDirRecursive, all fine and compare" $ do
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "outputDir")
+                        "outputDir"
       (system $ "diff -r --no-dereference "
-                          ++ specDir' ++ "inputDir" ++ " "
+                          ++ toString tmpDir ++ "inputDir" ++ " "
-                          ++ specDir' ++ "outputDir")
+                          ++ toString tmpDir ++ "outputDir")
         `shouldReturn` ExitSuccess
-      removeDirIfExists (specDir `ba` "outputDir")
+      removeDirIfExists "outputDir"
 
     -- posix failures --
     it "copyDirRecursive, source directory does not exist" $
-      copyDirRecursive' (specDir `ba` "doesNotExist")
+      copyDirRecursive' "doesNotExist"
-                        (specDir `ba` "outputDir")
+                        "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "copyDirRecursive, no write permission on output dir" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "noWritePerm/foo")
+                        "noWritePerm/foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursive, cannot open output dir" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "noPerms/foo")
+                        "noPerms/foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursive, cannot open source dir" $
-      copyDirRecursive' (specDir `ba` "noPerms/inputDir")
+      copyDirRecursive' "noPerms/inputDir"
-                        (specDir `ba` "foo")
+                        "foo"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyDirRecursive, destination dir already exists" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "alreadyExistsD")
+                        "alreadyExistsD"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "copyDirRecursive, destination already exists and is a file" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "alreadyExists")
+                        "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "copyDirRecursive, wrong input (regular file)" $
-      copyDirRecursive' (specDir `ba` "wrongInput")
+      copyDirRecursive' "wrongInput"
-                        (specDir `ba` "outputDir")
+                        "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "copyDirRecursive, wrong input (symlink to directory)" $
-      copyDirRecursive' (specDir `ba` "wrongInputSymL")
+      copyDirRecursive' "wrongInputSymL"
-                        (specDir `ba` "outputDir")
+                        "outputDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     -- custom failures
     it "copyDirRecursive, destination in source" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "inputDir/foo")
+                        "inputDir/foo"
         `shouldThrow`
         isDestinationInSource
 
     it "copyDirRecursive, destination and source same directory" $
-      copyDirRecursive' (specDir `ba` "inputDir")
+      copyDirRecursive' "inputDir"
-                        (specDir `ba` "inputDir")
+                        "inputDir"
         `shouldThrow`
         isSameFile

test/HPath/IO/CopyFileOverwriteSpec.hs

@@ -20,90 +20,110 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "inputFile"
+  createRegularFile' "alreadyExists"
+  createSymlink' "inputFileSymL" "inputFile"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/inputFile"
+  createDir' "outputDirNoWrite"
+  createDir' "wrongInput"
+  noPerms "noPerms"
+  noWritableDirPerms "outputDirNoWrite"
+  writeFile' "inputFile" "Blahfaselgagaga"
+  writeFile' "alreadyExists" "dsaldsalkaklsdlkasksdadasl"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/copyFileOverwriteSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "outputDirNoWrite"
+  deleteFile' "noPerms/inputFile"
+  deleteFile' "inputFile"
+  deleteFile' "alreadyExists"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "outputDirNoWrite"
+  deleteDir' "wrongInput"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.copyFileOverwrite" $ do
 
     -- successes --
     it "copyFileOverwrite, everything clear" $ do
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
-      removeFileIfExists (specDir `ba` "outputFile")
+      removeFileIfExists "outputFile"
 
     it "copyFileOverwrite, output file already exists, all clear" $ do
-      copyFile' (specDir `ba` "alreadyExists") (specDir `ba` "alreadyExists.bak")
+      copyFile' "alreadyExists" "alreadyExists.bak"
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                         (specDir `ba` "alreadyExists")
+                         "alreadyExists"
-      (system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
+      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ specDir' ++ "alreadyExists")
+                          ++ toString tmpDir ++ "alreadyExists")
         `shouldReturn` ExitSuccess
-      removeFileIfExists (specDir `ba` "alreadyExists")
+      removeFileIfExists "alreadyExists"
-      copyFile' (specDir `ba` "alreadyExists.bak") (specDir `ba` "alreadyExists")
+      copyFile' "alreadyExists.bak" "alreadyExists"
-      removeFileIfExists (specDir `ba` "alreadyExists.bak")
+      removeFileIfExists "alreadyExists.bak"
 
     it "copyFileOverwrite, and compare" $ do
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
-      (system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
+      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ specDir' ++ "outputFile")
+                          ++ toString tmpDir ++ "outputFile")
         `shouldReturn` ExitSuccess
-      removeFileIfExists (specDir `ba` "outputFile")
+      removeFileIfExists "outputFile"
 
     -- posix failures --
     it "copyFileOverwrite, input file does not exist" $
-      copyFileOverwrite' (specDir `ba` "noSuchFile")
+      copyFileOverwrite' "noSuchFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "copyFileOverwrite, no permission to write to output directory" $
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "outputDirNoWrite/outputFile")
+                "outputDirNoWrite/outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFileOverwrite, cannot open output directory" $
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "noPerms/outputFile")
+                "noPerms/outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFileOverwrite, cannot open source directory" $
-      copyFileOverwrite' (specDir `ba` "noPerms/inputFile")
+      copyFileOverwrite' "noPerms/inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFileOverwrite, wrong input type (symlink)" $
-      copyFileOverwrite' (specDir `ba` "inputFileSymL")
+      copyFileOverwrite' "inputFileSymL"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "copyFileOverwrite, wrong input type (directory)" $
-      copyFileOverwrite' (specDir `ba` "wrongInput")
+      copyFileOverwrite' "wrongInput"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "copyFileOverwrite, output file already exists and is a dir" $
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "alreadyExistsD")
+                "alreadyExistsD"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     -- custom failures --
     it "copyFileOverwrite, output and input are same file" $
-      copyFileOverwrite' (specDir `ba` "inputFile")
+      copyFileOverwrite' "inputFile"
-                (specDir `ba` "inputFile")
+                "inputFile"
         `shouldThrow` isSameFile

test/HPath/IO/CopyFileSpec.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE OverloadedStrings #-}
 
+
 module HPath.IO.CopyFileSpec where
 
 
@@ -20,86 +21,105 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "inputFile"
+  createRegularFile' "alreadyExists"
+  createSymlink' "inputFileSymL" "inputFile"
+  createDir' "alreadyExistsD"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/inputFile"
+  createDir' "outputDirNoWrite"
+  createDir' "wrongInput"
+  noPerms "noPerms"
+  noWritableDirPerms "outputDirNoWrite"
+  writeFile' "inputFile" "Blahfaselgagaga"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/copyFileSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "outputDirNoWrite"
+  deleteFile' "noPerms/inputFile"
+  deleteFile' "inputFile"
+  deleteFile' "alreadyExists"
+  deleteFile' "inputFileSymL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "noPerms"
+  deleteDir' "outputDirNoWrite"
+  deleteDir' "wrongInput"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.copyFile" $ do
 
     -- successes --
     it "copyFile, everything clear" $ do
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
-      removeFileIfExists (specDir `ba` "outputFile")
+      removeFileIfExists "outputFile"
 
     it "copyFile, and compare" $ do
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
-      (system $ "cmp -s " ++ specDir' ++ "inputFile" ++ " "
+      (system $ "cmp -s " ++ toString tmpDir ++ "inputFile" ++ " "
-                          ++ specDir' ++ "outputFile")
+                          ++ toString tmpDir ++ "outputFile")
         `shouldReturn` ExitSuccess
-      removeFileIfExists (specDir `ba` "outputFile")
+      removeFileIfExists "outputFile"
 
     -- posix failures --
     it "copyFile, input file does not exist" $
-      copyFile' (specDir `ba` "noSuchFile")
+      copyFile' "noSuchFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "copyFile, no permission to write to output directory" $
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "outputDirNoWrite/outputFile")
+                "outputDirNoWrite/outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFile, cannot open output directory" $
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "noPerms/outputFile")
+                "noPerms/outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFile, cannot open source directory" $
-      copyFile' (specDir `ba` "noPerms/inputFile")
+      copyFile' "noPerms/inputFile"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "copyFile, wrong input type (symlink)" $
-      copyFile' (specDir `ba` "inputFileSymL")
+      copyFile' "inputFileSymL"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "copyFile, wrong input type (directory)" $
-      copyFile' (specDir `ba` "wrongInput")
+      copyFile' "wrongInput"
-                (specDir `ba` "outputFile")
+                "outputFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "copyFile, output file already exists" $
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "alreadyExists")
+                "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "copyFile, output file already exists and is a dir" $
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "alreadyExistsD")
+                "alreadyExistsD"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     -- custom failures --
     it "copyFile, output and input are same file" $
-      copyFile' (specDir `ba` "inputFile")
+      copyFile' "inputFile"
-                (specDir `ba` "inputFile")
+                "inputFile"
         `shouldThrow`
         isSameFile

test/HPath/IO/CreateDirSpec.hs

@@ -17,38 +17,47 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createDir' "alreadyExists"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/createDirSpec/"
 
-specDir' :: String
+
-specDir' = toString specDir
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteDir' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.createDir" $ do
 
     -- successes --
     it "createDir, all fine" $ do
-      createDir' (specDir `ba` "newDir")
+      createDir' "newDir"
-      removeDirIfExists (specDir `ba` "newDir")
+      removeDirIfExists "newDir"
 
     -- posix failures --
     it "createDir, can't write to output directory" $
-      createDir' (specDir `ba` "noWritePerms/newDir")
+      createDir' "noWritePerms/newDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "createDir, can't open output directory" $
-      createDir' (specDir `ba` "noPerms/newDir")
+      createDir' "noPerms/newDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "createDir, destination directory already exists" $
-      createDir' (specDir `ba` "alreadyExists")
+      createDir' "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 

test/HPath/IO/CreateRegularFileSpec.hs

@@ -17,38 +17,47 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "alreadyExists"
+  createDir' "noPerms"
+  createDir' "noWritePerms"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerms"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/createRegularFileSpec/"
 
-specDir' :: String
+
-specDir' = toString specDir
+cleanupFiles :: IO ()
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerms"
+  deleteFile' "alreadyExists"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerms"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.createRegularFile" $ do
 
     -- successes --
     it "createRegularFile, all fine" $ do
-      createRegularFile' (specDir `ba` "newDir")
+      createRegularFile' "newDir"
-      removeFileIfExists (specDir `ba` "newDir")
+      removeFileIfExists "newDir"
 
     -- posix failures --
     it "createRegularFile, can't write to destination directory" $
-      createRegularFile' (specDir `ba` "noWritePerms/newDir")
+      createRegularFile' "noWritePerms/newDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "createRegularFile, can't write to destination directory" $
-      createRegularFile' (specDir `ba` "noPerms/newDir")
+      createRegularFile' "noPerms/newDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "createRegularFile, destination file already exists" $
-      createRegularFile' (specDir `ba` "alreadyExists")
+      createRegularFile' "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 

test/HPath/IO/DeleteDirRecursiveSpec.hs

@@ -21,76 +21,90 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createRegularFile' "dir/.keep"
+  createSymlink' "dirSym" "dir/"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/.keep"
+  createDir' "noWritable"
+  createRegularFile' "noWritable/.keep"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/deleteDirRecursiveSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  deleteFile' "file"
+  deleteFile' "dir/.keep"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "noPerms/.keep"
+  deleteDir' "noPerms"
+  deleteFile' "noWritable/.keep"
+  deleteDir' "noWritable"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.deleteDirRecursive" $ do
 
     -- successes --
     it "deleteDirRecursive, empty directory, all fine" $ do
-      createDir' (specDir `ba` "testDir")
+      createDir' "testDir"
-      deleteDirRecursive' (specDir `ba` "testDir")
+      deleteDirRecursive' "testDir"
-      getSymbolicLinkStatus (specDir `ba` "testDir")
+      getSymbolicLinkStatus "testDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "deleteDirRecursive, empty directory with null permissions, all fine" $ do
-      createDir' (specDir `ba` "noPerms/testDir")
+      createDir' "noPerms/testDir"
-      noPerms (specDir `ba` "noPerms/testDir")
+      noPerms "noPerms/testDir"
-      deleteDirRecursive' (specDir `ba` "noPerms/testDir")
+      deleteDirRecursive' "noPerms/testDir"
 
     it "deleteDirRecursive, non-empty directory, all fine" $ do
-      createDir' (specDir `ba` "nonEmpty")
+      createDir' "nonEmpty"
-      createDir' (specDir `ba` "nonEmpty/dir1")
+      createDir' "nonEmpty/dir1"
-      createDir' (specDir `ba` "nonEmpty/dir2")
+      createDir' "nonEmpty/dir2"
-      createDir' (specDir `ba` "nonEmpty/dir2/dir3")
+      createDir' "nonEmpty/dir2/dir3"
-      createRegularFile' (specDir `ba` "nonEmpty/file1")
+      createRegularFile' "nonEmpty/file1"
-      createRegularFile' (specDir `ba` "nonEmpty/dir1/file2")
+      createRegularFile' "nonEmpty/dir1/file2"
-      deleteDirRecursive' (specDir `ba` "nonEmpty")
+      deleteDirRecursive' "nonEmpty"
-      getSymbolicLinkStatus (specDir `ba` "nonEmpty")
+      getSymbolicLinkStatus "nonEmpty"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     -- posix failures --
     it "deleteDirRecursive, can't open parent directory" $ do
-      createDir' (specDir `ba` "noPerms/foo")
+      createDir' "noPerms/foo"
-      noPerms (specDir `ba` "noPerms")
+      noPerms "noPerms"
-      (deleteDirRecursive' (specDir `ba` "noPerms/foo")
+      (deleteDirRecursive' "noPerms/foo")
         `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied))
+        (\e -> ioeGetErrorType e == PermissionDenied)
-        >> normalDirPerms (specDir `ba` "noPerms")
+      normalDirPerms "noPerms"
-        >> deleteDir' (specDir `ba` "noPerms/foo")
+      deleteDir' "noPerms/foo"
 
     it "deleteDirRecursive, can't write to parent directory" $ do
-      createDir' (specDir `ba` "noWritable/foo")
+      createDir' "noWritable/foo"
-      noWritableDirPerms (specDir `ba` "noWritable")
+      noWritableDirPerms "noWritable"
-      (deleteDirRecursive' (specDir `ba` "noWritable/foo")
+      (deleteDirRecursive' "noWritable/foo")
         `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied))
+        (\e -> ioeGetErrorType e == PermissionDenied)
-      normalDirPerms (specDir `ba` "noWritable")
+      normalDirPerms "noWritable"
-      deleteDir' (specDir `ba` "noWritable/foo")
+      deleteDir' "noWritable/foo"
 
     it "deleteDirRecursive, wrong file type (symlink to directory)" $
-      deleteDirRecursive' (specDir `ba` "dirSym")
+      deleteDirRecursive' "dirSym"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "deleteDirRecursive, wrong file type (regular file)" $
-      deleteDirRecursive' (specDir `ba` "file")
+      deleteDirRecursive' "file"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "deleteDirRecursive, directory does not exist" $
-      deleteDirRecursive' (specDir `ba` "doesNotExist")
+      deleteDirRecursive' "doesNotExist"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 

test/HPath/IO/DeleteDirSpec.hs

@@ -21,74 +21,88 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "file"
+  createDir' "dir"
+  createRegularFile' "dir/.keep"
+  createSymlink' "dirSym" "dir/"
+  createDir' "noPerms"
+  createRegularFile' "noPerms/.keep"
+  createDir' "noWritable"
+  createRegularFile' "noWritable/.keep"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/deleteDirSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  deleteFile' "file"
+  deleteFile' "dir/.keep"
+  deleteDir' "dir"
+  deleteFile' "dirSym"
+  deleteFile' "noPerms/.keep"
+  deleteDir' "noPerms"
+  deleteFile' "noWritable/.keep"
+  deleteDir' "noWritable"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.deleteDir" $ do
 
     -- successes --
     it "deleteDir, empty directory, all fine" $ do
-      createDir' (specDir `ba` "testDir")
+      createDir' "testDir"
-      deleteDir' (specDir `ba` "testDir")
+      deleteDir' "testDir"
-      getSymbolicLinkStatus (specDir `ba` "testDir")
+      getSymbolicLinkStatus "testDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "deleteDir, directory with null permissions, all fine" $ do
-      createDir' (specDir `ba` "noPerms/testDir")
+      createDir' "noPerms/testDir"
-      noPerms (specDir `ba` "noPerms/testDir")
+      noPerms "noPerms/testDir"
-      deleteDir' (specDir `ba` "noPerms/testDir")
+      deleteDir' "noPerms/testDir"
-      getSymbolicLinkStatus (specDir `ba` "testDir")
+      getSymbolicLinkStatus "testDir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     -- posix failures --
     it "deleteDir, wrong file type (symlink to directory)" $
-      deleteDir' (specDir `ba` "dirSym")
+      deleteDir' "dirSym"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "deleteDir, wrong file type (regular file)" $
-      deleteDir' (specDir `ba` "file")
+      deleteDir' "file"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "deleteDir, directory does not exist" $
-      deleteDir' (specDir `ba` "doesNotExist")
+      deleteDir' "doesNotExist"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "deleteDir, directory not empty" $
-      deleteDir' (specDir `ba` "dir")
+      deleteDir' "dir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == UnsatisfiedConstraints)
 
     it "deleteDir, can't open parent directory" $ do
-      createDir' (specDir `ba` "noPerms/foo")
+      createDir' "noPerms/foo"
-      noPerms (specDir `ba` "noPerms")
+      noPerms "noPerms"
-      (deleteDir' (specDir `ba` "noPerms/foo")
+      (deleteDir' "noPerms/foo")
         `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied))
+        (\e -> ioeGetErrorType e == PermissionDenied)
-        >> normalDirPerms (specDir `ba` "noPerms")
+      normalDirPerms "noPerms"
-        >> deleteDir' (specDir `ba` "noPerms/foo")
+      deleteDir' "noPerms/foo"
 
     it "deleteDir, can't write to parent directory, still fine" $ do
-      createDir' (specDir `ba` "noWritable/foo")
+      createDir' "noWritable/foo"
-      noWritableDirPerms (specDir `ba` "noWritable")
+      noWritableDirPerms "noWritable"
-      (deleteDir' (specDir `ba` "noWritable/foo")
+      (deleteDir' "noWritable/foo")
         `shouldThrow`
-        (\e -> ioeGetErrorType e == PermissionDenied))
+        (\e -> ioeGetErrorType e == PermissionDenied)
-      normalDirPerms (specDir `ba` "noWritable")
+      normalDirPerms "noWritable"
-      deleteDir' (specDir `ba` "noWritable/foo")
+      deleteDir' "noWritable/foo"
 
 
 

test/HPath/IO/DeleteFileSpec.hs

@@ -21,49 +21,58 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "foo"
+  createSymlink' "syml" "foo"
+  createDir' "dir"
+  createDir' "noPerms"
+  noPerms "noPerms"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/deleteFileSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "foo"
+  deleteFile' "syml"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.deleteFile" $ do
 
     -- successes --
     it "deleteFile, regular file, all fine" $ do
-      createRegularFile' (specDir `ba` "testFile")
+      createRegularFile' "testFile"
-      deleteFile' (specDir `ba` "testFile")
+      deleteFile' "testFile"
-      getSymbolicLinkStatus (specDir `ba` "testFile")
+      getSymbolicLinkStatus "testFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "deleteFile, symlink, all fine" $ do
-      recreateSymlink' (specDir `ba` "syml")
+      recreateSymlink' "syml"
-                       (specDir `ba` "testFile")
+                       "testFile"
-      deleteFile' (specDir `ba` "testFile")
+      deleteFile' "testFile"
-      getSymbolicLinkStatus (specDir `ba` "testFile")
+      getSymbolicLinkStatus "testFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     -- posix failures --
     it "deleteFile, wrong file type (directory)" $
-      deleteFile' (specDir `ba` "dir")
+      deleteFile' "dir"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "deleteFile, file does not exist" $
-      deleteFile' (specDir `ba` "doesNotExist")
+      deleteFile' "doesNotExist"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "deleteFile, can't read directory" $
-      deleteFile' (specDir `ba` "noPerms/blah")
+      deleteFile' "noPerms/blah"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 

test/HPath/IO/GetDirsFilesSpec.hs

@@ -16,6 +16,7 @@ import Data.Maybe
     fromJust
   )
 import qualified HPath as P
+import HPath.IO
 import Test.Hspec
 import System.IO.Error
   (
@@ -34,56 +35,71 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "file"
+  createRegularFile' "Lala"
+  createRegularFile' ".hidden"
+  createSymlink' "syml" "Lala"
+  createDir' "dir"
+  createSymlink' "dirsym" "dir"
+  createDir' "noPerms"
+  noPerms "noPerms"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/getDirsFilesSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "file"
+  deleteFile' "Lala"
+  deleteFile' ".hidden"
+  deleteFile' "syml"
+  deleteDir' "dir"
+  deleteFile' "dirsym"
+  deleteDir' "noPerms"
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.getDirsFiles" $ do
 
     -- successes --
-    it "getDirsFiles, all fine" $ do
+    it "getDirsFiles, all fine" $
-      pwd <- fromJust <$> getEnv "PWD" >>= P.parseAbs
+      withRawTmpDir $ \p -> do
-      expectedFiles <- mapM P.parseRel [(specDir `ba ` ".hidden")
+      expectedFiles <- mapM P.parseRel [".hidden"
-                                       ,(specDir `ba ` "Lala")
+                                       ,"Lala"
-                                       ,(specDir `ba ` "dir")
+                                       ,"dir"
-                                       ,(specDir `ba ` "dirsym")
+                                       ,"dirsym"
-                                       ,(specDir `ba ` "file")
+                                       ,"file"
-                                       ,(specDir `ba ` "noPerms")
+                                       ,"noPerms"
-                                       ,(specDir `ba ` "syml")]
+                                       ,"syml"]
-      (fmap sort $ getDirsFiles' specDir)
+      (fmap sort $ getDirsFiles p)
-        `shouldReturn` fmap (pwd P.</>) expectedFiles
+        `shouldReturn` fmap (p P.</>) expectedFiles
 
     -- posix failures --
     it "getDirsFiles, nonexistent directory" $
-      getDirsFiles' (specDir `ba ` "nothingHere")
+      getDirsFiles' "nothingHere"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "getDirsFiles, wrong file type (file)" $
-      getDirsFiles' (specDir `ba ` "file")
+      getDirsFiles' "file"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InappropriateType)
 
     it "getDirsFiles, wrong file type (symlink to file)" $
-      getDirsFiles' (specDir `ba ` "syml")
+      getDirsFiles' "syml"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "getDirsFiles, wrong file type (symlink to dir)" $
-      getDirsFiles' (specDir `ba ` "dirsym")
+      getDirsFiles' "dirsym"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "getDirsFiles, can't open directory" $
-      getDirsFiles' (specDir `ba ` "noPerms")
+      getDirsFiles' "noPerms"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 

test/HPath/IO/GetFileTypeSpec.hs

@@ -18,53 +18,66 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "regularfile"
+  createSymlink' "symlink" "regularfile"
+  createSymlink' "brokenSymlink" "broken"
+  createDir' "directory"
+  createSymlink' "symlinkD" "directory"
+  createDir' "noPerms"
+  noPerms "noPerms"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/getFileTypeSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  deleteFile' "regularfile"
+  deleteFile' "symlink"
+  deleteFile' "brokenSymlink"
+  deleteDir' "directory"
+  deleteFile' "symlinkD"
+  deleteDir' "noPerms"
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.getFileType" $ do
 
     -- successes --
     it "getFileType, regular file" $
-      getFileType' (specDir `ba` "regularfile")
+      getFileType' "regularfile"
         `shouldReturn` RegularFile
 
     it "getFileType, directory" $
-      getFileType' (specDir `ba` "directory")
+      getFileType' "directory"
         `shouldReturn` Directory
 
     it "getFileType, directory with null permissions" $
-      getFileType' (specDir `ba` "noPerms")
+      getFileType' "noPerms"
         `shouldReturn` Directory
 
     it "getFileType, symlink to file" $
-      getFileType' (specDir `ba` "symlink")
+      getFileType' "symlink"
         `shouldReturn` SymbolicLink
 
     it "getFileType, symlink to directory" $
-      getFileType' (specDir `ba` "symlinkD")
+      getFileType' "symlinkD"
         `shouldReturn` SymbolicLink
 
     it "getFileType, broken symlink" $
-      getFileType' (specDir `ba` "brokenSymlink")
+      getFileType' "brokenSymlink"
         `shouldReturn` SymbolicLink
 
     -- posix failures --
     it "getFileType, file does not exist" $
-      getFileType' (specDir `ba` "nothingHere")
+      getFileType' "nothingHere"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "getFileType, can't open directory" $
-      getFileType' (specDir `ba` "noPerms/forz")
+      getFileType' "noPerms/forz"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 

test/HPath/IO/MoveFileOverwriteSpec.hs

@@ -18,76 +18,92 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/moveFileOverwriteSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.moveFileOverwrite" $ do
 
     -- successes --
     it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "movedFile")
+                         "movedFile"
 
     it "moveFileOverwrite, all fine" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "dir/movedFile")
+                         "dir/movedFile"
 
     it "moveFileOverwrite, all fine on symlink" $
-      moveFileOverwrite' (specDir `ba` "myFileL")
+      moveFileOverwrite' "myFileL"
-                         (specDir `ba` "movedFile")
+                         "movedFile"
 
     it "moveFileOverwrite, all fine on directory" $
-      moveFileOverwrite' (specDir `ba` "dir")
+      moveFileOverwrite' "dir"
-                         (specDir `ba` "movedFile")
+                         "movedFile"
 
     it "moveFileOverwrite, destination file already exists" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "alreadyExists")
+                         "alreadyExists"
 
     -- posix failures --
     it "moveFileOverwrite, source file does not exist" $
-      moveFileOverwrite' (specDir `ba` "fileDoesNotExist")
+      moveFileOverwrite' "fileDoesNotExist"
-                         (specDir `ba` "movedFile")
+                         "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "moveFileOverwrite, can't write to destination directory" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "noWritePerm/movedFile")
+                         "noWritePerm/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "moveFileOverwrite, can't open destination directory" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "noPerms/movedFile")
+                         "noPerms/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "moveFileOverwrite, can't open source directory" $
-      moveFileOverwrite' (specDir `ba` "noPerms/myFile")
+      moveFileOverwrite' "noPerms/myFile"
-                         (specDir `ba` "movedFile")
+                         "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     -- custom failures --
     it "moveFileOverwrite, move from file to dir" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "alreadyExistsD")
+                         "alreadyExistsD"
         `shouldThrow`
         isDirDoesExist
 
     it "moveFileOverwrite, source and dest are same file" $
-      moveFileOverwrite' (specDir `ba` "myFile")
+      moveFileOverwrite' "myFile"
-                         (specDir `ba` "myFile")
+                         "myFile"
         `shouldThrow`
         isSameFile
 

test/HPath/IO/MoveFileSpec.hs

@@ -18,78 +18,96 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/moveFileSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
+
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.moveFile" $ do
 
     -- successes --
     it "moveFile, all fine" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "movedFile")
+                "movedFile"
 
     it "moveFile, all fine" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "dir/movedFile")
+                "dir/movedFile"
 
     it "moveFile, all fine on symlink" $
-      moveFile' (specDir `ba` "myFileL")
+      moveFile' "myFileL"
-                (specDir `ba` "movedFile")
+                "movedFile"
 
     it "moveFile, all fine on directory" $
-      moveFile' (specDir `ba` "dir")
+      moveFile' "dir"
-                (specDir `ba` "movedFile")
+                "movedFile"
 
     -- posix failures --
     it "moveFile, source file does not exist" $
-      moveFile' (specDir `ba` "fileDoesNotExist")
+      moveFile' "fileDoesNotExist"
-                (specDir `ba` "movedFile")
+                "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "moveFile, can't write to destination directory" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "noWritePerm/movedFile")
+                "noWritePerm/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "moveFile, can't open destination directory" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "noPerms/movedFile")
+                "noPerms/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "moveFile, can't open source directory" $
-      moveFile' (specDir `ba` "noPerms/myFile")
+      moveFile' "noPerms/myFile"
-                (specDir `ba` "movedFile")
+                "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     -- custom failures --
     it "moveFile, destination file already exists" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "alreadyExists")
+                "alreadyExists"
         `shouldThrow`
         isFileDoesExist
 
     it "moveFile, move from file to dir" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "alreadyExistsD")
+                "alreadyExistsD"
         `shouldThrow`
         isDirDoesExist
 
     it "moveFile, source and dest are same file" $
-      moveFile' (specDir `ba` "myFile")
+      moveFile' "myFile"
-                (specDir `ba` "myFile")
+                "myFile"
         `shouldThrow`
         isSameFile
 

test/HPath/IO/RecreateSymlinkSpec.hs

@@ -18,78 +18,95 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/recreateSymlinkSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.recreateSymlink" $ do
 
     -- successes --
     it "recreateSymLink, all fine" $ do
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "movedFile")
+                       "movedFile"
-      removeFileIfExists (specDir `ba` "movedFile")
+      removeFileIfExists "movedFile"
 
     it "recreateSymLink, all fine" $ do
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "dir/movedFile")
+                       "dir/movedFile"
-      removeFileIfExists (specDir `ba` "dir/movedFile")
+      removeFileIfExists "dir/movedFile"
 
     -- posix failures --
     it "recreateSymLink, wrong input type (file)" $
-      recreateSymlink' (specDir `ba` "myFile")
+      recreateSymlink' "myFile"
-                       (specDir `ba` "movedFile")
+                       "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "recreateSymLink, wrong input type (directory)" $
-      recreateSymlink' (specDir `ba` "dir")
+      recreateSymlink' "dir"
-                       (specDir `ba` "movedFile")
+                       "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == InvalidArgument)
 
     it "recreateSymLink, can't write to destination directory" $
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "noWritePerm/movedFile")
+                       "noWritePerm/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "recreateSymLink, can't open destination directory" $
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "noPerms/movedFile")
+                       "noPerms/movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "recreateSymLink, can't open source directory" $
-      recreateSymlink' (specDir `ba` "noPerms/myFileL")
+      recreateSymlink' "noPerms/myFileL"
-                       (specDir `ba` "movedFile")
+                       "movedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "recreateSymLink, destination file already exists" $
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "alreadyExists")
+                       "alreadyExists"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     it "recreateSymLink, destination already exists and is a dir" $
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "alreadyExistsD")
+                       "alreadyExistsD"
         `shouldThrow`
         (\e -> ioeGetErrorType e == AlreadyExists)
 
     -- custom failures --
     it "recreateSymLink, source and destination are the same file" $
-      recreateSymlink' (specDir `ba` "myFileL")
+      recreateSymlink' "myFileL"
-                       (specDir `ba` "myFileL")
+                       "myFileL"
         `shouldThrow`
         isSameFile
 

test/HPath/IO/RenameFileSpec.hs

@@ -18,78 +18,95 @@ import qualified Data.ByteString as BS
 import           Data.ByteString.UTF8 (toString)
 
 
-ba :: BS.ByteString -> BS.ByteString -> BS.ByteString
+setupFiles :: IO ()
-ba = BS.append
+setupFiles = do
+  createRegularFile' "myFile"
+  createSymlink' "myFileL" "myFile"
+  createRegularFile' "alreadyExists"
+  createDir' "alreadyExistsD"
+  createDir' "dir"
+  createDir' "noPerms"
+  createDir' "noWritePerm"
+  noPerms "noPerms"
+  noWritableDirPerms "noWritePerm"
+  writeFile' "myFile" "Blahfaselgagaga"
 
-specDir :: BS.ByteString
-specDir = "test/HPath/IO/renameFileSpec/"
 
-specDir' :: String
+cleanupFiles :: IO ()
-specDir' = toString specDir
+cleanupFiles = do
+  normalDirPerms "noPerms"
+  normalDirPerms "noWritePerm"
+  deleteFile' "myFile"
+  deleteFile' "myFileL"
+  deleteFile' "alreadyExists"
+  deleteDir' "alreadyExistsD"
+  deleteDir' "dir"
+  deleteDir' "noPerms"
+  deleteDir' "noWritePerm"
 
 
 spec :: Spec
-spec =
+spec = before_ setupFiles $ after_ cleanupFiles $
   describe "HPath.IO.renameFile" $ do
 
     -- successes --
     it "renameFile, all fine" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "renamedFile")
+                  "renamedFile"
 
     it "renameFile, all fine" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "dir/renamedFile")
+                  "dir/renamedFile"
 
     it "renameFile, all fine on symlink" $
-      renameFile' (specDir `ba` "myFileL")
+      renameFile' "myFileL"
-                  (specDir `ba` "renamedFile")
+                  "renamedFile"
 
     it "renameFile, all fine on directory" $
-      renameFile' (specDir `ba` "dir")
+      renameFile' "dir"
-                  (specDir `ba` "renamedFile")
+                  "renamedFile"
 
     -- posix failures --
     it "renameFile, source file does not exist" $
-      renameFile' (specDir `ba` "fileDoesNotExist")
+      renameFile' "fileDoesNotExist"
-                  (specDir `ba` "renamedFile")
+                  "renamedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == NoSuchThing)
 
     it "renameFile, can't write to output directory" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "noWritePerm/renamedFile")
+                  "noWritePerm/renamedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "renameFile, can't open output directory" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "noPerms/renamedFile")
+                  "noPerms/renamedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     it "renameFile, can't open source directory" $
-      renameFile' (specDir `ba` "noPerms/myFile")
+      renameFile' "noPerms/myFile"
-                  (specDir `ba` "renamedFile")
+                  "renamedFile"
         `shouldThrow`
         (\e -> ioeGetErrorType e == PermissionDenied)
 
     -- custom failures --
     it "renameFile, destination file already exists" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "alreadyExists")
+                  "alreadyExists"
         `shouldThrow`
         isFileDoesExist
 
     it "renameFile, move from file to dir" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "alreadyExistsD")
+                  "alreadyExistsD"
         `shouldThrow`
         isDirDoesExist
 
     it "renameFile, source and dest are same file" $
-      renameFile' (specDir `ba` "myFile")
+      renameFile' "myFile"
-                  (specDir `ba` "myFile")
+                  "myFile"
         `shouldThrow`
         isSameFile
 

test/HPath/IO/canonicalizePathSpec/brokenSym

@@ -1 +0,0 @@
-nothing

test/HPath/IO/canonicalizePathSpec/dirSym

@@ -1 +0,0 @@
-dir

test/HPath/IO/canonicalizePathSpec/fileSym

@@ -1 +0,0 @@
-file

test/HPath/IO/copyDirRecursiveOverwriteSpec/alreadyExistsD/bar/inputFile3

@@ -1,8 +0,0 @@
-dadasasddas
-sda
-
-!!1
-sda
-
-
-11

test/HPath/IO/copyDirRecursiveOverwriteSpec/alreadyExistsD/foo/inputFile1

@@ -1 +0,0 @@
-dadasasddas

test/HPath/IO/copyDirRecursiveOverwriteSpec/alreadyExistsD/inputFile2

@@ -1,4 +0,0 @@
-dadasasddas
-das
-sda
-sda

test/HPath/IO/copyDirRecursiveOverwriteSpec/inputDir/bar/inputFile3

@@ -1,8 +0,0 @@
-dadasasddas
-sda
-
-!!1
-sda
-
-
-11

test/HPath/IO/copyDirRecursiveOverwriteSpec/inputDir/foo/inputFile1

@@ -1 +0,0 @@
-dadasasddas

test/HPath/IO/copyDirRecursiveOverwriteSpec/inputDir/inputFile2

@@ -1,4 +0,0 @@
-dadasasddas
-das
-sda
-sda

test/HPath/IO/copyDirRecursiveOverwriteSpec/noPerms/inputDir/bar/inputFile3

@@ -1,8 +0,0 @@
-dadasasddas
-sda
-
-!!1
-sda
-
-
-11

test/HPath/IO/copyDirRecursiveOverwriteSpec/noPerms/inputDir/foo/inputFile1

@@ -1 +0,0 @@
-dadasasddas

test/HPath/IO/copyDirRecursiveOverwriteSpec/noPerms/inputDir/inputFile2

@@ -1,4 +0,0 @@
-dadasasddas
-das
-sda
-sda

test/HPath/IO/copyDirRecursiveOverwriteSpec/wrongInputSymL

@@ -1 +0,0 @@
-inputDir/

test/HPath/IO/copyDirRecursiveSpec/inputDir/bar/inputFile3

@@ -1,8 +0,0 @@
-dadasasddas
-sda
-
-!!1
-sda
-
-
-11

test/HPath/IO/copyDirRecursiveSpec/inputDir/foo/inputFile1

@@ -1 +0,0 @@
-dadasasddas

test/HPath/IO/copyDirRecursiveSpec/inputDir/inputFile2

@@ -1,4 +0,0 @@
-dadasasddas
-das
-sda
-sda

test/HPath/IO/copyDirRecursiveSpec/noPerms/inputDir/bar/inputFile3

@@ -1,8 +0,0 @@
-dadasasddas
-sda
-
-!!1
-sda
-
-
-11

test/HPath/IO/copyDirRecursiveSpec/noPerms/inputDir/foo/inputFile1

@@ -1 +0,0 @@
-dadasasddas

test/HPath/IO/copyDirRecursiveSpec/noPerms/inputDir/inputFile2

@@ -1,4 +0,0 @@
-dadasasddas
-das
-sda
-sda

test/HPath/IO/copyDirRecursiveSpec/wrongInputSymL

@@ -1 +0,0 @@
-inputDir/

test/HPath/IO/copyFileOverwriteSpec/alreadyExists

@@ -1,16 +0,0 @@
-adaöölsdaöl
-dsalö
-ölsda
-ääödsf
-äsdfä
-öä453
-öä
-435
-ä45343
-5
-453
-453453453
-das
-asd
-das
-

test/HPath/IO/copyFileOverwriteSpec/inputFile

@@ -1,4 +0,0 @@
-abc
-def
-
-dsadasdsa

test/HPath/IO/copyFileOverwriteSpec/inputFileSymL

@@ -1 +0,0 @@
-inputFile

test/HPath/IO/copyFileSpec/inputFile

@@ -1,2 +0,0 @@
-abc
-def

test/HPath/IO/copyFileSpec/inputFileSymL

@@ -1 +0,0 @@
-inputFile

test/HPath/IO/deleteDirRecursiveSpec/dirSym

@@ -1 +0,0 @@
-dir

test/HPath/IO/deleteDirSpec/dirSym

@@ -1 +0,0 @@
-dir

test/HPath/IO/deleteFileSpec/syml

@@ -1 +0,0 @@
-foo

test/HPath/IO/getDirsFilesSpec/dirsym

@@ -1 +0,0 @@
-dir

test/HPath/IO/getDirsFilesSpec/syml

@@ -1 +0,0 @@
-Lala

test/HPath/IO/getFileTypeSpec/brokenSymlink

@@ -1 +0,0 @@
-broken

test/HPath/IO/getFileTypeSpec/symlink

@@ -1 +0,0 @@
-regularfile

test/HPath/IO/getFileTypeSpec/symlinkD

@@ -1 +0,0 @@
-directory

test/HPath/IO/moveFileOverwriteSpec/myFile

@@ -1,4 +0,0 @@
-asd
-sda
-
-sda