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 FunctorB and TraversableB, which is how Symbolic values are turned into Concrete ones.

Take the value from a concrete variable.

Take the value from an opaque concrete variable.

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.

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

Symbolic variable names.

A mapping of symbolic values to concrete values.

Environment errors.

Create an empty environment.

Insert a symbolic / concrete pairing in to the environment.

Cast a Dynamic in to a concrete value.

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

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

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.

Optional command configuration.

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

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

A sequence of actions to execute.

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

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

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.

Drops invalid actions from the sequence.

Generates a single action from a set of possible commands.

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

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.

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.

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.