{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeApplications #-}

module Test.Syd.OptParse where

import Control.Applicative
import Control.Monad
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text as T
import Data.Yaml
import qualified Env
import GHC.Generics (Generic)
import Options.Applicative as OptParse
import qualified Options.Applicative.Help as OptParse (string)
import Path
import Path.IO
import Test.Syd.Run
import YamlParse.Applicative as YamlParse

getSettings :: IO Settings
getSettings :: IO Settings
getSettings = do
  Flags
flags <- IO Flags
getFlags
  Environment
env <- IO Environment
getEnvironment
  Maybe Configuration
config <- Flags -> Environment -> IO (Maybe Configuration)
getConfiguration Flags
flags Environment
env
  Flags -> Environment -> Maybe Configuration -> IO Settings
combineToSettings Flags
flags Environment
env Maybe Configuration
config

-- | Test suite definition and run settings
data Settings = Settings
  { -- | The seed to use for deterministic randomness
    Settings -> Int
settingSeed :: !Int,
    -- | Randomise the execution order of the tests in the test suite
    Settings -> Bool
settingRandomiseExecutionOrder :: !Bool,
    -- | How parallel to run the test suite
    Settings -> Threads
settingThreads :: !Threads,
    -- | How many examples to run a property test with
    Settings -> Int
settingMaxSuccess :: !Int,
    -- | The maximum size parameter to supply to generators
    Settings -> Int
settingMaxSize :: !Int,
    -- | The maximum number of discarded examples per tested example
    Settings -> Int
settingMaxDiscard :: !Int,
    -- | The maximum number of tries to use while shrinking a counterexample.
    Settings -> Int
settingMaxShrinks :: !Int,
    -- | Whether to write golden tests if they do not exist yet
    Settings -> Bool
settingGoldenStart :: !Bool,
    -- | Whether to overwrite golden tests instead of having them fail
    Settings -> Bool
settingGoldenReset :: !Bool,
    -- | Whether to use colour in the output
    Settings -> Maybe Bool
settingColour :: !(Maybe Bool),
    -- | The filter to use to select which tests to run
    Settings -> Maybe Text
settingFilter :: !(Maybe Text),
    -- | Whether to stop upon the first test failure
    Settings -> Bool
settingFailFast :: !Bool,
    -- | How many iterations to use to look diagnose flakiness
    Settings -> Iterations
settingIterations :: Iterations
  }
  deriving (Int -> Settings -> ShowS
[Settings] -> ShowS
Settings -> String
(Int -> Settings -> ShowS)
-> (Settings -> String) -> ([Settings] -> ShowS) -> Show Settings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Settings] -> ShowS
$cshowList :: [Settings] -> ShowS
show :: Settings -> String
$cshow :: Settings -> String
showsPrec :: Int -> Settings -> ShowS
$cshowsPrec :: Int -> Settings -> ShowS
Show, Settings -> Settings -> Bool
(Settings -> Settings -> Bool)
-> (Settings -> Settings -> Bool) -> Eq Settings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Settings -> Settings -> Bool
$c/= :: Settings -> Settings -> Bool
== :: Settings -> Settings -> Bool
$c== :: Settings -> Settings -> Bool
Eq, (forall x. Settings -> Rep Settings x)
-> (forall x. Rep Settings x -> Settings) -> Generic Settings
forall x. Rep Settings x -> Settings
forall x. Settings -> Rep Settings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Settings x -> Settings
$cfrom :: forall x. Settings -> Rep Settings x
Generic)

defaultSettings :: Settings
defaultSettings :: Settings
defaultSettings =
  let d :: (TestRunSettings -> t) -> t
d TestRunSettings -> t
func = TestRunSettings -> t
func TestRunSettings
defaultTestRunSettings
   in Settings :: Int
-> Bool
-> Threads
-> Int
-> Int
-> Int
-> Int
-> Bool
-> Bool
-> Maybe Bool
-> Maybe Text
-> Bool
-> Iterations
-> Settings
Settings
        { settingSeed :: Int
settingSeed = (TestRunSettings -> Int) -> Int
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Int
testRunSettingSeed,
          settingRandomiseExecutionOrder :: Bool
settingRandomiseExecutionOrder = Bool
True,
          settingThreads :: Threads
settingThreads = Threads
ByCapabilities,
          settingMaxSuccess :: Int
settingMaxSuccess = (TestRunSettings -> Int) -> Int
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Int
testRunSettingMaxSuccess,
          settingMaxSize :: Int
settingMaxSize = (TestRunSettings -> Int) -> Int
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Int
testRunSettingMaxSize,
          settingMaxDiscard :: Int
settingMaxDiscard = (TestRunSettings -> Int) -> Int
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Int
testRunSettingMaxDiscardRatio,
          settingMaxShrinks :: Int
settingMaxShrinks = (TestRunSettings -> Int) -> Int
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Int
testRunSettingMaxShrinks,
          settingGoldenStart :: Bool
settingGoldenStart = (TestRunSettings -> Bool) -> Bool
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Bool
testRunSettingGoldenStart,
          settingGoldenReset :: Bool
settingGoldenReset = (TestRunSettings -> Bool) -> Bool
forall t. (TestRunSettings -> t) -> t
d TestRunSettings -> Bool
testRunSettingGoldenReset,
          settingColour :: Maybe Bool
settingColour = Maybe Bool
forall a. Maybe a
Nothing,
          settingFilter :: Maybe Text
settingFilter = Maybe Text
forall a. Maybe a
Nothing,
          settingFailFast :: Bool
settingFailFast = Bool
False,
          settingIterations :: Iterations
settingIterations = Iterations
OneIteration
        }

data Threads
  = -- | One thread
    Synchronous
  | -- | As many threads as 'getNumCapabilities' tells you you have
    ByCapabilities
  | -- | A given number of threads
    Asynchronous Int
  deriving (Int -> Threads -> ShowS
[Threads] -> ShowS
Threads -> String
(Int -> Threads -> ShowS)
-> (Threads -> String) -> ([Threads] -> ShowS) -> Show Threads
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Threads] -> ShowS
$cshowList :: [Threads] -> ShowS
show :: Threads -> String
$cshow :: Threads -> String
showsPrec :: Int -> Threads -> ShowS
$cshowsPrec :: Int -> Threads -> ShowS
Show, Threads -> Threads -> Bool
(Threads -> Threads -> Bool)
-> (Threads -> Threads -> Bool) -> Eq Threads
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Threads -> Threads -> Bool
$c/= :: Threads -> Threads -> Bool
== :: Threads -> Threads -> Bool
$c== :: Threads -> Threads -> Bool
Eq, (forall x. Threads -> Rep Threads x)
-> (forall x. Rep Threads x -> Threads) -> Generic Threads
forall x. Rep Threads x -> Threads
forall x. Threads -> Rep Threads x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Threads x -> Threads
$cfrom :: forall x. Threads -> Rep Threads x
Generic)

data Iterations
  = -- | Run the test suite once, the default
    OneIteration
  | -- | Run the test suite for the given number of iterations, or until we can find flakiness
    Iterations Int
  | -- | Run the test suite over and over, until we can find some flakiness
    Continuous
  deriving (Int -> Iterations -> ShowS
[Iterations] -> ShowS
Iterations -> String
(Int -> Iterations -> ShowS)
-> (Iterations -> String)
-> ([Iterations] -> ShowS)
-> Show Iterations
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Iterations] -> ShowS
$cshowList :: [Iterations] -> ShowS
show :: Iterations -> String
$cshow :: Iterations -> String
showsPrec :: Int -> Iterations -> ShowS
$cshowsPrec :: Int -> Iterations -> ShowS
Show, Iterations -> Iterations -> Bool
(Iterations -> Iterations -> Bool)
-> (Iterations -> Iterations -> Bool) -> Eq Iterations
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Iterations -> Iterations -> Bool
$c/= :: Iterations -> Iterations -> Bool
== :: Iterations -> Iterations -> Bool
$c== :: Iterations -> Iterations -> Bool
Eq, (forall x. Iterations -> Rep Iterations x)
-> (forall x. Rep Iterations x -> Iterations) -> Generic Iterations
forall x. Rep Iterations x -> Iterations
forall x. Iterations -> Rep Iterations x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Iterations x -> Iterations
$cfrom :: forall x. Iterations -> Rep Iterations x
Generic)

-- | Combine everything to 'Settings'
combineToSettings :: Flags -> Environment -> Maybe Configuration -> IO Settings
combineToSettings :: Flags -> Environment -> Maybe Configuration -> IO Settings
combineToSettings Flags {Maybe Bool
Maybe Int
Maybe String
Maybe Text
Maybe Iterations
Maybe Threads
flagIterations :: Flags -> Maybe Iterations
flagFailFast :: Flags -> Maybe Bool
flagFilter :: Flags -> Maybe Text
flagColour :: Flags -> Maybe Bool
flagGoldenReset :: Flags -> Maybe Bool
flagGoldenStart :: Flags -> Maybe Bool
flagMaxShrinks :: Flags -> Maybe Int
flagMaxDiscard :: Flags -> Maybe Int
flagMaxSize :: Flags -> Maybe Int
flagMaxSuccess :: Flags -> Maybe Int
flagThreads :: Flags -> Maybe Threads
flagRandomiseExecutionOrder :: Flags -> Maybe Bool
flagSeed :: Flags -> Maybe Int
flagConfigFile :: Flags -> Maybe String
flagIterations :: Maybe Iterations
flagFailFast :: Maybe Bool
flagFilter :: Maybe Text
flagColour :: Maybe Bool
flagGoldenReset :: Maybe Bool
flagGoldenStart :: Maybe Bool
flagMaxShrinks :: Maybe Int
flagMaxDiscard :: Maybe Int
flagMaxSize :: Maybe Int
flagMaxSuccess :: Maybe Int
flagThreads :: Maybe Threads
flagRandomiseExecutionOrder :: Maybe Bool
flagSeed :: Maybe Int
flagConfigFile :: Maybe String
..} Environment {Maybe Bool
Maybe Int
Maybe String
Maybe Text
Maybe Iterations
Maybe Threads
envIterations :: Environment -> Maybe Iterations
envFailFast :: Environment -> Maybe Bool
envFilter :: Environment -> Maybe Text
envColour :: Environment -> Maybe Bool
envGoldenReset :: Environment -> Maybe Bool
envGoldenStart :: Environment -> Maybe Bool
envMaxShrinks :: Environment -> Maybe Int
envMaxDiscard :: Environment -> Maybe Int
envMaxSuccess :: Environment -> Maybe Int
envMaxSize :: Environment -> Maybe Int
envThreads :: Environment -> Maybe Threads
envRandomiseExecutionOrder :: Environment -> Maybe Bool
envSeed :: Environment -> Maybe Int
envConfigFile :: Environment -> Maybe String
envIterations :: Maybe Iterations
envFailFast :: Maybe Bool
envFilter :: Maybe Text
envColour :: Maybe Bool
envGoldenReset :: Maybe Bool
envGoldenStart :: Maybe Bool
envMaxShrinks :: Maybe Int
envMaxDiscard :: Maybe Int
envMaxSuccess :: Maybe Int
envMaxSize :: Maybe Int
envThreads :: Maybe Threads
envRandomiseExecutionOrder :: Maybe Bool
envSeed :: Maybe Int
envConfigFile :: Maybe String
..} Maybe Configuration
mConf = do
  let d :: (Settings -> t) -> t
d Settings -> t
func = Settings -> t
func Settings
defaultSettings
  Settings -> IO Settings
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Settings :: Int
-> Bool
-> Threads
-> Int
-> Int
-> Int
-> Int
-> Bool
-> Bool
-> Maybe Bool
-> Maybe Text
-> Bool
-> Iterations
-> Settings
Settings
      { settingSeed :: Int
settingSeed = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Int) -> Int
forall t. (Settings -> t) -> t
d Settings -> Int
settingSeed) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
flagSeed Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Int
envSeed Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Int) -> Maybe Int
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Int
configSeed,
        settingRandomiseExecutionOrder :: Bool
settingRandomiseExecutionOrder = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Bool) -> Bool
forall t. (Settings -> t) -> t
d Settings -> Bool
settingRandomiseExecutionOrder) (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Maybe Bool
flagRandomiseExecutionOrder Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Bool
envRandomiseExecutionOrder Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Bool) -> Maybe Bool
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Bool
configRandomiseExecutionOrder,
        settingThreads :: Threads
settingThreads = Threads -> Maybe Threads -> Threads
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Threads) -> Threads
forall t. (Settings -> t) -> t
d Settings -> Threads
settingThreads) (Maybe Threads -> Threads) -> Maybe Threads -> Threads
forall a b. (a -> b) -> a -> b
$ Maybe Threads
flagThreads Maybe Threads -> Maybe Threads -> Maybe Threads
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Threads
envThreads Maybe Threads -> Maybe Threads -> Maybe Threads
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Threads) -> Maybe Threads
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Threads
configThreads,
        settingMaxSuccess :: Int
settingMaxSuccess = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Int) -> Int
forall t. (Settings -> t) -> t
d Settings -> Int
settingMaxSuccess) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
flagMaxSuccess Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Int
envMaxSuccess Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Int) -> Maybe Int
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Int
configMaxSuccess,
        settingMaxSize :: Int
settingMaxSize = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Int) -> Int
forall t. (Settings -> t) -> t
d Settings -> Int
settingMaxSize) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
flagMaxSize Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Int
envMaxSize Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Int) -> Maybe Int
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Int
configMaxSize,
        settingMaxDiscard :: Int
settingMaxDiscard = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Int) -> Int
forall t. (Settings -> t) -> t
d Settings -> Int
settingMaxDiscard) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
flagMaxDiscard Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Int
envMaxDiscard Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Int) -> Maybe Int
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Int
configMaxDiscard,
        settingMaxShrinks :: Int
settingMaxShrinks = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Int) -> Int
forall t. (Settings -> t) -> t
d Settings -> Int
settingMaxShrinks) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
flagMaxShrinks Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Int
envMaxShrinks Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Int) -> Maybe Int
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Int
configMaxShrinks,
        settingGoldenStart :: Bool
settingGoldenStart = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Bool) -> Bool
forall t. (Settings -> t) -> t
d Settings -> Bool
settingGoldenStart) (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Maybe Bool
flagGoldenStart Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Bool
envGoldenStart Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Bool) -> Maybe Bool
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Bool
configGoldenStart,
        settingGoldenReset :: Bool
settingGoldenReset = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Bool) -> Bool
forall t. (Settings -> t) -> t
d Settings -> Bool
settingGoldenReset) (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Maybe Bool
flagGoldenReset Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Bool
envGoldenReset Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Bool) -> Maybe Bool
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Bool
configGoldenReset,
        settingColour :: Maybe Bool
settingColour = Maybe Bool
flagColour Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Bool
envColour Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Bool) -> Maybe Bool
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Bool
configColour,
        settingFilter :: Maybe Text
settingFilter = Maybe Text
flagFilter Maybe Text -> Maybe Text -> Maybe Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Text
envFilter Maybe Text -> Maybe Text -> Maybe Text
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Text) -> Maybe Text
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Text
configFilter,
        settingFailFast :: Bool
settingFailFast = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Bool) -> Bool
forall t. (Settings -> t) -> t
d Settings -> Bool
settingFailFast) (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Maybe Bool
flagFailFast Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Bool
envFailFast Maybe Bool -> Maybe Bool -> Maybe Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Bool) -> Maybe Bool
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Bool
configFailFast,
        settingIterations :: Iterations
settingIterations = Iterations -> Maybe Iterations -> Iterations
forall a. a -> Maybe a -> a
fromMaybe ((Settings -> Iterations) -> Iterations
forall t. (Settings -> t) -> t
d Settings -> Iterations
settingIterations) (Maybe Iterations -> Iterations) -> Maybe Iterations -> Iterations
forall a b. (a -> b) -> a -> b
$ Maybe Iterations
flagIterations Maybe Iterations -> Maybe Iterations -> Maybe Iterations
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe Iterations
envIterations Maybe Iterations -> Maybe Iterations -> Maybe Iterations
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Configuration -> Maybe Iterations) -> Maybe Iterations
forall a. (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe Iterations
configIterations
      }
  where
    mc :: (Configuration -> Maybe a) -> Maybe a
    mc :: (Configuration -> Maybe a) -> Maybe a
mc Configuration -> Maybe a
f = Maybe Configuration
mConf Maybe Configuration -> (Configuration -> Maybe a) -> Maybe a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Configuration -> Maybe a
f

-- | What we find in the configuration variable.
--
-- Do nothing clever here, just represent the configuration file.
-- For example, use 'Maybe FilePath', not 'Path Abs File'.
--
-- Use 'YamlParse.readConfigFile' or 'YamlParse.readFirstConfigFile' to read a configuration.
data Configuration = Configuration
  { Configuration -> Maybe Int
configSeed :: !(Maybe Int),
    Configuration -> Maybe Bool
configRandomiseExecutionOrder :: !(Maybe Bool),
    Configuration -> Maybe Threads
configThreads :: !(Maybe Threads),
    Configuration -> Maybe Int
configMaxSize :: !(Maybe Int),
    Configuration -> Maybe Int
configMaxSuccess :: !(Maybe Int),
    Configuration -> Maybe Int
configMaxDiscard :: !(Maybe Int),
    Configuration -> Maybe Int
configMaxShrinks :: !(Maybe Int),
    Configuration -> Maybe Bool
configGoldenStart :: !(Maybe Bool),
    Configuration -> Maybe Bool
configGoldenReset :: !(Maybe Bool),
    Configuration -> Maybe Bool
configColour :: !(Maybe Bool),
    Configuration -> Maybe Text
configFilter :: !(Maybe Text),
    Configuration -> Maybe Bool
configFailFast :: !(Maybe Bool),
    Configuration -> Maybe Iterations
configIterations :: !(Maybe Iterations)
  }
  deriving (Int -> Configuration -> ShowS
[Configuration] -> ShowS
Configuration -> String
(Int -> Configuration -> ShowS)
-> (Configuration -> String)
-> ([Configuration] -> ShowS)
-> Show Configuration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Configuration] -> ShowS
$cshowList :: [Configuration] -> ShowS
show :: Configuration -> String
$cshow :: Configuration -> String
showsPrec :: Int -> Configuration -> ShowS
$cshowsPrec :: Int -> Configuration -> ShowS
Show, Configuration -> Configuration -> Bool
(Configuration -> Configuration -> Bool)
-> (Configuration -> Configuration -> Bool) -> Eq Configuration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Configuration -> Configuration -> Bool
$c/= :: Configuration -> Configuration -> Bool
== :: Configuration -> Configuration -> Bool
$c== :: Configuration -> Configuration -> Bool
Eq, (forall x. Configuration -> Rep Configuration x)
-> (forall x. Rep Configuration x -> Configuration)
-> Generic Configuration
forall x. Rep Configuration x -> Configuration
forall x. Configuration -> Rep Configuration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Configuration x -> Configuration
$cfrom :: forall x. Configuration -> Rep Configuration x
Generic)

instance FromJSON Configuration where
  parseJSON :: Value -> Parser Configuration
parseJSON = Value -> Parser Configuration
forall a. YamlSchema a => Value -> Parser a
viaYamlSchema

-- | We use 'yamlparse-applicative' for parsing a YAML config.
instance YamlSchema Configuration where
  yamlSchema :: YamlParser Configuration
yamlSchema =
    Text -> ObjectParser Configuration -> YamlParser Configuration
forall o. Text -> ObjectParser o -> YamlParser o
objectParser Text
"Configuration" (ObjectParser Configuration -> YamlParser Configuration)
-> ObjectParser Configuration -> YamlParser Configuration
forall a b. (a -> b) -> a -> b
$
      Maybe Int
-> Maybe Bool
-> Maybe Threads
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe Bool
-> Maybe Iterations
-> Configuration
Configuration
        (Maybe Int
 -> Maybe Bool
 -> Maybe Threads
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Iterations
 -> Configuration)
-> Parser Object (Maybe Int)
-> Parser
     Object
     (Maybe Bool
      -> Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Text -> Parser Object (Maybe Int)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"seed" Text
"Seed for random generation of test cases"
        Parser
  Object
  (Maybe Bool
   -> Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Bool)
-> Parser
     Object
     (Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Bool)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"randomise-execution-order" Text
"Randomise the execution order of the tests in the test suite"
        Parser
  Object
  (Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Threads)
-> Parser
     Object
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Threads)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"parallelism" Text
"How parallel to execute the tests"
        Parser
  Object
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Int)
-> Parser
     Object
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Int)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"max-success" Text
"Number of quickcheck examples to run"
        Parser
  Object
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Int)
-> Parser
     Object
     (Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Int)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"max-size" Text
"Maximum size parameter to pass to generators"
        Parser
  Object
  (Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Int)
-> Parser
     Object
     (Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Int)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"max-discard" Text
"Maximum number of discarded tests per successful test before giving up"
        Parser
  Object
  (Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Int)
-> Parser
     Object
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Int)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"max-shrinks" Text
"Maximum number of shrinks of a failing test input"
        Parser
  Object
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Bool)
-> Parser
     Object
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Bool)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"golden-start" Text
"Whether to write golden tests if they do not exist yet"
        Parser
  Object
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Configuration)
-> Parser Object (Maybe Bool)
-> Parser
     Object
     (Maybe Bool
      -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Bool)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"golden-reset" Text
"Whether to overwrite golden tests instead of having them fail"
        Parser
  Object
  (Maybe Bool
   -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Configuration)
-> Parser Object (Maybe Bool)
-> Parser
     Object
     (Maybe Text -> Maybe Bool -> Maybe Iterations -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Bool)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"colour" Text
"Whether to use coloured output"
        Parser
  Object
  (Maybe Text -> Maybe Bool -> Maybe Iterations -> Configuration)
-> Parser Object (Maybe Text)
-> Parser Object (Maybe Bool -> Maybe Iterations -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Text)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"filter" Text
"Filter to select which parts of the test tree to run"
        Parser Object (Maybe Bool -> Maybe Iterations -> Configuration)
-> Parser Object (Maybe Bool)
-> Parser Object (Maybe Iterations -> Configuration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Bool)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"fail-fast" Text
"Whether to stop executing upon the first test failure"
        Parser Object (Maybe Iterations -> Configuration)
-> Parser Object (Maybe Iterations) -> ObjectParser Configuration
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Text -> Text -> Parser Object (Maybe Iterations)
forall a. YamlSchema a => Text -> Text -> ObjectParser (Maybe a)
optionalField Text
"iterations" Text
"How many iterations to use to look diagnose flakiness"

instance YamlSchema Threads where
  yamlSchema :: YamlParser Threads
yamlSchema = ((Maybe Int -> Threads)
 -> Parser Value (Maybe Int) -> YamlParser Threads)
-> Parser Value (Maybe Int)
-> (Maybe Int -> Threads)
-> YamlParser Threads
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe Int -> Threads)
-> Parser Value (Maybe Int) -> YamlParser Threads
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Parser Value (Maybe Int)
forall a. YamlSchema a => YamlParser a
yamlSchema ((Maybe Int -> Threads) -> YamlParser Threads)
-> (Maybe Int -> Threads) -> YamlParser Threads
forall a b. (a -> b) -> a -> b
$ \case
    Maybe Int
Nothing -> Threads
ByCapabilities
    Just Int
1 -> Threads
Synchronous
    Just Int
n -> Int -> Threads
Asynchronous Int
n

instance YamlSchema Iterations where
  yamlSchema :: YamlParser Iterations
yamlSchema = ((Maybe Int -> Iterations)
 -> Parser Value (Maybe Int) -> YamlParser Iterations)
-> Parser Value (Maybe Int)
-> (Maybe Int -> Iterations)
-> YamlParser Iterations
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe Int -> Iterations)
-> Parser Value (Maybe Int) -> YamlParser Iterations
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Parser Value (Maybe Int)
forall a. YamlSchema a => YamlParser a
yamlSchema ((Maybe Int -> Iterations) -> YamlParser Iterations)
-> (Maybe Int -> Iterations) -> YamlParser Iterations
forall a b. (a -> b) -> a -> b
$ \case
    Maybe Int
Nothing -> Iterations
OneIteration
    Just Int
0 -> Iterations
Continuous
    Just Int
1 -> Iterations
OneIteration
    Just Int
n -> Int -> Iterations
Iterations Int
n

-- | Get the configuration
--
-- We use the flags and environment because they can contain information to override where to look for the configuration files.
-- We return a 'Maybe' because there may not be a configuration file.
getConfiguration :: Flags -> Environment -> IO (Maybe Configuration)
getConfiguration :: Flags -> Environment -> IO (Maybe Configuration)
getConfiguration Flags {Maybe Bool
Maybe Int
Maybe String
Maybe Text
Maybe Iterations
Maybe Threads
flagIterations :: Maybe Iterations
flagFailFast :: Maybe Bool
flagFilter :: Maybe Text
flagColour :: Maybe Bool
flagGoldenReset :: Maybe Bool
flagGoldenStart :: Maybe Bool
flagMaxShrinks :: Maybe Int
flagMaxDiscard :: Maybe Int
flagMaxSize :: Maybe Int
flagMaxSuccess :: Maybe Int
flagThreads :: Maybe Threads
flagRandomiseExecutionOrder :: Maybe Bool
flagSeed :: Maybe Int
flagConfigFile :: Maybe String
flagIterations :: Flags -> Maybe Iterations
flagFailFast :: Flags -> Maybe Bool
flagFilter :: Flags -> Maybe Text
flagColour :: Flags -> Maybe Bool
flagGoldenReset :: Flags -> Maybe Bool
flagGoldenStart :: Flags -> Maybe Bool
flagMaxShrinks :: Flags -> Maybe Int
flagMaxDiscard :: Flags -> Maybe Int
flagMaxSize :: Flags -> Maybe Int
flagMaxSuccess :: Flags -> Maybe Int
flagThreads :: Flags -> Maybe Threads
flagRandomiseExecutionOrder :: Flags -> Maybe Bool
flagSeed :: Flags -> Maybe Int
flagConfigFile :: Flags -> Maybe String
..} Environment {Maybe Bool
Maybe Int
Maybe String
Maybe Text
Maybe Iterations
Maybe Threads
envIterations :: Maybe Iterations
envFailFast :: Maybe Bool
envFilter :: Maybe Text
envColour :: Maybe Bool
envGoldenReset :: Maybe Bool
envGoldenStart :: Maybe Bool
envMaxShrinks :: Maybe Int
envMaxDiscard :: Maybe Int
envMaxSuccess :: Maybe Int
envMaxSize :: Maybe Int
envThreads :: Maybe Threads
envRandomiseExecutionOrder :: Maybe Bool
envSeed :: Maybe Int
envConfigFile :: Maybe String
envIterations :: Environment -> Maybe Iterations
envFailFast :: Environment -> Maybe Bool
envFilter :: Environment -> Maybe Text
envColour :: Environment -> Maybe Bool
envGoldenReset :: Environment -> Maybe Bool
envGoldenStart :: Environment -> Maybe Bool
envMaxShrinks :: Environment -> Maybe Int
envMaxDiscard :: Environment -> Maybe Int
envMaxSuccess :: Environment -> Maybe Int
envMaxSize :: Environment -> Maybe Int
envThreads :: Environment -> Maybe Threads
envRandomiseExecutionOrder :: Environment -> Maybe Bool
envSeed :: Environment -> Maybe Int
envConfigFile :: Environment -> Maybe String
..} =
  case Maybe String
flagConfigFile Maybe String -> Maybe String -> Maybe String
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe String
envConfigFile of
    Maybe String
Nothing -> IO (Path Abs File)
defaultConfigFile IO (Path Abs File)
-> (Path Abs File -> IO (Maybe Configuration))
-> IO (Maybe Configuration)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Path Abs File -> IO (Maybe Configuration)
forall a r.
(YamlSchema a, FromJSON a) =>
Path r File -> IO (Maybe a)
YamlParse.readConfigFile
    Just String
cf -> do
      Path Abs File
afp <- String -> IO (Path Abs File)
forall (m :: * -> *). MonadIO m => String -> m (Path Abs File)
resolveFile' String
cf
      Path Abs File -> IO (Maybe Configuration)
forall a r.
(YamlSchema a, FromJSON a) =>
Path r File -> IO (Maybe a)
YamlParse.readConfigFile Path Abs File
afp

-- | Where to get the configuration file by default.
defaultConfigFile :: IO (Path Abs File)
defaultConfigFile :: IO (Path Abs File)
defaultConfigFile = String -> IO (Path Abs File)
forall (m :: * -> *). MonadIO m => String -> m (Path Abs File)
resolveFile' String
".sydtest.yaml"

-- | What we find in the configuration variable.
--
-- Do nothing clever here, just represent the relevant parts of the environment.
-- For example, use 'Text', not 'SqliteConfig'.
data Environment = Environment
  { Environment -> Maybe String
envConfigFile :: Maybe FilePath,
    Environment -> Maybe Int
envSeed :: !(Maybe Int),
    Environment -> Maybe Bool
envRandomiseExecutionOrder :: !(Maybe Bool),
    Environment -> Maybe Threads
envThreads :: !(Maybe Threads),
    Environment -> Maybe Int
envMaxSize :: !(Maybe Int),
    Environment -> Maybe Int
envMaxSuccess :: !(Maybe Int),
    Environment -> Maybe Int
envMaxDiscard :: !(Maybe Int),
    Environment -> Maybe Int
envMaxShrinks :: !(Maybe Int),
    Environment -> Maybe Bool
envGoldenStart :: !(Maybe Bool),
    Environment -> Maybe Bool
envGoldenReset :: !(Maybe Bool),
    Environment -> Maybe Bool
envColour :: !(Maybe Bool),
    Environment -> Maybe Text
envFilter :: !(Maybe Text),
    Environment -> Maybe Bool
envFailFast :: !(Maybe Bool),
    Environment -> Maybe Iterations
envIterations :: !(Maybe Iterations)
  }
  deriving (Int -> Environment -> ShowS
[Environment] -> ShowS
Environment -> String
(Int -> Environment -> ShowS)
-> (Environment -> String)
-> ([Environment] -> ShowS)
-> Show Environment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Environment] -> ShowS
$cshowList :: [Environment] -> ShowS
show :: Environment -> String
$cshow :: Environment -> String
showsPrec :: Int -> Environment -> ShowS
$cshowsPrec :: Int -> Environment -> ShowS
Show, Environment -> Environment -> Bool
(Environment -> Environment -> Bool)
-> (Environment -> Environment -> Bool) -> Eq Environment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Environment -> Environment -> Bool
$c/= :: Environment -> Environment -> Bool
== :: Environment -> Environment -> Bool
$c== :: Environment -> Environment -> Bool
Eq, (forall x. Environment -> Rep Environment x)
-> (forall x. Rep Environment x -> Environment)
-> Generic Environment
forall x. Rep Environment x -> Environment
forall x. Environment -> Rep Environment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Environment x -> Environment
$cfrom :: forall x. Environment -> Rep Environment x
Generic)

getEnvironment :: IO Environment
getEnvironment :: IO Environment
getEnvironment = (Info Error -> Info Error)
-> Parser Error Environment -> IO Environment
forall e a. (Info Error -> Info e) -> Parser e a -> IO a
Env.parse (String -> Info Error -> Info Error
forall e. String -> Info e -> Info e
Env.header String
"Environment") Parser Error Environment
environmentParser

-- | The 'envparse' parser for the 'Environment'
environmentParser :: Env.Parser Env.Error Environment
environmentParser :: Parser Error Environment
environmentParser =
  String -> Parser Error Environment -> Parser Error Environment
forall e a. String -> Parser e a -> Parser e a
Env.prefixed String
"SYDTEST_" (Parser Error Environment -> Parser Error Environment)
-> Parser Error Environment -> Parser Error Environment
forall a b. (a -> b) -> a -> b
$
    Maybe String
-> Maybe Int
-> Maybe Bool
-> Maybe Threads
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe Bool
-> Maybe Iterations
-> Environment
Environment
      (Maybe String
 -> Maybe Int
 -> Maybe Bool
 -> Maybe Threads
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Iterations
 -> Environment)
-> Parser Error (Maybe String)
-> Parser
     Error
     (Maybe Int
      -> Maybe Bool
      -> Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reader Error (Maybe String)
-> String -> Mod Var (Maybe String) -> Parser Error (Maybe String)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((String -> Maybe String)
-> Either Error String -> Either Error (Maybe String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Maybe String
forall a. a -> Maybe a
Just (Either Error String -> Either Error (Maybe String))
-> (String -> Either Error String) -> Reader Error (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error String
forall s e. IsString s => Reader e s
Env.str) String
"CONFIG_FILE" (Mod Var (Maybe String)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe String)
-> Mod Var (Maybe String) -> Mod Var (Maybe String)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe String)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Config file")
        Parser
  Error
  (Maybe Int
   -> Maybe Bool
   -> Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Int)
-> Parser
     Error
     (Maybe Bool
      -> Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Int)
-> String -> Mod Var (Maybe Int) -> Parser Error (Maybe Int)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Int -> Maybe Int) -> Either Error Int -> Either Error (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Maybe Int
forall a. a -> Maybe a
Just (Either Error Int -> Either Error (Maybe Int))
-> (String -> Either Error Int) -> Reader Error (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"SEED" (Mod Var (Maybe Int)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Int) -> Mod Var (Maybe Int) -> Mod Var (Maybe Int)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Int)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Seed for random generation of test cases")
        Parser
  Error
  (Maybe Bool
   -> Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Bool)
-> Parser
     Error
     (Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Bool)
-> String -> Mod Var (Maybe Bool) -> Parser Error (Maybe Bool)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Bool -> Maybe Bool)
-> Either Error Bool -> Either Error (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Either Error Bool -> Either Error (Maybe Bool))
-> (String -> Either Error Bool) -> Reader Error (Maybe Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Bool
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"RANDOMISE_EXECUTION_ORDER" (Mod Var (Maybe Bool)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Bool)
-> Mod Var (Maybe Bool) -> Mod Var (Maybe Bool)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Bool)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Randomise the execution order of the tests in the test suite")
        Parser
  Error
  (Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Threads)
-> Parser
     Error
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Threads)
-> String
-> Mod Var (Maybe Threads)
-> Parser Error (Maybe Threads)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Threads -> Maybe Threads)
-> Either Error Threads -> Either Error (Maybe Threads)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Threads -> Maybe Threads
forall a. a -> Maybe a
Just (Either Error Threads -> Either Error (Maybe Threads))
-> (String -> Either Error Threads) -> Reader Error (Maybe Threads)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto (String -> Either Error Int)
-> (Int -> Either Error Threads) -> String -> Either Error Threads
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Int -> Either Error Threads
forall e. Int -> Either e Threads
parseThreads)) String
"PARALLELISM" (Mod Var (Maybe Threads)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Threads)
-> Mod Var (Maybe Threads) -> Mod Var (Maybe Threads)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Threads)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"How parallel to execute the tests")
        Parser
  Error
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Int)
-> Parser
     Error
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Int)
-> String -> Mod Var (Maybe Int) -> Parser Error (Maybe Int)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Int -> Maybe Int) -> Either Error Int -> Either Error (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Maybe Int
forall a. a -> Maybe a
Just (Either Error Int -> Either Error (Maybe Int))
-> (String -> Either Error Int) -> Reader Error (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"MAX_SUCCESS" (Mod Var (Maybe Int)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Int) -> Mod Var (Maybe Int) -> Mod Var (Maybe Int)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Int)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Number of quickcheck examples to run")
        Parser
  Error
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Int)
-> Parser
     Error
     (Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Int)
-> String -> Mod Var (Maybe Int) -> Parser Error (Maybe Int)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Int -> Maybe Int) -> Either Error Int -> Either Error (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Maybe Int
forall a. a -> Maybe a
Just (Either Error Int -> Either Error (Maybe Int))
-> (String -> Either Error Int) -> Reader Error (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"MAX_SIZE" (Mod Var (Maybe Int)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Int) -> Mod Var (Maybe Int) -> Mod Var (Maybe Int)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Int)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Maximum size parameter to pass to generators")
        Parser
  Error
  (Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Int)
-> Parser
     Error
     (Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Int)
-> String -> Mod Var (Maybe Int) -> Parser Error (Maybe Int)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Int -> Maybe Int) -> Either Error Int -> Either Error (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Maybe Int
forall a. a -> Maybe a
Just (Either Error Int -> Either Error (Maybe Int))
-> (String -> Either Error Int) -> Reader Error (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"MAX_DISCARD" (Mod Var (Maybe Int)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Int) -> Mod Var (Maybe Int) -> Mod Var (Maybe Int)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Int)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Maximum number of discarded tests per successful test before giving up")
        Parser
  Error
  (Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Int)
-> Parser
     Error
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Int)
-> String -> Mod Var (Maybe Int) -> Parser Error (Maybe Int)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Int -> Maybe Int) -> Either Error Int -> Either Error (Maybe Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Maybe Int
forall a. a -> Maybe a
Just (Either Error Int -> Either Error (Maybe Int))
-> (String -> Either Error Int) -> Reader Error (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"MAX_SHRINKS" (Mod Var (Maybe Int)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Int) -> Mod Var (Maybe Int) -> Mod Var (Maybe Int)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Int)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Maximum number of shrinks of a failing test input")
        Parser
  Error
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Bool)
-> Parser
     Error
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Bool)
-> String -> Mod Var (Maybe Bool) -> Parser Error (Maybe Bool)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Bool -> Maybe Bool)
-> Either Error Bool -> Either Error (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Either Error Bool -> Either Error (Maybe Bool))
-> (String -> Either Error Bool) -> Reader Error (Maybe Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Bool
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"GOLDEN_START" (Mod Var (Maybe Bool)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Bool)
-> Mod Var (Maybe Bool) -> Mod Var (Maybe Bool)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Bool)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Whether to write golden tests if they do not exist yet")
        Parser
  Error
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Environment)
-> Parser Error (Maybe Bool)
-> Parser
     Error
     (Maybe Bool
      -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Bool)
-> String -> Mod Var (Maybe Bool) -> Parser Error (Maybe Bool)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Bool -> Maybe Bool)
-> Either Error Bool -> Either Error (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Either Error Bool -> Either Error (Maybe Bool))
-> (String -> Either Error Bool) -> Reader Error (Maybe Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Bool
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"GOLDEN_RESET" (Mod Var (Maybe Bool)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Bool)
-> Mod Var (Maybe Bool) -> Mod Var (Maybe Bool)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Bool)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Whether to overwrite golden tests instead of having them fail")
        Parser
  Error
  (Maybe Bool
   -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Environment)
-> Parser Error (Maybe Bool)
-> Parser
     Error (Maybe Text -> Maybe Bool -> Maybe Iterations -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Bool)
-> String -> Mod Var (Maybe Bool) -> Parser Error (Maybe Bool)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Bool -> Maybe Bool)
-> Either Error Bool -> Either Error (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Either Error Bool -> Either Error (Maybe Bool))
-> (String -> Either Error Bool) -> Reader Error (Maybe Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Bool
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"COLOUR" (Mod Var (Maybe Bool)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Bool)
-> Mod Var (Maybe Bool) -> Mod Var (Maybe Bool)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Bool)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Whether to use coloured output")
        Parser
  Error (Maybe Text -> Maybe Bool -> Maybe Iterations -> Environment)
-> Parser Error (Maybe Text)
-> Parser Error (Maybe Bool -> Maybe Iterations -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Text)
-> String -> Mod Var (Maybe Text) -> Parser Error (Maybe Text)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Text -> Maybe Text)
-> Either Error Text -> Either Error (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> Maybe Text
forall a. a -> Maybe a
Just (Either Error Text -> Either Error (Maybe Text))
-> (String -> Either Error Text) -> Reader Error (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Text
forall s e. IsString s => Reader e s
Env.str) String
"FILTER" (Mod Var (Maybe Text)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Text)
-> Mod Var (Maybe Text) -> Mod Var (Maybe Text)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Text)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Filter to select which parts of the test tree to run")
        Parser Error (Maybe Bool -> Maybe Iterations -> Environment)
-> Parser Error (Maybe Bool)
-> Parser Error (Maybe Iterations -> Environment)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Bool)
-> String -> Mod Var (Maybe Bool) -> Parser Error (Maybe Bool)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Bool -> Maybe Bool)
-> Either Error Bool -> Either Error (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Either Error Bool -> Either Error (Maybe Bool))
-> (String -> Either Error Bool) -> Reader Error (Maybe Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Either Error Bool
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto) String
"FAIL_FAST" (Mod Var (Maybe Bool)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Bool)
-> Mod Var (Maybe Bool) -> Mod Var (Maybe Bool)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Bool)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"Whether to stop executing upon the first test failure")
        Parser Error (Maybe Iterations -> Environment)
-> Parser Error (Maybe Iterations) -> Parser Error Environment
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reader Error (Maybe Iterations)
-> String
-> Mod Var (Maybe Iterations)
-> Parser Error (Maybe Iterations)
forall e a.
AsUnset e =>
Reader e a -> String -> Mod Var a -> Parser e a
Env.var ((Iterations -> Maybe Iterations)
-> Either Error Iterations -> Either Error (Maybe Iterations)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Iterations -> Maybe Iterations
forall a. a -> Maybe a
Just (Either Error Iterations -> Either Error (Maybe Iterations))
-> (String -> Either Error Iterations)
-> Reader Error (Maybe Iterations)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Either Error Int
forall e a. (AsUnread e, Read a) => Reader e a
Env.auto (String -> Either Error Int)
-> (Int -> Either Error Iterations)
-> String
-> Either Error Iterations
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Int -> Either Error Iterations
forall e. Int -> Either e Iterations
parseIterations)) String
"ITERATIONS" (Mod Var (Maybe Iterations)
forall a. Mod Var (Maybe a)
mE Mod Var (Maybe Iterations)
-> Mod Var (Maybe Iterations) -> Mod Var (Maybe Iterations)
forall a. Semigroup a => a -> a -> a
<> String -> Mod Var (Maybe Iterations)
forall (t :: * -> *) a. HasHelp t => String -> Mod t a
Env.help String
"How many iterations to use to look diagnose flakiness")
  where
    parseThreads :: Int -> Either e Threads
    parseThreads :: Int -> Either e Threads
parseThreads Int
1 = Threads -> Either e Threads
forall a b. b -> Either a b
Right Threads
Synchronous
    parseThreads Int
i = Threads -> Either e Threads
forall a b. b -> Either a b
Right (Int -> Threads
Asynchronous Int
i)
    parseIterations :: Int -> Either e Iterations
    parseIterations :: Int -> Either e Iterations
parseIterations Int
0 = Iterations -> Either e Iterations
forall a b. b -> Either a b
Right Iterations
Continuous
    parseIterations Int
1 = Iterations -> Either e Iterations
forall a b. b -> Either a b
Right Iterations
OneIteration
    parseIterations Int
i = Iterations -> Either e Iterations
forall a b. b -> Either a b
Right (Int -> Iterations
Iterations Int
i)
    mE :: Mod Var (Maybe a)
mE = Maybe a -> Mod Var (Maybe a)
forall a. a -> Mod Var a
Env.def Maybe a
forall a. Maybe a
Nothing

-- | Get the command-line flags
getFlags :: IO Flags
getFlags :: IO Flags
getFlags = ParserPrefs -> ParserInfo Flags -> IO Flags
forall a. ParserPrefs -> ParserInfo a -> IO a
customExecParser ParserPrefs
prefs_ ParserInfo Flags
flagsParser

-- | The 'optparse-applicative' parsing preferences
prefs_ :: OptParse.ParserPrefs
prefs_ :: ParserPrefs
prefs_ =
  -- I like these preferences. Use what you like.
  ParserPrefs
OptParse.defaultPrefs
    { prefShowHelpOnError :: Bool
OptParse.prefShowHelpOnError = Bool
True,
      prefShowHelpOnEmpty :: Bool
OptParse.prefShowHelpOnEmpty = Bool
True
    }

-- | The @optparse-applicative@ parser for 'Flags'
flagsParser :: OptParse.ParserInfo Flags
flagsParser :: ParserInfo Flags
flagsParser =
  Parser Flags -> InfoMod Flags -> ParserInfo Flags
forall a. Parser a -> InfoMod a -> ParserInfo a
OptParse.info
    (Parser (Flags -> Flags)
forall a. Parser (a -> a)
OptParse.helper Parser (Flags -> Flags) -> Parser Flags -> Parser Flags
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Flags
parseFlags)
    (InfoMod Flags
forall a. InfoMod a
OptParse.fullDesc InfoMod Flags -> InfoMod Flags -> InfoMod Flags
forall a. Semigroup a => a -> a -> a
<> Maybe Doc -> InfoMod Flags
forall a. Maybe Doc -> InfoMod a
OptParse.footerDoc (Doc -> Maybe Doc
forall a. a -> Maybe a
Just (Doc -> Maybe Doc) -> Doc -> Maybe Doc
forall a b. (a -> b) -> a -> b
$ String -> Doc
OptParse.string String
footerStr))
  where
    -- Show the variables from the environment that we parse and the config file format
    footerStr :: String
footerStr =
      [String] -> String
unlines
        [ Parser Error Environment -> String
forall e a. Parser e a -> String
Env.helpDoc Parser Error Environment
environmentParser,
          String
"",
          String
"Configuration file format:",
          Text -> String
T.unpack (YamlSchema Configuration => Text
forall a. YamlSchema a => Text
YamlParse.prettyColourisedSchemaDoc @Configuration)
        ]

-- | The flags that are common across commands.
data Flags = Flags
  { Flags -> Maybe String
flagConfigFile :: !(Maybe FilePath),
    Flags -> Maybe Int
flagSeed :: !(Maybe Int),
    Flags -> Maybe Bool
flagRandomiseExecutionOrder :: !(Maybe Bool),
    Flags -> Maybe Threads
flagThreads :: !(Maybe Threads),
    Flags -> Maybe Int
flagMaxSuccess :: !(Maybe Int),
    Flags -> Maybe Int
flagMaxSize :: !(Maybe Int),
    Flags -> Maybe Int
flagMaxDiscard :: !(Maybe Int),
    Flags -> Maybe Int
flagMaxShrinks :: !(Maybe Int),
    Flags -> Maybe Bool
flagGoldenStart :: !(Maybe Bool),
    Flags -> Maybe Bool
flagGoldenReset :: !(Maybe Bool),
    Flags -> Maybe Bool
flagColour :: !(Maybe Bool),
    Flags -> Maybe Text
flagFilter :: !(Maybe Text),
    Flags -> Maybe Bool
flagFailFast :: !(Maybe Bool),
    Flags -> Maybe Iterations
flagIterations :: !(Maybe Iterations)
  }
  deriving (Int -> Flags -> ShowS
[Flags] -> ShowS
Flags -> String
(Int -> Flags -> ShowS)
-> (Flags -> String) -> ([Flags] -> ShowS) -> Show Flags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flags] -> ShowS
$cshowList :: [Flags] -> ShowS
show :: Flags -> String
$cshow :: Flags -> String
showsPrec :: Int -> Flags -> ShowS
$cshowsPrec :: Int -> Flags -> ShowS
Show, Flags -> Flags -> Bool
(Flags -> Flags -> Bool) -> (Flags -> Flags -> Bool) -> Eq Flags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flags -> Flags -> Bool
$c/= :: Flags -> Flags -> Bool
== :: Flags -> Flags -> Bool
$c== :: Flags -> Flags -> Bool
Eq, (forall x. Flags -> Rep Flags x)
-> (forall x. Rep Flags x -> Flags) -> Generic Flags
forall x. Rep Flags x -> Flags
forall x. Flags -> Rep Flags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Flags x -> Flags
$cfrom :: forall x. Flags -> Rep Flags x
Generic)

-- | The 'optparse-applicative' parser for the 'Flags'.
parseFlags :: OptParse.Parser Flags
parseFlags :: Parser Flags
parseFlags =
  Maybe String
-> Maybe Int
-> Maybe Bool
-> Maybe Threads
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Int
-> Maybe Bool
-> Maybe Bool
-> Maybe Bool
-> Maybe Text
-> Maybe Bool
-> Maybe Iterations
-> Flags
Flags
    (Maybe String
 -> Maybe Int
 -> Maybe Bool
 -> Maybe Threads
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Int
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Bool
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Iterations
 -> Flags)
-> Parser (Maybe String)
-> Parser
     (Maybe Int
      -> Maybe Bool
      -> Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser String -> Parser (Maybe String)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Mod OptionFields String -> Parser String
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          ( [Mod OptionFields String] -> Mod OptionFields String
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields String
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"config-file",
                String -> Mod OptionFields String
forall (f :: * -> *) a. String -> Mod f a
help String
"Path to an altenative config file",
                String -> Mod OptionFields String
forall (f :: * -> *) a. HasMetavar f => String -> Mod f a
metavar String
"FILEPATH"
              ]
          )
      )
    Parser
  (Maybe Int
   -> Maybe Bool
   -> Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Int)
-> Parser
     (Maybe Bool
      -> Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
          ReadM Int
forall a. Read a => ReadM a
auto
          ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"seed",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"Seed for random generation of test cases"
              ]
          )
      )
    Parser
  (Maybe Bool
   -> Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Threads
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag
          Bool
True
          Bool
False
          ( [Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"no-randomise-execution-order",
                String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Randomise the execution order of the tests in the test suite"
              ]
          )
      )
    Parser
  (Maybe Threads
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Threads)
-> Parser
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Threads -> Parser (Maybe Threads)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ( ( \case
              Int
1 -> Threads
Synchronous
              Int
i -> Int -> Threads
Asynchronous Int
i
          )
            (Int -> Threads) -> Parser Int -> Parser Threads
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option ReadM Int
forall a. Read a => ReadM a
auto ([Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat [Char -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'j', String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"jobs", String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"How parallel to execute the tests"])
        )
          Parser Threads -> Parser Threads -> Parser Threads
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Threads -> Threads -> Mod FlagFields Threads -> Parser Threads
forall a. a -> a -> Mod FlagFields a -> Parser a
flag Threads
ByCapabilities Threads
Synchronous ([Mod FlagFields Threads] -> Mod FlagFields Threads
forall a. Monoid a => [a] -> a
mconcat [String -> Mod FlagFields Threads
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"synchronous", String -> Mod FlagFields Threads
forall (f :: * -> *) a. String -> Mod f a
help String
"execute tests synchronously"])
      )
    Parser
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int
      -> Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
          ReadM Int
forall a. Read a => ReadM a
auto
          ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-success",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"qc-max-success",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"Number of quickcheck examples to run"
              ]
          )
      )
    Parser
  (Maybe Int
   -> Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int
      -> Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
          ReadM Int
forall a. Read a => ReadM a
auto
          ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-size",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"qc-max-size",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"Maximum size parameter to pass to generators"
              ]
          )
      )
    Parser
  (Maybe Int
   -> Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Int)
-> Parser
     (Maybe Int
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
          ReadM Int
forall a. Read a => ReadM a
auto
          ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-discard",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"qc-max-discard",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"Maximum number of discarded tests per successful test before giving up"
              ]
          )
      )
    Parser
  (Maybe Int
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Int)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Int -> Parser (Maybe Int)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
          ReadM Int
forall a. Read a => ReadM a
auto
          ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"max-shrinks",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"qc-max-shrinks",
                String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"Maximum number of shrinks of a failing test input"
              ]
          )
      )
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Iterations
      -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag
          Bool
True
          Bool
False
          ( [Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"no-golden-start",
                String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Whether to write golden tests if they do not exist yet"
              ]
          )
      )
    Parser
  (Maybe Bool
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Iterations
   -> Flags)
-> Parser (Maybe Bool)
-> Parser
     (Maybe Bool
      -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Bool -> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> a -> Mod FlagFields a -> Parser a
flag
          Bool
False
          Bool
True
          ( [Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"golden-reset",
                String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Whether to overwrite golden tests instead of having them fail"
              ]
          )
      )
    Parser
  (Maybe Bool
   -> Maybe Text -> Maybe Bool -> Maybe Iterations -> Flags)
-> Parser (Maybe Bool)
-> Parser (Maybe Text -> Maybe Bool -> Maybe Iterations -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> Mod FlagFields a -> Parser a
flag' Bool
True ([Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat [String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"colour", String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"color", String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Always use colour in output"])
          Parser Bool -> Parser Bool -> Parser Bool
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Bool -> Mod FlagFields Bool -> Parser Bool
forall a. a -> Mod FlagFields a -> Parser a
flag' Bool
False ([Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat [String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"no-colour", String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"no-color", String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Never use colour in output"])
      )
    Parser (Maybe Text -> Maybe Bool -> Maybe Iterations -> Flags)
-> Parser (Maybe Text)
-> Parser (Maybe Bool -> Maybe Iterations -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Text -> Parser (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Mod OptionFields Text -> Parser Text
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          ( [Mod OptionFields Text] -> Mod OptionFields Text
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"filter",
                String -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"match",
                String -> Mod OptionFields Text
forall (f :: * -> *) a. String -> Mod f a
help String
"Filter to select which parts of the test tree to run"
              ]
          )
      )
    Parser (Maybe Bool -> Maybe Iterations -> Flags)
-> Parser (Maybe Bool) -> Parser (Maybe Iterations -> Flags)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Bool -> Parser (Maybe Bool)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( Mod FlagFields Bool -> Parser Bool
switch
          ( [Mod FlagFields Bool] -> Mod FlagFields Bool
forall a. Monoid a => [a] -> a
mconcat
              [ String -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"fail-fast",
                String -> Mod FlagFields Bool
forall (f :: * -> *) a. String -> Mod f a
help String
"Whether to stop upon the first test failure"
              ]
          )
      )
    Parser (Maybe Iterations -> Flags)
-> Parser (Maybe Iterations) -> Parser Flags
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Iterations -> Parser (Maybe Iterations)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
      ( ( ( \case
              Int
0 -> Iterations
Continuous
              Int
1 -> Iterations
OneIteration
              Int
i -> Int -> Iterations
Iterations Int
i
          )
            (Int -> Iterations) -> Parser Int -> Parser Iterations
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM Int -> Mod OptionFields Int -> Parser Int
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
              ReadM Int
forall a. Read a => ReadM a
auto
              ( [Mod OptionFields Int] -> Mod OptionFields Int
forall a. Monoid a => [a] -> a
mconcat
                  [ String -> Mod OptionFields Int
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"iterations",
                    String -> Mod OptionFields Int
forall (f :: * -> *) a. String -> Mod f a
help String
"How many iterations to use to look diagnose flakiness"
                  ]
              )
        )
          Parser Iterations -> Parser Iterations -> Parser Iterations
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Iterations
-> Iterations -> Mod FlagFields Iterations -> Parser Iterations
forall a. a -> a -> Mod FlagFields a -> Parser a
flag
            Iterations
OneIteration
            Iterations
Continuous
            ( [Mod FlagFields Iterations] -> Mod FlagFields Iterations
forall a. Monoid a => [a] -> a
mconcat
                [ String -> Mod FlagFields Iterations
forall (f :: * -> *) a. HasName f => String -> Mod f a
long String
"continuous",
                  String -> Mod FlagFields Iterations
forall (f :: * -> *) a. String -> Mod f a
help String
"Run the test suite over and over again until it fails, to diagnose flakiness"
                ]
            )
      )