Test.StateMachine

The main module for state machine based testing, it contains combinators that help you build sequential and parallel properties.

Sequential property combinators

forAllCommands

Arguments

:: Testable prop

=> (Show (cmd Symbolic), Show (resp Symbolic), Show (model Symbolic))

=> (Traversable cmd, Foldable resp)

=> StateMachine model cmd m resp

-> Maybe Int

Minimum number of commands.

-> (Commands cmd resp -> prop)

Predicate.

-> Property

existsCommands

Arguments

:: forall model cmd m resp prop. (Testable prop, Foldable resp)

=> (Show (model Symbolic), Show (cmd Symbolic), Show (resp Symbolic))

=> StateMachine model cmd m resp

-> [model Symbolic -> Gen (cmd Symbolic)]

Generators.

-> (Commands cmd resp -> prop)

Predicate.

-> Property

Generate commands from a list of generators.

runCommands :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadIO m) => StateMachine model cmd m resp -> Commands cmd resp -> PropertyM m (History cmd resp, model Concrete, Reason)

runCommandsWithSetup :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadIO m) => m (StateMachine model cmd m resp) -> Commands cmd resp -> PropertyM m (History cmd resp, model Concrete, Reason)

prettyCommands :: (MonadIO m, CanDiff (model Concrete)) => (Show (cmd Concrete), Show (resp Concrete)) => StateMachine model cmd m resp -> History cmd resp -> Property -> PropertyM m ()

prettyCommands' :: (MonadIO m, CanDiff (model Concrete), CanDiff [tag]) => (Show (cmd Concrete), Show (resp Concrete)) => StateMachine model cmd m resp -> ([Event model cmd resp Symbolic] -> [tag]) -> Commands cmd resp -> History cmd resp -> Property -> PropertyM m ()

Variant of prettyCommands that also prints the tags covered by each command.

checkCommandNames :: forall cmd resp. CommandNames cmd => Commands cmd resp -> Property -> Property

Print the percentage of each command used. The prefix check is an unfortunate remaining for backwards compatibility.

coverCommandNames :: forall cmd resp. CommandNames cmd => Commands cmd resp -> Property -> Property

Fail if some commands have not been executed.

commandNames :: forall cmd resp. CommandNames cmd => Commands cmd resp -> [(String, Int)]

commandNamesInOrder :: forall cmd resp. CommandNames cmd => Commands cmd resp -> [String]

saveCommands :: (Show (cmd Symbolic), Show (resp Symbolic)) => FilePath -> Commands cmd resp -> Property -> Property

runSavedCommands :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadIO m) => (Read (cmd Symbolic), Read (resp Symbolic)) => StateMachine model cmd m resp -> FilePath -> PropertyM m (Commands cmd resp, History cmd resp, model Concrete, Reason)

showLabelledExamples :: (Show tag, Show (model Symbolic)) => (Show (cmd Symbolic), Show (resp Symbolic)) => (Traversable cmd, Foldable resp) => StateMachine model cmd m resp -> ([Event model cmd resp Symbolic] -> [tag]) -> IO ()

showLabelledExamples'

Arguments

:: (Show tag, Show (model Symbolic))

=> (Show (cmd Symbolic), Show (resp Symbolic))

=> (Traversable cmd, Foldable resp)

=> StateMachine model cmd m resp

-> Maybe Int

Seed

-> Int

Number of tests to run to find examples

-> ([Event model cmd resp Symbolic] -> [tag])

-> (tag -> Bool)

Tag filter (can be const True)

-> IO ()

Show minimal examples for each of the generated tags.

noCleanup :: Monad m => model Concrete -> m ()

Parallel property combinators

forAllParallelCommands

Arguments

:: Testable prop

=> (Show (cmd Symbolic), Show (resp Symbolic), Show (model Symbolic))

=> (Traversable cmd, Foldable resp)

=> StateMachine model cmd m resp

-> Maybe Int

-> (ParallelCommands cmd resp -> prop)

Predicate.

-> Property

forAllNParallelCommands

Arguments

:: Testable prop

=> (Show (cmd Symbolic), Show (resp Symbolic), Show (model Symbolic))

=> (Traversable cmd, Foldable resp)

=> StateMachine model cmd m resp

-> Int

Number of threads

-> (NParallelCommands cmd resp -> prop)

Predicate.

-> Property

runNParallelCommands :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadUnliftIO m) => StateMachine model cmd m resp -> NParallelCommands cmd resp -> PropertyM m [(History cmd resp, model Concrete, Logic)]

runNParallelCommandsWithSetup :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadUnliftIO m) => m (StateMachine model cmd m resp) -> NParallelCommands cmd resp -> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommands :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadUnliftIO m) => StateMachine model cmd m resp -> ParallelCommands cmd resp -> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommandsWithSetup :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadUnliftIO m) => m (StateMachine model cmd m resp) -> ParallelCommands cmd resp -> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommands' :: (Show (cmd Concrete), Show (resp Concrete)) => (Traversable cmd, Foldable resp) => (MonadMask m, MonadUnliftIO m) => m (StateMachine model cmd m resp) -> (cmd Concrete -> resp Concrete) -> ParallelCommands cmd resp -> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommandsNTimes

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> StateMachine model cmd m resp

-> ParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommandsNTimesWithSetup

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> m (StateMachine model cmd m resp)

-> ParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

runNParallelCommandsNTimes'

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> m (StateMachine model cmd m resp)

-> (cmd Concrete -> resp Concrete)

-> NParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

runParallelCommandsNTimes'

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> m (StateMachine model cmd m resp)

-> (cmd Concrete -> resp Concrete)

-> ParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

runNParallelCommandsNTimes

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> StateMachine model cmd m resp

-> NParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

runNParallelCommandsNTimesWithSetup

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> (Traversable cmd, Foldable resp)

=> (MonadMask m, MonadUnliftIO m)

=> Int

How many times to execute the parallel program.

-> m (StateMachine model cmd m resp)

-> NParallelCommands cmd resp

-> PropertyM m [(History cmd resp, model Concrete, Logic)]

prettyNParallelCommands

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> MonadIO m

=> Foldable cmd

=> NParallelCommands cmd resp

-> [(History cmd resp, a, Logic)]

Output of runNParallelCommands.

-> PropertyM m ()

prettyParallelCommands

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> MonadIO m

=> Foldable cmd

=> ParallelCommands cmd resp

-> [(History cmd resp, a, Logic)]

Output of runNParallelCommands.

-> PropertyM m ()

prettyParallelCommandsWithOpts

Arguments

:: (MonadIO m, Foldable cmd)

=> (Show (cmd Concrete), Show (resp Concrete))

=> ParallelCommands cmd resp

-> Maybe GraphOptions

-> [(History cmd resp, a, Logic)]

Output of runParallelCommands.

-> PropertyM m ()

Takes the output of parallel program runs and pretty prints a counterexample if any of the runs fail.

prettyNParallelCommandsWithOpts

Arguments

:: (Show (cmd Concrete), Show (resp Concrete))

=> MonadIO m

=> Foldable cmd

=> NParallelCommands cmd resp

-> Maybe GraphOptions

-> [(History cmd resp, a, Logic)]

Output of runNParallelCommands.

-> PropertyM m ()

Takes the output of parallel program runs and pretty prints a counterexample if any of the runs fail.

checkCommandNamesParallel :: forall cmd resp t. Foldable t => CommandNames cmd => ParallelCommandsF t cmd resp -> Property -> Property

Print the percentage of each command used. The prefix check is an unfortunate remaining for backwards compatibility.

coverCommandNamesParallel :: forall cmd resp t. Foldable t => CommandNames cmd => ParallelCommandsF t cmd resp -> Property -> Property

Fail if some commands have not been executed.

commandNamesParallel :: forall cmd resp t. Foldable t => CommandNames cmd => ParallelCommandsF t cmd resp -> [(String, Int)]

Types

data StateMachine model cmd m resp

Constructors

StateMachine (forall r. model r) (forall r. (Show1 r, Ord1 r) => model r -> cmd r -> resp r -> model r) (model Symbolic -> cmd Symbolic -> Logic) (model Concrete -> cmd Concrete -> resp Concrete -> Logic) (Maybe (model Concrete -> Logic)) (model Symbolic -> Maybe (Gen (cmd Symbolic))) (model Symbolic -> cmd Symbolic -> [cmd Symbolic]) (cmd Concrete -> m (resp Concrete)) (model Symbolic -> cmd Symbolic -> GenSym (resp Symbolic)) (model Concrete -> m ())

data Concrete a

Instances

Eq1 Concrete

Defined in Test.StateMachine.Types.References

Methods

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

Ord1 Concrete

Defined in Test.StateMachine.Types.References

Methods

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

Show1 Concrete

Defined in Test.StateMachine.Types.References

Methods

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

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

Show a => Show (Concrete a)

Defined in Test.StateMachine.Types.References

Methods

showsPrec :: Int -> Concrete a -> ShowS

show :: Concrete a -> String

showList :: [Concrete a] -> ShowS

Eq a => Eq (Concrete a)

Defined in Test.StateMachine.Types.References

Methods

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

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

Ord a => Ord (Concrete a)

Defined in Test.StateMachine.Types.References

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

Instances

Eq1 Symbolic

Defined in Test.StateMachine.Types.References

Methods

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

Ord1 Symbolic

Defined in Test.StateMachine.Types.References

Methods

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

Show1 Symbolic

Defined in Test.StateMachine.Types.References

Methods

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

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

Typeable a => Read (Symbolic a)

Defined in Test.StateMachine.Types.References

Methods

readsPrec :: Int -> ReadS (Symbolic a)

readList :: ReadS [Symbolic a]

readPrec :: ReadPrec (Symbolic a)

readListPrec :: ReadPrec [Symbolic a]

Show (Symbolic a)

Defined in Test.StateMachine.Types.References

Methods

showsPrec :: Int -> Symbolic a -> ShowS

show :: Symbolic a -> String

showList :: [Symbolic a] -> ShowS

Eq (Symbolic a)

Defined in Test.StateMachine.Types.References

Methods

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

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

Ord (Symbolic a)

Defined in Test.StateMachine.Types.References

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

Typeable a => Read (Reference a Symbolic)

Defined in Test.StateMachine.Types.References

Methods

readsPrec :: Int -> ReadS (Reference a Symbolic)

readList :: ReadS [Reference a Symbolic]

readPrec :: ReadPrec (Reference a Symbolic)

readListPrec :: ReadPrec [Reference a Symbolic]

data Reference a r

Instances

Foldable (Reference a :: (Type -> Type) -> Type)

Defined in Test.StateMachine.Types.References

Methods

foldMap :: Monoid m => (forall (x :: k). p x -> m) -> Reference a p -> m

Functor (Reference a :: (Type -> Type) -> Type)

Defined in Test.StateMachine.Types.References

Methods

fmap :: (forall (x :: k). p x -> q x) -> Reference a p -> Reference a q

Traversable (Reference a :: (Type -> Type) -> Type)

Defined in Test.StateMachine.Types.References

Methods

traverse :: Applicative f => (forall (a0 :: k). p a0 -> f (q a0)) -> Reference a p -> f (Reference a q)

Generic (Reference a r)

Defined in Test.StateMachine.Types.References

Associated Types

type Rep (Reference a r) :: Type -> Type

Methods

from :: Reference a r -> Rep (Reference a r) x

to :: Rep (Reference a r) x -> Reference a r

Typeable a => Read (Reference a Symbolic)

Defined in Test.StateMachine.Types.References

Methods

readsPrec :: Int -> ReadS (Reference a Symbolic)

readList :: ReadS [Reference a Symbolic]

readPrec :: ReadPrec (Reference a Symbolic)

readListPrec :: ReadPrec [Reference a Symbolic]

(Show1 r, Show a) => Show (Reference a r)

Defined in Test.StateMachine.Types.References

Methods

showsPrec :: Int -> Reference a r -> ShowS

show :: Reference a r -> String

showList :: [Reference a r] -> ShowS

(Eq a, Eq1 r) => Eq (Reference a r)

Defined in Test.StateMachine.Types.References

Methods

(==) :: Reference a r -> Reference a r -> Bool

(/=) :: Reference a r -> Reference a r -> Bool

(Ord a, Ord1 r) => Ord (Reference a r)

Defined in Test.StateMachine.Types.References

Methods

compare :: Reference a r -> Reference a r -> Ordering

(<) :: Reference a r -> Reference a r -> Bool

(<=) :: Reference a r -> Reference a r -> Bool

(>) :: Reference a r -> Reference a r -> Bool

(>=) :: Reference a r -> Reference a r -> Bool

max :: Reference a r -> Reference a r -> Reference a r

min :: Reference a r -> Reference a r -> Reference a r

type Rep (Reference a r)

Defined in Test.StateMachine.Types.References

type Rep (Reference a r) = D1 ('MetaData "Reference" "Test.StateMachine.Types.References" "quickcheck-state-machine-0.9.0-8zWHYIJYc77JtQ2efkvn1E-no-vendored-treediff" 'True) (C1 ('MetaCons "Reference" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (r a))))

concrete :: Reference a Concrete -> a

reference :: Typeable a => a -> Reference a Concrete

newtype Opaque a

Constructors

Opaque

Fields

• unOpaque :: a

Instances

Show (Opaque a)

Defined in Test.StateMachine.Types.References

Methods

showsPrec :: Int -> Opaque a -> ShowS

show :: Opaque a -> String

showList :: [Opaque a] -> ShowS

Eq a => Eq (Opaque a)

Defined in Test.StateMachine.Types.References

Methods

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

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

Ord a => Ord (Opaque a)

Defined in Test.StateMachine.Types.References

Methods

compare :: Opaque a -> Opaque a -> Ordering

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

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

(>) :: Opaque a -> Opaque a -> Bool

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

max :: Opaque a -> Opaque a -> Opaque a

min :: Opaque a -> Opaque a -> Opaque a

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

data Reason

Constructors

Ok

PreconditionFailed String

PostconditionFailed String

InvariantBroken String

ExceptionThrown String

MockSemanticsMismatch String

Instances

Show Reason

Defined in Test.StateMachine.Types

Methods

showsPrec :: Int -> Reason -> ShowS

show :: Reason -> String

showList :: [Reason] -> ShowS

Eq Reason

Defined in Test.StateMachine.Types

Methods

(==) :: Reason -> Reason -> Bool

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

data GenSym a

Instances

Applicative GenSym

Defined in Test.StateMachine.Types.GenSym

Methods

pure :: a -> GenSym a

(<*>) :: GenSym (a -> b) -> GenSym a -> GenSym b

liftA2 :: (a -> b -> c) -> GenSym a -> GenSym b -> GenSym c

(*>) :: GenSym a -> GenSym b -> GenSym b

(<*) :: GenSym a -> GenSym b -> GenSym a

Functor GenSym

Defined in Test.StateMachine.Types.GenSym

Methods

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

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

Monad GenSym

Defined in Test.StateMachine.Types.GenSym

Methods

(>>=) :: GenSym a -> (a -> GenSym b) -> GenSym b

(>>) :: GenSym a -> GenSym b -> GenSym b

return :: a -> GenSym a

genSym :: Typeable a => GenSym (Reference a Symbolic)

class CommandNames (cmd :: k -> Type) where

The names of all possible commands

This is used for things like tagging, coverage checking, etc.

Minimal complete definition

Nothing

Methods

cmdName :: cmd r -> String

Name of this particular command

default cmdName :: (Generic1 cmd, CommandNames (Rep1 cmd)) => cmd r -> String

cmdNames :: Proxy (cmd r) -> [String]

Name of all possible commands

default cmdNames :: forall r. CommandNames (Rep1 cmd) => Proxy (cmd r) -> [String]

Instances

CommandNames (U1 :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). U1 r -> String

cmdNames :: forall (r :: k0). Proxy (U1 r) -> [String]

CommandNames f => CommandNames (Rec1 f :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). Rec1 f r -> String

cmdNames :: forall (r :: k0). Proxy (Rec1 f r) -> [String]

(CommandNames f, CommandNames g) => CommandNames (f :*: g :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). (f :*: g) r -> String

cmdNames :: forall (r :: k0). Proxy ((f :*: g) r) -> [String]

(CommandNames f, CommandNames g) => CommandNames (f :+: g :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). (f :+: g) r -> String

cmdNames :: forall (r :: k0). Proxy ((f :+: g) r) -> [String]

CommandNames (K1 i c :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). K1 i c r -> String

cmdNames :: forall (r :: k0). Proxy (K1 i c r) -> [String]

Constructor c => CommandNames (M1 C c f :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). M1 C c f r -> String

cmdNames :: forall (r :: k0). Proxy (M1 C c f r) -> [String]

CommandNames f => CommandNames (M1 D c f :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). M1 D c f r -> String

cmdNames :: forall (r :: k0). Proxy (M1 D c f r) -> [String]

CommandNames f => CommandNames (M1 S c f :: k -> Type)

Defined in Test.StateMachine.ConstructorName

Methods

cmdName :: forall (r :: k0). M1 S c f r -> String

cmdNames :: forall (r :: k0). Proxy (M1 S c f r) -> [String]

module Test.StateMachine.Logic

Diffing class

class CanDiff x where

Associated Types

type AnExpr x

Expressions that will be diffed

type ADiff x

What will the diff of two AnExprs result in

Methods

toDiff :: x -> AnExpr x

Extract the expression from the data

exprDiff :: Proxy x -> AnExpr x -> AnExpr x -> ADiff x

Diff two expressions

diffToDocCompact :: Proxy x -> ADiff x -> Doc

Output a diff in compact form

diffToDoc :: Proxy x -> ADiff x -> Doc

Output a diff

exprToDoc :: Proxy x -> AnExpr x -> Doc

Output an expression