{-# LANGUAGE CPP #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}

-- Copyright (C) 2011 John Millikin <jmillikin@gmail.com>
--
-- See license.txt for details
module FilesystemTests.Posix
	( suite_Posix
	) where

import           Prelude hiding (FilePath)
import           Control.Exception (bracket)
import           Control.Monad
import           Control.Monad.IO.Class (liftIO)
import qualified Data.ByteString
import           Data.ByteString (ByteString)
import qualified Data.ByteString.Char8 as Char8
import qualified Data.Text
import           Data.Text (Text)
import qualified Data.Text.IO
import           Data.Time.Clock (diffUTCTime, getCurrentTime)
import           Foreign
import           Foreign.C
import           Test.Chell

#if MIN_VERSION_base(4,2,0)
import qualified GHC.IO.Exception as GHC
#else
import qualified GHC.IOBase as GHC
#endif

import qualified System.Posix.IO as PosixIO

import           Filesystem
import           Filesystem.Path
import qualified Filesystem.Path.Rules as Rules
import qualified Filesystem.Path.CurrentOS as CurrentOS

import           FilesystemTests.Util (assertionsWithTemp, todo)

suite_Posix :: Suite
suite_Posix = suite "posix" $
	(concatMap suiteTests
		[ suite_IsFile
		, suite_IsDirectory
		, suite_Rename
		, suite_CanonicalizePath
		, suite_CreateDirectory
		, suite_CreateTree
		, suite_RemoveFile
		, suite_RemoveDirectory
		, suite_RemoveTree
		, suite_GetWorkingDirectory
		, suite_SetWorkingDirectory
		, suite_GetHomeDirectory
		, suite_GetDesktopDirectory
		, suite_GetModified
		, suite_GetSize
		, suite_CopyFile
		, suite_WithFile
		, suite_WithTextFile
		, suite_RegressionTests
		]) ++
	[ test_ListDirectory
	, todo "getDocumentsDirectory"
	, todo "getAppDataDirectory"
	, todo "getAppCacheDirectory"
	, todo "getAppConfigDirectory"
	, todo "openFile"
	, todo "readFile"
	, todo "writeFile"
	, todo "appendFile"
	, todo "openTextFile"
	, todo "readTextFile"
	, todo "writeTextFile"
	, todo "appendTextFile"
	]

suite_IsFile :: Suite
suite_IsFile = suite "isFile"
	[ test_IsFile "ascii" (decode "test.txt")
	, test_IsFile "utf8" (fromText "\xA1\xA2.txt")
	, test_IsFile "iso8859" (decode "\xA1\xA2\xA3.txt")
	, test_PipeIsFile "pipe.ascii" (decode "test.txt")
	, test_PipeIsFile "pipe.utf8" (fromText "\xA1\xA2.txt")
	, test_PipeIsFile "pipe.iso8859" (decode "\xA1\xA2\xA3.txt")
	]

suite_IsDirectory :: Suite
suite_IsDirectory = suite "isDirectory"
	[ test_IsDirectory "ascii" (decode "test.d")
	, test_IsDirectory "utf8" (fromText "\xA1\xA2.d")
	, test_IsDirectory "iso8859" (decode "\xA1\xA2\xA3.d")
	]

suite_Rename :: Suite
suite_Rename = suite "rename"
	[ test_Rename "ascii"
		(decode "old_test.txt")
		(decode "new_test.txt")
	, test_Rename "utf8"
		(fromText "old_\xA1\xA2.txt")
		(fromText "new_\xA1\xA2.txt")
	, test_Rename "iso8859"
		(decode "old_\xA1\xA2\xA3.txt")
		(decode "new_\xA1\xA2\xA3.txt")
	]

suite_CanonicalizePath :: Suite
suite_CanonicalizePath = suite "canonicalizePath"
	[ test_CanonicalizePath "ascii"
		(decode "test-a.txt")
		(decode "test-b.txt")
	, test_CanonicalizePath "utf8"
		(fromText "\xA1\xA2-a.txt")
		(fromText "\xA1\xA2-b.txt")
	, test_CanonicalizePath "iso8859"
		(decode "\xA1\xA2\xA3-a.txt")
#ifdef CABAL_OS_DARWIN
		(decode "%A1%A2%A3-b.txt")
#else
		(decode "\xA1\xA2\xA3-b.txt")
#endif
	, test_CanonicalizePath_TrailingSlash
	]

suite_CreateDirectory :: Suite
suite_CreateDirectory = suite "createDirectory"
	[ test_CreateDirectory "ascii"
		(decode "test.d")
	, test_CreateDirectory "utf8"
		(fromText "\xA1\xA2.d")
	, test_CreateDirectory "iso8859"
		(decode "\xA1\xA2\xA3.d")
	, test_CreateDirectory_FailExists
	, test_CreateDirectory_SucceedExists
	, test_CreateDirectory_FailFileExists
	]

suite_CreateTree :: Suite
suite_CreateTree = suite "createTree"
	[ test_CreateTree "ascii"
		(decode "test.d")
	, test_CreateTree "ascii-slash"
		(decode "test.d/")
	, test_CreateTree "utf8"
		(fromText "\xA1\xA2.d")
	, test_CreateTree "utf8-slash"
		(fromText "\xA1\xA2.d/")
	, test_CreateTree "iso8859"
		(decode "\xA1\xA2\xA3.d")
	, test_CreateTree "iso8859-slash"
		(decode "\xA1\xA2\xA3.d/")
	]

suite_RemoveFile :: Suite
suite_RemoveFile = suite "removeFile"
	[ test_RemoveFile "ascii"
		(decode "test.txt")
	, test_RemoveFile "utf8"
		(fromText "\xA1\xA2.txt")
	, test_RemoveFile "iso8859"
		(decode "\xA1\xA2\xA3.txt")
	]

suite_RemoveDirectory :: Suite
suite_RemoveDirectory = suite "removeDirectory"
	[ test_RemoveDirectory "ascii"
		(decode "test.d")
	, test_RemoveDirectory "utf8"
		(fromText "\xA1\xA2.d")
	, test_RemoveDirectory "iso8859"
		(decode "\xA1\xA2\xA3.d")
	]

suite_RemoveTree :: Suite
suite_RemoveTree = suite "removeTree"
	[ test_RemoveTree "ascii"
		(decode "test.d")
	, test_RemoveTree "utf8"
		(fromText "\xA1\xA2.d")
	, test_RemoveTree "iso8859"
		(decode "\xA1\xA2\xA3.d")
	]

suite_GetWorkingDirectory :: Suite
suite_GetWorkingDirectory = suite "getWorkingDirectory"
	[ test_GetWorkingDirectory "ascii"
		(decode "test.d")
	, test_GetWorkingDirectory "utf8"
		(fromText "\xA1\xA2.d")
	, test_GetWorkingDirectory "iso8859"
		(decode "\xA1\xA2\xA3.d")
	]

suite_SetWorkingDirectory :: Suite
suite_SetWorkingDirectory = suite "setWorkingDirectory"
	[ test_SetWorkingDirectory "ascii"
		(decode "test.d")
	, test_SetWorkingDirectory "utf8"
		(fromText "\xA1\xA2.d")
	, test_SetWorkingDirectory "iso8859"
		(decode "\xA1\xA2\xA3.d")
	]

suite_GetHomeDirectory :: Suite
suite_GetHomeDirectory = suite "getHomeDirectory"
	[ test_GetHomeDirectory "ascii"
		(decode "/home/test.d")
	, test_GetHomeDirectory "utf8"
		(decode "/home/\xA1\xA2.d")
	, test_GetHomeDirectory "iso8859"
		(decode "/home/\xA1\xA2\xA3.d")
	]

suite_GetDesktopDirectory :: Suite
suite_GetDesktopDirectory = suite "getDesktopDirectory"
	[ test_GetDesktopDirectory "ascii"
		(decode "/desktop/test.d")
	, test_GetDesktopDirectory "utf8"
		(decode "/desktop/\xA1\xA2.d")
	, test_GetDesktopDirectory "iso8859"
		(decode "/desktop/\xA1\xA2\xA3.d")
	]

suite_GetModified :: Suite
suite_GetModified = suite "getModified"
	[ test_GetModified "ascii"
		(decode "test.txt")
	, test_GetModified "utf8"
		(fromText "\xA1\xA2.txt")
	, test_GetModified "iso8859"
		(decode "\xA1\xA2\xA3.txt")
	]

suite_GetSize :: Suite
suite_GetSize = suite "getSize"
	[ test_GetSize "ascii"
		(decode "test.txt")
	, test_GetSize "utf8"
		(fromText "\xA1\xA2.txt")
	, test_GetSize "iso8859"
		(decode "\xA1\xA2\xA3.txt")
	]

suite_CopyFile :: Suite
suite_CopyFile = suite "copyFile"
	[ test_CopyFile "ascii"
		(decode "old_test.txt")
		(decode "new_test.txt")
	, test_CopyFile "utf8"
		(fromText "old_\xA1\xA2.txt")
		(fromText "new_\xA1\xA2.txt")
	, test_CopyFile "iso8859"
#ifdef CABAL_OS_DARWIN
		(decode "old_%A1%A2%A3.txt")
#else
		(decode "old_\xA1\xA2\xA3.txt")
#endif
#ifdef CABAL_OS_DARWIN
		(decode "new_%A1%A2%A3.txt")
#else
		(decode "new_\xA1\xA2\xA3.txt")
#endif
	]

suite_WithFile :: Suite
suite_WithFile = suite "withFile"
	[ test_WithFile_Read "read.ascii"
		(decode "test.txt")
	, test_WithFile_Read "read.utf8"
		(fromText "\xA1\xA2.txt")
	, test_WithFile_Read "read.iso8859"
#ifdef CABAL_OS_DARWIN
		(decode "%A1%A2%A3.txt")
#else
		(decode "\xA1\xA2\xA3.txt")
#endif
	, test_WithFile_Write "write.ascii"
		(decode "test.txt")
	, test_WithFile_Write "write.utf8"
		(fromText "\xA1\xA2.txt")
	, test_WithFile_Write "write.iso8859"
		(decode "\xA1\xA2\xA3.txt")
	]

suite_WithTextFile :: Suite
suite_WithTextFile = suite "withTextFile"
	[ test_WithTextFile "ascii"
		(decode "test.txt")
	, test_WithTextFile "utf8"
		(fromText "\xA1\xA2.txt")
	, test_WithTextFile "iso8859"
#ifdef CABAL_OS_DARWIN
		(decode "%A1%A2%A3.txt")
#else
		(decode "\xA1\xA2\xA3.txt")
#endif
	]

suite_RegressionTests :: Suite
suite_RegressionTests = suite "regression-tests"
	[ test_ListDirectoryLeaksFds
	]

test_IsFile :: String -> FilePath -> Test
test_IsFile test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let path = tmp </> file_name
	
	before <- liftIO $ Filesystem.isFile path
	$expect (not before)
	
	touch_ffi path "contents\n"
	
	after <- liftIO $ Filesystem.isFile path
	$expect after

test_PipeIsFile :: String -> FilePath -> Test
test_PipeIsFile test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let path = tmp </> file_name
	
	before <- liftIO $ Filesystem.isFile path
	$expect (not before)
	
	mkfifo_ffi path
	
	after <- liftIO $ Filesystem.isFile path
	$expect after

test_IsDirectory :: String -> FilePath -> Test
test_IsDirectory test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	let path = tmp </> dir_name
	
	before <- liftIO $ Filesystem.isDirectory path
	$expect (not before)
	
	mkdir_ffi path
	
	after <- liftIO $ Filesystem.isDirectory path
	$expect after

test_Rename :: String -> FilePath -> FilePath -> Test
test_Rename test_name old_name new_name = assertionsWithTemp test_name $ \tmp -> do
	let old_path = tmp </> old_name
	let new_path = tmp </> new_name
	
	touch_ffi old_path ""
	
	old_before <- liftIO $ Filesystem.isFile old_path
	new_before <- liftIO $ Filesystem.isFile new_path
	$expect old_before
	$expect (not new_before)
	
	liftIO $ Filesystem.rename old_path new_path
	
	old_after <- liftIO $ Filesystem.isFile old_path
	new_after <- liftIO $ Filesystem.isFile new_path
	$expect (not old_after)
	$expect new_after

test_CopyFile :: String -> FilePath -> FilePath -> Test
test_CopyFile test_name old_name new_name = assertionsWithTemp test_name $ \tmp -> do
	let old_path = tmp </> old_name
	let new_path = tmp </> new_name
	
	touch_ffi old_path ""
	
	old_before <- liftIO $ Filesystem.isFile old_path
	new_before <- liftIO $ Filesystem.isFile new_path
	$expect old_before
	$expect (not new_before)
	
	liftIO $ Filesystem.copyFile old_path new_path
	
	old_after <- liftIO $ Filesystem.isFile old_path
	new_after <- liftIO $ Filesystem.isFile new_path
	$expect old_after
	$expect new_after
	old_contents <- liftIO $
		Filesystem.withTextFile old_path ReadMode $
		Data.Text.IO.hGetContents
	new_contents <- liftIO $
		Filesystem.withTextFile new_path ReadMode $
		Data.Text.IO.hGetContents
	$expect (equalLines old_contents new_contents)

test_CanonicalizePath :: String -> FilePath -> FilePath -> Test
test_CanonicalizePath test_name src_name dst_name = assertionsWithTemp test_name $ \tmp -> do
	let src_path = tmp </> src_name
	let subdir = tmp </> "subdir"
	
	-- canonicalize the directory first, to avoid false negatives if
	-- it gets placed in a symlinked location.
	mkdir_ffi subdir
	canon_subdir <- liftIO (Filesystem.canonicalizePath subdir)
	
	let dst_path = canon_subdir </> dst_name
	
	touch_ffi dst_path ""
	symlink_ffi dst_path src_path
	
	canonicalized <- liftIO $ Filesystem.canonicalizePath src_path
	$expect $ equal canonicalized dst_path

test_CanonicalizePath_TrailingSlash :: Test
test_CanonicalizePath_TrailingSlash = assertionsWithTemp "trailing-slash" $ \tmp -> do
	let src_path = tmp </> "src"
	let subdir = tmp </> "subdir"
	
	-- canonicalize the directory first, to avoid false negatives if
	-- it gets placed in a symlinked location.
	mkdir_ffi subdir
	canon_subdir <- liftIO (Filesystem.canonicalizePath (tmp </> "subdir"))
	
	let dst_path = canon_subdir </> "dst"
	
	mkdir_ffi dst_path
	symlink_ffi dst_path src_path
	
	canonicalized <- liftIO (Filesystem.canonicalizePath (src_path </> empty))
	$expect (equal canonicalized (dst_path </> empty))

test_CreateDirectory :: String -> FilePath -> Test
test_CreateDirectory test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	let dir_path = tmp </> dir_name
	
	exists_before <- liftIO $ Filesystem.isDirectory dir_path
	$assert (not exists_before)
	
	liftIO $ Filesystem.createDirectory False dir_path
	exists_after <- liftIO $ Filesystem.isDirectory dir_path
	
	$expect exists_after

test_CreateDirectory_FailExists :: Test
test_CreateDirectory_FailExists = assertionsWithTemp "fail-if-exists" $ \tmp -> do
	let dir_path = tmp </> "subdir"
	mkdir_ffi dir_path
	
	$expect $ throwsEq
		(mkAlreadyExists "createDirectory" dir_path)
		(Filesystem.createDirectory False dir_path)

test_CreateDirectory_SucceedExists :: Test
test_CreateDirectory_SucceedExists = assertionsWithTemp "succeed-if-exists" $ \tmp -> do
	let dir_path = tmp </> "subdir"
	mkdir_ffi dir_path
	
	liftIO $ Filesystem.createDirectory True dir_path

test_CreateDirectory_FailFileExists :: Test
test_CreateDirectory_FailFileExists = assertionsWithTemp "fail-if-file-exists" $ \tmp -> do
	let dir_path = tmp </> "subdir"
	touch_ffi dir_path ""
	
	$expect $ throwsEq
		(mkAlreadyExists "createDirectory" dir_path)
		(Filesystem.createDirectory False dir_path)
	$expect $ throwsEq
		(mkAlreadyExists "createDirectory" dir_path)
		(Filesystem.createDirectory True dir_path)

mkAlreadyExists :: String -> FilePath -> GHC.IOError
mkAlreadyExists loc path = GHC.IOError Nothing GHC.AlreadyExists loc "File exists"
#if MIN_VERSION_base(4,2,0)
	(Just (errnoCInt eEXIST))
#endif
	(Just (CurrentOS.encodeString path))

test_CreateTree :: String -> FilePath -> Test
test_CreateTree test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	let dir_path = tmp </> dir_name
	let subdir = dir_path </> "subdir"
	
	dir_exists_before <- liftIO $ Filesystem.isDirectory dir_path
	subdir_exists_before <- liftIO $ Filesystem.isDirectory subdir
	$assert (not dir_exists_before)
	$assert (not subdir_exists_before)
	
	liftIO $ Filesystem.createTree subdir
	dir_exists_after <- liftIO $ Filesystem.isDirectory dir_path
	subdir_exists_after <- liftIO $ Filesystem.isDirectory subdir
	
	$expect dir_exists_after
	$expect subdir_exists_after

test_ListDirectory :: Test
test_ListDirectory = assertionsWithTemp "listDirectory" $ \tmp -> do
	-- OSX replaces non-UTF8 filenames with http-style %XX escapes
	let paths =
#ifdef CABAL_OS_DARWIN
		[ tmp </> decode "%A1%A2%A3.txt"
		, tmp </> decode "test.txt"
		, tmp </> fromText "\xA1\xA2.txt"
		]
#else
		[ tmp </> decode "test.txt"
		, tmp </> fromText "\xA1\xA2.txt"
		, tmp </> decode "\xA1\xA2\xA3.txt"
		]
#endif
	forM_ paths (\path -> touch_ffi path "")
	
	names <- liftIO $ Filesystem.listDirectory tmp
	$expect $ sameItems paths names

test_RemoveFile :: String -> FilePath -> Test
test_RemoveFile test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	
	touch_ffi file_path "contents\n"
	
	before <- liftIO $ Filesystem.isFile file_path
	$assert before
	
	liftIO $ Filesystem.removeFile file_path
	
	after <- liftIO $ Filesystem.isFile file_path
	$expect (not after)

test_RemoveDirectory :: String -> FilePath -> Test
test_RemoveDirectory test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	let dir_path = tmp </> dir_name
	
	mkdir_ffi dir_path
	
	before <- liftIO $ Filesystem.isDirectory dir_path
	$assert before
	
	liftIO $ Filesystem.removeDirectory dir_path
	
	after <- liftIO $ Filesystem.isDirectory dir_path
	$expect (not after)

test_RemoveTree :: String -> FilePath -> Test
test_RemoveTree test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	let dir_path = tmp </> dir_name
	let subdir = dir_path </> "subdir"
	
	mkdir_ffi dir_path
	mkdir_ffi subdir
	
	dir_before <- liftIO $ Filesystem.isDirectory dir_path
	subdir_before <- liftIO $ Filesystem.isDirectory subdir
	$assert dir_before
	$assert subdir_before
	
	liftIO $ Filesystem.removeTree dir_path
	
	dir_after <- liftIO $ Filesystem.isDirectory dir_path
	subdir_after <- liftIO $ Filesystem.isDirectory subdir
	$expect (not dir_after)
	$expect (not subdir_after)

test_GetWorkingDirectory :: String -> FilePath -> Test
test_GetWorkingDirectory test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	-- canonicalize to avoid issues with symlinked temp dirs
	canon_tmp <- liftIO (Filesystem.canonicalizePath tmp)
	let dir_path = canon_tmp </> dir_name
	
	mkdir_ffi dir_path
	chdir_ffi dir_path
	
	cwd <- liftIO $ Filesystem.getWorkingDirectory
	$expect (equal cwd dir_path)

test_SetWorkingDirectory :: String -> FilePath -> Test
test_SetWorkingDirectory test_name dir_name = assertionsWithTemp test_name $ \tmp -> do
	-- canonicalize to avoid issues with symlinked temp dirs
	canon_tmp <- liftIO (Filesystem.canonicalizePath tmp)
	let dir_path = canon_tmp </> dir_name
	
	mkdir_ffi dir_path
	liftIO $ Filesystem.setWorkingDirectory dir_path
	
	cwd <- getcwd_ffi
	$expect (equal cwd dir_path)

test_GetHomeDirectory :: String -> FilePath -> Test
test_GetHomeDirectory test_name dir_name = assertions test_name $ do
	path <- liftIO $ withEnv "HOME" (Just dir_name) Filesystem.getHomeDirectory
	$expect (equal path dir_name)

test_GetDesktopDirectory :: String -> FilePath -> Test
test_GetDesktopDirectory test_name dir_name = assertions test_name $ do
	path <- liftIO $
		withEnv "XDG_DESKTOP_DIR" (Just dir_name) $
		Filesystem.getDesktopDirectory
	$expect (equal path dir_name)
	
	fallback <- liftIO $
		withEnv "XDG_DESKTOP_DIR" Nothing $
		withEnv "HOME" (Just dir_name) $
		Filesystem.getDesktopDirectory
	$expect (equal fallback (dir_name </> "Desktop"))

test_GetModified :: String -> FilePath -> Test
test_GetModified test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	
	touch_ffi file_path ""
	now <- liftIO getCurrentTime
	
	mtime <- liftIO $ Filesystem.getModified file_path
	$expect (equalWithin (diffUTCTime mtime now) 0 2)

test_GetSize :: String -> FilePath -> Test
test_GetSize test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	let contents = "contents\n"
	
	touch_ffi file_path contents
	
	size <- liftIO $ Filesystem.getSize file_path
	$expect (equal size (toInteger (Data.ByteString.length contents)))

test_WithFile_Read :: String -> FilePath -> Test
test_WithFile_Read test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	let contents = "contents\n"
	
	touch_ffi file_path contents
	
	read_contents <- liftIO $
		Filesystem.withFile file_path ReadMode $
		Data.ByteString.hGetContents
	$expect (equalLines contents read_contents)

test_WithFile_Write :: String -> FilePath -> Test
test_WithFile_Write test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	let contents = "contents\n"
	
	liftIO $
		Filesystem.withFile file_path WriteMode $
		(\h -> Data.ByteString.hPut h contents)
	
	read_contents <- liftIO $
		Filesystem.withFile file_path ReadMode $
		Data.ByteString.hGetContents
	$expect (equalLines contents read_contents)

test_WithTextFile :: String -> FilePath -> Test
test_WithTextFile test_name file_name = assertionsWithTemp test_name $ \tmp -> do
	let file_path = tmp </> file_name
	let contents = "contents\n"
	
	touch_ffi file_path (Char8.pack contents)
	
	read_contents <- liftIO $
		Filesystem.withTextFile file_path ReadMode $
		Data.Text.IO.hGetContents
	$expect (equalLines (Data.Text.pack contents) read_contents)

test_ListDirectoryLeaksFds :: Test
test_ListDirectoryLeaksFds = assertionsWithTemp "listDirectory-leaks-fds" $ \tmp -> do
	-- Test that listDirectory doesn't leak file descriptors.
	let dir_path = tmp </> "subdir"
	mkdir_ffi dir_path
	
	nullfd1 <- liftIO $ PosixIO.openFd "/dev/null" PosixIO.ReadOnly Nothing PosixIO.defaultFileFlags
	liftIO $ PosixIO.closeFd nullfd1
	
	subdirContents <- liftIO $ listDirectory dir_path
	
	nullfd2 <- liftIO $ PosixIO.openFd "/dev/null" PosixIO.ReadOnly Nothing PosixIO.defaultFileFlags
	liftIO $ PosixIO.closeFd nullfd2
	
	$assert (equal nullfd1 nullfd2)

withPathCString :: FilePath -> (CString -> IO a) -> IO a
withPathCString p = Data.ByteString.useAsCString (encode p)

decode :: ByteString -> FilePath
decode = Rules.decode Rules.posix

encode :: FilePath -> ByteString
encode = Rules.encode Rules.posix

fromText :: Text -> FilePath
fromText = Rules.fromText Rules.posix

-- | Create a file using the raw POSIX API, via FFI
touch_ffi :: FilePath -> Data.ByteString.ByteString -> Assertions ()
touch_ffi path contents = do
	fp <- liftIO $ withPathCString path $ \path_cstr ->
		Foreign.C.withCString "wb" $ \mode_cstr ->
		c_fopen path_cstr mode_cstr
	
	$assert (fp /= nullPtr)
	
	_ <- liftIO $ Data.ByteString.useAsCStringLen contents $ \(buf, len) ->
		c_fwrite buf 1 (fromIntegral len) fp
	
	_ <- liftIO $ c_fclose fp
	return ()

-- | Create a directory using the raw POSIX API, via FFI
mkdir_ffi :: FilePath -> Assertions ()
mkdir_ffi path = do
	ret <- liftIO $ withPathCString path $ \path_cstr ->
		c_mkdir path_cstr 0o700
	
	$assert (ret == 0)

-- | Create a symlink using the raw POSIX API, via FFI
symlink_ffi :: FilePath -> FilePath -> Assertions ()
symlink_ffi dst src  = do
	ret <- liftIO $
		withPathCString dst $ \dst_p ->
		withPathCString src $ \src_p ->
		c_symlink dst_p src_p
	
	$assert (ret == 0)

-- | Create a FIFO using the raw POSIX API, via FFI
mkfifo_ffi :: FilePath -> Assertions ()
mkfifo_ffi path = do
	ret <- liftIO $ withPathCString path $ \path_cstr ->
		c_mkfifo path_cstr 0o700
	
	$assert (ret == 0)

getcwd_ffi :: Assertions FilePath
getcwd_ffi = do
	buf <- liftIO $ c_getcwd nullPtr 0
	$assert (buf /= nullPtr)
	bytes <- liftIO $ Data.ByteString.packCString buf
	liftIO $ c_free buf
	return (decode bytes)

chdir_ffi :: FilePath -> Assertions ()
chdir_ffi path = do
	ret <- liftIO $
		withPathCString path $ \path_p ->
		c_chdir path_p
	$assert (ret == 0)

errnoCInt :: Errno -> CInt
errnoCInt (Errno x) = x

withEnv :: ByteString -> Maybe FilePath -> IO a -> IO a
withEnv name val io = bracket set unset (\_ -> io) where
	set = do
		old <- getEnv name
		setEnv name (fmap encode val)
		return old
	unset = setEnv name

getEnv :: ByteString -> IO (Maybe ByteString)
getEnv name = Data.ByteString.useAsCString name $ \cName -> do
	ret <- liftIO (c_getenv cName)
	if ret == nullPtr
		then return Nothing
		else fmap Just (Data.ByteString.packCString ret)

setEnv :: ByteString -> Maybe ByteString -> IO ()
setEnv name Nothing = throwErrnoIfMinus1_ "setEnv" $
	Data.ByteString.useAsCString name c_unsetenv
setEnv name (Just val) = throwErrnoIfMinus1_ "setEnv" $
	Data.ByteString.useAsCString name $ \cName ->
	Data.ByteString.useAsCString val $ \cVal ->
	c_setenv cName cVal 1

foreign import ccall unsafe "fopen"
	c_fopen :: CString -> CString -> IO (Ptr ())

foreign import ccall unsafe "fclose"
	c_fclose :: Ptr () -> IO CInt

foreign import ccall unsafe "fwrite"
	c_fwrite :: CString -> CSize -> CSize -> Ptr () -> IO CSize

foreign import ccall unsafe "mkdir"
	c_mkdir :: CString -> CInt -> IO CInt

foreign import ccall unsafe "symlink"
	c_symlink :: CString -> CString -> IO CInt

foreign import ccall unsafe "mkfifo"
	c_mkfifo :: CString -> CInt -> IO CInt

foreign import ccall unsafe "getcwd"
	c_getcwd :: CString -> CSize -> IO CString

foreign import ccall unsafe "chdir"
	c_chdir :: CString -> IO CInt

foreign import ccall unsafe "free"
	c_free :: Ptr a -> IO ()

foreign import ccall unsafe "getenv"
	c_getenv :: CString -> IO CString

foreign import ccall unsafe "setenv"
	c_setenv :: CString -> CString -> CInt -> IO CInt

foreign import ccall unsafe "unsetenv"
	c_unsetenv :: CString -> IO CInt
