Hedgehog.Internal.State

Variables

newtype Var a v

Variables are the potential or actual result of executing an action. They are parameterised by either Symbolic or Concrete depending on the phase of the test.

Symbolic variables are the potential results of actions. These are used when generating the sequence of actions to execute. They allow actions which occur later in the sequence to make use of the result of an action which came earlier in the sequence.

Concrete variables are the actual results of actions. These are used during test execution. They provide access to the actual runtime value of a variable.

The state update Callback for a command needs to be polymorphic in the type of variable because it is used in both the generation and the execution phase.

The order of arguments makes Var HTraverable, which is how Symbolic values are turned into Concrete ones.

Constructors

Var (v a)

Instances

FunctorB (Var a :: (Type -> Type) -> Type)

Defined in Hedgehog.Internal.State

Methods

bmap :: (forall (a0 :: k). f a0 -> g a0) -> Var a f -> Var a g

TraversableB (Var a :: (Type -> Type) -> Type)

Defined in Hedgehog.Internal.State

Methods

btraverse :: Applicative e => (forall (a0 :: k). f a0 -> e (g a0)) -> Var a f -> e (Var a g)

(Show a, Show1 v) => Show (Var a v)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Var a v -> ShowS

show :: Var a v -> String

showList :: [Var a v] -> ShowS

(Eq a, Eq1 v) => Eq (Var a v)

Defined in Hedgehog.Internal.State

Methods

(==) :: Var a v -> Var a v -> Bool

(/=) :: Var a v -> Var a v -> Bool

(Ord a, Ord1 v) => Ord (Var a v)

Defined in Hedgehog.Internal.State

Methods

compare :: Var a v -> Var a v -> Ordering

(<) :: Var a v -> Var a v -> Bool

(<=) :: Var a v -> Var a v -> Bool

(>) :: Var a v -> Var a v -> Bool

(>=) :: Var a v -> Var a v -> Bool

max :: Var a v -> Var a v -> Var a v

min :: Var a v -> Var a v -> Var a v

concrete :: Var a Concrete -> a

Take the value from a concrete variable.

opaque :: Var (Opaque a) Concrete -> a

Take the value from an opaque concrete variable.

newtype Concrete a where

Concrete values: At test-execution time, Symbolic values from generation are replaced with Concrete values from performing actions. This type gives us something of the same kind as Symbolic to pass as a type argument to Var.

Constructors

Concrete :: a -> Concrete a

Instances

Foldable Concrete

Defined in Hedgehog.Internal.State

Methods

fold :: Monoid m => Concrete m -> m

foldMap :: Monoid m => (a -> m) -> Concrete a -> m

foldMap' :: Monoid m => (a -> m) -> Concrete a -> m

foldr :: (a -> b -> b) -> b -> Concrete a -> b

foldr' :: (a -> b -> b) -> b -> Concrete a -> b

foldl :: (b -> a -> b) -> b -> Concrete a -> b

foldl' :: (b -> a -> b) -> b -> Concrete a -> b

foldr1 :: (a -> a -> a) -> Concrete a -> a

foldl1 :: (a -> a -> a) -> Concrete a -> a

toList :: Concrete a -> [a]

null :: Concrete a -> Bool

length :: Concrete a -> Int

elem :: Eq a => a -> Concrete a -> Bool

maximum :: Ord a => Concrete a -> a

minimum :: Ord a => Concrete a -> a

sum :: Num a => Concrete a -> a

product :: Num a => Concrete a -> a

Eq1 Concrete

Defined in Hedgehog.Internal.State

Methods

liftEq :: (a -> b -> Bool) -> Concrete a -> Concrete b -> Bool

Ord1 Concrete

Defined in Hedgehog.Internal.State

Methods

liftCompare :: (a -> b -> Ordering) -> Concrete a -> Concrete b -> Ordering

Show1 Concrete

Defined in Hedgehog.Internal.State

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Concrete a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Concrete a] -> ShowS

Traversable Concrete

Defined in Hedgehog.Internal.State

Methods

traverse :: Applicative f => (a -> f b) -> Concrete a -> f (Concrete b)

sequenceA :: Applicative f => Concrete (f a) -> f (Concrete a)

mapM :: Monad m => (a -> m b) -> Concrete a -> m (Concrete b)

sequence :: Monad m => Concrete (m a) -> m (Concrete a)

Functor Concrete

Defined in Hedgehog.Internal.State

Methods

fmap :: (a -> b) -> Concrete a -> Concrete b

(<$) :: a -> Concrete b -> Concrete a

Show a => Show (Concrete a)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Concrete a -> ShowS

show :: Concrete a -> String

showList :: [Concrete a] -> ShowS

Eq a => Eq (Concrete a)

Defined in Hedgehog.Internal.State

Methods

(==) :: Concrete a -> Concrete a -> Bool

(/=) :: Concrete a -> Concrete a -> Bool

Ord a => Ord (Concrete a)

Defined in Hedgehog.Internal.State

Methods

compare :: Concrete a -> Concrete a -> Ordering

(<) :: Concrete a -> Concrete a -> Bool

(<=) :: Concrete a -> Concrete a -> Bool

(>) :: Concrete a -> Concrete a -> Bool

(>=) :: Concrete a -> Concrete a -> Bool

max :: Concrete a -> Concrete a -> Concrete a

min :: Concrete a -> Concrete a -> Concrete a

data Symbolic a where

Symbolic values: Because hedgehog generates actions in a separate phase before execution, you will sometimes need to refer to the result of a previous action in a generator without knowing the value of the result (e.g., to get the ID of a previously-created user).

Symbolic variables provide a token to stand in for the actual variables at generation time (and in Require/Update callbacks). At execution time, real values are available, so your execute actions work on Concrete variables.

See also: Command, Var

Constructors

Symbolic :: Typeable a => Name -> Symbolic a

Instances

Eq1 Symbolic

Defined in Hedgehog.Internal.State

Methods

liftEq :: (a -> b -> Bool) -> Symbolic a -> Symbolic b -> Bool

Ord1 Symbolic

Defined in Hedgehog.Internal.State

Methods

liftCompare :: (a -> b -> Ordering) -> Symbolic a -> Symbolic b -> Ordering

Show1 Symbolic

Defined in Hedgehog.Internal.State

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Symbolic a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Symbolic a] -> ShowS

Show (Symbolic a)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Symbolic a -> ShowS

show :: Symbolic a -> String

showList :: [Symbolic a] -> ShowS

Eq (Symbolic a)

Defined in Hedgehog.Internal.State

Methods

(==) :: Symbolic a -> Symbolic a -> Bool

(/=) :: Symbolic a -> Symbolic a -> Bool

Ord (Symbolic a)

Defined in Hedgehog.Internal.State

Methods

compare :: Symbolic a -> Symbolic a -> Ordering

(<) :: Symbolic a -> Symbolic a -> Bool

(<=) :: Symbolic a -> Symbolic a -> Bool

(>) :: Symbolic a -> Symbolic a -> Bool

(>=) :: Symbolic a -> Symbolic a -> Bool

max :: Symbolic a -> Symbolic a -> Symbolic a

min :: Symbolic a -> Symbolic a -> Symbolic a

newtype Name

Symbolic variable names.

Constructors

Name Int

Instances

Num Name

Defined in Hedgehog.Internal.State

Methods

(+) :: Name -> Name -> Name

(-) :: Name -> Name -> Name

(*) :: Name -> Name -> Name

negate :: Name -> Name

abs :: Name -> Name

signum :: Name -> Name

fromInteger :: Integer -> Name

Show Name

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

Eq Name

Defined in Hedgehog.Internal.State

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Ord Name

Defined in Hedgehog.Internal.State

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Environment

newtype Environment

A mapping of symbolic values to concrete values.

Constructors

Environment

Fields

• unEnvironment :: Map Name Dynamic

Instances

Show Environment

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Environment -> ShowS

show :: Environment -> String

showList :: [Environment] -> ShowS

data EnvironmentError

Environment errors.

Constructors

EnvironmentValueNotFound !Name

EnvironmentTypeError !TypeRep !TypeRep

Instances

Show EnvironmentError

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> EnvironmentError -> ShowS

show :: EnvironmentError -> String

showList :: [EnvironmentError] -> ShowS

Eq EnvironmentError

Defined in Hedgehog.Internal.State

Methods

(==) :: EnvironmentError -> EnvironmentError -> Bool

(/=) :: EnvironmentError -> EnvironmentError -> Bool

Ord EnvironmentError

Defined in Hedgehog.Internal.State

Methods

compare :: EnvironmentError -> EnvironmentError -> Ordering

(<) :: EnvironmentError -> EnvironmentError -> Bool

(<=) :: EnvironmentError -> EnvironmentError -> Bool

(>) :: EnvironmentError -> EnvironmentError -> Bool

(>=) :: EnvironmentError -> EnvironmentError -> Bool

max :: EnvironmentError -> EnvironmentError -> EnvironmentError

min :: EnvironmentError -> EnvironmentError -> EnvironmentError

emptyEnvironment :: Environment

Create an empty environment.

insertConcrete :: Symbolic a -> Concrete a -> Environment -> Environment

Insert a symbolic / concrete pairing in to the environment.

reifyDynamic :: forall a. Typeable a => Dynamic -> Either EnvironmentError (Concrete a)

Cast a Dynamic in to a concrete value.

reifyEnvironment :: Environment -> forall a. Symbolic a -> Either EnvironmentError (Concrete a)

Turns an environment in to a function for looking up a concrete value from a symbolic one.

reify :: TraversableB t => Environment -> t Symbolic -> Either EnvironmentError (t Concrete)

Convert a symbolic structure to a concrete one, using the provided environment.

Commands

data Command gen m (state :: (Type -> Type) -> Type)

The specification for the expected behaviour of an Action. These are used to generate sequences of actions to test.

This is the main type you will use when writing state machine tests. gen is usually an instance of MonadGen, and m is usually an instance of MonadTest. These constraints appear when you pass your Command list to sequential or parallel.

Constructors

forall input output.(TraversableB input, Show (input Symbolic), Show output, Typeable output) => Command

Fields

• commandGen :: state Symbolic -> Maybe (gen (input Symbolic))

  A generator which provides random arguments for a command. If the command cannot be executed in the current state, it should return Nothing.

• commandExecute :: input Concrete -> m output

  Executes a command using the arguments generated by commandGen.

• commandCallbacks :: [Callback input output state]

  A set of callbacks which provide optional command configuration such as pre-condtions, post-conditions and state updates.

data Callback input output state

Optional command configuration.

Constructors

Require (state Symbolic -> input Symbolic -> Bool)

A pre-condition for a command that must be verified before the command can be executed. This is mainly used during shrinking to ensure that it is still OK to run a command despite the fact that some previously executed commands may have been removed from the sequence.

Update (forall v. Ord1 v => state v -> input v -> Var output v -> state v)

Updates the model state, given the input and output of the command. Note that this function is polymorphic in the type of values. This is because it must work over Symbolic values when we are generating actions, and Concrete values when we are executing them.

Ensure (state Concrete -> state Concrete -> input Concrete -> output -> Test ())

A post-condition for a command that must be verified for the command to be considered a success.

This callback receives the state prior to execution as the first argument, and the state after execution as the second argument.

commandGenOK :: Command gen m state -> state Symbolic -> Bool

Checks that input for a command can be executed in the given state.

Actions

data Action m (state :: (Type -> Type) -> Type)

An instantiation of a Command which can be executed, and its effect evaluated.

Constructors

forall input output.(TraversableB input, Show (input Symbolic), Show output) => Action

Fields

• actionInput :: input Symbolic
• actionOutput :: Symbolic output
• actionExecute :: input Concrete -> m output
• actionRequire :: state Symbolic -> input Symbolic -> Bool
• actionUpdate :: forall v. Ord1 v => state v -> input v -> Var output v -> state v
• actionEnsure :: state Concrete -> state Concrete -> input Concrete -> output -> Test ()

Instances

Show (Action m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Action m state -> ShowS

show :: Action m state -> String

showList :: [Action m state] -> ShowS

newtype Sequential m state

A sequence of actions to execute.

Constructors

Sequential

Fields

• sequentialActions :: [Action m state]

  The sequence of actions.

Instances

Show (Sequential m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Sequential m state -> ShowS

show :: Sequential m state -> String

showList :: [Sequential m state] -> ShowS

data Parallel m state

A sequential prefix of actions to execute, with two branches to execute in parallel.

Constructors

Parallel

Fields

• parallelPrefix :: [Action m state]

  The sequential prefix.

• parallelBranch1 :: [Action m state]

  The first branch.

• parallelBranch2 :: [Action m state]

  The second branch.

Instances

Show (Parallel m state)

Defined in Hedgehog.Internal.State

Methods

showsPrec :: Int -> Parallel m state -> ShowS

show :: Parallel m state -> String

showList :: [Parallel m state] -> ShowS

takeVariables :: forall t. TraversableB t => t Symbolic -> Map Name TypeRep

Collects all the symbolic values in a data structure and produces a set of all the variables they refer to.

variablesOK :: TraversableB t => t Symbolic -> Map Name TypeRep -> Bool

Checks that the symbolic values in the data structure refer only to the variables in the provided set, and that they are of the correct type.

dropInvalid :: [Action m state] -> State (Context state) [Action m state]

Drops invalid actions from the sequence.

action :: (MonadGen gen, MonadTest m) => [Command gen m state] -> GenT (StateT (Context state) (GenBase gen)) (Action m state)

Generates a single action from a set of possible commands.

sequential :: (MonadGen gen, MonadTest m) => Range Int -> (forall v. state v) -> [Command gen m state] -> gen (Sequential m state)

Generates a sequence of actions from an initial model state and set of commands.

parallel :: (MonadGen gen, MonadTest m) => Range Int -> Range Int -> (forall v. state v) -> [Command gen m state] -> gen (Parallel m state)

Given the initial model state and set of commands, generates prefix actions to be run sequentially, followed by two branches to be run in parallel.

executeSequential :: (MonadTest m, MonadCatch m, HasCallStack) => (forall v. state v) -> Sequential m state -> m ()

Executes a list of actions sequentially, verifying that all post-conditions are met and no exceptions are thrown.

To generate a sequence of actions to execute, see the sequential combinator in the Hedgehog.Gen module.

executeParallel :: (MonadTest m, MonadCatch m, MonadBaseControl IO m, HasCallStack) => (forall v. state v) -> Parallel m state -> m ()

Executes the prefix actions sequentially, then executes the two branches in parallel, verifying that no exceptions are thrown and that there is at least one sequential interleaving where all the post-conditions are met.

To generate parallel actions to execute, see the parallel combinator in the Hedgehog.Gen module.