filepath-1.4.100.0: bench/BenchFilePath.hs

{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE QuasiQuotes #-}

module Main where

import System.OsPath.Types
import System.OsPath.Encoding ( ucs2le )
import System.Environment
import qualified System.OsString.Internal.Types as OST
import qualified Data.ByteString.Short as SBS

import TastyBench
import Data.List
import Data.Maybe
import GHC.IO.Encoding

import qualified System.FilePath.Posix as PF
import qualified System.FilePath.Posix as WF
import qualified System.OsString.Posix as OSP
import qualified System.OsString.Windows as WSP
import qualified System.OsPath.Posix as APF
import qualified System.OsPath.Windows as AWF


data Config = Config {
    format  :: Format
  , stdev   :: Double
  , timeout :: Integer
  }

data Format = Print
            | CSV
  deriving (Read, Show)

defaultConfig :: Config
defaultConfig = Config defaultFormat defaultStdev defaultTimeout

defaultFormat :: Format
defaultFormat = Print

defaultStdev :: Double
defaultStdev = 0.02

defaultTimeout :: Integer
defaultTimeout = 800000

parseConfig :: [String] -> Config
parseConfig [] = defaultConfig
parseConfig xs =
  let format'  = maybe defaultFormat  (read . fromJust . stripPrefix "--format=" ) $ find ("--format="  `isPrefixOf`) xs
      stdev'   = maybe defaultStdev   (read . fromJust . stripPrefix "--stdev="  ) $ find ("--stdev="   `isPrefixOf`) xs
      timeout' = maybe defaultTimeout (read . fromJust . stripPrefix "--timeout=") $ find ("--timeout=" `isPrefixOf`) xs
  in Config format' stdev' timeout'


main :: IO ()
main = do
  setLocaleEncoding utf8
  args <- getArgs
  let config = parseConfig args
  benchGroup config
    [ ("filepath (string)",
      [("splitExtension (posix)"      , nf PF.splitExtension posixPath)
      ,("splitExtension (windows)"    , nf WF.splitExtension windowsPath)
      ,("takeExtension (posix)"       , nf PF.takeExtension posixPath)
      ,("takeExtension (windows)"     , nf WF.takeExtension windowsPath)
      ,("replaceExtension (posix)"    , nf (PF.replaceExtension ".lol") posixPath)
      ,("replaceExtension (windows)"  , nf (WF.replaceExtension ".lol") windowsPath)
      ,("dropExtension (posix)"       , nf PF.dropExtension posixPath)
      ,("dropExtension (windows)"     , nf WF.dropExtension windowsPath)
      ,("addExtension (posix)"        , nf (PF.addExtension ".lol") posixPath)
      ,("addExtension (windows)"      , nf (WF.addExtension ".lol") windowsPath)
      ,("hasExtension (posix)"        , nf PF.hasExtension posixPath)
      ,("hasExtension (windows)"      , nf WF.hasExtension windowsPath)
      ,("splitExtensions (posix)"     , nf PF.splitExtensions posixPath)
      ,("splitExtensions (windows)"   , nf WF.splitExtensions windowsPath)
      ,("dropExtensions (posix)"      , nf PF.dropExtensions posixPath)
      ,("dropExtensions (windows)"    , nf WF.dropExtensions windowsPath)
      ,("takeExtensions (posix)"      , nf PF.takeExtensions posixPath)
      ,("takeExtensions (windows)"    , nf WF.takeExtensions windowsPath)
      ,("replaceExtensions (posix)"   , nf (PF.replaceExtensions ".lol") posixPath)
      ,("replaceExtensions (windows)" , nf (WF.replaceExtensions ".lol") windowsPath)
      ,("isExtensionOf (posix)"       , nf (PF.isExtensionOf ".lol") posixPath)
      ,("isExtensionOf (windows)"     , nf (WF.isExtensionOf ".lol") windowsPath)
      ,("stripExtension (posix)"      , nf (PF.stripExtension ".lol") posixPath)
      ,("stripExtension (windows)"    , nf (WF.stripExtension ".lol") windowsPath)

      ,("splitFileName (posix)"       , nf PF.splitFileName posixPath)
      ,("splitFileName (windows)"     , nf WF.splitFileName windowsPath)
      ,("takeFileName (posix)"        , nf PF.takeFileName posixPath)
      ,("takeFileName (windows)"      , nf WF.takeFileName windowsPath)
      ,("replaceFileName (posix)"     , nf (PF.replaceFileName "lol") posixPath)
      ,("replaceFileName (windows)"   , nf (WF.replaceFileName "lol") windowsPath)
      ,("dropFileName (posix)"        , nf PF.dropFileName posixPath)
      ,("dropFileName (windows)"      , nf WF.dropFileName windowsPath)
      ,("takeBaseName (posix)"        , nf PF.takeBaseName posixPath)
      ,("takeBaseName (windows)"      , nf WF.takeBaseName windowsPath)
      ,("replaceBaseName (posix)"     , nf (PF.replaceBaseName "lol") posixPath)
      ,("replaceBaseName (windows)"   , nf (WF.replaceBaseName "lol") windowsPath)
      ,("takeDirectory (posix)"       , nf PF.takeDirectory posixPath)
      ,("takeDirectory (windows)"     , nf WF.takeDirectory windowsPath)
      ,("replaceDirectory (posix)"    , nf (PF.replaceDirectory "lol") posixPath)
      ,("replaceDirectory (windows)"  , nf (WF.replaceDirectory "lol") windowsPath)
      ,("combine (posix)"             , nf (PF.combine "lol") posixPath)
      ,("combine (windows)"           , nf (WF.combine "lol") windowsPath)
      ,("splitPath (posix)"           , nf PF.splitPath    posixPath)
      ,("splitPath (windows)"         , nf WF.splitPath    windowsPath)
      ,("joinPath (posix)"            , nf PF.joinPath     (PF.splitPath posixPath))
      ,("joinPath (windows)"          , nf WF.joinPath     (WF.splitPath windowsPath))
      ,("splitDirectories (posix)"    , nf PF.splitDirectories    posixPath)
      ,("splitDirectories (windows)"  , nf WF.splitDirectories    windowsPath)

      ,("splitDrive (posix)"          , nf PF.splitDrive    posixPath)
      ,("splitDrive (windows)"        , nf WF.splitDrive    windowsPath)
      ,("joinDrive (posix)"           , nf (PF.joinDrive "/")    posixPath)
      ,("joinDrive (windows)"         , nf (WF.joinDrive "C:\\")  windowsPath)
      ,("takeDrive (posix)"           , nf PF.takeDrive    posixPath)
      ,("takeDrive (windows)"         , nf WF.takeDrive    windowsPath)
      ,("hasDrive (posix)"            , nf PF.hasDrive    posixPath)
      ,("hasDrive (windows)"          , nf WF.hasDrive    windowsPath)
      ,("dropDrive (posix)"           , nf PF.dropDrive    posixPath)
      ,("dropDrive (windows)"         , nf WF.dropDrive    windowsPath)
      ,("isDrive (posix)"             , nf PF.isDrive    posixPath)
      ,("isDrive (windows)"           , nf WF.isDrive    windowsPath)

      ,("hasTrailingPathSeparator (posix)"    , nf PF.hasTrailingPathSeparator    posixPath)
      ,("hasTrailingPathSeparator (windows)"  , nf WF.hasTrailingPathSeparator    windowsPath)
      ,("addTrailingPathSeparator (posix)"    , nf PF.addTrailingPathSeparator    posixPath)
      ,("addTrailingPathSeparator (windows)"  , nf WF.addTrailingPathSeparator    windowsPath)
      ,("dropTrailingPathSeparator (posix)"   , nf PF.addTrailingPathSeparator    posixPath)
      ,("dropTrailingPathSeparator (windows)" , nf WF.addTrailingPathSeparator    windowsPath)

      ,("normalise (posix)"           , nf PF.normalise    posixPath)
      ,("normalise (windows)"         , nf WF.normalise    windowsPath)
      ,("equalFilePath (posix)"       , nf (PF.equalFilePath "abc/def/zs")   posixPath)
      ,("equalFilePath (windows)"     , nf (WF.equalFilePath "abc/def/zs")   windowsPath)
      ,("makeRelative (posix)"        , nf (PF.makeRelative "abc/def/zs")   posixPath)
      ,("makeRelative (windows)"      , nf (WF.makeRelative "abc/def/zs")   windowsPath)
      ,("isRelative (posix)"          , nf PF.isRelative    posixPath)
      ,("isRelative (windows)"        , nf WF.isRelative    windowsPath)
      ,("isAbsolute (posix)"          , nf PF.isAbsolute    posixPath)
      ,("isAbsolute (windows)"        , nf WF.isAbsolute    windowsPath)
      ,("isValid (posix)"             , nf PF.isValid    posixPath)
      ,("isValid (windows)"           , nf WF.isValid    windowsPath)
      ,("makeValid (posix)"           , nf PF.makeValid    posixPath)
      ,("makeValid (windows)"         , nf WF.makeValid    windowsPath)

      ,("splitSearchPath (posix)"    , nf PF.splitSearchPath posixSearchPath)
      ,("splitSearchPath (windows)"  , nf WF.splitSearchPath windowsSearchPath)
      ]
      )

    , ("filepath (AFPP)",
      [ ("splitExtension (posix)"      , nf APF.splitExtension posixPathAFPP)
      , ("splitExtension (windows)"    , nf AWF.splitExtension windowsPathAFPP)
      , ("takeExtension (posix)"       , nf APF.takeExtension posixPathAFPP)
      , ("takeExtension (windows)"     , nf AWF.takeExtension windowsPathAFPP)
      , ("replaceExtension (posix)"    , nf (APF.replaceExtension [OSP.pstr|.lol|]) posixPathAFPP)
      , ("replaceExtension (windows)"  , nf (AWF.replaceExtension [WSP.pstr|.lol|]) windowsPathAFPP)
      , ("dropExtension (posix)"       , nf APF.dropExtension posixPathAFPP)
      , ("dropExtension (windows)"     , nf AWF.dropExtension windowsPathAFPP)
      , ("addExtension (posix)"        , nf (APF.addExtension [OSP.pstr|.lol|]) posixPathAFPP)
      , ("addExtension (windows)"      , nf (AWF.addExtension [WSP.pstr|.lol|]) windowsPathAFPP)
      , ("hasExtension (posix)"        , nf APF.hasExtension posixPathAFPP)
      , ("hasExtension (windows)"      , nf AWF.hasExtension windowsPathAFPP)
      , ("splitExtensions (posix)"     , nf APF.splitExtensions posixPathAFPP)
      , ("splitExtensions (windows)"   , nf AWF.splitExtensions windowsPathAFPP)
      , ("dropExtensions (posix)"      , nf APF.dropExtensions posixPathAFPP)
      , ("dropExtensions (windows)"    , nf AWF.dropExtensions windowsPathAFPP)
      , ("takeExtensions (posix)"      , nf APF.takeExtensions posixPathAFPP)
      , ("takeExtensions (windows)"    , nf AWF.takeExtensions windowsPathAFPP)
      , ("replaceExtensions (posix)"   , nf (APF.replaceExtensions [OSP.pstr|.lol|]) posixPathAFPP)
      , ("replaceExtensions (windows)" , nf (AWF.replaceExtensions [WSP.pstr|.lol|]) windowsPathAFPP)
      , ("isExtensionOf (posix)"       , nf (APF.isExtensionOf [OSP.pstr|.lol|]) posixPathAFPP)
      , ("isExtensionOf (windows)"     , nf (AWF.isExtensionOf [WSP.pstr|.lol|]) windowsPathAFPP)
      , ("stripExtension (posix)"      , nf (APF.stripExtension [OSP.pstr|.lol|]) posixPathAFPP)
      , ("stripExtension (windows)"    , nf (AWF.stripExtension [WSP.pstr|.lol|]) windowsPathAFPP)

      , ("splitFileName (posix)"       , nf APF.splitFileName posixPathAFPP)
      , ("splitFileName (windows)"     , nf AWF.splitFileName windowsPathAFPP)
      , ("takeFileName (posix)"        , nf APF.takeFileName posixPathAFPP)
      , ("takeFileName (windows)"      , nf AWF.takeFileName windowsPathAFPP)
      , ("replaceFileName (posix)"     , nf (APF.replaceFileName [OSP.pstr|lol|]) posixPathAFPP)
      , ("replaceFileName (windows)"   , nf (AWF.replaceFileName [WSP.pstr|lol|]) windowsPathAFPP)
      , ("dropFileName (posix)"        , nf APF.dropFileName posixPathAFPP)
      , ("dropFileName (windows)"      , nf AWF.dropFileName windowsPathAFPP)
      , ("takeBaseName (posix)"        , nf APF.takeBaseName posixPathAFPP)
      , ("takeBaseName (windows)"      , nf AWF.takeBaseName windowsPathAFPP)
      , ("replaceBaseName (posix)"     , nf (APF.replaceBaseName [OSP.pstr|lol|]) posixPathAFPP)
      , ("replaceBaseName (windows)"   , nf (AWF.replaceBaseName [WSP.pstr|lol|]) windowsPathAFPP)
      , ("takeDirectory (posix)"       , nf APF.takeDirectory posixPathAFPP)
      , ("takeDirectory (windows)"     , nf AWF.takeDirectory windowsPathAFPP)
      , ("replaceDirectory (posix)"    , nf (APF.replaceDirectory [OSP.pstr|lol|]) posixPathAFPP)
      , ("replaceDirectory (windows)"  , nf (AWF.replaceDirectory [WSP.pstr|lol|]) windowsPathAFPP)
      , ("combine (posix)"             , nf (APF.combine [OSP.pstr|lol|]) posixPathAFPP)
      , ("combine (windows)"           , nf (AWF.combine [WSP.pstr|lol|]) windowsPathAFPP)
      , ("splitPath (posix)"           , nf APF.splitPath    posixPathAFPP)
      , ("splitPath (windows)"         , nf AWF.splitPath    windowsPathAFPP)
      , ("joinPath (posix)"            , nf APF.joinPath     (APF.splitPath posixPathAFPP))
      , ("joinPath (windows)"          , nf AWF.joinPath     (AWF.splitPath windowsPathAFPP))
      , ("splitDirectories (posix)"    , nf APF.splitDirectories    posixPathAFPP)
      , ("splitDirectories (windows)"  , nf AWF.splitDirectories    windowsPathAFPP)

      , ("splitDrive (posix)"          , nf APF.splitDrive    posixPathAFPP)
      , ("splitDrive (windows)"        , nf AWF.splitDrive    windowsPathAFPP)
      , ("joinDrive (posix)"           , nf (APF.joinDrive [OSP.pstr|/|])    posixPathAFPP)
      , ("joinDrive (windows)"         , nf (AWF.joinDrive [WSP.pstr|C:\|])    windowsPathAFPP)
      , ("takeDrive (posix)"           , nf APF.takeDrive    posixPathAFPP)
      , ("takeDrive (windows)"         , nf AWF.takeDrive    windowsPathAFPP)
      , ("hasDrive (posix)"            , nf APF.hasDrive    posixPathAFPP)
      , ("hasDrive (windows)"          , nf AWF.hasDrive    windowsPathAFPP)
      , ("dropDrive (posix)"           , nf APF.dropDrive    posixPathAFPP)
      , ("dropDrive (windows)"         , nf AWF.dropDrive    windowsPathAFPP)
      , ("isDrive (posix)"             , nf APF.isDrive    posixPathAFPP)
      , ("isDrive (windows)"           , nf AWF.isDrive    windowsPathAFPP)

      , ("hasTrailingPathSeparator (posix)"    , nf APF.hasTrailingPathSeparator    posixPathAFPP)
      , ("hasTrailingPathSeparator (windows)"  , nf AWF.hasTrailingPathSeparator    windowsPathAFPP)
      , ("addTrailingPathSeparator (posix)"    , nf APF.addTrailingPathSeparator    posixPathAFPP)
      , ("addTrailingPathSeparator (windows)"  , nf AWF.addTrailingPathSeparator    windowsPathAFPP)
      , ("dropTrailingPathSeparator (posix)"   , nf APF.addTrailingPathSeparator    posixPathAFPP)
      , ("dropTrailingPathSeparator (windows)" , nf AWF.addTrailingPathSeparator    windowsPathAFPP)

      , ("normalise (posix)"           , nf APF.normalise    posixPathAFPP)
      , ("normalise (windows)"         , nf AWF.normalise    windowsPathAFPP)
      , ("equalFilePath (posix)"       , nf (APF.equalFilePath [OSP.pstr|abc/def/zs|])   posixPathAFPP)
      , ("equalFilePath (windows)"     , nf (AWF.equalFilePath [WSP.pstr|abc/def/zs|])   windowsPathAFPP)
      , ("makeRelative (posix)"        , nf (APF.makeRelative [OSP.pstr|abc/def/zs|])   posixPathAFPP)
      , ("makeRelative (windows)"      , nf (AWF.makeRelative [WSP.pstr|abc/def/zs|])   windowsPathAFPP)
      , ("isRelative (posix)"          , nf APF.isRelative    posixPathAFPP)
      , ("isRelative (windows)"        , nf AWF.isRelative    windowsPathAFPP)
      , ("isAbsolute (posix)"          , nf APF.isAbsolute    posixPathAFPP)
      , ("isAbsolute (windows)"        , nf AWF.isAbsolute    windowsPathAFPP)
      , ("isValid (posix)"             , nf APF.isValid    posixPathAFPP)
      , ("isValid (windows)"           , nf AWF.isValid    windowsPathAFPP)
      , ("makeValid (posix)"           , nf APF.makeValid    posixPathAFPP)
      , ("makeValid (windows)"         , nf AWF.makeValid    windowsPathAFPP)

      , ("splitSearchPath (posix)"     , nf APF.splitSearchPath posixSearchPathAFPP)
      , ("splitSearchPath (windows)"   , nf AWF.splitSearchPath windowsSearchPathAFPP)
      ]
      )

    , ("encoding/decoding",
      [ ("decodeUtf (posix)"                  , nf (APF.decodeUtf @Maybe) posixPathAFPP)
      , ("decodeUtf (windows)"                , nf (AWF.decodeUtf @Maybe) windowsPathAFPP)
      , ("decodeWith (windows)"               , nf (AWF.decodeWith ucs2le) windowsPathAFPP)

      , ("encodeUtf (posix)"                  , nf (APF.encodeUtf @Maybe) posixPath)
      , ("encodeUtf (windows)"                , nf (AWF.encodeUtf @Maybe) windowsPath)
      , ("encodeWith (windows)"               , nf (AWF.encodeWith ucs2le) windowsPath)

      , ("unpack PlatformString (posix)"       , nf APF.unpack posixPathAFPP)
      , ("unpack PlatformString (windows)"     , nf AWF.unpack windowsPathAFPP)
      , ("pack PlatformString (posix)"         , nf APF.pack (APF.unpack posixPathAFPP))
      , ("pack PlatformString (windows)"       , nf AWF.pack (AWF.unpack windowsPathAFPP))

      , ("fromBytes (posix)"                  , nf (OSP.fromBytes @Maybe) (SBS.fromShort . OST.getPosixString $ posixPathAFPP))
      , ("fromBytes (windows)"                , nf (WSP.fromBytes @Maybe) (SBS.fromShort . OST.getWindowsString $ windowsPathAFPP))
      ]
      )
    ]


posixPath :: FilePath
posixPath = "/foo/bar/bath/baz/baz/tz/fooooooooooooooo/laaaaaaaaaaaaaaa/baaaaaaaaaaaaar/zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz/zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz/kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk/kkkkkkkkkkkkkkkkkk/h/h/h/a/s/r/a/h/gt/r/r/r/s/s.txt"

windowsPath :: FilePath
windowsPath = "C:\\foo\\bar\\bath\\baz\\baz\\tz\\fooooooooooooooo\\laaaaaaaaaaaaaaa\\baaaaaaaaaaaaar\\zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk\\kkkkkkkkkkkkkkkkkk\\h\\h\\h\\a\\s\\r\\a\\h\\gt\\r\\r\\r\\s\\s.txt"

posixPathAFPP :: PosixPath
posixPathAFPP = [OSP.pstr|/foo/bar/bath/baz/baz/tz/fooooooooooooooo/laaaaaaaaaaaaaaa/baaaaaaaaaaaaar/zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz/zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz/kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk/kkkkkkkkkkkkkkkkkk/h/h/h/a/s/r/a/h/gt/r/r/r/s/s.txt|]

windowsPathAFPP :: WindowsPath
windowsPathAFPP = [WSP.pstr|C:\\foo\\bar\\bath\\baz\\baz\\tz\\fooooooooooooooo\\laaaaaaaaaaaaaaa\\baaaaaaaaaaaaar\\zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk\\kkkkkkkkkkkkkkkkkk\\h\\h\\h\\a\\s\\r\\a\\h\\gt\\r\\r\\r\\s\\s.txt|]

posixSearchPath :: FilePath
posixSearchPath = ":foo:bar:bath:baz:baz:tz:fooooooooooooooo:laaaaaaaaaaaaaaa:baaaaaaaaaaaaar:zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz:zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz:kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk:kkkkkkkkkkkkkkkkkk:h:h:h:a:s:r:a:h:gt:r:r:r:s:s.txt"

windowsSearchPath :: FilePath
windowsSearchPath = "foo;bar;bath;baz;baz;tz;fooooooooooooooo;laaaaaaaaaaaaaaa;baaaaaaaaaaaaar;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk;kkkkkkkkkkkkkkkkkk;h;h;h;a;s;r;a;h;gt;r;r;r;s;s.txt"

posixSearchPathAFPP :: PosixString
posixSearchPathAFPP = [OSP.pstr|:foo:bar:bath:baz:baz:tz:fooooooooooooooo:laaaaaaaaaaaaaaa:baaaaaaaaaaaaar:zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz:zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz:kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk:kkkkkkkkkkkkkkkkkk:h:h:h:a:s:r:a:h:gt:r:r:r:s:s.txt|]

windowsSearchPathAFPP :: WindowsString
windowsSearchPathAFPP = [WSP.pstr|foo;bar;bath;baz;baz;tz;fooooooooooooooo;laaaaaaaaaaaaaaa;baaaaaaaaaaaaar;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk;kkkkkkkkkkkkkkkkkk;h;h;h;a;s;r;a;h;gt;r;r;r;s;s.txt|]


benchGroup :: Config -> [(String, [(String, Benchmarkable)])] -> IO ()
benchGroup _ [] = pure ()
benchGroup format ((name, benchs):xs) = do
  putStrLn name
  bench format benchs
  benchGroup format xs

bench :: Config -> [(String, Benchmarkable)] -> IO ()
bench _ [] = pure ()
bench config@Config{..} (x:xs) = do
  let (name, benchmarkable) = x
  case format of
    CSV -> putStr (name ++ ",")
    Print -> putStr ("    " ++ name ++ ": ")
  est <- measureUntil CpuTime False (Timeout timeout "") (RelStDev stdev) benchmarkable
  case format of
    CSV -> putStr $ csvEstimate est
    Print -> putStr $ "\n      " ++ prettyEstimate est
  putStr "\n"
  bench config xs