diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -57,7 +57,7 @@
 You can decide whether a path is absolute or relative
 by just watching (the beginning of) the path string.
 In contrast to that, you have to access the disk
-in order to check the existence and type of an disk object.
+in order to check the existence and type of a disk object.
 Even more, the disk object might change at any time,
 e.g. the user might delete a file and create a directory of the same name,
 or the disk object might not exist,
@@ -72,7 +72,7 @@
 The reality check must be performed
 and is performed by the standard functions
 for every access to the object.
-If an disk object is not of the type required by the path type
+If a disk object is not of the type required by the path type
 then this is a runtime exception that must be handled at runtime
 but it is not a programming error.
 
@@ -115,7 +115,7 @@
 The rule is: Just give the path the type you expect
 but do not perform any checking
 (unless you want to warn the user earlier about imminent danger).
-The disk object type must checked for every access to the object, anyway,
+The disk object type must be checked for every access to the object, anyway,
 so there is no point in checking it immediately.
 With your choice of the `fd` parameter
 you just document its intended use.
diff --git a/pathtype.cabal b/pathtype.cabal
--- a/pathtype.cabal
+++ b/pathtype.cabal
@@ -1,6 +1,6 @@
 Cabal-Version:       2.2
 Name:                pathtype
-Version:             0.8.1.1
+Version:             0.8.1.2
 Synopsis:            Type-safe replacement for System.FilePath etc
 Description:
   This package provides type-safe access to filepath manipulations.
@@ -54,13 +54,12 @@
 Category:            System
 License-file:        LICENSE
 Author:              Ben Moseley, Ben Millwood, Henning Thielemann
-Maintainer:          haskell@henning-thielemann.de, ben@moseley.name
-HomePage:            http://hub.darcs.net/thielema/pathtype/
+Maintainer:          haskell@henning-thielemann.de
+HomePage:            https://hub.darcs.net/thielema/pathtype/
 Build-Type:          Simple
 Extra-Source-Files:
   CHANGELOG
   README.md
-  test/TestTemplate.hs
   posix/System/Path/Host.hs
   windows/System/Path/Host.hs
   directory/pre-1.2/System/Path/ModificationTime.hs
@@ -68,28 +67,25 @@
 
 Source-Repository head
   Type:     darcs
-  Location: http://hub.darcs.net/thielema/pathtype/
+  Location: https://hub.darcs.net/thielema/pathtype/
 
 Source-Repository this
-  Tag:      0.8.1.1
+  Tag:      0.8.1.2
   Type:     darcs
-  Location: http://hub.darcs.net/thielema/pathtype/
+  Location: https://hub.darcs.net/thielema/pathtype/
 
 Flag old-time
   Description: Build with directory < 1.2 and old-time
-  Default:     True
-
-Flag buildTools
-  Description: Build tool for updating test module
   Default:     False
 
 Library
   Build-Depends:
     utility-ht >=0.0.11 && <0.1,
+    doctest-exitcode-stdio >=0.0 && <0.1,
     QuickCheck >= 2.1.0.1 && < 3,
     deepseq >= 1.3 && <1.5,
     time >= 1.0 && < 2,
-    transformers >=0.3 && <0.6,
+    transformers >=0.3 && <0.7,
     semigroups >=0.1 && <1.0,
     tagged >=0.7 && <0.9,
     base >= 4 && < 5
@@ -129,26 +125,17 @@
 Test-Suite test
   Type: exitcode-stdio-1.0
   Main-Is: Test.hs
-  Other-Modules: TestResult
+  Other-Modules:
+    Test.Posix.System.Path.Internal
+    Test.Windows.System.Path.Internal
   Hs-Source-Dirs: test
 
   Build-Depends:
     pathtype,
-    random >=1.0 && <1.3,
+    QuickCheck,
+    doctest-exitcode-stdio,
+    doctest-lib >=0.1 && <0.1.1,
     base
-
-  GHC-Options: -Wall -fwarn-tabs -fwarn-incomplete-record-updates -fwarn-unused-do-bind
-  Default-Language: Haskell98
-
-Executable create-pathtype-test
-  If flag(buildTools)
-    Build-Depends:
-      utility-ht >=0.0.12 && <0.1,
-      base
-  Else
-    Buildable: False
-  Main-Is: CreateTest.hs
-  Hs-Source-Dirs: tool
 
   GHC-Options: -Wall -fwarn-tabs -fwarn-incomplete-record-updates -fwarn-unused-do-bind
   Default-Language: Haskell98
diff --git a/src/System/Path/Directory.hs b/src/System/Path/Directory.hs
--- a/src/System/Path/Directory.hs
+++ b/src/System/Path/Directory.hs
@@ -8,14 +8,9 @@
 --
 --   You will typically want to import as follows:
 --
---   > import Prelude hiding (FilePath)
---   > import System.Path
---   > import System.Path.Directory
---   > import System.Path.IO
---
---
--- Ben Moseley - (c) 2009
---
+--   > import qualified System.Path.IO as PathIO
+--   > import qualified System.Path as Path
+--   > import System.Path.Directory (createDirectory)
 module System.Path.Directory
 (
   -- * Actions on directories
@@ -58,7 +53,7 @@
   setPermissions,
 
   -- * Timestamps
-  getModificationTime
+  getModificationTime,
 )
 
 where
diff --git a/src/System/Path/Internal.hs b/src/System/Path/Internal.hs
--- a/src/System/Path/Internal.hs
+++ b/src/System/Path/Internal.hs
@@ -184,6 +184,7 @@
 import Text.Show.HT (concatS)
 import Text.Printf (printf)
 
+import qualified Test.DocTest.Driver as DocTest
 import qualified Test.QuickCheck as QC
 import Test.QuickCheck
           (Gen, Property, property, Arbitrary(arbitrary), frequency)
@@ -192,6 +193,23 @@
 import Prelude hiding (FilePath, maybe, abs)
 
 
+{- $setup
+>>> :set -XTypeFamilies
+>>>
+>>> :set -fno-warn-warnings-deprecations
+>>> import qualified System.Path.PartClass as Class
+>>> import qualified System.Path.Generic as Path
+>>> import qualified System.Path.Posix as Posix
+>>> import qualified System.Path.Windows as Windows
+>>> import System.Path.Generic ((</>), (<.>), relFile, relDir, absFile, absDir)
+>>> import Data.List (isSuffixOf, isPrefixOf)
+>>> import Data.Char (toLower)
+>>> import qualified Test.QuickCheck as QC
+>>> forAllAbsRel :: (Class.FileDir fd, QC.Testable prop) => (Default.AbsRel fd -> prop) -> QC.Property
+>>> forAllAbsRel = QC.forAll QC.arbitrary
+-}
+
+
 ------------------------------------------------------------------------
 -- Types
 
@@ -259,7 +277,7 @@
 
 -- | Map over the components of the path.
 --
--- >> Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets"
+-- prop> Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets"
 pathMap ::
     (Class.FileDir fd) => (String -> String) -> Path os ar fd -> Path os ar fd
 pathMap f (Path ar pcs fd) = Path ar (map (pcMap f) pcs) (fdMap f fd)
@@ -331,13 +349,20 @@
 instead of 'relFile', 'relDir' and @relPath str :: FileDirPath ar@.
 Otherwise handling of all cases of 'Part.File', 'Part.Dir' and 'Part.FileDir' types
 becomes pretty complicated.
+
+>>> Posix.rootDir </> relDir "bla" </> relFile "blub"
+rootDir </> relPath "bla" </> relPath "blub"
+>>> Just (Posix.rootDir </> relDir "bla" </> relFile "blub")
+Just (rootDir </> relPath "bla" </> relPath "blub")
+>>> Posix.currentDir </> relDir "bla" </> relFile "blub"
+currentDir </> relPath "bla" </> relPath "blub"
+>>> Just (Posix.currentDir </> relDir "bla" </> relFile "blub")
+Just (currentDir </> relPath "bla" </> relPath "blub")
+>>> Windows.absDir "c:" </> relDir "bla" </> relFile "blub"
+absDir "c:" </> relPath "bla" </> relPath "blub"
+>>> Just (Windows.absDir "c:\\" </> relDir "bla" </> relFile "blub")
+Just (absDir "c:\\" </> relPath "bla" </> relPath "blub")
 -}
--- >> show (Posix.rootDir </> relDir "bla" </> relFile "blub") == "rootDir </> relPath \"bla\" </> relPath \"blub\""
--- >> show (Just (Posix.rootDir </> relDir "bla" </> relFile "blub")) == "Just (rootDir </> relPath \"bla\" </> relPath \"blub\")"
--- >> show (Posix.currentDir </> relDir "bla" </> relFile "blub") == "currentDir </> relPath \"bla\" </> relPath \"blub\""
--- >> show (Just (Posix.currentDir </> relDir "bla" </> relFile "blub")) == "Just (currentDir </> relPath \"bla\" </> relPath \"blub\")"
--- >> show (Windows.absDir "c:" </> relDir "bla" </> relFile "blub") == "absDir \"c:\" </> relPath \"bla\" </> relPath \"blub\""
--- >> show (Just (Windows.absDir "c:\\" </> relDir "bla" </> relFile "blub")) == "Just (absDir \"c:\\\\\" </> relPath \"bla\" </> relPath \"blub\")"
 instance
     (System os, Class.AbsRel ar, Class.FileDir fd) =>
         Show (Path os ar fd) where
@@ -369,17 +394,17 @@
 Currently it also parses Part.AbsRel and Part.FileDir paths,
 although these cannot be composed with the accepted combinators.
 -}
--- >> read "rootDir" == Posix.rootDir
--- >> read "rootDir" == Windows.rootDir
--- >> read "currentDir" == Posix.currentDir
--- >> read "currentDir" == Windows.currentDir
--- >> let path = Posix.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path
--- >> let path = Just (Posix.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path
--- >> let path = Posix.currentDir </> relDir "bla" </> relFile "blub" in read (show path) == path
--- >> let path = Just (Posix.currentDir </> relDir "bla" </> relFile "blub") in read (show path) == path
--- >> let path = Windows.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path
--- >> let path = Just (Windows.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path
--- >> let path = Windows.absDir "c:" </> relDir "bla" </> relFile "blub" in read (show path) == path
+-- prop> read "rootDir" == Posix.rootDir
+-- prop> read "rootDir" == Windows.rootDir
+-- prop> read "currentDir" == Posix.currentDir
+-- prop> read "currentDir" == Windows.currentDir
+-- prop> let path = Posix.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path
+-- prop> let path = Just (Posix.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path
+-- prop> let path = Posix.currentDir </> relDir "bla" </> relFile "blub" in read (show path) == path
+-- prop> let path = Just (Posix.currentDir </> relDir "bla" </> relFile "blub") in read (show path) == path
+-- prop> let path = Windows.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path
+-- prop> let path = Just (Windows.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path
+-- prop> let path = Windows.absDir "c:" </> relDir "bla" </> relFile "blub" in read (show path) == path
 instance
     (System os, Class.AbsRel ar, Class.FileDir fd) =>
         Read (Path os ar fd) where
@@ -446,6 +471,8 @@
 
 
 -- | Convert the 'Path' into a plain 'String' as required for OS calls.
+--
+-- prop> \p -> Path.asPath (Path.toString p) == (p::Default.AbsFile)
 toString ::
     (System os, Class.AbsRel ar, Class.FileDir fd) => Path os ar fd -> String
 toString = flip toStringS ""
@@ -469,15 +496,12 @@
             intersperse (showChar (selTag x pathSeparator)) $
             map (\(PathComponent pc) -> showString pc) pcs
 
-prop_asPath_toString :: (System os) => AbsFile os -> Property
-prop_asPath_toString p = property $ p == asPath (toString p)
 
-
 ------------------------------------------------------------------------
 -- Constants
 
--- >> Posix.toString Path.rootDir == "/"
--- >> Windows.toString Path.rootDir == "\\"
+-- prop> Posix.toString Path.rootDir == "/"
+-- prop> Windows.toString Path.rootDir == "\\"
 rootDir :: (System os) => AbsDir os
 rootDir = untag rootDirTagged
 
@@ -487,8 +511,8 @@
 rootStringTagged :: (System os) => Tagged os String
 rootStringTagged = fmap (\sep -> [sep]) pathSeparator
 
--- >> Posix.toString Path.currentDir == "."
--- >> Windows.toString Path.currentDir == "."
+-- prop> Posix.toString Path.currentDir == "."
+-- prop> Windows.toString Path.currentDir == "."
 currentDir :: (System os) => RelDir os
 currentDir = mempty
 
@@ -530,32 +554,32 @@
 -- | This function is intended for checking and parsing paths
 --   provided as user input.
 --
--- >> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/"
--- >> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp"
--- >> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp"
--- >> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp"
--- >> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing
--- >> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp"
--- >> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp"
--- >> fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt"
--- >> fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing
--- >> fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp"
--- >> fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp"
--- >> fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp"
--- >> fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\"
--- >> fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:"
--- >> fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp"
--- >> fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing
--- >> fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing
--- >> fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing
--- >> fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/"
+-- prop> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp"
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp"
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp"
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp"
+-- prop> fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp"
+-- prop> fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt"
+-- prop> fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing
+-- prop> fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp"
+-- prop> fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp"
+-- prop> fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp"
+-- prop> fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\"
+-- prop> fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:"
+-- prop> fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp"
+-- prop> fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing
+-- prop> fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing
+-- prop> fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing
+-- prop> fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing
 maybe, maybePath ::
     (System os, Class.AbsRel ar, Class.FileDir fd) =>
     String -> Maybe (Path os ar fd)
@@ -604,30 +628,30 @@
 
 -- | Construct a 'RelFile' from a 'String'.
 --
--- >> Posix.toString (Posix.relFile "file.txt") == "file.txt"
--- >> Posix.toString (Posix.relFile "tmp") == "tmp"
+-- prop> Posix.toString (Posix.relFile "file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.relFile "tmp") == "tmp"
 relFile :: (System os) => String -> RelFile os
 relFile = path
 
 -- | Construct a 'RelDir' from a 'String'.
 --
--- >> Posix.toString (Posix.relDir ".") == "."
--- >> Posix.toString (Posix.relDir "file.txt") == "file.txt"
--- >> Posix.toString (Posix.relDir "tmp") == "tmp"
+-- prop> Posix.toString (Posix.relDir ".") == "."
+-- prop> Posix.toString (Posix.relDir "file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.relDir "tmp") == "tmp"
 relDir :: (System os) => String -> RelDir os
 relDir = path
 
 -- | Construct an 'AbsFile' from a 'String'.
 --
--- >> Posix.toString (Posix.absFile "/file.txt") == "/file.txt"
--- >> Posix.toString (Posix.absFile "/tmp") == "/tmp"
+-- prop> Posix.toString (Posix.absFile "/file.txt") == "/file.txt"
+-- prop> Posix.toString (Posix.absFile "/tmp") == "/tmp"
 absFile :: (System os) => String -> AbsFile os
 absFile = path
 
 -- | Construct an 'AbsDir' from a 'String'.
 --
--- >> Posix.toString (Posix.absDir "/file.txt") == "/file.txt"
--- >> Posix.toString (Posix.absDir "/tmp") == "/tmp"
+-- prop> Posix.toString (Posix.absDir "/file.txt") == "/file.txt"
+-- prop> Posix.toString (Posix.absDir "/tmp") == "/tmp"
 absDir :: (System os) => String -> AbsDir os
 absDir = path
 
@@ -722,16 +746,16 @@
 --   then you should use 'path'.
 --   If you got the string as user input then use 'maybePath' or 'parsePath'.
 --
--- >> Posix.asPath "/tmp" == Posix.absDir "/tmp"
--- >> Posix.asPath "file.txt" == Posix.relFile "file.txt"
--- >> Path.isAbsolute (Posix.asAbsDir "/tmp")
--- >> Path.isRelative (Posix.asRelDir "/tmp")
--- >> Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp"
--- >> Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp"
--- >> Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp"
--- >> Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp"
--- >> Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp"
--- >> Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp"
+-- prop> Posix.asPath "/tmp" == Posix.absDir "/tmp"
+-- prop> Posix.asPath "file.txt" == Posix.relFile "file.txt"
+-- prop> Path.isAbsolute (Posix.asAbsDir "/tmp")
+-- prop> Path.isRelative (Posix.asRelDir "/tmp")
+-- prop> Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp"
+-- prop> Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp"
+-- prop> Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp"
+-- prop> Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp"
+-- prop> Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp"
+-- prop> Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp"
 asPath ::
     (System os, Class.AbsRel ar, Class.FileDir fd) => String -> Path os ar fd
 asPath = uncurry mkPathFromComponents . untag mkPathComponents
@@ -739,34 +763,34 @@
 
 -- | Use a 'String' as a 'RelFile'. No checking is done.
 --
--- >> Posix.toString (Posix.asRelFile "file.txt") == "file.txt"
--- >> Posix.toString (Posix.asRelFile "/file.txt") == "file.txt"
--- >> Posix.toString (Posix.asRelFile "tmp") == "tmp"
--- >> Posix.toString (Posix.asRelFile "/tmp") == "tmp"
+-- prop> Posix.toString (Posix.asRelFile "file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.asRelFile "/file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.asRelFile "tmp") == "tmp"
+-- prop> Posix.toString (Posix.asRelFile "/tmp") == "tmp"
 asRelFile :: (System os) => String -> RelFile os
 asRelFile = asPath
 
 -- | Use a 'String' as a 'RelDir'. No checking is done.
 --
--- >> Posix.toString (Posix.asRelDir ".") == "."
--- >> Posix.toString (Posix.asRelDir "file.txt") == "file.txt"
--- >> Posix.toString (Posix.asRelDir "/file.txt") == "file.txt"
--- >> Posix.toString (Posix.asRelDir "tmp") == "tmp"
--- >> Posix.toString (Posix.asRelDir "/tmp") == "tmp"
+-- prop> Posix.toString (Posix.asRelDir ".") == "."
+-- prop> Posix.toString (Posix.asRelDir "file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.asRelDir "/file.txt") == "file.txt"
+-- prop> Posix.toString (Posix.asRelDir "tmp") == "tmp"
+-- prop> Posix.toString (Posix.asRelDir "/tmp") == "tmp"
 asRelDir :: (System os) => String -> RelDir os
 asRelDir = asPath
 
 -- | Use a 'String' as an 'AbsFile'. No checking is done.
 --
--- >> Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt"
--- >> Posix.toString (Posix.asAbsFile "/tmp") == "/tmp"
+-- prop> Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt"
+-- prop> Posix.toString (Posix.asAbsFile "/tmp") == "/tmp"
 asAbsFile :: (System os) => String -> AbsFile os
 asAbsFile = asPath
 
 -- | Use a 'String' as an 'AbsDir'. No checking is done.
 --
--- >> Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt"
--- >> Posix.toString (Posix.asAbsDir "/tmp") == "/tmp"
+-- prop> Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt"
+-- prop> Posix.toString (Posix.asAbsDir "/tmp") == "/tmp"
 asAbsDir :: (System os) => String -> AbsDir os
 asAbsDir = asPath
 
@@ -805,12 +829,12 @@
 -- | Examines the supplied string and constructs an absolute or
 -- relative path as appropriate.
 --
--- >> Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp")
--- >> Path.mkPathAbsOrRel  "tmp" == Right (Posix.relDir "tmp")
--- >> Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp")
--- >> Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp")
--- >> Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp")
--- >> Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp")
+-- prop> Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp")
+-- prop> Path.mkPathAbsOrRel  "tmp" == Right (Posix.relDir "tmp")
+-- prop> Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp")
+-- prop> Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp")
+-- prop> Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp")
+-- prop> Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp")
 mkPathAbsOrRel, mkPathAbsOrRelPriv ::
     (System os, Class.FileDir fd) =>
     String -> Either (AbsPath os fd) (RelPath os fd)
@@ -839,8 +863,8 @@
 -- | Convert a 'String' into an 'AbsPath' by interpreting it as
 --   relative to the supplied directory if necessary.
 --
--- >> Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt"
--- >> Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt"
+-- prop> Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt"
+-- prop> Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt"
 mkAbsPath ::
     (System os, Class.FileDir fd) => AbsDir os -> String -> AbsPath os fd
 mkAbsPath d = either id (makeAbsolute d) . mkPathAbsOrRelPriv
@@ -945,6 +969,7 @@
     <$>
     splitAbsolute
 
+-- | > \p -> uncurry Path.mkPathFromComponents (Path.pathComponents p) == (p::Default.AbsDir)
 pathComponents ::
     (Class.FileDir fd) => Path os ar fd -> (ar, [PathComponent os])
 pathComponents (Path ar pcs fd) =
@@ -979,15 +1004,15 @@
 
 -- | Infix variant of 'combine'.
 --
--- >> Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt"
--- >> Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt"
--- >> Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt"
--- >> Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt"
--- >> Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt"
--- >> Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt"
--- >> Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt"
--- >> Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt"
--- >> Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt"
+-- prop> Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt"
+-- prop> Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt"
+-- prop> Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt"
+-- prop> Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt"
+-- prop> Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt"
+-- prop> Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt"
+-- prop> Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt"
+-- prop> Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt"
+-- prop> Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt"
 (</>) :: DirPath os ar -> RelPath os fd -> Path os ar fd
 Path ar pcs0 Part.Dir  </>  Path Part.Rel pcs1 fd  =  Path ar (pcs0 ++ pcs1) fd
 
@@ -1014,33 +1039,32 @@
 -- | Add an extension, even if there is already one there.
 --   E.g. @addExtension \"foo.txt\" \"bat\" -> \"foo.txt.bat\"@.
 --
--- >> Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib"
--- >> Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib"
--- >> Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib"
--- >> Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib"
--- >> Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib"
--- >> Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext"
+-- prop> Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib"
+-- prop> Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib"
+-- prop> Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib"
+-- prop> Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib"
+-- prop> Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib"
+-- prop> Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext"
 addExtension :: FilePath os ar -> String -> FilePath os ar
 addExtension = (<.>)
 
 -- | Join an (absolute or relative) directory path with a relative
 --   (file or directory) path to form a new path.
+--
+-- prop> \p -> Path.combine Path.currentDir p == (p::Default.RelDir)
 combine :: DirPath os ar -> RelPath os fd -> Path os ar fd
 combine = (</>)
 
-prop_combine_currentDir :: (System os) => RelDir os -> Property
-prop_combine_currentDir p = property $ combine currentDir p == p
 
-
 -- | Remove last extension, and the \".\" preceding it.
 --
--- >> Path.dropExtension x == fst (Path.splitExtension x)
+-- prop> forAllAbsRel $ \x -> Path.dropExtension x == fst (Path.splitExtension x)
 dropExtension :: FilePath os ar -> FilePath os ar
 dropExtension = fst . splitExtension
 
 -- | Drop all extensions
 --
--- >> not $ Path.hasAnExtension (Path.dropExtensions x)
+-- prop> forAllAbsRel $ \x -> not $ Path.hasAnExtension (Path.dropExtensions x)
 dropExtensions :: FilePath os ar -> FilePath os ar
 dropExtensions = fst . splitExtensions
 
@@ -1051,11 +1075,11 @@
 
 -- | Set the extension of a file, overwriting one if already present.
 --
--- >> Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob"
--- >> Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob"
--- >> Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob"
--- >> Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file"
--- >> Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt"
+-- prop> Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob"
+-- prop> Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob"
+-- prop> Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob"
+-- prop> Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file"
+-- prop> Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt"
 replaceExtension :: FilePath os ar -> String -> FilePath os ar
 replaceExtension p ext = dropExtension p <.> ext
 
@@ -1072,33 +1096,30 @@
 
 -- | Split on the extension. 'addExtension' is the inverse.
 --
--- >> uncurry (<.>) (Path.splitExtension x) == x
--- >> uncurry Path.addExtension (Path.splitExtension x) == x
--- >> Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt")
--- >> Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc")
--- >> Path.splitExtension (relFile "file") == (Posix.relFile "file","")
--- >> Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt")
--- >> Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris","")
--- >> Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext")
--- >> Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred")
+-- prop> forAllAbsRel $ \x -> uncurry (<.>) (Path.splitExtension x) == x
+-- prop> forAllAbsRel $ \x -> uncurry Path.addExtension (Path.splitExtension x) == x
+-- prop> Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt")
+-- prop> Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc")
+-- prop> Path.splitExtension (relFile "file") == (Posix.relFile "file","")
+-- prop> Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt")
+-- prop> Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris","")
+-- prop> Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext")
+-- prop> Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred")
 splitExtension :: FilePath os ar -> (FilePath os ar, String)
 splitExtension = splitFilePart splitExtensionPC
 
 -- | Split on all extensions
 --
--- >> Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz")
+-- prop> Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz")
+-- prop> \p -> uncurry (<.>) (Path.splitExtension p) == (p::Default.AbsFile)
 splitExtensions :: FilePath os ar -> (FilePath os ar, String)
 splitExtensions = splitFilePart splitExtensionsPC
 
-prop_split_combineExt :: (System os) => AbsFile os -> Property
-prop_split_combineExt p = property $ p == uncurry (<.>) (splitExtension p)
-
+-- | prop> \p -> uncurry Path.combine (Path.splitFileName p) == (p::Default.AbsFile)
 splitFileName :: FilePath os ar -> (DirPath os ar, RelFile os)
 splitFileName (Path ar pcs fd) = (Path ar pcs Part.Dir, atomicFile fd)
 
-prop_split_combine :: (System os) => AbsFile os -> Property
-prop_split_combine p = property $ uncurry combine (splitFileName p) == p
-
+-- | > \p -> (uncurry Path.combine <$> Path.splitDirName p) == toMaybe (not $ Default.isDrive p) (p::Default.AbsDir)
 splitDirName :: DirPath os ar -> Maybe (DirPath os ar, RelDir os)
 splitDirName = fmap (mapSnd dirFromFile . splitFileName) . fileFromDir
 
@@ -1110,51 +1131,49 @@
 
 -- | Get the basename of a file
 --
--- >> Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile"
--- >> Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile"
--- >> Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile"
+-- prop> Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile"
+-- prop> Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile"
+-- prop> Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile"
 takeBaseName :: FilePath os ar -> RelFile os
 takeBaseName = takeFileName . dropExtension
 
 takeDirectory :: FilePath os ar -> DirPath os ar
 takeDirectory = fst . splitFileName
 
--- >> Path.takeSuperDirectory (Posix.absDir "/tmp/somedir") == Just (absDir "/tmp")
--- >> Path.takeSuperDirectory (Posix.absDir "/tmp/") == Just (absDir "/")
--- >> Path.takeSuperDirectory (Posix.absDir "/") == Nothing
--- >> Path.takeSuperDirectory (Posix.relDir "tmp/somedir") == Just (relDir "tmp")
--- >> Path.takeSuperDirectory (Posix.relDir "./somedir") == Just (relDir ".")
--- >> Path.takeSuperDirectory (Posix.relDir "somedir") == Just Path.currentDir
--- >> Path.takeSuperDirectory (Posix.relDir "") == Nothing
+-- prop> Path.takeSuperDirectory (Posix.absDir "/tmp/somedir") == Just (absDir "/tmp")
+-- prop> Path.takeSuperDirectory (Posix.absDir "/tmp/") == Just (absDir "/")
+-- prop> Path.takeSuperDirectory (Posix.absDir "/") == Nothing
+-- prop> Path.takeSuperDirectory (Posix.relDir "tmp/somedir") == Just (relDir "tmp")
+-- prop> Path.takeSuperDirectory (Posix.relDir "./somedir") == Just (relDir ".")
+-- prop> Path.takeSuperDirectory (Posix.relDir "somedir") == Just Path.currentDir
+-- prop> Path.takeSuperDirectory (Posix.relDir "") == Nothing
 takeSuperDirectory :: DirPath os ar -> Maybe (DirPath os ar)
 takeSuperDirectory = fmap takeDirectory . fileFromDir
 
 -- | Get the extension of a file, returns @\"\"@ for no extension, @.ext@ otherwise.
 --
--- >> Path.takeExtension x == snd (Path.splitExtension x)
--- >> Path.takeExtension (Path.addExtension x "ext") == ".ext"
--- >> Path.takeExtension (Path.replaceExtension x "ext") == ".ext"
+-- prop> forAllAbsRel $ \x -> Path.takeExtension x == snd (Path.splitExtension x)
+-- prop> forAllAbsRel $ \x -> Path.takeExtension (Path.addExtension x "ext") == ".ext"
+-- prop> forAllAbsRel $ \x -> Path.takeExtension (Path.replaceExtension x "ext") == ".ext"
 takeExtension :: FilePath os ar -> String
 takeExtension = snd . splitExtension
 
 -- | Get all extensions
 --
--- >> Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz"
+-- prop> Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz"
 takeExtensions :: FilePath os ar -> String
 takeExtensions = snd . splitExtensions
 
 -- | Get the filename component of a file path (ie stripping all parent dirs)
 --
--- >> Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt"
--- >> Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt"
--- >> Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt"
+-- prop> Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt"
+-- prop> Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt"
+-- prop> Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt"
+-- prop> \p -> Path.toString (Path.takeFileName p) `isSuffixOf` Path.toString (p::Default.AbsFile)
 takeFileName :: FilePath os ar -> RelFile os
 takeFileName (Path _ _ fd) = atomicFile fd
 
-prop_takeFileName_end :: (System os) => AbsFile os -> Property
-prop_takeFileName_end p =
-    property $ toString (takeFileName p) `isSuffixOf` toString p
-
+-- | > \p -> fmap (\d -> toString d `isSuffixOf` toString p) (takeDirName p) == toMaybe (not $ isDrive p) True
 takeDirName :: DirPath os ar -> Maybe (RelDir os)
 takeDirName = fmap snd . splitDirName
 
@@ -1179,20 +1198,20 @@
 
 -- | Check whether two strings are equal as file paths.
 --
--- >>       Posix.equalFilePath "abc/def" "abc/def"
--- >>       Posix.equalFilePath "abc/def" "abc//def"
--- >>       Posix.equalFilePath "/tmp/" "/tmp"
--- >>       Posix.equalFilePath "/tmp" "//tmp"
--- >>       Posix.equalFilePath "/tmp" "///tmp"
--- >> not $ Posix.equalFilePath "abc" "def"
--- >> not $ Posix.equalFilePath "/tmp" "tmp"
--- >>       Windows.equalFilePath "abc\\def" "abc\\def"
--- >>       Windows.equalFilePath "abc\\def" "abc\\\\def"
--- >>       Windows.equalFilePath "file" "File"
--- >>       Windows.equalFilePath "\\file" "\\\\file"
--- >>       Windows.equalFilePath "\\file" "\\\\\\file"
--- >> not $ Windows.equalFilePath "abc" "def"
--- >> not $ Windows.equalFilePath "file" "dir"
+-- prop>       Posix.equalFilePath "abc/def" "abc/def"
+-- prop>       Posix.equalFilePath "abc/def" "abc//def"
+-- prop>       Posix.equalFilePath "/tmp/" "/tmp"
+-- prop>       Posix.equalFilePath "/tmp" "//tmp"
+-- prop>       Posix.equalFilePath "/tmp" "///tmp"
+-- prop> not $ Posix.equalFilePath "abc" "def"
+-- prop> not $ Posix.equalFilePath "/tmp" "tmp"
+-- prop>       Windows.equalFilePath "abc\\def" "abc\\def"
+-- prop>       Windows.equalFilePath "abc\\def" "abc\\\\def"
+-- prop>       Windows.equalFilePath "file" "File"
+-- prop>       Windows.equalFilePath "\\file" "\\\\file"
+-- prop>       Windows.equalFilePath "\\file" "\\\\\\file"
+-- prop> not $ Windows.equalFilePath "abc" "def"
+-- prop> not $ Windows.equalFilePath "file" "dir"
 equalFilePath :: (System os) => Tagged os (String -> String -> Bool)
 equalFilePath = equating <$> mkPathAbsOrRelTagged
 
@@ -1205,21 +1224,21 @@
 --   It is an unchecked error if the path components contain path separators.
 --   It is an unchecked error if a 'RelFile' path is empty.
 --
--- >> Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir"
--- >> Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt"
+-- prop> Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir"
+-- prop> Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt"
 joinPath :: (Class.FileDir fd) => [String] -> RelPath os fd
 joinPath = mkPathFromComponents Part.Rel . map PathComponent
 
 -- | Currently just transforms:
 --
--- >> Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file"
+-- prop> Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file"
 normalise :: (System os) => Path os ar fd -> Path os ar fd
 normalise = mapPathDirs (filter (PathComponent currentDirComponent /=))
 
 -- | Deconstructs a path into its components.
 --
--- >> Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing)
--- >> Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt")
+-- prop> Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing)
+-- prop> Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt")
 splitPath ::
     (Class.AbsRel ar, Class.FileOrDir fd) =>
     Path os ar fd -> (Bool, [RelDir os], Maybe (RelFile os))
@@ -1235,11 +1254,11 @@
 --   the supplied 'AbsDir' from the front. It is a runtime 'error' if the
 --   supplied 'AbsPath' doesn't start with the 'AbsDir'.
 --
--- >> Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt"
--- >> Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir"
--- >> Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt"
--- >> Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir"
--- >> Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir"
+-- prop> Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt"
+-- prop> Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir"
+-- prop> Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt"
+-- prop> Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir"
+-- prop> Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir"
 makeRelative ::
     (System os, Class.FileDir fd) =>
     AbsDir os -> AbsPath os fd -> RelPath os fd
@@ -1250,9 +1269,9 @@
                 (toString orig) (toString relTo)) $
     makeRelativeMaybe relTo orig
 
--- >> Path.makeRelativeMaybe (Posix.absDir "/tmp/somedir") (absFile "/tmp/anotherdir/file.txt") == Nothing
--- >> Path.makeRelativeMaybe (Posix.absDir "/Tmp") (absFile "/tmp/anotherdir/file.txt") == Nothing
--- >> Path.makeRelativeMaybe (Windows.absDir "\\Tmp") (absFile "\\tmp\\anotherdir\\file.txt") == Just (relFile "anotherdir\\file.txt")
+-- prop> Path.makeRelativeMaybe (Posix.absDir "/tmp/somedir") (absFile "/tmp/anotherdir/file.txt") == Nothing
+-- prop> Path.makeRelativeMaybe (Posix.absDir "/Tmp") (absFile "/tmp/anotherdir/file.txt") == Nothing
+-- prop> Path.makeRelativeMaybe (Windows.absDir "\\Tmp") (absFile "\\tmp\\anotherdir\\file.txt") == Just (relFile "anotherdir\\file.txt")
 makeRelativeMaybe ::
     (System os, Class.FileDir fd) =>
     AbsDir os -> AbsPath os fd -> Maybe (RelPath os fd)
@@ -1266,9 +1285,11 @@
 -- | Joins an absolute directory with a relative path to construct a
 --   new absolute path.
 --
--- >> Path.makeAbsolute (absDir "/tmp") (relFile "file.txt")      == Posix.absFile "/tmp/file.txt"
--- >> Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt"
--- >> Path.makeAbsolute (absDir "/tmp") (relDir  "adir/dir")      == Posix.absDir "/tmp/adir/dir"
+-- prop> Path.makeAbsolute (absDir "/tmp") (relFile "file.txt")      == Posix.absFile "/tmp/file.txt"
+-- prop> Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt"
+-- prop> Path.makeAbsolute (absDir "/tmp") (relDir  "adir/dir")      == Posix.absDir "/tmp/adir/dir"
+-- prop> \base p -> Default.toString p `isSuffixOf` Path.toString (Path.makeAbsolute base (Path.idFile p))
+-- prop> \base p -> Default.toString base `isPrefixOf` Path.toString (Path.makeAbsolute base (Path.idFile p))
 makeAbsolute :: (System os) => AbsDir os -> RelPath os fd -> AbsPath os fd
 makeAbsolute = genericMakeAbsolute
 
@@ -1290,9 +1311,9 @@
 --   You should avoid the use of 'genericMakeAbsolute'-type functions,
 --   because then you avoid to absolutize a path that was already absolutized.
 --
--- >> Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt")       == Posix.absFile "/tmp/file.txt"
--- >> Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt")  == Posix.absFile "/tmp/adir/file.txt"
--- >> Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt"
+-- prop> Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt")       == Posix.absFile "/tmp/file.txt"
+-- prop> Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt")  == Posix.absFile "/tmp/adir/file.txt"
+-- prop> Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt"
 genericMakeAbsolute ::
     (System os, Class.AbsRel ar) => AbsDir os -> Path os ar fd -> AbsPath os fd
 genericMakeAbsolute base p = withAbsRel id (base </>) p
@@ -1305,16 +1326,6 @@
   cwdString <- SD.getCurrentDirectory -- we don't use System.Path.Directory impl here to avoid module cycle
   return $ genericMakeAbsolute (asAbsDir cwdString) p
 
-prop_makeAbsoluteFromDir_endSame ::
-    (System os) => AbsDir os -> RelFile os -> Property
-prop_makeAbsoluteFromDir_endSame base p =
-    property $ toString p `isSuffixOf` toString (makeAbsolute base p)
-
-prop_makeAbsoluteFromDir_startSame ::
-    (System os) => AbsDir os -> RelFile os -> Property
-prop_makeAbsoluteFromDir_startSame base p =
-    property $ toString base `isPrefixOf` toString (makeAbsolute base p)
-
 -- prop_makeAbsoluteFromDir_startSameAbs :: AbsDir os -> AbsFile -> Property
 -- prop_makeAbsoluteFromDir_startSameAbs base p = property $ show base `isPrefixOf` show (makeAbsolute base p)
 
@@ -1387,18 +1398,18 @@
 
 -- | Test whether a @'Path' ar fd@ is absolute.
 --
--- >> Path.isAbsolute (Posix.absFile "/fred")
--- >> Path.isAbsolute (Windows.absFile "\\fred")
--- >> Path.isAbsolute (Windows.absFile "c:\\fred")
--- >> Path.isAbsolute (Windows.absFile "c:fred")
+-- prop> Path.isAbsolute (Posix.absFile "/fred")
+-- prop> Path.isAbsolute (Windows.absFile "\\fred")
+-- prop> Path.isAbsolute (Windows.absFile "c:\\fred")
+-- prop> Path.isAbsolute (Windows.absFile "c:fred")
 isAbsolute :: Class.AbsRel ar => Path os ar fd -> Bool
 isAbsolute = withAbsRel (const True) (const False)
 
 -- | Invariant - this should return True iff arg is of type @'Path' Part.Rel _@
 --
 -- > isRelative = not . isAbsolute
--- >> Path.isRelative (Posix.relFile "fred")
--- >> Path.isRelative (Windows.relFile "fred")
+-- prop> Path.isRelative (Posix.relFile "fred")
+-- prop> Path.isRelative (Windows.relFile "fred")
 isRelative :: Class.AbsRel ar => Path os ar fd -> Bool
 isRelative = not . isAbsolute
 
@@ -1423,15 +1434,15 @@
 
 -- | Does the given filename have an extension?
 --
--- >> null (Path.takeExtension x) == not (Path.hasAnExtension x)
+-- prop> forAllAbsRel $ \x -> null (Path.takeExtension x) == not (Path.hasAnExtension x)
 hasAnExtension :: FilePath os ar -> Bool
 hasAnExtension = not . null . snd . splitExtension
 
 -- | Does the given filename have the given extension?
 --
--- >> Path.hasExtension ".hs" (Posix.relFile "MyCode.hs")
--- >> Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs")
--- >> not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak")
+-- prop> Path.hasExtension ".hs" (Posix.relFile "MyCode.hs")
+-- prop> Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs")
+-- prop> not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak")
 hasExtension :: String -> FilePath os ar -> Bool
 hasExtension ext = (==ext) . snd . splitExtension
 
@@ -1441,7 +1452,7 @@
 
 -- | Part.File extension character
 --
--- >> Posix.extSeparator == '.'
+-- prop> Posix.extSeparator == '.'
 extSeparator :: Char
 extSeparator = '.'
 
@@ -1452,13 +1463,13 @@
 
 -- | Is the character an extension character?
 --
--- >> Posix.isExtSeparator a == (a == Posix.extSeparator)
+-- prop> \a -> Posix.isExtSeparator a == (a == Posix.extSeparator)
 isExtSeparator :: Char -> Bool
 isExtSeparator = (== extSeparator)
 
 -- | Is the character a file separator?
 --
--- >> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)
+-- prop> \a -> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)
 isSearchPathSeparator :: Char -> Bool
 isSearchPathSeparator = (== searchPathSeparator)
 
@@ -1474,10 +1485,10 @@
 -- | This is a more flexible variant of 'addExtension' / '<.>' which can
 --   work with files or directories
 --
--- >> Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x"
--- >> Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x"
--- >> Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x"
--- >> Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile
+-- prop> Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x"
+-- prop> Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x"
+-- prop> Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x"
+-- prop> Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile
 genericAddExtension ::
     (Class.FileDir fd) => Path os ar fd -> String -> Path os ar fd
 genericAddExtension =
@@ -1646,34 +1657,20 @@
 ------------------------------------------------------------------------
 -- QuickCheck
 
-testAll :: (System os) => os -> [(String, IO ())]
+testAll :: (System os) => os -> [(String, DocTest.T ())]
 testAll os =
-    ("asPath_toString",
-        quickCheck os prop_asPath_toString) :
     ("mkPathFromComponents_pathComponents",
         quickCheck os prop_mkPathFromComponents_pathComponents) :
-    ("combine_currentDir",
-        quickCheck os prop_combine_currentDir) :
-    ("makeAbsoluteFromDir_endSame",
-        quickCheck os prop_makeAbsoluteFromDir_endSame) :
-    ("makeAbsoluteFromDir_startSame",
-        quickCheck os prop_makeAbsoluteFromDir_startSame) :
-    ("split_combine",
-        quickCheck os prop_split_combine) :
     ("splitDir_combine",
         quickCheck os prop_splitDir_combine) :
-    ("takeFileName_end",
-        quickCheck os prop_takeFileName_end) :
     ("takeDirName_end",
         quickCheck os prop_takeDirName_end) :
-    ("split_combineExt",
-        quickCheck os prop_split_combineExt) :
     []
 
 quickCheck ::
     (QC.Testable prop, System os, Class.FileDir fd, Class.AbsRel ar) =>
-    os -> (Path os ar fd -> prop) -> IO ()
-quickCheck _ = QC.quickCheck
+    os -> (Path os ar fd -> prop) -> DocTest.T ()
+quickCheck _ = DocTest.property
 
 -- test :: Testable a => a -> IO ()
 -- test = quickCheck
diff --git a/src/System/Path/Posix.hs b/src/System/Path/Posix.hs
--- a/src/System/Path/Posix.hs
+++ b/src/System/Path/Posix.hs
@@ -38,6 +38,8 @@
 
 import Data.Tagged (Tagged(Tagged), untag)
 
+import qualified Test.DocTest.Driver as DocTest
+
 import Prelude hiding (FilePath, maybe, abs)
 
 
@@ -239,5 +241,5 @@
 hasTrailingPathSeparator = isPathSeparator . last
 
 
-testAll :: [(String, IO ())]
+testAll :: [(String, DocTest.T ())]
 testAll = Core.testAll Posix
diff --git a/src/System/Path/Windows.hs b/src/System/Path/Windows.hs
--- a/src/System/Path/Windows.hs
+++ b/src/System/Path/Windows.hs
@@ -41,6 +41,7 @@
 import Data.Char (isAlpha, toLower)
 import Data.Monoid (mempty, (<>))
 
+import qualified Test.DocTest.Driver as DocTest
 import qualified Test.QuickCheck as QC
 
 import Prelude hiding (FilePath, maybe, abs)
@@ -250,5 +251,5 @@
 hasTrailingPathSeparator = isPathSeparator . last
 
 
-testAll :: [(String, IO ())]
+testAll :: [(String, DocTest.T ())]
 testAll = Core.testAll Windows
diff --git a/test/Test.hs b/test/Test.hs
--- a/test/Test.hs
+++ b/test/Test.hs
@@ -1,38 +1,24 @@
 module Main (main) where
 
-import TestResult (results)
+import qualified Test.Posix.System.Path.Internal as TestPosix
+import qualified Test.Windows.System.Path.Internal as TestWindows
 
+import qualified Test.DocTest.Driver as DocTest
+
 import qualified System.Path.Posix as Posix
 import qualified System.Path.Windows as Windows
-import System.Path (rootDir, relDir, relFile, (</>), (<.>))
-import System.Random (newStdGen, random)
-import System.Exit (exitFailure)
-import Control.Monad (void)
-import Text.Printf (printf)
 
 
 main :: IO ()
-main = do
-  g <- newStdGen
-  let (a,_g') = random g
-      -- TODO - integrate with QuickCheck
-      x = rootDir </> relDir "tmp" </> relFile "someFile" <.> "ext"
-
-  let allResults = results a x
-  void $ printf "Running %d tests...\n" $ length allResults
-
-  let fails = map fst $ filter (not . snd) allResults
-  if null fails
-    then do
-      putStrLn "Passed."
-    else do
-      putStrLn "Failed tests:"
-      mapM_ putStrLn fails
-      exitFailure
+main = DocTest.run $ do
+  DocTest.printLine "\nPosix"
+  TestPosix.test
+  DocTest.printLine "\nWindows"
+  TestWindows.test
 
-  putStrLn "Running QuickCheck tests ..."
+  DocTest.printLine "\nTests of internal functions"
   let runQC prefix =
-        mapM_ $ \(name, test) -> putStr (prefix ++ name ++ ": ") >> test
+        mapM_ $ \(name, test) ->
+          DocTest.printPrefix (prefix ++ name ++ ": ") >> test
   runQC "Posix." Posix.testAll
   runQC "Windows." Windows.testAll
-  putStrLn "Tests completed."
diff --git a/test/Test/Posix/System/Path/Internal.hs b/test/Test/Posix/System/Path/Internal.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/Posix/System/Path/Internal.hs
@@ -0,0 +1,877 @@
+-- Do not edit! Automatically created with doctest-extract from src/System/Path/Internal.hs
+{-# LINE 196 "src/System/Path/Internal.hs" #-}
+
+{-# OPTIONS_GHC -XTypeFamilies #-}
+
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
+module Test.Posix.System.Path.Internal where
+
+import qualified System.Path.Posix as Default
+import Test.DocTest.Base
+import qualified Test.DocTest.Driver as DocTest
+
+{-# LINE 200 "src/System/Path/Internal.hs" #-}
+import     qualified System.Path.PartClass as Class
+import     qualified System.Path.Generic as Path
+import     qualified System.Path.Posix as Posix
+import     qualified System.Path.Windows as Windows
+import     System.Path.Generic ((</>), (<.>), relFile, relDir, absFile, absDir)
+import     Data.List (isSuffixOf, isPrefixOf)
+import     Data.Char (toLower)
+import     qualified Test.QuickCheck as QC
+forAllAbsRel     :: (Class.FileDir fd, QC.Testable prop) => (Default.AbsRel fd -> prop) -> QC.Property
+forAllAbsRel     = QC.forAll QC.arbitrary
+
+test :: DocTest.T ()
+test = do
+ DocTest.printPrefix "System.Path.Internal:280: "
+{-# LINE 280 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 280 "src/System/Path/Internal.hs" #-}
+        (Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets")
+ DocTest.printPrefix "System.Path.Internal:353: "
+{-# LINE 353 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 353 "src/System/Path/Internal.hs" #-}
+   (Posix.rootDir </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "rootDir </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:355: "
+{-# LINE 355 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 355 "src/System/Path/Internal.hs" #-}
+   (Just (Posix.rootDir </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (rootDir </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:357: "
+{-# LINE 357 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 357 "src/System/Path/Internal.hs" #-}
+   (Posix.currentDir </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "currentDir </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:359: "
+{-# LINE 359 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 359 "src/System/Path/Internal.hs" #-}
+   (Just (Posix.currentDir </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (currentDir </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:361: "
+{-# LINE 361 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 361 "src/System/Path/Internal.hs" #-}
+   (Windows.absDir "c:" </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "absDir \"c:\" </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:363: "
+{-# LINE 363 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 363 "src/System/Path/Internal.hs" #-}
+   (Just (Windows.absDir "c:\\" </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (absDir \"c:\\\\\" </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:475: "
+{-# LINE 475 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 475 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.asPath (Path.toString p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:557: "
+{-# LINE 557 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 557 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/")
+ DocTest.printPrefix "System.Path.Internal:558: "
+{-# LINE 558 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 558 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:559: "
+{-# LINE 559 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 559 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:560: "
+{-# LINE 560 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 560 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:561: "
+{-# LINE 561 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 561 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:562: "
+{-# LINE 562 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 562 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:563: "
+{-# LINE 563 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 563 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:564: "
+{-# LINE 564 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 564 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:565: "
+{-# LINE 565 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 565 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:566: "
+{-# LINE 566 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 566 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:567: "
+{-# LINE 567 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 567 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:568: "
+{-# LINE 568 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 568 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:569: "
+{-# LINE 569 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 569 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:570: "
+{-# LINE 570 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 570 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:571: "
+{-# LINE 571 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 571 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt")
+ DocTest.printPrefix "System.Path.Internal:572: "
+{-# LINE 572 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 572 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:573: "
+{-# LINE 573 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 573 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp")
+ DocTest.printPrefix "System.Path.Internal:574: "
+{-# LINE 574 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 574 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp")
+ DocTest.printPrefix "System.Path.Internal:575: "
+{-# LINE 575 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 575 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp")
+ DocTest.printPrefix "System.Path.Internal:576: "
+{-# LINE 576 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 576 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\")
+ DocTest.printPrefix "System.Path.Internal:577: "
+{-# LINE 577 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 577 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:")
+ DocTest.printPrefix "System.Path.Internal:578: "
+{-# LINE 578 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 578 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp")
+ DocTest.printPrefix "System.Path.Internal:579: "
+{-# LINE 579 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 579 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:580: "
+{-# LINE 580 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 580 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:581: "
+{-# LINE 581 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 581 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:582: "
+{-# LINE 582 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 582 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:631: "
+{-# LINE 631 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 631 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relFile "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:632: "
+{-# LINE 632 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 632 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relFile "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:638: "
+{-# LINE 638 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 638 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir ".") == ".")
+ DocTest.printPrefix "System.Path.Internal:639: "
+{-# LINE 639 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 639 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:640: "
+{-# LINE 640 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 640 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:646: "
+{-# LINE 646 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 646 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absFile "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:647: "
+{-# LINE 647 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 647 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absFile "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:653: "
+{-# LINE 653 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 653 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:654: "
+{-# LINE 654 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 654 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:749: "
+{-# LINE 749 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 749 "src/System/Path/Internal.hs" #-}
+        (Posix.asPath "/tmp" == Posix.absDir "/tmp")
+ DocTest.printPrefix "System.Path.Internal:750: "
+{-# LINE 750 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 750 "src/System/Path/Internal.hs" #-}
+        (Posix.asPath "file.txt" == Posix.relFile "file.txt")
+ DocTest.printPrefix "System.Path.Internal:751: "
+{-# LINE 751 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 751 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Posix.asAbsDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:752: "
+{-# LINE 752 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 752 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Posix.asRelDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:753: "
+{-# LINE 753 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 753 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:754: "
+{-# LINE 754 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 754 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp")
+ DocTest.printPrefix "System.Path.Internal:755: "
+{-# LINE 755 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 755 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp")
+ DocTest.printPrefix "System.Path.Internal:756: "
+{-# LINE 756 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 756 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp")
+ DocTest.printPrefix "System.Path.Internal:757: "
+{-# LINE 757 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 757 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp")
+ DocTest.printPrefix "System.Path.Internal:758: "
+{-# LINE 758 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 758 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp")
+ DocTest.printPrefix "System.Path.Internal:766: "
+{-# LINE 766 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 766 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:767: "
+{-# LINE 767 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 767 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "/file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:768: "
+{-# LINE 768 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 768 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:769: "
+{-# LINE 769 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 769 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "/tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:775: "
+{-# LINE 775 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 775 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir ".") == ".")
+ DocTest.printPrefix "System.Path.Internal:776: "
+{-# LINE 776 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 776 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:777: "
+{-# LINE 777 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 777 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "/file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:778: "
+{-# LINE 778 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 778 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:779: "
+{-# LINE 779 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 779 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "/tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:785: "
+{-# LINE 785 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 785 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:786: "
+{-# LINE 786 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 786 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsFile "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:792: "
+{-# LINE 792 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 792 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:793: "
+{-# LINE 793 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 793 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsDir "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:832: "
+{-# LINE 832 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 832 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:833: "
+{-# LINE 833 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 833 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel  "tmp" == Right (Posix.relDir "tmp"))
+ DocTest.printPrefix "System.Path.Internal:834: "
+{-# LINE 834 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 834 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp"))
+ DocTest.printPrefix "System.Path.Internal:835: "
+{-# LINE 835 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 835 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp"))
+ DocTest.printPrefix "System.Path.Internal:836: "
+{-# LINE 836 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 836 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp"))
+ DocTest.printPrefix "System.Path.Internal:837: "
+{-# LINE 837 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 837 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp"))
+ DocTest.printPrefix "System.Path.Internal:866: "
+{-# LINE 866 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 866 "src/System/Path/Internal.hs" #-}
+        (Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt")
+ DocTest.printPrefix "System.Path.Internal:867: "
+{-# LINE 867 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 867 "src/System/Path/Internal.hs" #-}
+        (Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt")
+ DocTest.printPrefix "System.Path.Internal:1007: "
+{-# LINE 1007 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1007 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1008: "
+{-# LINE 1008 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1008 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1009: "
+{-# LINE 1009 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1009 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1010: "
+{-# LINE 1010 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1010 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1011: "
+{-# LINE 1011 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1011 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1012: "
+{-# LINE 1012 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1012 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1013: "
+{-# LINE 1013 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1013 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1014: "
+{-# LINE 1014 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1014 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1015: "
+{-# LINE 1015 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1015 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1042: "
+{-# LINE 1042 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1042 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib")
+ DocTest.printPrefix "System.Path.Internal:1043: "
+{-# LINE 1043 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1043 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib")
+ DocTest.printPrefix "System.Path.Internal:1044: "
+{-# LINE 1044 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1044 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib")
+ DocTest.printPrefix "System.Path.Internal:1045: "
+{-# LINE 1045 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1045 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib")
+ DocTest.printPrefix "System.Path.Internal:1046: "
+{-# LINE 1046 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1046 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib")
+ DocTest.printPrefix "System.Path.Internal:1047: "
+{-# LINE 1047 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1047 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext")
+ DocTest.printPrefix "System.Path.Internal:1054: "
+{-# LINE 1054 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1054 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.combine Path.currentDir p == (p::Default.RelDir))
+ DocTest.printPrefix "System.Path.Internal:1061: "
+{-# LINE 1061 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1061 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.dropExtension x == fst (Path.splitExtension x))
+ DocTest.printPrefix "System.Path.Internal:1067: "
+{-# LINE 1067 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1067 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> not $ Path.hasAnExtension (Path.dropExtensions x))
+ DocTest.printPrefix "System.Path.Internal:1078: "
+{-# LINE 1078 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1078 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1079: "
+{-# LINE 1079 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1079 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1080: "
+{-# LINE 1080 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1080 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1081: "
+{-# LINE 1081 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1081 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file")
+ DocTest.printPrefix "System.Path.Internal:1082: "
+{-# LINE 1082 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1082 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt")
+ DocTest.printPrefix "System.Path.Internal:1099: "
+{-# LINE 1099 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1099 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> uncurry (<.>) (Path.splitExtension x) == x)
+ DocTest.printPrefix "System.Path.Internal:1100: "
+{-# LINE 1100 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1100 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> uncurry Path.addExtension (Path.splitExtension x) == x)
+ DocTest.printPrefix "System.Path.Internal:1101: "
+{-# LINE 1101 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1101 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt"))
+ DocTest.printPrefix "System.Path.Internal:1102: "
+{-# LINE 1102 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1102 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc"))
+ DocTest.printPrefix "System.Path.Internal:1103: "
+{-# LINE 1103 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1103 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file") == (Posix.relFile "file",""))
+ DocTest.printPrefix "System.Path.Internal:1104: "
+{-# LINE 1104 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1104 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt"))
+ DocTest.printPrefix "System.Path.Internal:1105: "
+{-# LINE 1105 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1105 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris",""))
+ DocTest.printPrefix "System.Path.Internal:1106: "
+{-# LINE 1106 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1106 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext"))
+ DocTest.printPrefix "System.Path.Internal:1107: "
+{-# LINE 1107 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1107 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred"))
+ DocTest.printPrefix "System.Path.Internal:1113: "
+{-# LINE 1113 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1113 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz"))
+ DocTest.printPrefix "System.Path.Internal:1114: "
+{-# LINE 1114 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1114 "src/System/Path/Internal.hs" #-}
+        (\p -> uncurry (<.>) (Path.splitExtension p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1118: "
+{-# LINE 1118 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1118 "src/System/Path/Internal.hs" #-}
+          (\p -> uncurry Path.combine (Path.splitFileName p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1134: "
+{-# LINE 1134 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1134 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1135: "
+{-# LINE 1135 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1135 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1136: "
+{-# LINE 1136 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1136 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1155: "
+{-# LINE 1155 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1155 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension x == snd (Path.splitExtension x))
+ DocTest.printPrefix "System.Path.Internal:1156: "
+{-# LINE 1156 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1156 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension (Path.addExtension x "ext") == ".ext")
+ DocTest.printPrefix "System.Path.Internal:1157: "
+{-# LINE 1157 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1157 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension (Path.replaceExtension x "ext") == ".ext")
+ DocTest.printPrefix "System.Path.Internal:1163: "
+{-# LINE 1163 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1163 "src/System/Path/Internal.hs" #-}
+        (Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz")
+ DocTest.printPrefix "System.Path.Internal:1169: "
+{-# LINE 1169 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1169 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1170: "
+{-# LINE 1170 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1170 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1171: "
+{-# LINE 1171 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1171 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1172: "
+{-# LINE 1172 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1172 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.toString (Path.takeFileName p) `isSuffixOf` Path.toString (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1201: "
+{-# LINE 1201 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1201 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "abc/def" "abc/def")
+ DocTest.printPrefix "System.Path.Internal:1202: "
+{-# LINE 1202 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1202 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "abc/def" "abc//def")
+ DocTest.printPrefix "System.Path.Internal:1203: "
+{-# LINE 1203 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1203 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp/" "/tmp")
+ DocTest.printPrefix "System.Path.Internal:1204: "
+{-# LINE 1204 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1204 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp" "//tmp")
+ DocTest.printPrefix "System.Path.Internal:1205: "
+{-# LINE 1205 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1205 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp" "///tmp")
+ DocTest.printPrefix "System.Path.Internal:1206: "
+{-# LINE 1206 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1206 "src/System/Path/Internal.hs" #-}
+        (not $ Posix.equalFilePath "abc" "def")
+ DocTest.printPrefix "System.Path.Internal:1207: "
+{-# LINE 1207 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1207 "src/System/Path/Internal.hs" #-}
+        (not $ Posix.equalFilePath "/tmp" "tmp")
+ DocTest.printPrefix "System.Path.Internal:1208: "
+{-# LINE 1208 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1208 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "abc\\def" "abc\\def")
+ DocTest.printPrefix "System.Path.Internal:1209: "
+{-# LINE 1209 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1209 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "abc\\def" "abc\\\\def")
+ DocTest.printPrefix "System.Path.Internal:1210: "
+{-# LINE 1210 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1210 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "file" "File")
+ DocTest.printPrefix "System.Path.Internal:1211: "
+{-# LINE 1211 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1211 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "\\file" "\\\\file")
+ DocTest.printPrefix "System.Path.Internal:1212: "
+{-# LINE 1212 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1212 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "\\file" "\\\\\\file")
+ DocTest.printPrefix "System.Path.Internal:1213: "
+{-# LINE 1213 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1213 "src/System/Path/Internal.hs" #-}
+        (not $ Windows.equalFilePath "abc" "def")
+ DocTest.printPrefix "System.Path.Internal:1214: "
+{-# LINE 1214 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1214 "src/System/Path/Internal.hs" #-}
+        (not $ Windows.equalFilePath "file" "dir")
+ DocTest.printPrefix "System.Path.Internal:1227: "
+{-# LINE 1227 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1227 "src/System/Path/Internal.hs" #-}
+        (Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir")
+ DocTest.printPrefix "System.Path.Internal:1228: "
+{-# LINE 1228 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1228 "src/System/Path/Internal.hs" #-}
+        (Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1234: "
+{-# LINE 1234 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1234 "src/System/Path/Internal.hs" #-}
+        (Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file")
+ DocTest.printPrefix "System.Path.Internal:1240: "
+{-# LINE 1240 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1240 "src/System/Path/Internal.hs" #-}
+        (Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing))
+ DocTest.printPrefix "System.Path.Internal:1241: "
+{-# LINE 1241 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1241 "src/System/Path/Internal.hs" #-}
+        (Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt"))
+ DocTest.printPrefix "System.Path.Internal:1257: "
+{-# LINE 1257 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1257 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1258: "
+{-# LINE 1258 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1258 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir")
+ DocTest.printPrefix "System.Path.Internal:1259: "
+{-# LINE 1259 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1259 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt")
+ DocTest.printPrefix "System.Path.Internal:1260: "
+{-# LINE 1260 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1260 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir")
+ DocTest.printPrefix "System.Path.Internal:1261: "
+{-# LINE 1261 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1261 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir")
+ DocTest.printPrefix "System.Path.Internal:1288: "
+{-# LINE 1288 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1288 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relFile "file.txt")      == Posix.absFile "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1289: "
+{-# LINE 1289 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1289 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1290: "
+{-# LINE 1290 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1290 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relDir  "adir/dir")      == Posix.absDir "/tmp/adir/dir")
+ DocTest.printPrefix "System.Path.Internal:1291: "
+{-# LINE 1291 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1291 "src/System/Path/Internal.hs" #-}
+        (\base p -> Default.toString p `isSuffixOf` Path.toString (Path.makeAbsolute base (Path.idFile p)))
+ DocTest.printPrefix "System.Path.Internal:1292: "
+{-# LINE 1292 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1292 "src/System/Path/Internal.hs" #-}
+        (\base p -> Default.toString base `isPrefixOf` Path.toString (Path.makeAbsolute base (Path.idFile p)))
+ DocTest.printPrefix "System.Path.Internal:1314: "
+{-# LINE 1314 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1314 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt")       == Posix.absFile "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1315: "
+{-# LINE 1315 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1315 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt")  == Posix.absFile "/tmp/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1316: "
+{-# LINE 1316 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1316 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1401: "
+{-# LINE 1401 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1401 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Posix.absFile "/fred"))
+ DocTest.printPrefix "System.Path.Internal:1402: "
+{-# LINE 1402 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1402 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "\\fred"))
+ DocTest.printPrefix "System.Path.Internal:1403: "
+{-# LINE 1403 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1403 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "c:\\fred"))
+ DocTest.printPrefix "System.Path.Internal:1404: "
+{-# LINE 1404 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1404 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "c:fred"))
+ DocTest.printPrefix "System.Path.Internal:1411: "
+{-# LINE 1411 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1411 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Posix.relFile "fred"))
+ DocTest.printPrefix "System.Path.Internal:1412: "
+{-# LINE 1412 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1412 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Windows.relFile "fred"))
+ DocTest.printPrefix "System.Path.Internal:1437: "
+{-# LINE 1437 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1437 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> null (Path.takeExtension x) == not (Path.hasAnExtension x))
+ DocTest.printPrefix "System.Path.Internal:1443: "
+{-# LINE 1443 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1443 "src/System/Path/Internal.hs" #-}
+        (Path.hasExtension ".hs" (Posix.relFile "MyCode.hs"))
+ DocTest.printPrefix "System.Path.Internal:1444: "
+{-# LINE 1444 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1444 "src/System/Path/Internal.hs" #-}
+        (Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs"))
+ DocTest.printPrefix "System.Path.Internal:1445: "
+{-# LINE 1445 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1445 "src/System/Path/Internal.hs" #-}
+        (not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak"))
+ DocTest.printPrefix "System.Path.Internal:1455: "
+{-# LINE 1455 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1455 "src/System/Path/Internal.hs" #-}
+        (Posix.extSeparator == '.')
+ DocTest.printPrefix "System.Path.Internal:1466: "
+{-# LINE 1466 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1466 "src/System/Path/Internal.hs" #-}
+        (\a -> Posix.isExtSeparator a == (a == Posix.extSeparator))
+ DocTest.printPrefix "System.Path.Internal:1472: "
+{-# LINE 1472 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1472 "src/System/Path/Internal.hs" #-}
+        (\a -> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator))
+ DocTest.printPrefix "System.Path.Internal:1488: "
+{-# LINE 1488 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1488 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x")
+ DocTest.printPrefix "System.Path.Internal:1489: "
+{-# LINE 1489 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1489 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x")
+ DocTest.printPrefix "System.Path.Internal:1490: "
+{-# LINE 1490 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1490 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x")
+ DocTest.printPrefix "System.Path.Internal:1491: "
+{-# LINE 1491 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1491 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile)
diff --git a/test/Test/Windows/System/Path/Internal.hs b/test/Test/Windows/System/Path/Internal.hs
new file mode 100644
--- /dev/null
+++ b/test/Test/Windows/System/Path/Internal.hs
@@ -0,0 +1,877 @@
+-- Do not edit! Automatically created with doctest-extract from src/System/Path/Internal.hs
+{-# LINE 196 "src/System/Path/Internal.hs" #-}
+
+{-# OPTIONS_GHC -XTypeFamilies #-}
+
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
+module Test.Windows.System.Path.Internal where
+
+import qualified System.Path.Windows as Default
+import Test.DocTest.Base
+import qualified Test.DocTest.Driver as DocTest
+
+{-# LINE 200 "src/System/Path/Internal.hs" #-}
+import     qualified System.Path.PartClass as Class
+import     qualified System.Path.Generic as Path
+import     qualified System.Path.Posix as Posix
+import     qualified System.Path.Windows as Windows
+import     System.Path.Generic ((</>), (<.>), relFile, relDir, absFile, absDir)
+import     Data.List (isSuffixOf, isPrefixOf)
+import     Data.Char (toLower)
+import     qualified Test.QuickCheck as QC
+forAllAbsRel     :: (Class.FileDir fd, QC.Testable prop) => (Default.AbsRel fd -> prop) -> QC.Property
+forAllAbsRel     = QC.forAll QC.arbitrary
+
+test :: DocTest.T ()
+test = do
+ DocTest.printPrefix "System.Path.Internal:280: "
+{-# LINE 280 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 280 "src/System/Path/Internal.hs" #-}
+        (Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets")
+ DocTest.printPrefix "System.Path.Internal:353: "
+{-# LINE 353 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 353 "src/System/Path/Internal.hs" #-}
+   (Posix.rootDir </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "rootDir </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:355: "
+{-# LINE 355 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 355 "src/System/Path/Internal.hs" #-}
+   (Just (Posix.rootDir </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (rootDir </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:357: "
+{-# LINE 357 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 357 "src/System/Path/Internal.hs" #-}
+   (Posix.currentDir </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "currentDir </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:359: "
+{-# LINE 359 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 359 "src/System/Path/Internal.hs" #-}
+   (Just (Posix.currentDir </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (currentDir </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:361: "
+{-# LINE 361 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 361 "src/System/Path/Internal.hs" #-}
+   (Windows.absDir "c:" </> relDir "bla" </> relFile "blub")
+  [ExpectedLine [LineChunk "absDir \"c:\" </> relPath \"bla\" </> relPath \"blub\""]]
+ DocTest.printPrefix "System.Path.Internal:363: "
+{-# LINE 363 "src/System/Path/Internal.hs" #-}
+ DocTest.example
+{-# LINE 363 "src/System/Path/Internal.hs" #-}
+   (Just (Windows.absDir "c:\\" </> relDir "bla" </> relFile "blub"))
+  [ExpectedLine [LineChunk "Just (absDir \"c:\\\\\" </> relPath \"bla\" </> relPath \"blub\")"]]
+ DocTest.printPrefix "System.Path.Internal:475: "
+{-# LINE 475 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 475 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.asPath (Path.toString p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:557: "
+{-# LINE 557 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 557 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/")
+ DocTest.printPrefix "System.Path.Internal:558: "
+{-# LINE 558 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 558 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:559: "
+{-# LINE 559 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 559 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:560: "
+{-# LINE 560 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 560 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:561: "
+{-# LINE 561 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 561 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:562: "
+{-# LINE 562 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 562 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:563: "
+{-# LINE 563 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 563 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:564: "
+{-# LINE 564 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 564 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:565: "
+{-# LINE 565 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 565 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:566: "
+{-# LINE 566 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 566 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:567: "
+{-# LINE 567 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 567 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:568: "
+{-# LINE 568 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 568 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:569: "
+{-# LINE 569 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 569 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:570: "
+{-# LINE 570 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 570 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp")
+ DocTest.printPrefix "System.Path.Internal:571: "
+{-# LINE 571 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 571 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt")
+ DocTest.printPrefix "System.Path.Internal:572: "
+{-# LINE 572 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 572 "src/System/Path/Internal.hs" #-}
+        (fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:573: "
+{-# LINE 573 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 573 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp")
+ DocTest.printPrefix "System.Path.Internal:574: "
+{-# LINE 574 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 574 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp")
+ DocTest.printPrefix "System.Path.Internal:575: "
+{-# LINE 575 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 575 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp")
+ DocTest.printPrefix "System.Path.Internal:576: "
+{-# LINE 576 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 576 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\")
+ DocTest.printPrefix "System.Path.Internal:577: "
+{-# LINE 577 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 577 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:")
+ DocTest.printPrefix "System.Path.Internal:578: "
+{-# LINE 578 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 578 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp")
+ DocTest.printPrefix "System.Path.Internal:579: "
+{-# LINE 579 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 579 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:580: "
+{-# LINE 580 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 580 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:581: "
+{-# LINE 581 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 581 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:582: "
+{-# LINE 582 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 582 "src/System/Path/Internal.hs" #-}
+        (fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing)
+ DocTest.printPrefix "System.Path.Internal:631: "
+{-# LINE 631 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 631 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relFile "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:632: "
+{-# LINE 632 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 632 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relFile "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:638: "
+{-# LINE 638 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 638 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir ".") == ".")
+ DocTest.printPrefix "System.Path.Internal:639: "
+{-# LINE 639 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 639 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:640: "
+{-# LINE 640 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 640 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:646: "
+{-# LINE 646 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 646 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absFile "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:647: "
+{-# LINE 647 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 647 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absFile "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:653: "
+{-# LINE 653 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 653 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:654: "
+{-# LINE 654 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 654 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:749: "
+{-# LINE 749 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 749 "src/System/Path/Internal.hs" #-}
+        (Posix.asPath "/tmp" == Posix.absDir "/tmp")
+ DocTest.printPrefix "System.Path.Internal:750: "
+{-# LINE 750 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 750 "src/System/Path/Internal.hs" #-}
+        (Posix.asPath "file.txt" == Posix.relFile "file.txt")
+ DocTest.printPrefix "System.Path.Internal:751: "
+{-# LINE 751 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 751 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Posix.asAbsDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:752: "
+{-# LINE 752 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 752 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Posix.asRelDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:753: "
+{-# LINE 753 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 753 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:754: "
+{-# LINE 754 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 754 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp")
+ DocTest.printPrefix "System.Path.Internal:755: "
+{-# LINE 755 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 755 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp")
+ DocTest.printPrefix "System.Path.Internal:756: "
+{-# LINE 756 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 756 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp")
+ DocTest.printPrefix "System.Path.Internal:757: "
+{-# LINE 757 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 757 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp")
+ DocTest.printPrefix "System.Path.Internal:758: "
+{-# LINE 758 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 758 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp")
+ DocTest.printPrefix "System.Path.Internal:766: "
+{-# LINE 766 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 766 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:767: "
+{-# LINE 767 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 767 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "/file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:768: "
+{-# LINE 768 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 768 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:769: "
+{-# LINE 769 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 769 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelFile "/tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:775: "
+{-# LINE 775 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 775 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir ".") == ".")
+ DocTest.printPrefix "System.Path.Internal:776: "
+{-# LINE 776 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 776 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:777: "
+{-# LINE 777 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 777 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "/file.txt") == "file.txt")
+ DocTest.printPrefix "System.Path.Internal:778: "
+{-# LINE 778 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 778 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:779: "
+{-# LINE 779 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 779 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asRelDir "/tmp") == "tmp")
+ DocTest.printPrefix "System.Path.Internal:785: "
+{-# LINE 785 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 785 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:786: "
+{-# LINE 786 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 786 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsFile "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:792: "
+{-# LINE 792 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 792 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt")
+ DocTest.printPrefix "System.Path.Internal:793: "
+{-# LINE 793 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 793 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.asAbsDir "/tmp") == "/tmp")
+ DocTest.printPrefix "System.Path.Internal:832: "
+{-# LINE 832 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 832 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp"))
+ DocTest.printPrefix "System.Path.Internal:833: "
+{-# LINE 833 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 833 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel  "tmp" == Right (Posix.relDir "tmp"))
+ DocTest.printPrefix "System.Path.Internal:834: "
+{-# LINE 834 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 834 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp"))
+ DocTest.printPrefix "System.Path.Internal:835: "
+{-# LINE 835 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 835 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp"))
+ DocTest.printPrefix "System.Path.Internal:836: "
+{-# LINE 836 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 836 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp"))
+ DocTest.printPrefix "System.Path.Internal:837: "
+{-# LINE 837 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 837 "src/System/Path/Internal.hs" #-}
+        (Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp"))
+ DocTest.printPrefix "System.Path.Internal:866: "
+{-# LINE 866 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 866 "src/System/Path/Internal.hs" #-}
+        (Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt")
+ DocTest.printPrefix "System.Path.Internal:867: "
+{-# LINE 867 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 867 "src/System/Path/Internal.hs" #-}
+        (Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt")
+ DocTest.printPrefix "System.Path.Internal:1007: "
+{-# LINE 1007 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1007 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1008: "
+{-# LINE 1008 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1008 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1009: "
+{-# LINE 1009 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1009 "src/System/Path/Internal.hs" #-}
+        (Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1010: "
+{-# LINE 1010 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1010 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1011: "
+{-# LINE 1011 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1011 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1012: "
+{-# LINE 1012 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1012 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1013: "
+{-# LINE 1013 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1013 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1014: "
+{-# LINE 1014 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1014 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1015: "
+{-# LINE 1015 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1015 "src/System/Path/Internal.hs" #-}
+        (Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt")
+ DocTest.printPrefix "System.Path.Internal:1042: "
+{-# LINE 1042 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1042 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib")
+ DocTest.printPrefix "System.Path.Internal:1043: "
+{-# LINE 1043 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1043 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib")
+ DocTest.printPrefix "System.Path.Internal:1044: "
+{-# LINE 1044 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1044 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib")
+ DocTest.printPrefix "System.Path.Internal:1045: "
+{-# LINE 1045 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1045 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib")
+ DocTest.printPrefix "System.Path.Internal:1046: "
+{-# LINE 1046 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1046 "src/System/Path/Internal.hs" #-}
+        (Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib")
+ DocTest.printPrefix "System.Path.Internal:1047: "
+{-# LINE 1047 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1047 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext")
+ DocTest.printPrefix "System.Path.Internal:1054: "
+{-# LINE 1054 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1054 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.combine Path.currentDir p == (p::Default.RelDir))
+ DocTest.printPrefix "System.Path.Internal:1061: "
+{-# LINE 1061 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1061 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.dropExtension x == fst (Path.splitExtension x))
+ DocTest.printPrefix "System.Path.Internal:1067: "
+{-# LINE 1067 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1067 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> not $ Path.hasAnExtension (Path.dropExtensions x))
+ DocTest.printPrefix "System.Path.Internal:1078: "
+{-# LINE 1078 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1078 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1079: "
+{-# LINE 1079 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1079 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1080: "
+{-# LINE 1080 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1080 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob")
+ DocTest.printPrefix "System.Path.Internal:1081: "
+{-# LINE 1081 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1081 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file")
+ DocTest.printPrefix "System.Path.Internal:1082: "
+{-# LINE 1082 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1082 "src/System/Path/Internal.hs" #-}
+        (Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt")
+ DocTest.printPrefix "System.Path.Internal:1099: "
+{-# LINE 1099 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1099 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> uncurry (<.>) (Path.splitExtension x) == x)
+ DocTest.printPrefix "System.Path.Internal:1100: "
+{-# LINE 1100 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1100 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> uncurry Path.addExtension (Path.splitExtension x) == x)
+ DocTest.printPrefix "System.Path.Internal:1101: "
+{-# LINE 1101 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1101 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt"))
+ DocTest.printPrefix "System.Path.Internal:1102: "
+{-# LINE 1102 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1102 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc"))
+ DocTest.printPrefix "System.Path.Internal:1103: "
+{-# LINE 1103 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1103 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file") == (Posix.relFile "file",""))
+ DocTest.printPrefix "System.Path.Internal:1104: "
+{-# LINE 1104 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1104 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt"))
+ DocTest.printPrefix "System.Path.Internal:1105: "
+{-# LINE 1105 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1105 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris",""))
+ DocTest.printPrefix "System.Path.Internal:1106: "
+{-# LINE 1106 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1106 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext"))
+ DocTest.printPrefix "System.Path.Internal:1107: "
+{-# LINE 1107 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1107 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred"))
+ DocTest.printPrefix "System.Path.Internal:1113: "
+{-# LINE 1113 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1113 "src/System/Path/Internal.hs" #-}
+        (Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz"))
+ DocTest.printPrefix "System.Path.Internal:1114: "
+{-# LINE 1114 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1114 "src/System/Path/Internal.hs" #-}
+        (\p -> uncurry (<.>) (Path.splitExtension p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1118: "
+{-# LINE 1118 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1118 "src/System/Path/Internal.hs" #-}
+          (\p -> uncurry Path.combine (Path.splitFileName p) == (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1134: "
+{-# LINE 1134 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1134 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1135: "
+{-# LINE 1135 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1135 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1136: "
+{-# LINE 1136 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1136 "src/System/Path/Internal.hs" #-}
+        (Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile")
+ DocTest.printPrefix "System.Path.Internal:1155: "
+{-# LINE 1155 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1155 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension x == snd (Path.splitExtension x))
+ DocTest.printPrefix "System.Path.Internal:1156: "
+{-# LINE 1156 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1156 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension (Path.addExtension x "ext") == ".ext")
+ DocTest.printPrefix "System.Path.Internal:1157: "
+{-# LINE 1157 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1157 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> Path.takeExtension (Path.replaceExtension x "ext") == ".ext")
+ DocTest.printPrefix "System.Path.Internal:1163: "
+{-# LINE 1163 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1163 "src/System/Path/Internal.hs" #-}
+        (Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz")
+ DocTest.printPrefix "System.Path.Internal:1169: "
+{-# LINE 1169 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1169 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1170: "
+{-# LINE 1170 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1170 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1171: "
+{-# LINE 1171 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1171 "src/System/Path/Internal.hs" #-}
+        (Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt")
+ DocTest.printPrefix "System.Path.Internal:1172: "
+{-# LINE 1172 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1172 "src/System/Path/Internal.hs" #-}
+        (\p -> Path.toString (Path.takeFileName p) `isSuffixOf` Path.toString (p::Default.AbsFile))
+ DocTest.printPrefix "System.Path.Internal:1201: "
+{-# LINE 1201 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1201 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "abc/def" "abc/def")
+ DocTest.printPrefix "System.Path.Internal:1202: "
+{-# LINE 1202 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1202 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "abc/def" "abc//def")
+ DocTest.printPrefix "System.Path.Internal:1203: "
+{-# LINE 1203 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1203 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp/" "/tmp")
+ DocTest.printPrefix "System.Path.Internal:1204: "
+{-# LINE 1204 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1204 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp" "//tmp")
+ DocTest.printPrefix "System.Path.Internal:1205: "
+{-# LINE 1205 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1205 "src/System/Path/Internal.hs" #-}
+        (Posix.equalFilePath "/tmp" "///tmp")
+ DocTest.printPrefix "System.Path.Internal:1206: "
+{-# LINE 1206 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1206 "src/System/Path/Internal.hs" #-}
+        (not $ Posix.equalFilePath "abc" "def")
+ DocTest.printPrefix "System.Path.Internal:1207: "
+{-# LINE 1207 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1207 "src/System/Path/Internal.hs" #-}
+        (not $ Posix.equalFilePath "/tmp" "tmp")
+ DocTest.printPrefix "System.Path.Internal:1208: "
+{-# LINE 1208 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1208 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "abc\\def" "abc\\def")
+ DocTest.printPrefix "System.Path.Internal:1209: "
+{-# LINE 1209 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1209 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "abc\\def" "abc\\\\def")
+ DocTest.printPrefix "System.Path.Internal:1210: "
+{-# LINE 1210 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1210 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "file" "File")
+ DocTest.printPrefix "System.Path.Internal:1211: "
+{-# LINE 1211 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1211 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "\\file" "\\\\file")
+ DocTest.printPrefix "System.Path.Internal:1212: "
+{-# LINE 1212 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1212 "src/System/Path/Internal.hs" #-}
+        (Windows.equalFilePath "\\file" "\\\\\\file")
+ DocTest.printPrefix "System.Path.Internal:1213: "
+{-# LINE 1213 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1213 "src/System/Path/Internal.hs" #-}
+        (not $ Windows.equalFilePath "abc" "def")
+ DocTest.printPrefix "System.Path.Internal:1214: "
+{-# LINE 1214 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1214 "src/System/Path/Internal.hs" #-}
+        (not $ Windows.equalFilePath "file" "dir")
+ DocTest.printPrefix "System.Path.Internal:1227: "
+{-# LINE 1227 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1227 "src/System/Path/Internal.hs" #-}
+        (Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir")
+ DocTest.printPrefix "System.Path.Internal:1228: "
+{-# LINE 1228 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1228 "src/System/Path/Internal.hs" #-}
+        (Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1234: "
+{-# LINE 1234 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1234 "src/System/Path/Internal.hs" #-}
+        (Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file")
+ DocTest.printPrefix "System.Path.Internal:1240: "
+{-# LINE 1240 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1240 "src/System/Path/Internal.hs" #-}
+        (Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing))
+ DocTest.printPrefix "System.Path.Internal:1241: "
+{-# LINE 1241 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1241 "src/System/Path/Internal.hs" #-}
+        (Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt"))
+ DocTest.printPrefix "System.Path.Internal:1257: "
+{-# LINE 1257 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1257 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1258: "
+{-# LINE 1258 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1258 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir")
+ DocTest.printPrefix "System.Path.Internal:1259: "
+{-# LINE 1259 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1259 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt")
+ DocTest.printPrefix "System.Path.Internal:1260: "
+{-# LINE 1260 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1260 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir")
+ DocTest.printPrefix "System.Path.Internal:1261: "
+{-# LINE 1261 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1261 "src/System/Path/Internal.hs" #-}
+        (Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir")
+ DocTest.printPrefix "System.Path.Internal:1288: "
+{-# LINE 1288 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1288 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relFile "file.txt")      == Posix.absFile "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1289: "
+{-# LINE 1289 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1289 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1290: "
+{-# LINE 1290 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1290 "src/System/Path/Internal.hs" #-}
+        (Path.makeAbsolute (absDir "/tmp") (relDir  "adir/dir")      == Posix.absDir "/tmp/adir/dir")
+ DocTest.printPrefix "System.Path.Internal:1291: "
+{-# LINE 1291 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1291 "src/System/Path/Internal.hs" #-}
+        (\base p -> Default.toString p `isSuffixOf` Path.toString (Path.makeAbsolute base (Path.idFile p)))
+ DocTest.printPrefix "System.Path.Internal:1292: "
+{-# LINE 1292 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1292 "src/System/Path/Internal.hs" #-}
+        (\base p -> Default.toString base `isPrefixOf` Path.toString (Path.makeAbsolute base (Path.idFile p)))
+ DocTest.printPrefix "System.Path.Internal:1314: "
+{-# LINE 1314 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1314 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt")       == Posix.absFile "/tmp/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1315: "
+{-# LINE 1315 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1315 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt")  == Posix.absFile "/tmp/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1316: "
+{-# LINE 1316 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1316 "src/System/Path/Internal.hs" #-}
+        (Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt")
+ DocTest.printPrefix "System.Path.Internal:1401: "
+{-# LINE 1401 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1401 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Posix.absFile "/fred"))
+ DocTest.printPrefix "System.Path.Internal:1402: "
+{-# LINE 1402 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1402 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "\\fred"))
+ DocTest.printPrefix "System.Path.Internal:1403: "
+{-# LINE 1403 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1403 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "c:\\fred"))
+ DocTest.printPrefix "System.Path.Internal:1404: "
+{-# LINE 1404 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1404 "src/System/Path/Internal.hs" #-}
+        (Path.isAbsolute (Windows.absFile "c:fred"))
+ DocTest.printPrefix "System.Path.Internal:1411: "
+{-# LINE 1411 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1411 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Posix.relFile "fred"))
+ DocTest.printPrefix "System.Path.Internal:1412: "
+{-# LINE 1412 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1412 "src/System/Path/Internal.hs" #-}
+        (Path.isRelative (Windows.relFile "fred"))
+ DocTest.printPrefix "System.Path.Internal:1437: "
+{-# LINE 1437 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1437 "src/System/Path/Internal.hs" #-}
+        (forAllAbsRel $ \x -> null (Path.takeExtension x) == not (Path.hasAnExtension x))
+ DocTest.printPrefix "System.Path.Internal:1443: "
+{-# LINE 1443 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1443 "src/System/Path/Internal.hs" #-}
+        (Path.hasExtension ".hs" (Posix.relFile "MyCode.hs"))
+ DocTest.printPrefix "System.Path.Internal:1444: "
+{-# LINE 1444 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1444 "src/System/Path/Internal.hs" #-}
+        (Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs"))
+ DocTest.printPrefix "System.Path.Internal:1445: "
+{-# LINE 1445 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1445 "src/System/Path/Internal.hs" #-}
+        (not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak"))
+ DocTest.printPrefix "System.Path.Internal:1455: "
+{-# LINE 1455 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1455 "src/System/Path/Internal.hs" #-}
+        (Posix.extSeparator == '.')
+ DocTest.printPrefix "System.Path.Internal:1466: "
+{-# LINE 1466 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1466 "src/System/Path/Internal.hs" #-}
+        (\a -> Posix.isExtSeparator a == (a == Posix.extSeparator))
+ DocTest.printPrefix "System.Path.Internal:1472: "
+{-# LINE 1472 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1472 "src/System/Path/Internal.hs" #-}
+        (\a -> Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator))
+ DocTest.printPrefix "System.Path.Internal:1488: "
+{-# LINE 1488 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1488 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x")
+ DocTest.printPrefix "System.Path.Internal:1489: "
+{-# LINE 1489 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1489 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x")
+ DocTest.printPrefix "System.Path.Internal:1490: "
+{-# LINE 1490 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1490 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x")
+ DocTest.printPrefix "System.Path.Internal:1491: "
+{-# LINE 1491 "src/System/Path/Internal.hs" #-}
+ DocTest.property
+{-# LINE 1491 "src/System/Path/Internal.hs" #-}
+        (Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile)
diff --git a/test/TestResult.hs b/test/TestResult.hs
deleted file mode 100644
--- a/test/TestResult.hs
+++ /dev/null
@@ -1,576 +0,0 @@
-{- Do not edit! Created from test/TestTemplate.hs -}
-{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
-module TestResult (results) where
-
-import qualified System.Path.PartClass as Class
-import qualified System.Path.Generic as Path
-import qualified System.Path.Posix as Posix
-import qualified System.Path.Windows as Windows
-import System.Path.Generic ((</>), (<.>), relFile, relDir, absFile, absDir)
-import Data.Char (toLower)
-
-
-results :: (Class.AbsRel ar) => Char -> Posix.FilePath ar -> [(String, Bool)]
-results a x =
-  {-# LINE 258 "src/System/Path/Internal.hs" #-}
-  ("Path.pathMap (map toLower) (absDir \"/tmp/Reports/SpreadSheets\") == Posix.absDir \"/tmp/reports/spreadsheets\"",
-      Path.pathMap (map toLower) (absDir "/tmp/Reports/SpreadSheets") == Posix.absDir "/tmp/reports/spreadsheets") :
-  {-# LINE 331 "src/System/Path/Internal.hs" #-}
-  ("show (Posix.rootDir </> relDir \"bla\" </> relFile \"blub\") == \"rootDir </> relPath \\\"bla\\\" </> relPath \\\"blub\\\"\"",
-      show (Posix.rootDir </> relDir "bla" </> relFile "blub") == "rootDir </> relPath \"bla\" </> relPath \"blub\"") :
-  {-# LINE 332 "src/System/Path/Internal.hs" #-}
-  ("show (Just (Posix.rootDir </> relDir \"bla\" </> relFile \"blub\")) == \"Just (rootDir </> relPath \\\"bla\\\" </> relPath \\\"blub\\\")\"",
-      show (Just (Posix.rootDir </> relDir "bla" </> relFile "blub")) == "Just (rootDir </> relPath \"bla\" </> relPath \"blub\")") :
-  {-# LINE 333 "src/System/Path/Internal.hs" #-}
-  ("show (Posix.currentDir </> relDir \"bla\" </> relFile \"blub\") == \"currentDir </> relPath \\\"bla\\\" </> relPath \\\"blub\\\"\"",
-      show (Posix.currentDir </> relDir "bla" </> relFile "blub") == "currentDir </> relPath \"bla\" </> relPath \"blub\"") :
-  {-# LINE 334 "src/System/Path/Internal.hs" #-}
-  ("show (Just (Posix.currentDir </> relDir \"bla\" </> relFile \"blub\")) == \"Just (currentDir </> relPath \\\"bla\\\" </> relPath \\\"blub\\\")\"",
-      show (Just (Posix.currentDir </> relDir "bla" </> relFile "blub")) == "Just (currentDir </> relPath \"bla\" </> relPath \"blub\")") :
-  {-# LINE 335 "src/System/Path/Internal.hs" #-}
-  ("show (Windows.absDir \"c:\" </> relDir \"bla\" </> relFile \"blub\") == \"absDir \\\"c:\\\" </> relPath \\\"bla\\\" </> relPath \\\"blub\\\"\"",
-      show (Windows.absDir "c:" </> relDir "bla" </> relFile "blub") == "absDir \"c:\" </> relPath \"bla\" </> relPath \"blub\"") :
-  {-# LINE 336 "src/System/Path/Internal.hs" #-}
-  ("show (Just (Windows.absDir \"c:\\\\\" </> relDir \"bla\" </> relFile \"blub\")) == \"Just (absDir \\\"c:\\\\\\\\\\\" </> relPath \\\"bla\\\" </> relPath \\\"blub\\\")\"",
-      show (Just (Windows.absDir "c:\\" </> relDir "bla" </> relFile "blub")) == "Just (absDir \"c:\\\\\" </> relPath \"bla\" </> relPath \"blub\")") :
-  {-# LINE 368 "src/System/Path/Internal.hs" #-}
-  ("read \"rootDir\" == Posix.rootDir",
-      read "rootDir" == Posix.rootDir) :
-  {-# LINE 369 "src/System/Path/Internal.hs" #-}
-  ("read \"rootDir\" == Windows.rootDir",
-      read "rootDir" == Windows.rootDir) :
-  {-# LINE 370 "src/System/Path/Internal.hs" #-}
-  ("read \"currentDir\" == Posix.currentDir",
-      read "currentDir" == Posix.currentDir) :
-  {-# LINE 371 "src/System/Path/Internal.hs" #-}
-  ("read \"currentDir\" == Windows.currentDir",
-      read "currentDir" == Windows.currentDir) :
-  {-# LINE 372 "src/System/Path/Internal.hs" #-}
-  ("let path = Posix.rootDir </> relDir \"bla\" </> relFile \"blub\" in read (show path) == path",
-      let path = Posix.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path) :
-  {-# LINE 373 "src/System/Path/Internal.hs" #-}
-  ("let path = Just (Posix.rootDir </> relDir \"bla\" </> relFile \"blub\") in read (show path) == path",
-      let path = Just (Posix.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path) :
-  {-# LINE 374 "src/System/Path/Internal.hs" #-}
-  ("let path = Posix.currentDir </> relDir \"bla\" </> relFile \"blub\" in read (show path) == path",
-      let path = Posix.currentDir </> relDir "bla" </> relFile "blub" in read (show path) == path) :
-  {-# LINE 375 "src/System/Path/Internal.hs" #-}
-  ("let path = Just (Posix.currentDir </> relDir \"bla\" </> relFile \"blub\") in read (show path) == path",
-      let path = Just (Posix.currentDir </> relDir "bla" </> relFile "blub") in read (show path) == path) :
-  {-# LINE 376 "src/System/Path/Internal.hs" #-}
-  ("let path = Windows.rootDir </> relDir \"bla\" </> relFile \"blub\" in read (show path) == path",
-      let path = Windows.rootDir </> relDir "bla" </> relFile "blub" in read (show path) == path) :
-  {-# LINE 377 "src/System/Path/Internal.hs" #-}
-  ("let path = Just (Windows.rootDir </> relDir \"bla\" </> relFile \"blub\") in read (show path) == path",
-      let path = Just (Windows.rootDir </> relDir "bla" </> relFile "blub") in read (show path) == path) :
-  {-# LINE 378 "src/System/Path/Internal.hs" #-}
-  ("let path = Windows.absDir \"c:\" </> relDir \"bla\" </> relFile \"blub\" in read (show path) == path",
-      let path = Windows.absDir "c:" </> relDir "bla" </> relFile "blub" in read (show path) == path) :
-  {-# LINE 475 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString Path.rootDir == \"/\"",
-      Posix.toString Path.rootDir == "/") :
-  {-# LINE 476 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString Path.rootDir == \"\\\\\"",
-      Windows.toString Path.rootDir == "\\") :
-  {-# LINE 486 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString Path.currentDir == \".\"",
-      Posix.toString Path.currentDir == ".") :
-  {-# LINE 487 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString Path.currentDir == \".\"",
-      Windows.toString Path.currentDir == ".") :
-  {-# LINE 529 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/\" :: Maybe Posix.AbsDir) == Just \"/\"",
-      fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsDir) == Just "/") :
-  {-# LINE 530 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/\" :: Maybe Posix.AbsFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.AbsFile) == Nothing) :
-  {-# LINE 531 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/\" :: Maybe Posix.RelDir) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelDir) == Nothing) :
-  {-# LINE 532 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/\" :: Maybe Posix.RelFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/" :: Maybe Posix.RelFile) == Nothing) :
-  {-# LINE 533 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp\" :: Maybe Posix.AbsDir) == Just \"/tmp\"",
-      fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsDir) == Just "/tmp") :
-  {-# LINE 534 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp\" :: Maybe Posix.AbsFile) == Just \"/tmp\"",
-      fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsFile) == Just "/tmp") :
-  {-# LINE 535 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp\" :: Maybe Posix.RelDir) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelDir) == Nothing) :
-  {-# LINE 536 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp\" :: Maybe Posix.RelFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.RelFile) == Nothing) :
-  {-# LINE 537 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp/\" :: Maybe Posix.AbsDir) == Just \"/tmp\"",
-      fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsDir) == Just "/tmp") :
-  {-# LINE 538 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp/\" :: Maybe Posix.AbsFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsFile) == Nothing) :
-  {-# LINE 539 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp/\" :: Maybe Posix.RelDir) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelDir) == Nothing) :
-  {-# LINE 540 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp/\" :: Maybe Posix.RelFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.RelFile) == Nothing) :
-  {-# LINE 541 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp\" :: Maybe Posix.AbsRelFileDir) == Just \"/tmp\"",
-      fmap Posix.toString (Posix.maybePath "/tmp" :: Maybe Posix.AbsRelFileDir) == Just "/tmp") :
-  {-# LINE 542 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"/tmp/\" :: Maybe Posix.AbsRelFileDir) == Just \"/tmp\"",
-      fmap Posix.toString (Posix.maybePath "/tmp/" :: Maybe Posix.AbsRelFileDir) == Just "/tmp") :
-  {-# LINE 543 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"file.txt\" :: Maybe Posix.RelFile) == Just \"file.txt\"",
-      fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.RelFile) == Just "file.txt") :
-  {-# LINE 544 "src/System/Path/Internal.hs" #-}
-  ("fmap Posix.toString (Posix.maybePath \"file.txt\" :: Maybe Posix.AbsFile) == Nothing",
-      fmap Posix.toString (Posix.maybePath "file.txt" :: Maybe Posix.AbsFile) == Nothing) :
-  {-# LINE 545 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"\\\\tmp\" :: Maybe Windows.AbsDir) == Just \"\\\\tmp\"",
-      fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.AbsDir) == Just "\\tmp") :
-  {-# LINE 546 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:\\\\tmp\" :: Maybe Windows.AbsDir) == Just \"a:\\\\tmp\"",
-      fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.AbsDir) == Just "a:\\tmp") :
-  {-# LINE 547 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:tmp\" :: Maybe Windows.AbsDir) == Just \"a:tmp\"",
-      fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.AbsDir) == Just "a:tmp") :
-  {-# LINE 548 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:\\\\\" :: Maybe Windows.AbsDir) == Just \"a:\\\\\"",
-      fmap Windows.toString (Windows.maybePath "a:\\" :: Maybe Windows.AbsDir) == Just "a:\\") :
-  {-# LINE 549 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:\" :: Maybe Windows.AbsDir) == Just \"a:\"",
-      fmap Windows.toString (Windows.maybePath "a:" :: Maybe Windows.AbsDir) == Just "a:") :
-  {-# LINE 550 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"tmp\" :: Maybe Windows.RelDir) == Just \"tmp\"",
-      fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.RelDir) == Just "tmp") :
-  {-# LINE 551 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"\\\\tmp\" :: Maybe Windows.RelDir) == Nothing",
-      fmap Windows.toString (Windows.maybePath "\\tmp" :: Maybe Windows.RelDir) == Nothing) :
-  {-# LINE 552 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:\\\\tmp\" :: Maybe Windows.RelDir) == Nothing",
-      fmap Windows.toString (Windows.maybePath "a:\\tmp" :: Maybe Windows.RelDir) == Nothing) :
-  {-# LINE 553 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"a:tmp\" :: Maybe Windows.RelDir) == Nothing",
-      fmap Windows.toString (Windows.maybePath "a:tmp" :: Maybe Windows.RelDir) == Nothing) :
-  {-# LINE 554 "src/System/Path/Internal.hs" #-}
-  ("fmap Windows.toString (Windows.maybePath \"tmp\" :: Maybe Windows.AbsDir) == Nothing",
-      fmap Windows.toString (Windows.maybePath "tmp" :: Maybe Windows.AbsDir) == Nothing) :
-  {-# LINE 606 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relFile \"file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.relFile "file.txt") == "file.txt") :
-  {-# LINE 607 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relFile \"tmp\") == \"tmp\"",
-      Posix.toString (Posix.relFile "tmp") == "tmp") :
-  {-# LINE 613 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relDir \".\") == \".\"",
-      Posix.toString (Posix.relDir ".") == ".") :
-  {-# LINE 614 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relDir \"file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.relDir "file.txt") == "file.txt") :
-  {-# LINE 615 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relDir \"tmp\") == \"tmp\"",
-      Posix.toString (Posix.relDir "tmp") == "tmp") :
-  {-# LINE 621 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absFile \"/file.txt\") == \"/file.txt\"",
-      Posix.toString (Posix.absFile "/file.txt") == "/file.txt") :
-  {-# LINE 622 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absFile \"/tmp\") == \"/tmp\"",
-      Posix.toString (Posix.absFile "/tmp") == "/tmp") :
-  {-# LINE 628 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absDir \"/file.txt\") == \"/file.txt\"",
-      Posix.toString (Posix.absDir "/file.txt") == "/file.txt") :
-  {-# LINE 629 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absDir \"/tmp\") == \"/tmp\"",
-      Posix.toString (Posix.absDir "/tmp") == "/tmp") :
-  {-# LINE 724 "src/System/Path/Internal.hs" #-}
-  ("Posix.asPath \"/tmp\" == Posix.absDir \"/tmp\"",
-      Posix.asPath "/tmp" == Posix.absDir "/tmp") :
-  {-# LINE 725 "src/System/Path/Internal.hs" #-}
-  ("Posix.asPath \"file.txt\" == Posix.relFile \"file.txt\"",
-      Posix.asPath "file.txt" == Posix.relFile "file.txt") :
-  {-# LINE 726 "src/System/Path/Internal.hs" #-}
-  ("Path.isAbsolute (Posix.asAbsDir \"/tmp\")",
-      Path.isAbsolute (Posix.asAbsDir "/tmp")) :
-  {-# LINE 727 "src/System/Path/Internal.hs" #-}
-  ("Path.isRelative (Posix.asRelDir \"/tmp\")",
-      Path.isRelative (Posix.asRelDir "/tmp")) :
-  {-# LINE 728 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asPath \"/tmp\" :: Posix.AbsDir) == \"/tmp\"",
-      Posix.toString (Posix.asPath "/tmp" :: Posix.AbsDir) == "/tmp") :
-  {-# LINE 729 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asPath \"/tmp\" :: Posix.RelDir) == \"tmp\"",
-      Posix.toString (Posix.asPath "/tmp" :: Posix.RelDir) == "tmp") :
-  {-# LINE 730 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.asPath \"\\\\tmp\" :: Windows.AbsDir) == \"\\\\tmp\"",
-      Windows.toString (Windows.asPath "\\tmp" :: Windows.AbsDir) == "\\tmp") :
-  {-# LINE 731 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.asPath \"a:\\\\tmp\" :: Windows.AbsDir) == \"a:\\\\tmp\"",
-      Windows.toString (Windows.asPath "a:\\tmp" :: Windows.AbsDir) == "a:\\tmp") :
-  {-# LINE 732 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.asPath \"a:tmp\" :: Windows.AbsDir) == \"a:tmp\"",
-      Windows.toString (Windows.asPath "a:tmp" :: Windows.AbsDir) == "a:tmp") :
-  {-# LINE 733 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.asPath \"tmp\" :: Windows.RelDir) == \"tmp\"",
-      Windows.toString (Windows.asPath "tmp" :: Windows.RelDir) == "tmp") :
-  {-# LINE 741 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelFile \"file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.asRelFile "file.txt") == "file.txt") :
-  {-# LINE 742 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelFile \"/file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.asRelFile "/file.txt") == "file.txt") :
-  {-# LINE 743 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelFile \"tmp\") == \"tmp\"",
-      Posix.toString (Posix.asRelFile "tmp") == "tmp") :
-  {-# LINE 744 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelFile \"/tmp\") == \"tmp\"",
-      Posix.toString (Posix.asRelFile "/tmp") == "tmp") :
-  {-# LINE 750 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelDir \".\") == \".\"",
-      Posix.toString (Posix.asRelDir ".") == ".") :
-  {-# LINE 751 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelDir \"file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.asRelDir "file.txt") == "file.txt") :
-  {-# LINE 752 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelDir \"/file.txt\") == \"file.txt\"",
-      Posix.toString (Posix.asRelDir "/file.txt") == "file.txt") :
-  {-# LINE 753 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelDir \"tmp\") == \"tmp\"",
-      Posix.toString (Posix.asRelDir "tmp") == "tmp") :
-  {-# LINE 754 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asRelDir \"/tmp\") == \"tmp\"",
-      Posix.toString (Posix.asRelDir "/tmp") == "tmp") :
-  {-# LINE 760 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asAbsFile \"/file.txt\") == \"/file.txt\"",
-      Posix.toString (Posix.asAbsFile "/file.txt") == "/file.txt") :
-  {-# LINE 761 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asAbsFile \"/tmp\") == \"/tmp\"",
-      Posix.toString (Posix.asAbsFile "/tmp") == "/tmp") :
-  {-# LINE 767 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asAbsDir \"/file.txt\") == \"/file.txt\"",
-      Posix.toString (Posix.asAbsDir "/file.txt") == "/file.txt") :
-  {-# LINE 768 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.asAbsDir \"/tmp\") == \"/tmp\"",
-      Posix.toString (Posix.asAbsDir "/tmp") == "/tmp") :
-  {-# LINE 807 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel \"/tmp\" == Left (Posix.absDir \"/tmp\")",
-      Path.mkPathAbsOrRel "/tmp" == Left (Posix.absDir "/tmp")) :
-  {-# LINE 808 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel  \"tmp\" == Right (Posix.relDir \"tmp\")",
-      Path.mkPathAbsOrRel  "tmp" == Right (Posix.relDir "tmp")) :
-  {-# LINE 809 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel \"\\\\tmp\" == Left (Windows.absDir \"\\\\tmp\")",
-      Path.mkPathAbsOrRel "\\tmp" == Left (Windows.absDir "\\tmp")) :
-  {-# LINE 810 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel \"d:\\\\tmp\" == Left (Windows.absDir \"d:\\\\tmp\")",
-      Path.mkPathAbsOrRel "d:\\tmp" == Left (Windows.absDir "d:\\tmp")) :
-  {-# LINE 811 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel \"d:tmp\" == Left (Windows.absDir \"d:tmp\")",
-      Path.mkPathAbsOrRel "d:tmp" == Left (Windows.absDir "d:tmp")) :
-  {-# LINE 812 "src/System/Path/Internal.hs" #-}
-  ("Path.mkPathAbsOrRel \"tmp\" == Right (Windows.relDir \"tmp\")",
-      Path.mkPathAbsOrRel "tmp" == Right (Windows.relDir "tmp")) :
-  {-# LINE 841 "src/System/Path/Internal.hs" #-}
-  ("Path.mkAbsPath (absDir \"/tmp\") \"foo.txt\" == Posix.absFile \"/tmp/foo.txt\"",
-      Path.mkAbsPath (absDir "/tmp") "foo.txt" == Posix.absFile "/tmp/foo.txt") :
-  {-# LINE 842 "src/System/Path/Internal.hs" #-}
-  ("Path.mkAbsPath (absDir \"/tmp\") \"/etc/foo.txt\" == Posix.absFile \"/etc/foo.txt\"",
-      Path.mkAbsPath (absDir "/tmp") "/etc/foo.txt" == Posix.absFile "/etc/foo.txt") :
-  {-# LINE 975 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absDir \"/tmp\" </> Posix.relFile \"file.txt\") == \"/tmp/file.txt\"",
-      Posix.toString (Posix.absDir "/tmp" </> Posix.relFile "file.txt") == "/tmp/file.txt") :
-  {-# LINE 976 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.absDir \"/tmp\" </> Posix.relDir \"dir\" </> Posix.relFile \"file.txt\") == \"/tmp/dir/file.txt\"",
-      Posix.toString (Posix.absDir "/tmp" </> Posix.relDir "dir" </> Posix.relFile "file.txt") == "/tmp/dir/file.txt") :
-  {-# LINE 977 "src/System/Path/Internal.hs" #-}
-  ("Posix.toString (Posix.relDir \"dir\" </> Posix.relFile \"file.txt\") == \"dir/file.txt\"",
-      Posix.toString (Posix.relDir "dir" </> Posix.relFile "file.txt") == "dir/file.txt") :
-  {-# LINE 978 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.absDir \"\\\\tmp\" </> Windows.relFile \"file.txt\") == \"\\\\tmp\\\\file.txt\"",
-      Windows.toString (Windows.absDir "\\tmp" </> Windows.relFile "file.txt") == "\\tmp\\file.txt") :
-  {-# LINE 979 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.absDir \"c:\\\\tmp\" </> Windows.relFile \"file.txt\") == \"c:\\\\tmp\\\\file.txt\"",
-      Windows.toString (Windows.absDir "c:\\tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt") :
-  {-# LINE 980 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.absDir \"c:tmp\" </> Windows.relFile \"file.txt\") == \"c:tmp\\\\file.txt\"",
-      Windows.toString (Windows.absDir "c:tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt") :
-  {-# LINE 981 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.absDir \"c:\\\\\" </> Windows.relDir \"tmp\" </> Windows.relFile \"file.txt\") == \"c:\\\\tmp\\\\file.txt\"",
-      Windows.toString (Windows.absDir "c:\\" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:\\tmp\\file.txt") :
-  {-# LINE 982 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.absDir \"c:\" </> Windows.relDir \"tmp\" </> Windows.relFile \"file.txt\") == \"c:tmp\\\\file.txt\"",
-      Windows.toString (Windows.absDir "c:" </> Windows.relDir "tmp" </> Windows.relFile "file.txt") == "c:tmp\\file.txt") :
-  {-# LINE 983 "src/System/Path/Internal.hs" #-}
-  ("Windows.toString (Windows.relDir \"dir\" </> Windows.relFile \"file.txt\") == \"dir\\\\file.txt\"",
-      Windows.toString (Windows.relDir "dir" </> Windows.relFile "file.txt") == "dir\\file.txt") :
-  {-# LINE 1010 "src/System/Path/Internal.hs" #-}
-  ("Path.addExtension (relFile \"file.txt\") \"bib\" == Posix.relFile \"file.txt.bib\"",
-      Path.addExtension (relFile "file.txt") "bib" == Posix.relFile "file.txt.bib") :
-  {-# LINE 1011 "src/System/Path/Internal.hs" #-}
-  ("Path.addExtension (relFile \"file.\") \".bib\" == Posix.relFile \"file..bib\"",
-      Path.addExtension (relFile "file.") ".bib" == Posix.relFile "file..bib") :
-  {-# LINE 1012 "src/System/Path/Internal.hs" #-}
-  ("Path.addExtension (relFile \"file\") \".bib\" == Posix.relFile \"file.bib\"",
-      Path.addExtension (relFile "file") ".bib" == Posix.relFile "file.bib") :
-  {-# LINE 1013 "src/System/Path/Internal.hs" #-}
-  ("Path.addExtension Path.emptyFile \"bib\" == Posix.relFile \".bib\"",
-      Path.addExtension Path.emptyFile "bib" == Posix.relFile ".bib") :
-  {-# LINE 1014 "src/System/Path/Internal.hs" #-}
-  ("Path.addExtension Path.emptyFile \".bib\" == Posix.relFile \".bib\"",
-      Path.addExtension Path.emptyFile ".bib" == Posix.relFile ".bib") :
-  {-# LINE 1015 "src/System/Path/Internal.hs" #-}
-  ("Path.takeFileName (Path.addExtension Path.emptyFile \"ext\") == Posix.relFile \".ext\"",
-      Path.takeFileName (Path.addExtension Path.emptyFile "ext") == Posix.relFile ".ext") :
-  {-# LINE 1030 "src/System/Path/Internal.hs" #-}
-  ("Path.dropExtension x == fst (Path.splitExtension x)",
-      Path.dropExtension x == fst (Path.splitExtension x)) :
-  {-# LINE 1036 "src/System/Path/Internal.hs" #-}
-  ("not $ Path.hasAnExtension (Path.dropExtensions x)",
-      not $ Path.hasAnExtension (Path.dropExtensions x)) :
-  {-# LINE 1047 "src/System/Path/Internal.hs" #-}
-  ("Path.replaceExtension (relFile \"file.txt\") \".bob\" == Posix.relFile \"file.bob\"",
-      Path.replaceExtension (relFile "file.txt") ".bob" == Posix.relFile "file.bob") :
-  {-# LINE 1048 "src/System/Path/Internal.hs" #-}
-  ("Path.replaceExtension (relFile \"file.txt\") \"bob\" == Posix.relFile \"file.bob\"",
-      Path.replaceExtension (relFile "file.txt") "bob" == Posix.relFile "file.bob") :
-  {-# LINE 1049 "src/System/Path/Internal.hs" #-}
-  ("Path.replaceExtension (relFile \"file\") \".bob\" == Posix.relFile \"file.bob\"",
-      Path.replaceExtension (relFile "file") ".bob" == Posix.relFile "file.bob") :
-  {-# LINE 1050 "src/System/Path/Internal.hs" #-}
-  ("Path.replaceExtension (relFile \"file.txt\") \"\" == Posix.relFile \"file\"",
-      Path.replaceExtension (relFile "file.txt") "" == Posix.relFile "file") :
-  {-# LINE 1051 "src/System/Path/Internal.hs" #-}
-  ("Path.replaceExtension (relFile \"file.fred.bob\") \"txt\" == Posix.relFile \"file.fred.txt\"",
-      Path.replaceExtension (relFile "file.fred.bob") "txt" == Posix.relFile "file.fred.txt") :
-  {-# LINE 1068 "src/System/Path/Internal.hs" #-}
-  ("uncurry (<.>) (Path.splitExtension x) == x",
-      uncurry (<.>) (Path.splitExtension x) == x) :
-  {-# LINE 1069 "src/System/Path/Internal.hs" #-}
-  ("uncurry Path.addExtension (Path.splitExtension x) == x",
-      uncurry Path.addExtension (Path.splitExtension x) == x) :
-  {-# LINE 1070 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file.txt\") == (Posix.relFile \"file\",\".txt\")",
-      Path.splitExtension (relFile "file.txt") == (Posix.relFile "file",".txt")) :
-  {-# LINE 1071 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \".bashrc\") == (Posix.emptyFile, \".bashrc\")",
-      Path.splitExtension (relFile ".bashrc") == (Posix.emptyFile, ".bashrc")) :
-  {-# LINE 1072 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file\") == (Posix.relFile \"file\",\"\")",
-      Path.splitExtension (relFile "file") == (Posix.relFile "file","")) :
-  {-# LINE 1073 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file/file.txt\") == (Posix.relFile \"file/file\",\".txt\")",
-      Path.splitExtension (relFile "file/file.txt") == (Posix.relFile "file/file",".txt")) :
-  {-# LINE 1074 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file.txt/boris\") == (Posix.relFile \"file.txt/boris\",\"\")",
-      Path.splitExtension (relFile "file.txt/boris") == (Posix.relFile "file.txt/boris","")) :
-  {-# LINE 1075 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file.txt/boris.ext\") == (Posix.relFile \"file.txt/boris\",\".ext\")",
-      Path.splitExtension (relFile "file.txt/boris.ext") == (Posix.relFile "file.txt/boris",".ext")) :
-  {-# LINE 1076 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtension (relFile \"file/path.txt.bob.fred\") == (Posix.relFile \"file/path.txt.bob\",\".fred\")",
-      Path.splitExtension (relFile "file/path.txt.bob.fred") == (Posix.relFile "file/path.txt.bob",".fred")) :
-  {-# LINE 1082 "src/System/Path/Internal.hs" #-}
-  ("Path.splitExtensions (relFile \"file.tar.gz\") == (Posix.relFile \"file\",\".tar.gz\")",
-      Path.splitExtensions (relFile "file.tar.gz") == (Posix.relFile "file",".tar.gz")) :
-  {-# LINE 1106 "src/System/Path/Internal.hs" #-}
-  ("Path.takeBaseName (absFile \"/tmp/somedir/myfile.txt\") == Posix.relFile \"myfile\"",
-      Path.takeBaseName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile") :
-  {-# LINE 1107 "src/System/Path/Internal.hs" #-}
-  ("Path.takeBaseName (relFile \"./myfile.txt\") == Posix.relFile \"myfile\"",
-      Path.takeBaseName (relFile "./myfile.txt") == Posix.relFile "myfile") :
-  {-# LINE 1108 "src/System/Path/Internal.hs" #-}
-  ("Path.takeBaseName (relFile \"myfile.txt\") == Posix.relFile \"myfile\"",
-      Path.takeBaseName (relFile "myfile.txt") == Posix.relFile "myfile") :
-  {-# LINE 1115 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.absDir \"/tmp/somedir\") == Just (absDir \"/tmp\")",
-      Path.takeSuperDirectory (Posix.absDir "/tmp/somedir") == Just (absDir "/tmp")) :
-  {-# LINE 1116 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.absDir \"/tmp/\") == Just (absDir \"/\")",
-      Path.takeSuperDirectory (Posix.absDir "/tmp/") == Just (absDir "/")) :
-  {-# LINE 1117 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.absDir \"/\") == Nothing",
-      Path.takeSuperDirectory (Posix.absDir "/") == Nothing) :
-  {-# LINE 1118 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.relDir \"tmp/somedir\") == Just (relDir \"tmp\")",
-      Path.takeSuperDirectory (Posix.relDir "tmp/somedir") == Just (relDir "tmp")) :
-  {-# LINE 1119 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.relDir \"./somedir\") == Just (relDir \".\")",
-      Path.takeSuperDirectory (Posix.relDir "./somedir") == Just (relDir ".")) :
-  {-# LINE 1120 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.relDir \"somedir\") == Just Path.currentDir",
-      Path.takeSuperDirectory (Posix.relDir "somedir") == Just Path.currentDir) :
-  {-# LINE 1121 "src/System/Path/Internal.hs" #-}
-  ("Path.takeSuperDirectory (Posix.relDir \"\") == Nothing",
-      Path.takeSuperDirectory (Posix.relDir "") == Nothing) :
-  {-# LINE 1127 "src/System/Path/Internal.hs" #-}
-  ("Path.takeExtension x == snd (Path.splitExtension x)",
-      Path.takeExtension x == snd (Path.splitExtension x)) :
-  {-# LINE 1128 "src/System/Path/Internal.hs" #-}
-  ("Path.takeExtension (Path.addExtension x \"ext\") == \".ext\"",
-      Path.takeExtension (Path.addExtension x "ext") == ".ext") :
-  {-# LINE 1129 "src/System/Path/Internal.hs" #-}
-  ("Path.takeExtension (Path.replaceExtension x \"ext\") == \".ext\"",
-      Path.takeExtension (Path.replaceExtension x "ext") == ".ext") :
-  {-# LINE 1135 "src/System/Path/Internal.hs" #-}
-  ("Path.takeExtensions (Posix.relFile \"file.tar.gz\") == \".tar.gz\"",
-      Path.takeExtensions (Posix.relFile "file.tar.gz") == ".tar.gz") :
-  {-# LINE 1141 "src/System/Path/Internal.hs" #-}
-  ("Path.takeFileName (absFile \"/tmp/somedir/myfile.txt\") == Posix.relFile \"myfile.txt\"",
-      Path.takeFileName (absFile "/tmp/somedir/myfile.txt") == Posix.relFile "myfile.txt") :
-  {-# LINE 1142 "src/System/Path/Internal.hs" #-}
-  ("Path.takeFileName (relFile \"./myfile.txt\") == Posix.relFile \"myfile.txt\"",
-      Path.takeFileName (relFile "./myfile.txt") == Posix.relFile "myfile.txt") :
-  {-# LINE 1143 "src/System/Path/Internal.hs" #-}
-  ("Path.takeFileName (relFile \"myfile.txt\") == Posix.relFile \"myfile.txt\"",
-      Path.takeFileName (relFile "myfile.txt") == Posix.relFile "myfile.txt") :
-  {-# LINE 1175 "src/System/Path/Internal.hs" #-}
-  ("      Posix.equalFilePath \"abc/def\" \"abc/def\"",
-            Posix.equalFilePath "abc/def" "abc/def") :
-  {-# LINE 1176 "src/System/Path/Internal.hs" #-}
-  ("      Posix.equalFilePath \"abc/def\" \"abc//def\"",
-            Posix.equalFilePath "abc/def" "abc//def") :
-  {-# LINE 1177 "src/System/Path/Internal.hs" #-}
-  ("      Posix.equalFilePath \"/tmp/\" \"/tmp\"",
-            Posix.equalFilePath "/tmp/" "/tmp") :
-  {-# LINE 1178 "src/System/Path/Internal.hs" #-}
-  ("      Posix.equalFilePath \"/tmp\" \"//tmp\"",
-            Posix.equalFilePath "/tmp" "//tmp") :
-  {-# LINE 1179 "src/System/Path/Internal.hs" #-}
-  ("      Posix.equalFilePath \"/tmp\" \"///tmp\"",
-            Posix.equalFilePath "/tmp" "///tmp") :
-  {-# LINE 1180 "src/System/Path/Internal.hs" #-}
-  ("not $ Posix.equalFilePath \"abc\" \"def\"",
-      not $ Posix.equalFilePath "abc" "def") :
-  {-# LINE 1181 "src/System/Path/Internal.hs" #-}
-  ("not $ Posix.equalFilePath \"/tmp\" \"tmp\"",
-      not $ Posix.equalFilePath "/tmp" "tmp") :
-  {-# LINE 1182 "src/System/Path/Internal.hs" #-}
-  ("      Windows.equalFilePath \"abc\\\\def\" \"abc\\\\def\"",
-            Windows.equalFilePath "abc\\def" "abc\\def") :
-  {-# LINE 1183 "src/System/Path/Internal.hs" #-}
-  ("      Windows.equalFilePath \"abc\\\\def\" \"abc\\\\\\\\def\"",
-            Windows.equalFilePath "abc\\def" "abc\\\\def") :
-  {-# LINE 1184 "src/System/Path/Internal.hs" #-}
-  ("      Windows.equalFilePath \"file\" \"File\"",
-            Windows.equalFilePath "file" "File") :
-  {-# LINE 1185 "src/System/Path/Internal.hs" #-}
-  ("      Windows.equalFilePath \"\\\\file\" \"\\\\\\\\file\"",
-            Windows.equalFilePath "\\file" "\\\\file") :
-  {-# LINE 1186 "src/System/Path/Internal.hs" #-}
-  ("      Windows.equalFilePath \"\\\\file\" \"\\\\\\\\\\\\file\"",
-            Windows.equalFilePath "\\file" "\\\\\\file") :
-  {-# LINE 1187 "src/System/Path/Internal.hs" #-}
-  ("not $ Windows.equalFilePath \"abc\" \"def\"",
-      not $ Windows.equalFilePath "abc" "def") :
-  {-# LINE 1188 "src/System/Path/Internal.hs" #-}
-  ("not $ Windows.equalFilePath \"file\" \"dir\"",
-      not $ Windows.equalFilePath "file" "dir") :
-  {-# LINE 1201 "src/System/Path/Internal.hs" #-}
-  ("Path.joinPath [\"tmp\",\"someDir\",\"dir\"] == Posix.relDir \"tmp/someDir/dir\"",
-      Path.joinPath ["tmp","someDir","dir"] == Posix.relDir "tmp/someDir/dir") :
-  {-# LINE 1202 "src/System/Path/Internal.hs" #-}
-  ("Path.joinPath [\"tmp\",\"someDir\",\"file.txt\"] == Posix.relFile \"tmp/someDir/file.txt\"",
-      Path.joinPath ["tmp","someDir","file.txt"] == Posix.relFile "tmp/someDir/file.txt") :
-  {-# LINE 1208 "src/System/Path/Internal.hs" #-}
-  ("Path.normalise (absFile \"/tmp/fred/./jim/./file\") == Posix.absFile \"/tmp/fred/jim/file\"",
-      Path.normalise (absFile "/tmp/fred/./jim/./file") == Posix.absFile "/tmp/fred/jim/file") :
-  {-# LINE 1214 "src/System/Path/Internal.hs" #-}
-  ("Path.splitPath (Posix.absDir \"/tmp/someDir/mydir.dir\") == (True, map relDir [\"tmp\",\"someDir\",\"mydir.dir\"], Nothing)",
-      Path.splitPath (Posix.absDir "/tmp/someDir/mydir.dir") == (True, map relDir ["tmp","someDir","mydir.dir"], Nothing)) :
-  {-# LINE 1215 "src/System/Path/Internal.hs" #-}
-  ("Path.splitPath (Posix.absFile \"/tmp/someDir/myfile.txt\") == (True, map relDir [\"tmp\",\"someDir\"], Just $ relFile \"myfile.txt\")",
-      Path.splitPath (Posix.absFile "/tmp/someDir/myfile.txt") == (True, map relDir ["tmp","someDir"], Just $ relFile "myfile.txt")) :
-  {-# LINE 1231 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelative (absDir \"/tmp/somedir\") (absFile \"/tmp/somedir/anotherdir/file.txt\") == Posix.relFile \"anotherdir/file.txt\"",
-      Path.makeRelative (absDir "/tmp/somedir") (absFile "/tmp/somedir/anotherdir/file.txt") == Posix.relFile "anotherdir/file.txt") :
-  {-# LINE 1232 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelative (absDir \"/tmp/somedir\") (absDir \"/tmp/somedir/anotherdir/dir\") == Posix.relDir \"anotherdir/dir\"",
-      Path.makeRelative (absDir "/tmp/somedir") (absDir "/tmp/somedir/anotherdir/dir") == Posix.relDir "anotherdir/dir") :
-  {-# LINE 1233 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelative (absDir \"c:\\\\tmp\\\\somedir\") (absFile \"C:\\\\Tmp\\\\SomeDir\\\\AnotherDir\\\\File.txt\") == Windows.relFile \"AnotherDir\\\\File.txt\"",
-      Path.makeRelative (absDir "c:\\tmp\\somedir") (absFile "C:\\Tmp\\SomeDir\\AnotherDir\\File.txt") == Windows.relFile "AnotherDir\\File.txt") :
-  {-# LINE 1234 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelative (absDir \"c:\\\\tmp\\\\somedir\") (absDir \"c:\\\\tmp\\\\somedir\\\\anotherdir\\\\dir\") == Windows.relDir \"anotherdir\\\\dir\"",
-      Path.makeRelative (absDir "c:\\tmp\\somedir") (absDir "c:\\tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir") :
-  {-# LINE 1235 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelative (absDir \"c:tmp\\\\somedir\") (absDir \"c:tmp\\\\somedir\\\\anotherdir\\\\dir\") == Windows.relDir \"anotherdir\\\\dir\"",
-      Path.makeRelative (absDir "c:tmp\\somedir") (absDir "c:tmp\\somedir\\anotherdir\\dir") == Windows.relDir "anotherdir\\dir") :
-  {-# LINE 1246 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelativeMaybe (Posix.absDir \"/tmp/somedir\") (absFile \"/tmp/anotherdir/file.txt\") == Nothing",
-      Path.makeRelativeMaybe (Posix.absDir "/tmp/somedir") (absFile "/tmp/anotherdir/file.txt") == Nothing) :
-  {-# LINE 1247 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelativeMaybe (Posix.absDir \"/Tmp\") (absFile \"/tmp/anotherdir/file.txt\") == Nothing",
-      Path.makeRelativeMaybe (Posix.absDir "/Tmp") (absFile "/tmp/anotherdir/file.txt") == Nothing) :
-  {-# LINE 1248 "src/System/Path/Internal.hs" #-}
-  ("Path.makeRelativeMaybe (Windows.absDir \"\\\\Tmp\") (absFile \"\\\\tmp\\\\anotherdir\\\\file.txt\") == Just (relFile \"anotherdir\\\\file.txt\")",
-      Path.makeRelativeMaybe (Windows.absDir "\\Tmp") (absFile "\\tmp\\anotherdir\\file.txt") == Just (relFile "anotherdir\\file.txt")) :
-  {-# LINE 1262 "src/System/Path/Internal.hs" #-}
-  ("Path.makeAbsolute (absDir \"/tmp\") (relFile \"file.txt\")      == Posix.absFile \"/tmp/file.txt\"",
-      Path.makeAbsolute (absDir "/tmp") (relFile "file.txt")      == Posix.absFile "/tmp/file.txt") :
-  {-# LINE 1263 "src/System/Path/Internal.hs" #-}
-  ("Path.makeAbsolute (absDir \"/tmp\") (relFile \"adir/file.txt\") == Posix.absFile \"/tmp/adir/file.txt\"",
-      Path.makeAbsolute (absDir "/tmp") (relFile "adir/file.txt") == Posix.absFile "/tmp/adir/file.txt") :
-  {-# LINE 1264 "src/System/Path/Internal.hs" #-}
-  ("Path.makeAbsolute (absDir \"/tmp\") (relDir  \"adir/dir\")      == Posix.absDir \"/tmp/adir/dir\"",
-      Path.makeAbsolute (absDir "/tmp") (relDir  "adir/dir")      == Posix.absDir "/tmp/adir/dir") :
-  {-# LINE 1286 "src/System/Path/Internal.hs" #-}
-  ("Path.genericMakeAbsolute (absDir \"/tmp\") (relFile \"file.txt\")       == Posix.absFile \"/tmp/file.txt\"",
-      Path.genericMakeAbsolute (absDir "/tmp") (relFile "file.txt")       == Posix.absFile "/tmp/file.txt") :
-  {-# LINE 1287 "src/System/Path/Internal.hs" #-}
-  ("Path.genericMakeAbsolute (absDir \"/tmp\") (relFile \"adir/file.txt\")  == Posix.absFile \"/tmp/adir/file.txt\"",
-      Path.genericMakeAbsolute (absDir "/tmp") (relFile "adir/file.txt")  == Posix.absFile "/tmp/adir/file.txt") :
-  {-# LINE 1288 "src/System/Path/Internal.hs" #-}
-  ("Path.genericMakeAbsolute (absDir \"/tmp\") (absFile \"/adir/file.txt\") == Posix.absFile \"/adir/file.txt\"",
-      Path.genericMakeAbsolute (absDir "/tmp") (absFile "/adir/file.txt") == Posix.absFile "/adir/file.txt") :
-  {-# LINE 1376 "src/System/Path/Internal.hs" #-}
-  ("Path.isAbsolute (Posix.absFile \"/fred\")",
-      Path.isAbsolute (Posix.absFile "/fred")) :
-  {-# LINE 1377 "src/System/Path/Internal.hs" #-}
-  ("Path.isAbsolute (Windows.absFile \"\\\\fred\")",
-      Path.isAbsolute (Windows.absFile "\\fred")) :
-  {-# LINE 1378 "src/System/Path/Internal.hs" #-}
-  ("Path.isAbsolute (Windows.absFile \"c:\\\\fred\")",
-      Path.isAbsolute (Windows.absFile "c:\\fred")) :
-  {-# LINE 1379 "src/System/Path/Internal.hs" #-}
-  ("Path.isAbsolute (Windows.absFile \"c:fred\")",
-      Path.isAbsolute (Windows.absFile "c:fred")) :
-  {-# LINE 1386 "src/System/Path/Internal.hs" #-}
-  ("Path.isRelative (Posix.relFile \"fred\")",
-      Path.isRelative (Posix.relFile "fred")) :
-  {-# LINE 1387 "src/System/Path/Internal.hs" #-}
-  ("Path.isRelative (Windows.relFile \"fred\")",
-      Path.isRelative (Windows.relFile "fred")) :
-  {-# LINE 1412 "src/System/Path/Internal.hs" #-}
-  ("null (Path.takeExtension x) == not (Path.hasAnExtension x)",
-      null (Path.takeExtension x) == not (Path.hasAnExtension x)) :
-  {-# LINE 1418 "src/System/Path/Internal.hs" #-}
-  ("Path.hasExtension \".hs\" (Posix.relFile \"MyCode.hs\")",
-      Path.hasExtension ".hs" (Posix.relFile "MyCode.hs")) :
-  {-# LINE 1419 "src/System/Path/Internal.hs" #-}
-  ("Path.hasExtension \".hs\" (Posix.relFile \"MyCode.bak.hs\")",
-      Path.hasExtension ".hs" (Posix.relFile "MyCode.bak.hs")) :
-  {-# LINE 1420 "src/System/Path/Internal.hs" #-}
-  ("not $ Path.hasExtension \".hs\" (Posix.relFile \"MyCode.hs.bak\")",
-      not $ Path.hasExtension ".hs" (Posix.relFile "MyCode.hs.bak")) :
-  {-# LINE 1430 "src/System/Path/Internal.hs" #-}
-  ("Posix.extSeparator == '.'",
-      Posix.extSeparator == '.') :
-  {-# LINE 1441 "src/System/Path/Internal.hs" #-}
-  ("Posix.isExtSeparator a == (a == Posix.extSeparator)",
-      Posix.isExtSeparator a == (a == Posix.extSeparator)) :
-  {-# LINE 1447 "src/System/Path/Internal.hs" #-}
-  ("Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)",
-      Posix.isSearchPathSeparator a == (a == Posix.searchPathSeparator)) :
-  {-# LINE 1463 "src/System/Path/Internal.hs" #-}
-  ("Path.genericAddExtension (absDir \"/\") \"x\" == Posix.absDir \"/.x\"",
-      Path.genericAddExtension (absDir "/") "x" == Posix.absDir "/.x") :
-  {-# LINE 1464 "src/System/Path/Internal.hs" #-}
-  ("Path.genericAddExtension (absDir \"/a\") \"x\" == Posix.absDir \"/a.x\"",
-      Path.genericAddExtension (absDir "/a") "x" == Posix.absDir "/a.x") :
-  {-# LINE 1465 "src/System/Path/Internal.hs" #-}
-  ("Path.genericAddExtension Path.emptyFile \"x\" == Posix.relFile \".x\"",
-      Path.genericAddExtension Path.emptyFile "x" == Posix.relFile ".x") :
-  {-# LINE 1466 "src/System/Path/Internal.hs" #-}
-  ("Path.genericAddExtension Path.emptyFile \"\" == Posix.emptyFile",
-      Path.genericAddExtension Path.emptyFile "" == Posix.emptyFile) :
-  []
diff --git a/test/TestTemplate.hs b/test/TestTemplate.hs
deleted file mode 100644
--- a/test/TestTemplate.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
-module TestResult (results) where
-
-import qualified System.Path.PartClass as Class
-import qualified System.Path.Generic as Path
-import qualified System.Path.Posix as Posix
-import qualified System.Path.Windows as Windows
-import System.Path.Generic ((</>), (<.>), relFile, relDir, absFile, absDir)
-import Data.Char (toLower)
-
-
-results :: (Class.AbsRel ar) => Char -> Posix.FilePath ar -> [(String, Bool)]
-results a x =
-  <TESTS_GO_HERE>
-  []
diff --git a/tool/CreateTest.hs b/tool/CreateTest.hs
deleted file mode 100644
--- a/tool/CreateTest.hs
+++ /dev/null
@@ -1,47 +0,0 @@
-module Main where
-
-import qualified Control.Functor.HT as FuncHT
-import Control.Applicative ((<$>), (<$))
-import Data.List (stripPrefix, isInfixOf)
-import Data.Maybe (mapMaybe)
-import Data.Tuple.HT (mapFst)
-import Data.Char (isSpace)
-
-import Text.Printf (printf)
-
-
-srcfiles :: [String]
-template, testModule, tok, testPrefix :: String
-
-srcfiles   =
-   map ("src/System/Path/" ++) $
-   ["Internal.hs", "Directory.hs", "IO.hs"]
-template   = "test/TestTemplate.hs"
-testModule = "test/TestResult.hs"
-tok        = "<TESTS_GO_HERE>"
-testPrefix = "-- >> "
-
-main :: IO ()
-main = do
-  let readFileNumbered path =
-        zip ((,) path <$> [(0::Int)..]) . lines <$> readFile path
-  testLines <-
-     mapMaybe (FuncHT.mapSnd $ stripPrefix testPrefix) .
-     map (\(n,row) -> mapFst ((,) n) $ span isSpace row) .
-     concat
-        <$> mapM readFileNumbered srcfiles
-  (templateHead,_:templateTail) <-
-     break (tok `isInfixOf`) . lines <$> readFile template
-  {-
-  Choose the same indentation depth as in the source file,
-  such that GHC reports precise source file locations.
-  -}
-  let outLines =
-        (\(((src,n),ind),t) ->
-           printf "  {-# LINE %d \"%s\" #-}\n  (%s,\n%s%s%s) :"
-              n src (show t) ind (' ' <$ testPrefix) t)
-         <$> testLines
-
-  writeFile testModule $ unlines $
-     ("{- Do not edit! Created from " ++ template ++ " -}") :
-     templateHead ++ outLines ++ templateTail
