diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,62 @@ +System.FilePath [![Build Status](https://travis-ci.org/ghc/packages-filepath.png?branch=master)](https://travis-ci.org/ghc/packages-filepath) +=============== + +I have written a `System.FilePath` module in part based on the one in +Yhc, and in part based on the one in Cabal (thanks to Lemmih). The aim +is to try and get this module into the base package, as `FilePath`s +are something many programs use, but its all too easy to hack up a +little function that gets it right most of the time on most platforms, +and there lies a source of bugs. + +This module is Posix (Linux) and Windows capable - just import +`System.FilePath` and it will pick the right one. Of course, if you +demand Windows paths on all OSes, then `System.FilePath.Windows` will +give you that (same with Posix). Written in Haskell 98 with +Hierarchical Modules. + +If you go to the +[Haddock](http://hackage.haskell.org/package/filepath/docs/System-FilePath.html) +page, there are a few little examples at the top of the re-exported module. + + +Acknowledgments +--------------- + +Thanks to Marc Webber, shapr, David House, Lemmih, others... + + +Competitors +----------- + +`System.FilePath` from Cabal, by Lemmih `FilePath.hs` and +`NameManip.hs` from MissingH + +The one from Cabal and `FilePath.hs` in MissingH are both very +similar, I stole lots of good ideas from those two. + +`NameManip.hs` seems to be more unix specific, but all functions in +that module have equivalents in this new `System.FilePath` module. + +Hopefully this new module can be used without noticing any lost +functions, and certainly adds new features/functions to the table. + + +Should `FilePath` be an abstract data type? +------------------------------------------- + +The answer for this library is no. This is a deliberate design decision. + +In Haskell 98 the definition is `type FilePath = String`, and all +functions operating on `FilePath`s, i.e. `readFile`/`writeFile` etc +take `FilePath`s. The only way to introduce an abstract type is to +provide wrappers for these functions or casts between `String`s and +`FilePathAbstract`s. + +There are also additional questions as to what constitutes a +`FilePath`, and what is just a pure `String`. For example, +"/path/file.ext" is a `FilePath`. Is "/" ? "/path" ? "path" ? +"file.ext" ? ".ext" ? "file" ? + +With that being accepted, it should be trivial to write +`System.FilePath.ByteString` which has the same interface as +`System.FilePath` yet operates on `ByteString`s. diff --git a/System/FilePath.hs b/System/FilePath.hs --- a/System/FilePath.hs +++ b/System/FilePath.hs @@ -1,11 +1,11 @@ {-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 701 +#if __GLASGOW_HASKELL__ >= 704 {-# LANGUAGE Safe #-} #endif {- | Module : System.FilePath Copyright : (c) Neil Mitchell 2005-2007 -License : BSD-style (see the file libraries/base/LICENSE) +License : BSD3 Maintainer : libraries@haskell.org Stability : stable diff --git a/System/FilePath/Internal.hs b/System/FilePath/Internal.hs --- a/System/FilePath/Internal.hs +++ b/System/FilePath/Internal.hs @@ -1,8 +1,23 @@ -{-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 701 +#if __GLASGOW_HASKELL__ >= 704 {-# LANGUAGE Safe #-} #endif + +-- This template expects CPP definitions for: +-- MODULE_NAME = Posix | Windows +-- IS_WINDOWS = False | True + +-- | +-- Module : System.FilePath.MODULE_NAME +-- Copyright : (c) Neil Mitchell 2005-2007 +-- License : BSD3 -- +-- Maintainer : libraries@haskell.org +-- Stability : stable +-- Portability : portable +-- +-- A library for FilePath manipulations, using MODULE_NAME style paths on +-- all platforms. Importing "System.FilePath" is usually better. +-- -- Some short examples: -- -- You are given a C file, you want to figure out the corresponding object (.o) file: @@ -26,10 +41,6 @@ -- tests, and should give clear semantics for the functions. ----------------------------------------------------------------------------- --- expects CPP definitions for: --- MODULE_NAME = Posix | Windows --- IS_WINDOWS = False | True - module System.FilePath.MODULE_NAME ( -- * Separator predicates @@ -76,7 +87,7 @@ ) where -import Data.Char(toLower, toUpper) +import Data.Char(toLower, toUpper, isAsciiLower, isAsciiUpper) import Data.Maybe(isJust, fromJust) import Data.List(isPrefixOf) @@ -293,7 +304,7 @@ -- | Is the given character a valid drive letter? -- only a-z and A-Z are letters, not isAlpha which is more unicodey isLetter :: Char -> Bool -isLetter x = (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z') +isLetter x = isAsciiLower x || isAsciiUpper x -- | Split a path into a drive and a path. @@ -525,9 +536,7 @@ -- > Windows: takeDirectory "foo\\bar\\\\" == "foo\\bar" -- > Windows: takeDirectory "C:\\" == "C:\\" takeDirectory :: FilePath -> FilePath -takeDirectory x = if isDrive file then file - else if null res && not (null file) then file - else res +takeDirectory x = if isDrive file || (null res && not (null file)) then file else res where res = reverse $ dropWhile isPathSeparator $ reverse file file = dropFileName x @@ -582,7 +591,7 @@ f y = (a++c) : f d where (a,b) = break isPathSeparator y - (c,d) = break (not . isPathSeparator) b + (c,d) = span isPathSeparator b -- | Just as 'splitPath', but don't add the trailing slashes to each element. -- @@ -597,7 +606,7 @@ where pathComponents = splitPath path - f xs = map g xs + f = map g g x = if null res then x else res where res = takeWhile (not . isPathSeparator) x @@ -610,7 +619,7 @@ -- Note that this definition on c:\\c:\\, join then split will give c:\\. joinPath :: [FilePath] -> FilePath -joinPath x = foldr combine "" x +joinPath = foldr combine "" @@ -788,7 +797,7 @@ where (drv,pth) = splitDrive path - validChars x = map f x + validChars = map f f x | x `elem` badCharacters = '_' | otherwise = x diff --git a/System/FilePath/Posix.hs b/System/FilePath/Posix.hs --- a/System/FilePath/Posix.hs +++ b/System/FilePath/Posix.hs @@ -1,27 +1,4 @@ {-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 701 -{-# LANGUAGE Safe #-} -#endif #define MODULE_NAME Posix #define IS_WINDOWS False - ------------------------------------------------------------------------------ --- | --- Module : System.FilePath.Posix --- Copyright : (c) Neil Mitchell 2005-2007 --- License : BSD-style (see the file libraries/base/LICENSE) --- --- Maintainer : libraries@haskell.org --- Stability : stable --- Portability : portable --- --- A library for FilePath manipulations, using Posix style paths on --- all platforms. Importing "System.FilePath" is usually better. - --- Unfortunately, this #include breaks when haddocking with Cabal -#ifdef __HADDOCK__ -module System.FilePath.Posix where -#else #include "Internal.hs" -#endif - diff --git a/System/FilePath/Windows.hs b/System/FilePath/Windows.hs --- a/System/FilePath/Windows.hs +++ b/System/FilePath/Windows.hs @@ -1,26 +1,4 @@ {-# LANGUAGE CPP #-} -#if __GLASGOW_HASKELL__ >= 701 -{-# LANGUAGE Safe #-} -#endif #define MODULE_NAME Windows #define IS_WINDOWS True - ------------------------------------------------------------------------------ --- | --- Module : System.FilePath.Windows --- Copyright : (c) Neil Mitchell 2005-2007 --- License : BSD-style (see the file libraries/base/LICENSE) --- --- Maintainer : libraries@haskell.org --- Stability : stable --- Portability : portable --- --- A library for FilePath manipulations, using Windows style paths on --- all platforms. Importing "System.FilePath" is usually better. - --- Unfortunately, this #include breaks when haddocking with Cabal -#ifdef __HADDOCK__ -module System.FilePath.Windows where -#else #include "Internal.hs" -#endif diff --git a/changelog.md b/changelog.md new file mode 100644 --- /dev/null +++ b/changelog.md @@ -0,0 +1,23 @@ +# Changelog for [`filepath` package](http://hackage.haskell.org/package/filepath) + +## 1.3.0.2 *Mar 2014* + + * Bundled with GHC 7.8.1 + + * Update to Cabal 1.10 format + + * Minor Haddock cleanups + +## 1.3.0.1 *Sep 2012* + + * Bundled with GHC 7.6.1 + + * No changes + +## 1.3.0.0 *Feb 2012* + + * Bundled with GHC 7.4.1 + + * Add support for SafeHaskell + + * Fix `normalise "/"` to result in `"/"` rather than `"/."` diff --git a/filepath.cabal b/filepath.cabal --- a/filepath.cabal +++ b/filepath.cabal @@ -1,25 +1,68 @@ Name: filepath -Version: 1.3.0.1 +Version: 1.3.0.2 +-- GHC 7.6.1 released with 1.3.0.1 License: BSD3 license-file: LICENSE Author: Neil Mitchell -bug-reports: http://hackage.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29 +Maintainer: libraries@haskell.org +bug-reports: http://ghc.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29&keywords=filepath Homepage: http://www-users.cs.york.ac.uk/~ndm/filepath/ Category: System build-type: Simple Synopsis: Library for manipulating FilePaths in a cross platform way. -cabal-version: >=1.6 -Extra-Source-Files: System/FilePath/Internal.hs +cabal-version: >=1.10 +tested-with: GHC==7.6.3, GHC==7.6.2, GHC==7.6.1, GHC==7.4.2, GHC==7.4.1, GHC==7.2.2, GHC==7.2.1, GHC==7.0.4, GHC==7.0.3, GHC==7.0.2, GHC==7.0.1, GHC==6.12.3 +description: + A library for 'FilePath' manipulations, using Posix or Windows filepaths + depending on the platform. + . + Both "System.FilePath.Posix" and "System.FilePath.Windows" provide + the same interface. See either for examples and a list of the + available functions. +Extra-Source-Files: + System/FilePath/Internal.hs + README.md + changelog.md + Library + default-language: Haskell98 + other-extensions: + CPP + if impl(GHC>=7.2) + other-extensions: Safe + Exposed-modules: System.FilePath System.FilePath.Posix System.FilePath.Windows - Extensions: CPP - Build-Depends: base >= 2 && < 5 + Build-Depends: + base >= 4 && < 4.8 + + ghc-options: -Wall + +-- When run directly from the Git repo, you need to +-- generate the tests/FilePath_Tests.hs file via +-- +-- cd tests/ && runghc ./GenTests.hs +Test-Suite filepath-tests + type: exitcode-stdio-1.0 + default-language: Haskell98 + main-is: FilePath_Test.hs + hs-source-dirs: tests + other-modules: AutoTest + build-depends: + filepath, + base, + QuickCheck == 2.6.*, + random == 1.0.* + source-repository head type: git - location: http://darcs.haskell.org/packages/filepath.git/ + location: http://git.haskell.org/packages/filepath.git +source-repository this + type: git + location: http://git.haskell.org/packages/filepath.git + tag: filepath-1.3.0.2-release diff --git a/tests/AutoTest.hs b/tests/AutoTest.hs new file mode 100644 --- /dev/null +++ b/tests/AutoTest.hs @@ -0,0 +1,106 @@ + +module AutoTest( + module AutoTest, + module Test.QuickCheck, + module Data.List + ) where + +import Test.QuickCheck hiding ((==>)) +import Data.Char +import System.Random +import Data.List +import Control.Monad + +infixr 0 ==> +a ==> b = not a || b + + +constTest :: Bool -> IO () +constTest True = return () +constTest False = error "Failed on constTest" + + + +data QFilePath = QFilePath FilePath + deriving Show + +instance Arbitrary QFilePath where + arbitrary = liftM QFilePath arbitrary + + +-- QuickCheck 2.4.1.1 has its own Arbitrary Char instance, so commented out for now +-- instance Arbitrary Char where +-- arbitrary = elements "?|./:\\abcd 123;_" + + + +quickSafe :: Testable a => a -> IO () +quickSafe prop = quickCheckWith (stdArgs { chatty = False }) prop + -- checkit quick prop + +-- below is mainly stolen from Test.QuickCheck, modified to crash out on failure +-- Doesn't compile with QuickCheck 2.4.1.1, so we just use the quickCheck function for now + +{- +quick :: Config +quick = Config + { configMaxTest = 500 + , configMaxFail = 1000 + , configSize = (+ 3) . (`div` 2) + , configEvery = \n args -> let s = show n in s ++ [ '\b' | _ <- s ] + } + +checkit :: Testable a => Config -> a -> IO () +checkit config a = + do rnd <- newStdGen + tests config (evaluate a) rnd 0 0 [] + + +tests :: Config -> Gen Result -> StdGen -> Int -> Int -> [[String]] -> IO () +tests config gen rnd0 ntest nfail stamps + | ntest == configMaxTest config = do done "OK, passed" ntest stamps + | nfail == configMaxFail config = do done "Arguments exhausted after" ntest stamps + error "More entropy required!" + | otherwise = + do putStr (configEvery config ntest (arguments result)) + case ok result of + Nothing -> + tests config gen rnd1 ntest (nfail+1) stamps + Just True -> + tests config gen rnd1 (ntest+1) nfail (stamp result:stamps) + Just False -> + error ( "Falsifiable, after " + ++ show ntest + ++ " tests:\n" + ++ unlines (arguments result) + ) + where + result = generate (configSize config ntest) rnd2 gen + (rnd1,rnd2) = split rnd0 + +done :: String -> Int -> [[String]] -> IO () +done mesg ntest stamps = + do putStr ( mesg ++ " " ++ show ntest ++ " tests" ++ table ) + where + table = display + . map entry + . reverse + . sort + . map pairLength + . group + . sort + . filter (not . null) + $ stamps + + display [] = ".\n" + display [x] = " (" ++ x ++ ").\n" + display xs = ".\n" ++ unlines (map (++ ".") xs) + + pairLength xss@(xs:_) = (length xss, xs) + entry (n, xs) = percentage n ntest + ++ " " + ++ concat (intersperse ", " xs) + + percentage n m = show ((100 * n) `div` m) ++ "%" +-} + diff --git a/tests/FilePath_Test.hs b/tests/FilePath_Test.hs new file mode 100644 --- /dev/null +++ b/tests/FilePath_Test.hs @@ -0,0 +1,602 @@ +import AutoTest +import qualified System.FilePath.Windows as W +import qualified System.FilePath.Posix as P +main = do + block1 + block2 + block3 + block4 + block5 + block6 + block7 + block8 + block9 + block10 + block11 + block12 +block1 = do + putStrLn "Test 1, from line 122" + constTest (W.pathSeparator == '\\') + putStrLn "Test 2, from line 123" + constTest (P.pathSeparator == '/') + putStrLn "Test 3, from line 124" + constTest (W.isPathSeparator W.pathSeparator) + putStrLn "Test 4, from line 124" + constTest (P.isPathSeparator P.pathSeparator) + putStrLn "Test 5, from line 130" + constTest (W.pathSeparators == [ '\\' , '/' ]) + putStrLn "Test 6, from line 131" + constTest (P.pathSeparators == [ '/' ]) + putStrLn "Test 7, from line 132" + constTest (W.pathSeparator ` elem ` W.pathSeparators) + putStrLn "Test 8, from line 132" + constTest (P.pathSeparator ` elem ` P.pathSeparators) + putStrLn "Test 9, from line 146" + constTest (W.searchPathSeparator == ';') + putStrLn "Test 10, from line 147" + constTest (P.searchPathSeparator == ':') + putStrLn "Test 11, from line 160" + constTest (W.extSeparator == '.') + putStrLn "Test 12, from line 160" + constTest (P.extSeparator == '.') + putStrLn "Test 13, from line 181" + constTest (P.splitSearchPath "File1:File2:File3" == [ "File1" , "File2" , "File3" ]) + putStrLn "Test 14, from line 182" + constTest (P.splitSearchPath "File1::File2:File3" == [ "File1" , "." , "File2" , "File3" ]) + putStrLn "Test 15, from line 183" + constTest (W.splitSearchPath "File1;File2;File3" == [ "File1" , "File2" , "File3" ]) + putStrLn "Test 16, from line 184" + constTest (W.splitSearchPath "File1;;File2;File3" == [ "File1" , "File2" , "File3" ]) + putStrLn "Test 17, from line 208" + constTest (W.splitExtension "file.txt" == ( "file" , ".txt" )) + putStrLn "Test 18, from line 208" + constTest (P.splitExtension "file.txt" == ( "file" , ".txt" )) + putStrLn "Test 19, from line 209" + constTest (W.splitExtension "file" == ( "file" , "" )) + putStrLn "Test 20, from line 209" + constTest (P.splitExtension "file" == ( "file" , "" )) + putStrLn "Test 21, from line 210" + constTest (W.splitExtension "file/file.txt" == ( "file/file" , ".txt" )) + putStrLn "Test 22, from line 210" + constTest (P.splitExtension "file/file.txt" == ( "file/file" , ".txt" )) + putStrLn "Test 23, from line 211" + constTest (W.splitExtension "file.txt/boris" == ( "file.txt/boris" , "" )) + putStrLn "Test 24, from line 211" + constTest (P.splitExtension "file.txt/boris" == ( "file.txt/boris" , "" )) + putStrLn "Test 25, from line 212" + constTest (W.splitExtension "file.txt/boris.ext" == ( "file.txt/boris" , ".ext" )) +block2 = do + putStrLn "Test 26, from line 212" + constTest (P.splitExtension "file.txt/boris.ext" == ( "file.txt/boris" , ".ext" )) + putStrLn "Test 27, from line 213" + constTest (W.splitExtension "file/path.txt.bob.fred" == ( "file/path.txt.bob" , ".fred" )) + putStrLn "Test 28, from line 213" + constTest (P.splitExtension "file/path.txt.bob.fred" == ( "file/path.txt.bob" , ".fred" )) + putStrLn "Test 29, from line 214" + constTest (W.splitExtension "file/path.txt/" == ( "file/path.txt/" , "" )) + putStrLn "Test 30, from line 214" + constTest (P.splitExtension "file/path.txt/" == ( "file/path.txt/" , "" )) + putStrLn "Test 31, from line 233" + constTest (W.replaceExtension "file.txt" ".bob" == "file.bob") + putStrLn "Test 32, from line 233" + constTest (P.replaceExtension "file.txt" ".bob" == "file.bob") + putStrLn "Test 33, from line 234" + constTest (W.replaceExtension "file.txt" "bob" == "file.bob") + putStrLn "Test 34, from line 234" + constTest (P.replaceExtension "file.txt" "bob" == "file.bob") + putStrLn "Test 35, from line 235" + constTest (W.replaceExtension "file" ".bob" == "file.bob") + putStrLn "Test 36, from line 235" + constTest (P.replaceExtension "file" ".bob" == "file.bob") + putStrLn "Test 37, from line 236" + constTest (W.replaceExtension "file.txt" "" == "file") + putStrLn "Test 38, from line 236" + constTest (P.replaceExtension "file.txt" "" == "file") + putStrLn "Test 39, from line 237" + constTest (W.replaceExtension "file.fred.bob" "txt" == "file.fred.txt") + putStrLn "Test 40, from line 237" + constTest (P.replaceExtension "file.fred.bob" "txt" == "file.fred.txt") + putStrLn "Test 41, from line 254" + constTest (W.addExtension "file.txt" "bib" == "file.txt.bib") + putStrLn "Test 42, from line 254" + constTest (P.addExtension "file.txt" "bib" == "file.txt.bib") + putStrLn "Test 43, from line 255" + constTest (W.addExtension "file." ".bib" == "file..bib") + putStrLn "Test 44, from line 255" + constTest (P.addExtension "file." ".bib" == "file..bib") + putStrLn "Test 45, from line 256" + constTest (W.addExtension "file" ".bib" == "file.bib") + putStrLn "Test 46, from line 256" + constTest (P.addExtension "file" ".bib" == "file.bib") + putStrLn "Test 47, from line 257" + constTest (W.addExtension "/" "x" == "/.x") + putStrLn "Test 48, from line 257" + constTest (P.addExtension "/" "x" == "/.x") + putStrLn "Test 49, from line 259" + constTest (W.addExtension "\\\\share" ".txt" == "\\\\share\\.txt") + putStrLn "Test 50, from line 280" + constTest (W.splitExtensions "file.tar.gz" == ( "file" , ".tar.gz" )) +block3 = do + putStrLn "Test 51, from line 280" + constTest (P.splitExtensions "file.tar.gz" == ( "file" , ".tar.gz" )) + putStrLn "Test 52, from line 295" + constTest (W.takeExtensions "file.tar.gz" == ".tar.gz") + putStrLn "Test 53, from line 295" + constTest (P.takeExtensions "file.tar.gz" == ".tar.gz") + putStrLn "Test 54, from line 314" + constTest (W.splitDrive "file" == ( "" , "file" )) + putStrLn "Test 55, from line 315" + constTest (W.splitDrive "c:/file" == ( "c:/" , "file" )) + putStrLn "Test 56, from line 316" + constTest (W.splitDrive "c:\\file" == ( "c:\\" , "file" )) + putStrLn "Test 57, from line 317" + constTest (W.splitDrive "\\\\shared\\test" == ( "\\\\shared\\" , "test" )) + putStrLn "Test 58, from line 318" + constTest (W.splitDrive "\\\\shared" == ( "\\\\shared" , "" )) + putStrLn "Test 59, from line 319" + constTest (W.splitDrive "\\\\?\\UNC\\shared\\file" == ( "\\\\?\\UNC\\shared\\" , "file" )) + putStrLn "Test 60, from line 320" + constTest (W.splitDrive "\\\\?\\UNCshared\\file" == ( "\\\\?\\" , "UNCshared\\file" )) + putStrLn "Test 61, from line 321" + constTest (W.splitDrive "\\\\?\\d:\\file" == ( "\\\\?\\d:\\" , "file" )) + putStrLn "Test 62, from line 322" + constTest (W.splitDrive "/d" == ( "" , "/d" )) + putStrLn "Test 63, from line 323" + constTest (P.splitDrive "/test" == ( "/" , "test" )) + putStrLn "Test 64, from line 324" + constTest (P.splitDrive "//test" == ( "//" , "test" )) + putStrLn "Test 65, from line 325" + constTest (P.splitDrive "test/file" == ( "" , "test/file" )) + putStrLn "Test 66, from line 326" + constTest (P.splitDrive "file" == ( "" , "file" )) + putStrLn "Test 67, from line 383" + constTest (W.joinDrive "C:" "foo" == "C:foo") + putStrLn "Test 68, from line 384" + constTest (W.joinDrive "C:\\" "bar" == "C:\\bar") + putStrLn "Test 69, from line 385" + constTest (W.joinDrive "\\\\share" "foo" == "\\\\share\\foo") + putStrLn "Test 70, from line 386" + constTest (W.joinDrive "/:" "foo" == "/:\\foo") + putStrLn "Test 71, from line 427" + constTest (W.splitFileName "file/bob.txt" == ( "file/" , "bob.txt" )) + putStrLn "Test 72, from line 427" + constTest (P.splitFileName "file/bob.txt" == ( "file/" , "bob.txt" )) + putStrLn "Test 73, from line 428" + constTest (W.splitFileName "file/" == ( "file/" , "" )) + putStrLn "Test 74, from line 428" + constTest (P.splitFileName "file/" == ( "file/" , "" )) + putStrLn "Test 75, from line 429" + constTest (W.splitFileName "bob" == ( "./" , "bob" )) +block4 = do + putStrLn "Test 76, from line 429" + constTest (P.splitFileName "bob" == ( "./" , "bob" )) + putStrLn "Test 77, from line 430" + constTest (P.splitFileName "/" == ( "/" , "" )) + putStrLn "Test 78, from line 431" + constTest (W.splitFileName "c:" == ( "c:" , "" )) + putStrLn "Test 79, from line 464" + constTest (W.takeFileName "test/" == "") + putStrLn "Test 80, from line 464" + constTest (P.takeFileName "test/" == "") + putStrLn "Test 81, from line 475" + constTest (W.takeBaseName "file/test.txt" == "test") + putStrLn "Test 82, from line 475" + constTest (P.takeBaseName "file/test.txt" == "test") + putStrLn "Test 83, from line 476" + constTest (W.takeBaseName "dave.ext" == "dave") + putStrLn "Test 84, from line 476" + constTest (P.takeBaseName "dave.ext" == "dave") + putStrLn "Test 85, from line 477" + constTest (W.takeBaseName "" == "") + putStrLn "Test 86, from line 477" + constTest (P.takeBaseName "" == "") + putStrLn "Test 87, from line 478" + constTest (W.takeBaseName "test" == "test") + putStrLn "Test 88, from line 478" + constTest (P.takeBaseName "test" == "test") + putStrLn "Test 89, from line 480" + constTest (W.takeBaseName "file/file.tar.gz" == "file.tar") + putStrLn "Test 90, from line 480" + constTest (P.takeBaseName "file/file.tar.gz" == "file.tar") + putStrLn "Test 91, from line 486" + constTest (W.replaceBaseName "file/test.txt" "bob" == "file/bob.txt") + putStrLn "Test 92, from line 486" + constTest (P.replaceBaseName "file/test.txt" "bob" == "file/bob.txt") + putStrLn "Test 93, from line 487" + constTest (W.replaceBaseName "fred" "bill" == "bill") + putStrLn "Test 94, from line 487" + constTest (P.replaceBaseName "fred" "bill" == "bill") + putStrLn "Test 95, from line 488" + constTest (W.replaceBaseName "/dave/fred/bob.gz.tar" "new" == "/dave/fred/new.tar") + putStrLn "Test 96, from line 488" + constTest (P.replaceBaseName "/dave/fred/bob.gz.tar" "new" == "/dave/fred/new.tar") + putStrLn "Test 97, from line 498" + constTest (W.hasTrailingPathSeparator "test" == False) + putStrLn "Test 98, from line 498" + constTest (P.hasTrailingPathSeparator "test" == False) + putStrLn "Test 99, from line 499" + constTest (W.hasTrailingPathSeparator "test/" == True) + putStrLn "Test 100, from line 499" + constTest (P.hasTrailingPathSeparator "test/" == True) +block5 = do + putStrLn "Test 101, from line 509" + constTest (P.addTrailingPathSeparator "test/rest" == "test/rest/") + putStrLn "Test 102, from line 516" + constTest (W.dropTrailingPathSeparator "file/test/" == "file/test") + putStrLn "Test 103, from line 516" + constTest (P.dropTrailingPathSeparator "file/test/" == "file/test") + putStrLn "Test 104, from line 518" + constTest (P.dropTrailingPathSeparator "/" == "/") + putStrLn "Test 105, from line 519" + constTest (W.dropTrailingPathSeparator "\\" == "\\") + putStrLn "Test 106, from line 531" + constTest (W.takeDirectory "foo" == ".") + putStrLn "Test 107, from line 531" + constTest (P.takeDirectory "foo" == ".") + putStrLn "Test 108, from line 532" + constTest (W.takeDirectory "/foo/bar/baz" == "/foo/bar") + putStrLn "Test 109, from line 532" + constTest (P.takeDirectory "/foo/bar/baz" == "/foo/bar") + putStrLn "Test 110, from line 533" + constTest (W.takeDirectory "/foo/bar/baz/" == "/foo/bar/baz") + putStrLn "Test 111, from line 533" + constTest (P.takeDirectory "/foo/bar/baz/" == "/foo/bar/baz") + putStrLn "Test 112, from line 534" + constTest (W.takeDirectory "foo/bar/baz" == "foo/bar") + putStrLn "Test 113, from line 534" + constTest (P.takeDirectory "foo/bar/baz" == "foo/bar") + putStrLn "Test 114, from line 535" + constTest (W.takeDirectory "foo\\bar" == "foo") + putStrLn "Test 115, from line 536" + constTest (W.takeDirectory "foo\\bar\\\\" == "foo\\bar") + putStrLn "Test 116, from line 537" + constTest (W.takeDirectory "C:\\" == "C:\\") + putStrLn "Test 117, from line 555" + constTest (P.combine "/" "test" == "/test") + putStrLn "Test 118, from line 556" + constTest (P.combine "home" "bob" == "home/bob") + putStrLn "Test 119, from line 557" + constTest (W.combine "home" "bob" == "home\\bob") + putStrLn "Test 120, from line 558" + constTest (W.combine "home" "/bob" == "/bob") + putStrLn "Test 121, from line 580" + constTest (W.splitPath "test//item/" == [ "test//" , "item/" ]) + putStrLn "Test 122, from line 580" + constTest (P.splitPath "test//item/" == [ "test//" , "item/" ]) + putStrLn "Test 123, from line 581" + constTest (W.splitPath "test/item/file" == [ "test/" , "item/" , "file" ]) + putStrLn "Test 124, from line 581" + constTest (P.splitPath "test/item/file" == [ "test/" , "item/" , "file" ]) + putStrLn "Test 125, from line 582" + constTest (W.splitPath "" == [ ]) +block6 = do + putStrLn "Test 126, from line 582" + constTest (P.splitPath "" == [ ]) + putStrLn "Test 127, from line 583" + constTest (W.splitPath "c:\\test\\path" == [ "c:\\" , "test\\" , "path" ]) + putStrLn "Test 128, from line 584" + constTest (P.splitPath "/file/test" == [ "/" , "file/" , "test" ]) + putStrLn "Test 129, from line 598" + constTest (W.splitDirectories "test/file" == [ "test" , "file" ]) + putStrLn "Test 130, from line 598" + constTest (P.splitDirectories "test/file" == [ "test" , "file" ]) + putStrLn "Test 131, from line 599" + constTest (W.splitDirectories "/test/file" == [ "/" , "test" , "file" ]) + putStrLn "Test 132, from line 599" + constTest (P.splitDirectories "/test/file" == [ "/" , "test" , "file" ]) + putStrLn "Test 133, from line 601" + constTest (W.splitDirectories "" == [ ]) + putStrLn "Test 134, from line 601" + constTest (P.splitDirectories "" == [ ]) + putStrLn "Test 135, from line 617" + constTest (W.joinPath [ ] == "") + putStrLn "Test 136, from line 617" + constTest (P.joinPath [ ] == "") + putStrLn "Test 137, from line 618" + constTest (P.joinPath [ "test" , "file" , "path" ] == "test/file/path") + putStrLn "Test 138, from line 639" + constTest (P.equalFilePath "foo" "foo/") + putStrLn "Test 139, from line 640" + constTest (not ( P.equalFilePath "foo" "/foo" )) + putStrLn "Test 140, from line 641" + constTest (not ( P.equalFilePath "foo" "FOO" )) + putStrLn "Test 141, from line 642" + constTest (W.equalFilePath "foo" "FOO") + putStrLn "Test 142, from line 661" + constTest (W.makeRelative "C:\\Home" "c:\\home\\bob" == "bob") + putStrLn "Test 143, from line 662" + constTest (W.makeRelative "C:\\Home" "c:/home/bob" == "bob") + putStrLn "Test 144, from line 663" + constTest (W.makeRelative "C:\\Home" "D:\\Home\\Bob" == "D:\\Home\\Bob") + putStrLn "Test 145, from line 664" + constTest (W.makeRelative "C:\\Home" "C:Home\\Bob" == "C:Home\\Bob") + putStrLn "Test 146, from line 665" + constTest (W.makeRelative "/Home" "/home/bob" == "bob") + putStrLn "Test 147, from line 666" + constTest (P.makeRelative "/Home" "/home/bob" == "/home/bob") + putStrLn "Test 148, from line 667" + constTest (P.makeRelative "/home/" "/home/bob/foo/bar" == "bob/foo/bar") + putStrLn "Test 149, from line 668" + constTest (P.makeRelative "/fred" "bob" == "bob") + putStrLn "Test 150, from line 669" + constTest (P.makeRelative "/file/test" "/file/test/fred" == "fred") +block7 = do + putStrLn "Test 151, from line 670" + constTest (P.makeRelative "/file/test" "/file/test/fred/" == "fred/") + putStrLn "Test 152, from line 671" + constTest (P.makeRelative "some/path" "some/path/a/b/c" == "a/b/c") + putStrLn "Test 153, from line 701" + constTest (P.normalise "/file/\\test////" == "/file/\\test/") + putStrLn "Test 154, from line 702" + constTest (P.normalise "/file/./test" == "/file/test") + putStrLn "Test 155, from line 703" + constTest (P.normalise "/test/file/../bob/fred/" == "/test/file/../bob/fred/") + putStrLn "Test 156, from line 704" + constTest (P.normalise "../bob/fred/" == "../bob/fred/") + putStrLn "Test 157, from line 705" + constTest (P.normalise "./bob/fred/" == "bob/fred/") + putStrLn "Test 158, from line 706" + constTest (W.normalise "c:\\file/bob\\" == "C:\\file\\bob\\") + putStrLn "Test 159, from line 707" + constTest (W.normalise "c:\\" == "C:\\") + putStrLn "Test 160, from line 708" + constTest (W.normalise "\\\\server\\test" == "\\\\server\\test") + putStrLn "Test 161, from line 709" + constTest (W.normalise "c:/file" == "C:\\file") + putStrLn "Test 162, from line 710" + constTest (W.normalise "." == ".") + putStrLn "Test 163, from line 710" + constTest (P.normalise "." == ".") + putStrLn "Test 164, from line 711" + constTest (P.normalise "./" == "./") + putStrLn "Test 165, from line 712" + constTest (P.normalise "./." == "./") + putStrLn "Test 166, from line 713" + constTest (P.normalise "/" == "/") + putStrLn "Test 167, from line 714" + constTest (P.normalise "bob/fred/." == "bob/fred/") + putStrLn "Test 168, from line 759" + constTest (W.isValid "" == False) + putStrLn "Test 169, from line 759" + constTest (P.isValid "" == False) + putStrLn "Test 170, from line 760" + constTest (P.isValid "/random_ path:*" == True) + putStrLn "Test 171, from line 762" + constTest (W.isValid "c:\\test" == True) + putStrLn "Test 172, from line 763" + constTest (W.isValid "c:\\test:of_test" == False) + putStrLn "Test 173, from line 764" + constTest (W.isValid "test*" == False) + putStrLn "Test 174, from line 765" + constTest (W.isValid "c:\\test\\nul" == False) + putStrLn "Test 175, from line 766" + constTest (W.isValid "c:\\test\\prn.txt" == False) +block8 = do + putStrLn "Test 176, from line 767" + constTest (W.isValid "c:\\nul\\file" == False) + putStrLn "Test 177, from line 768" + constTest (W.isValid "\\\\" == False) + putStrLn "Test 178, from line 785" + constTest (W.makeValid "" == "_") + putStrLn "Test 179, from line 785" + constTest (P.makeValid "" == "_") + putStrLn "Test 180, from line 786" + constTest (W.makeValid "c:\\test:of_test" == "c:\\test_of_test") + putStrLn "Test 181, from line 787" + constTest (W.makeValid "test*" == "test_") + putStrLn "Test 182, from line 788" + constTest (W.makeValid "c:\\test\\nul" == "c:\\test\\nul_") + putStrLn "Test 183, from line 789" + constTest (W.makeValid "c:\\test\\prn.txt" == "c:\\test\\prn_.txt") + putStrLn "Test 184, from line 790" + constTest (W.makeValid "c:\\test/prn.txt" == "c:\\test/prn_.txt") + putStrLn "Test 185, from line 791" + constTest (W.makeValid "c:\\nul\\file" == "c:\\nul_\\file") + putStrLn "Test 186, from line 813" + constTest (W.isRelative "path\\test" == True) + putStrLn "Test 187, from line 814" + constTest (W.isRelative "c:\\test" == False) + putStrLn "Test 188, from line 815" + constTest (W.isRelative "c:test" == True) + putStrLn "Test 189, from line 816" + constTest (W.isRelative "c:" == True) + putStrLn "Test 190, from line 817" + constTest (W.isRelative "\\\\foo" == False) + putStrLn "Test 191, from line 818" + constTest (W.isRelative "/foo" == True) + putStrLn "Test 192, from line 819" + constTest (P.isRelative "test/path" == True) + putStrLn "Test 193, from line 820" + constTest (P.isRelative "/test" == False) + putStrLn "Test 194, from line 139" + quickSafe (\ a -> (W.isPathSeparator a == ( a ` elem ` W.pathSeparators ))) + putStrLn "Test 195, from line 139" + quickSafe (\ a -> (P.isPathSeparator a == ( a ` elem ` P.pathSeparators ))) + putStrLn "Test 196, from line 153" + quickSafe (\ a -> (W.isSearchPathSeparator a == ( a == W.searchPathSeparator ))) + putStrLn "Test 197, from line 153" + quickSafe (\ a -> (P.isSearchPathSeparator a == ( a == P.searchPathSeparator ))) + putStrLn "Test 198, from line 166" + quickSafe (\ a -> (W.isExtSeparator a == ( a == W.extSeparator ))) + putStrLn "Test 199, from line 166" + quickSafe (\ a -> (P.isExtSeparator a == ( a == P.extSeparator ))) + putStrLn "Test 200, from line 206" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( W.splitExtension x ) == x)) +block9 = do + putStrLn "Test 201, from line 206" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( P.splitExtension x ) == x)) + putStrLn "Test 202, from line 207" + quickSafe (\ (QFilePath x) -> (uncurry W.addExtension ( W.splitExtension x ) == x)) + putStrLn "Test 203, from line 207" + quickSafe (\ (QFilePath x) -> (uncurry P.addExtension ( P.splitExtension x ) == x)) + putStrLn "Test 204, from line 225" + quickSafe (\ (QFilePath x) -> (W.takeExtension x == snd ( W.splitExtension x ))) + putStrLn "Test 205, from line 225" + quickSafe (\ (QFilePath x) -> (P.takeExtension x == snd ( P.splitExtension x ))) + putStrLn "Test 206, from line 226" + quickSafe (\ (QFilePath x) -> ((\ x -> W.takeExtension ( W.addExtension x "ext" ) == ".ext" ) ( W.makeValid x ))) + putStrLn "Test 207, from line 226" + quickSafe (\ (QFilePath x) -> ((\ x -> P.takeExtension ( P.addExtension x "ext" ) == ".ext" ) ( P.makeValid x ))) + putStrLn "Test 208, from line 227" + quickSafe (\ (QFilePath x) -> ((\ x -> W.takeExtension ( W.replaceExtension x "ext" ) == ".ext" ) ( W.makeValid x ))) + putStrLn "Test 209, from line 227" + quickSafe (\ (QFilePath x) -> ((\ x -> P.takeExtension ( P.replaceExtension x "ext" ) == ".ext" ) ( P.makeValid x ))) + putStrLn "Test 210, from line 247" + quickSafe (\ (QFilePath x) -> (W.dropExtension x == fst ( W.splitExtension x ))) + putStrLn "Test 211, from line 247" + quickSafe (\ (QFilePath x) -> (P.dropExtension x == fst ( P.splitExtension x ))) + putStrLn "Test 212, from line 258" + quickSafe (\ (QFilePath x) -> ((\ x -> W.takeFileName ( W.addExtension ( W.addTrailingPathSeparator x ) "ext" ) == ".ext" ) ( W.makeValid x ))) + putStrLn "Test 213, from line 258" + quickSafe (\ (QFilePath x) -> ((\ x -> P.takeFileName ( P.addExtension ( P.addTrailingPathSeparator x ) "ext" ) == ".ext" ) ( P.makeValid x ))) + putStrLn "Test 214, from line 271" + quickSafe (\ (QFilePath x) -> (null ( W.takeExtension x ) == not ( W.hasExtension x ))) + putStrLn "Test 215, from line 271" + quickSafe (\ (QFilePath x) -> (null ( P.takeExtension x ) == not ( P.hasExtension x ))) + putStrLn "Test 216, from line 278" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( W.splitExtensions x ) == x)) + putStrLn "Test 217, from line 278" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( P.splitExtensions x ) == x)) + putStrLn "Test 218, from line 279" + quickSafe (\ (QFilePath x) -> (uncurry W.addExtension ( W.splitExtensions x ) == x)) + putStrLn "Test 219, from line 279" + quickSafe (\ (QFilePath x) -> (uncurry P.addExtension ( P.splitExtensions x ) == x)) + putStrLn "Test 220, from line 289" + quickSafe (\ (QFilePath x) -> (not $ W.hasExtension ( W.dropExtensions x ))) + putStrLn "Test 221, from line 289" + quickSafe (\ (QFilePath x) -> (not $ P.hasExtension ( P.dropExtensions x ))) + putStrLn "Test 222, from line 313" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( W.splitDrive x ) == x)) + putStrLn "Test 223, from line 313" + quickSafe (\ (QFilePath x) -> (uncurry ( ++ ) ( P.splitDrive x ) == x)) + putStrLn "Test 224, from line 382" + quickSafe (\ (QFilePath x) -> (uncurry W.joinDrive ( W.splitDrive x ) == x)) + putStrLn "Test 225, from line 382" + quickSafe (\ (QFilePath x) -> (uncurry P.joinDrive ( P.splitDrive x ) == x)) +block10 = do + putStrLn "Test 226, from line 398" + quickSafe (\ (QFilePath x) -> (W.takeDrive x == fst ( W.splitDrive x ))) + putStrLn "Test 227, from line 398" + quickSafe (\ (QFilePath x) -> (P.takeDrive x == fst ( P.splitDrive x ))) + putStrLn "Test 228, from line 404" + quickSafe (\ (QFilePath x) -> (W.dropDrive x == snd ( W.splitDrive x ))) + putStrLn "Test 229, from line 404" + quickSafe (\ (QFilePath x) -> (P.dropDrive x == snd ( P.splitDrive x ))) + putStrLn "Test 230, from line 410" + quickSafe (\ (QFilePath x) -> (not ( W.hasDrive x ) == null ( W.takeDrive x ))) + putStrLn "Test 231, from line 410" + quickSafe (\ (QFilePath x) -> (not ( P.hasDrive x ) == null ( P.takeDrive x ))) + putStrLn "Test 232, from line 425" + quickSafe (\ (QFilePath x) -> ((\ x -> uncurry ( W. ) ( W.splitFileName x ) == x || fst ( W.splitFileName x ) == "./" ) ( W.makeValid x ))) + putStrLn "Test 233, from line 425" + quickSafe (\ (QFilePath x) -> ((\ x -> uncurry ( P. ) ( P.splitFileName x ) == x || fst ( P.splitFileName x ) == "./" ) ( P.makeValid x ))) + putStrLn "Test 234, from line 426" + quickSafe (\ (QFilePath x) -> ((\ x -> W.isValid ( fst ( W.splitFileName x ) ) ) ( W.makeValid x ))) + putStrLn "Test 235, from line 426" + quickSafe (\ (QFilePath x) -> ((\ x -> P.isValid ( fst ( P.splitFileName x ) ) ) ( P.makeValid x ))) + putStrLn "Test 236, from line 451" + quickSafe (\ (QFilePath x) -> ((\ x -> W.replaceFileName x ( W.takeFileName x ) == x ) ( W.makeValid x ))) + putStrLn "Test 237, from line 451" + quickSafe (\ (QFilePath x) -> ((\ x -> P.replaceFileName x ( P.takeFileName x ) == x ) ( P.makeValid x ))) + putStrLn "Test 238, from line 457" + quickSafe (\ (QFilePath x) -> (W.dropFileName x == fst ( W.splitFileName x ))) + putStrLn "Test 239, from line 457" + quickSafe (\ (QFilePath x) -> (P.dropFileName x == fst ( P.splitFileName x ))) + putStrLn "Test 240, from line 465" + quickSafe (\ (QFilePath x) -> (W.takeFileName x ` isSuffixOf ` x)) + putStrLn "Test 241, from line 465" + quickSafe (\ (QFilePath x) -> (P.takeFileName x ` isSuffixOf ` x)) + putStrLn "Test 242, from line 466" + quickSafe (\ (QFilePath x) -> (W.takeFileName x == snd ( W.splitFileName x ))) + putStrLn "Test 243, from line 466" + quickSafe (\ (QFilePath x) -> (P.takeFileName x == snd ( P.splitFileName x ))) + putStrLn "Test 244, from line 467" + quickSafe (\ (QFilePath x) -> ((\ x -> W.takeFileName ( W.replaceFileName x "fred" ) == "fred" ) ( W.makeValid x ))) + putStrLn "Test 245, from line 467" + quickSafe (\ (QFilePath x) -> ((\ x -> P.takeFileName ( P.replaceFileName x "fred" ) == "fred" ) ( P.makeValid x ))) + putStrLn "Test 246, from line 468" + quickSafe (\ (QFilePath x) -> ((\ x -> W.takeFileName ( x W. "fred" ) == "fred" ) ( W.makeValid x ))) + putStrLn "Test 247, from line 468" + quickSafe (\ (QFilePath x) -> ((\ x -> P.takeFileName ( x P. "fred" ) == "fred" ) ( P.makeValid x ))) + putStrLn "Test 248, from line 469" + quickSafe (\ (QFilePath x) -> ((\ x -> W.isRelative ( W.takeFileName x ) ) ( W.makeValid x ))) + putStrLn "Test 249, from line 469" + quickSafe (\ (QFilePath x) -> ((\ x -> P.isRelative ( P.takeFileName x ) ) ( P.makeValid x ))) + putStrLn "Test 250, from line 479" + quickSafe (\ (QFilePath x) -> (W.takeBaseName ( W.addTrailingPathSeparator x ) == "")) +block11 = do + putStrLn "Test 251, from line 479" + quickSafe (\ (QFilePath x) -> (P.takeBaseName ( P.addTrailingPathSeparator x ) == "")) + putStrLn "Test 252, from line 489" + quickSafe (\ (QFilePath x) -> ((\ x -> W.replaceBaseName x ( W.takeBaseName x ) == x ) ( W.makeValid x ))) + putStrLn "Test 253, from line 489" + quickSafe (\ (QFilePath x) -> ((\ x -> P.replaceBaseName x ( P.takeBaseName x ) == x ) ( P.makeValid x ))) + putStrLn "Test 254, from line 507" + quickSafe (\ (QFilePath x) -> (W.hasTrailingPathSeparator ( W.addTrailingPathSeparator x ))) + putStrLn "Test 255, from line 507" + quickSafe (\ (QFilePath x) -> (P.hasTrailingPathSeparator ( P.addTrailingPathSeparator x ))) + putStrLn "Test 256, from line 508" + quickSafe (\ (QFilePath x) -> (W.hasTrailingPathSeparator x ==> W.addTrailingPathSeparator x == x)) + putStrLn "Test 257, from line 508" + quickSafe (\ (QFilePath x) -> (P.hasTrailingPathSeparator x ==> P.addTrailingPathSeparator x == x)) + putStrLn "Test 258, from line 517" + quickSafe (\ (QFilePath x) -> (not ( P.hasTrailingPathSeparator ( P.dropTrailingPathSeparator x ) ) || P.isDrive x)) + putStrLn "Test 259, from line 530" + quickSafe (\ (QFilePath x) -> (W.takeDirectory x ` isPrefixOf ` x || W.takeDirectory x == ".")) + putStrLn "Test 260, from line 530" + quickSafe (\ (QFilePath x) -> (P.takeDirectory x ` isPrefixOf ` x || P.takeDirectory x == ".")) + putStrLn "Test 261, from line 547" + quickSafe (\ (QFilePath x) -> ((\ x -> W.replaceDirectory x ( W.takeDirectory x ) ` W.equalFilePath ` x ) ( W.makeValid x ))) + putStrLn "Test 262, from line 547" + quickSafe (\ (QFilePath x) -> ((\ x -> P.replaceDirectory x ( P.takeDirectory x ) ` P.equalFilePath ` x ) ( P.makeValid x ))) + putStrLn "Test 263, from line 554" + quickSafe (\ (QFilePath x) -> ((\ x -> W.combine ( W.takeDirectory x ) ( W.takeFileName x ) ` W.equalFilePath ` x ) ( W.makeValid x ))) + putStrLn "Test 264, from line 554" + quickSafe (\ (QFilePath x) -> ((\ x -> P.combine ( P.takeDirectory x ) ( P.takeFileName x ) ` P.equalFilePath ` x ) ( P.makeValid x ))) + putStrLn "Test 265, from line 579" + quickSafe (\ (QFilePath x) -> (concat ( W.splitPath x ) == x)) + putStrLn "Test 266, from line 579" + quickSafe (\ (QFilePath x) -> (concat ( P.splitPath x ) == x)) + putStrLn "Test 267, from line 600" + quickSafe (\ (QFilePath x) -> ((\ x -> W.joinPath ( W.splitDirectories x ) ` W.equalFilePath ` x ) ( W.makeValid x ))) + putStrLn "Test 268, from line 600" + quickSafe (\ (QFilePath x) -> ((\ x -> P.joinPath ( P.splitDirectories x ) ` P.equalFilePath ` x ) ( P.makeValid x ))) + putStrLn "Test 269, from line 616" + quickSafe (\ (QFilePath x) -> ((\ x -> W.joinPath ( W.splitPath x ) == x ) ( W.makeValid x ))) + putStrLn "Test 270, from line 616" + quickSafe (\ (QFilePath x) -> ((\ x -> P.joinPath ( P.splitPath x ) == x ) ( P.makeValid x ))) + putStrLn "Test 271, from line 637" + quickSafe (\ (QFilePath x) (QFilePath y) -> (x == y ==> W.equalFilePath x y)) + putStrLn "Test 272, from line 637" + quickSafe (\ (QFilePath x) (QFilePath y) -> (x == y ==> P.equalFilePath x y)) + putStrLn "Test 273, from line 638" + quickSafe (\ (QFilePath x) (QFilePath y) -> (W.normalise x == W.normalise y ==> W.equalFilePath x y)) + putStrLn "Test 274, from line 638" + quickSafe (\ (QFilePath x) (QFilePath y) -> (P.normalise x == P.normalise y ==> P.equalFilePath x y)) + putStrLn "Test 275, from line 658" + quickSafe (\ (QFilePath x) (QFilePath y) -> ((\ y -> W.equalFilePath x y || ( W.isRelative x && W.makeRelative y x == x ) || W.equalFilePath ( y W. W.makeRelative y x ) x ) ( W.makeValid y ))) +block12 = do + putStrLn "Test 276, from line 658" + quickSafe (\ (QFilePath x) (QFilePath y) -> ((\ y -> P.equalFilePath x y || ( P.isRelative x && P.makeRelative y x == x ) || P.equalFilePath ( y P. P.makeRelative y x ) x ) ( P.makeValid y ))) + putStrLn "Test 277, from line 659" + quickSafe (\ (QFilePath x) -> (W.makeRelative x x == ".")) + putStrLn "Test 278, from line 659" + quickSafe (\ (QFilePath x) -> (P.makeRelative x x == ".")) + putStrLn "Test 279, from line 660" + quickSafe (\ (QFilePath x) (QFilePath y) -> (null y || W.equalFilePath ( W.makeRelative x ( x W. y ) ) y || null ( W.takeFileName x ))) + putStrLn "Test 280, from line 660" + quickSafe (\ (QFilePath x) (QFilePath y) -> (null y || P.equalFilePath ( P.makeRelative x ( x P. y ) ) y || null ( P.takeFileName x ))) + putStrLn "Test 281, from line 761" + quickSafe (\ (QFilePath x) -> (P.isValid x == not ( null x ))) + putStrLn "Test 282, from line 783" + quickSafe (\ (QFilePath x) -> (W.isValid ( W.makeValid x ))) + putStrLn "Test 283, from line 783" + quickSafe (\ (QFilePath x) -> (P.isValid ( P.makeValid x ))) + putStrLn "Test 284, from line 784" + quickSafe (\ (QFilePath x) -> (W.isValid x ==> W.makeValid x == x)) + putStrLn "Test 285, from line 784" + quickSafe (\ (QFilePath x) -> (P.isValid x ==> P.makeValid x == x)) + putStrLn "Test 286, from line 840" + quickSafe (\ (QFilePath x) -> (W.isAbsolute x == not ( W.isRelative x ))) + putStrLn "Test 287, from line 840" + quickSafe (\ (QFilePath x) -> (P.isAbsolute x == not ( P.isRelative x )))