hedgehog-0.5.2: Hedgehog will eat all your bugs.

Safe HaskellNone
LanguageHaskell98

Hedgehog.Internal.Property

Contents

Synopsis

Property

data Property Source #

A property test, along with some configurable limits like how many times to run the test.

newtype PropertyT m a Source #

The property monad transformer allows both the generation of test inputs and the assertion of expectations.

Constructors

PropertyT 

Fields

Instances

MonadTrans PropertyT Source # 

Methods

lift :: Monad m => m a -> PropertyT m a #

Distributive PropertyT Source # 

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (PropertyT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint Source #

Methods

distribute :: Transformer f PropertyT m => PropertyT (f m) a -> f (PropertyT m) a Source #

MonadBase b m => MonadBase b (PropertyT m) Source # 

Methods

liftBase :: b α -> PropertyT m α #

MonadState s m => MonadState s (PropertyT m) Source # 

Methods

get :: PropertyT m s #

put :: s -> PropertyT m () #

state :: (s -> (a, s)) -> PropertyT m a #

MonadReader r m => MonadReader r (PropertyT m) Source # 

Methods

ask :: PropertyT m r #

local :: (r -> r) -> PropertyT m a -> PropertyT m a #

reader :: (r -> a) -> PropertyT m a #

MonadError e m => MonadError e (PropertyT m) Source # 

Methods

throwError :: e -> PropertyT m a #

catchError :: PropertyT m a -> (e -> PropertyT m a) -> PropertyT m a #

Monad m => Monad (PropertyT m) Source # 

Methods

(>>=) :: PropertyT m a -> (a -> PropertyT m b) -> PropertyT m b #

(>>) :: PropertyT m a -> PropertyT m b -> PropertyT m b #

return :: a -> PropertyT m a #

fail :: String -> PropertyT m a #

Functor m => Functor (PropertyT m) Source # 

Methods

fmap :: (a -> b) -> PropertyT m a -> PropertyT m b #

(<$) :: a -> PropertyT m b -> PropertyT m a #

Monad m => Applicative (PropertyT m) Source # 

Methods

pure :: a -> PropertyT m a #

(<*>) :: PropertyT m (a -> b) -> PropertyT m a -> PropertyT m b #

liftA2 :: (a -> b -> c) -> PropertyT m a -> PropertyT m b -> PropertyT m c #

(*>) :: PropertyT m a -> PropertyT m b -> PropertyT m b #

(<*) :: PropertyT m a -> PropertyT m b -> PropertyT m a #

MonadIO m => MonadIO (PropertyT m) Source # 

Methods

liftIO :: IO a -> PropertyT m a #

MonadPlus m => Alternative (PropertyT m) Source # 

Methods

empty :: PropertyT m a #

(<|>) :: PropertyT m a -> PropertyT m a -> PropertyT m a #

some :: PropertyT m a -> PropertyT m [a] #

many :: PropertyT m a -> PropertyT m [a] #

MonadPlus m => MonadPlus (PropertyT m) Source # 

Methods

mzero :: PropertyT m a #

mplus :: PropertyT m a -> PropertyT m a -> PropertyT m a #

MonadCatch m => MonadCatch (PropertyT m) Source # 

Methods

catch :: Exception e => PropertyT m a -> (e -> PropertyT m a) -> PropertyT m a #

MonadThrow m => MonadThrow (PropertyT m) Source # 

Methods

throwM :: Exception e => e -> PropertyT m a #

PrimMonad m => PrimMonad (PropertyT m) Source # 

Associated Types

type PrimState (PropertyT m :: * -> *) :: * #

Monad m => MonadTest (PropertyT m) Source # 

Methods

liftTest :: Test a -> PropertyT m a Source #

MFunctor * PropertyT Source # 

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b #

type Transformer t PropertyT m Source # 
type PrimState (PropertyT m) Source # 

newtype TestLimit Source #

The number of successful tests that need to be run before a property test is considered successful.

Can be constructed using numeric literals:

  200 :: TestLimit

Constructors

TestLimit Int 

Instances

Enum TestLimit Source # 
Eq TestLimit Source # 
Integral TestLimit Source # 
Num TestLimit Source # 
Ord TestLimit Source # 
Real TestLimit Source # 
Show TestLimit Source # 
Lift TestLimit Source # 

Methods

lift :: TestLimit -> Q Exp #

newtype DiscardLimit Source #

The number of discards to allow before giving up.

Can be constructed using numeric literals:

  10000 :: DiscardLimit

Constructors

DiscardLimit Int 

Instances

Enum DiscardLimit Source # 
Eq DiscardLimit Source # 
Integral DiscardLimit Source # 
Num DiscardLimit Source # 
Ord DiscardLimit Source # 
Real DiscardLimit Source # 
Show DiscardLimit Source # 
Lift DiscardLimit Source # 

Methods

lift :: DiscardLimit -> Q Exp #

newtype ShrinkLimit Source #

The number of shrinks to try before giving up on shrinking.

Can be constructed using numeric literals:

  1000 :: ShrinkLimit

Constructors

ShrinkLimit Int 

Instances

Enum ShrinkLimit Source # 
Eq ShrinkLimit Source # 
Integral ShrinkLimit Source # 
Num ShrinkLimit Source # 
Ord ShrinkLimit Source # 
Real ShrinkLimit Source # 
Show ShrinkLimit Source # 
Lift ShrinkLimit Source # 

Methods

lift :: ShrinkLimit -> Q Exp #

newtype ShrinkRetries Source #

The number of times to re-run a test during shrinking. This is useful if you are testing something which fails non-deterministically and you want to increase the change of getting a good shrink.

If you are doing parallel state machine testing, you should probably set shrink retries to something like 10. This will mean that during shrinking, a parallel test case requires 10 successful runs before it is passes and we try a different shrink.

Can be constructed using numeric literals:

  0 :: ShrinkRetries

Constructors

ShrinkRetries Int 

Instances

Enum ShrinkRetries Source # 
Eq ShrinkRetries Source # 
Integral ShrinkRetries Source # 
Num ShrinkRetries Source # 
Ord ShrinkRetries Source # 
Real ShrinkRetries Source # 
Show ShrinkRetries Source # 
Lift ShrinkRetries Source # 

Methods

lift :: ShrinkRetries -> Q Exp #

withTests :: TestLimit -> Property -> Property Source #

Set the number times a property should be executed before it is considered successful.

If you have a test that does not involve any generators and thus does not need to run repeatedly, you can use withTests 1 to define a property that will only be checked once.

withDiscards :: DiscardLimit -> Property -> Property Source #

Set the number times a property is allowed to discard before the test runner gives up.

withShrinks :: ShrinkLimit -> Property -> Property Source #

Set the number times a property is allowed to shrink before the test runner gives up and prints the counterexample.

withRetries :: ShrinkRetries -> Property -> Property Source #

Set the number times a property will be executed for each shrink before the test runner gives up and tries a different shrink. See ShrinkRetries for more information.

property :: HasCallStack => PropertyT IO () -> Property Source #

Creates a property with the default configuration.

test :: Monad m => TestT m a -> PropertyT m a Source #

Lift a test in to a property.

Because both TestT and PropertyT have MonadTest instances, this function is not often required. It can however be useful for writing functions directly in TestT and thus gaining a MonadTransControl instance at the expense of not being able to generate additional inputs using forAll.

One use case for this is writing tests which use ResourceT:

  property $ do
    n <- forAll $ Gen.int64 Range.linearBounded
    test . runResourceT $ do
      -- test with resource usage here

forAll :: (Monad m, Show a, HasCallStack) => Gen a -> PropertyT m a Source #

Generates a random input for the test by running the provided generator.

forAllT :: (Monad m, Show a, HasCallStack) => GenT m a -> PropertyT m a Source #

Generates a random input for the test by running the provided generator.

forAllWith :: (Monad m, HasCallStack) => (a -> String) -> Gen a -> PropertyT m a Source #

Generates a random input for the test by running the provided generator.

This is a the same as forAll but allows the user to provide a custom rendering function. This is useful for values which don't have a Show instance.

forAllWithT :: (Monad m, HasCallStack) => (a -> String) -> GenT m a -> PropertyT m a Source #

Generates a random input for the test by running the provided generator.

This is a the same as forAllT but allows the user to provide a custom rendering function. This is useful for values which don't have a Show instance.

discard :: Monad m => PropertyT m a Source #

Discards the current test entirely.

Group

data Group Source #

A named collection of property tests.

Constructors

Group 

newtype GroupName Source #

The name of a group of properties.

Can be constructed using OverloadedStrings:

  "fruit" :: GroupName

Constructors

GroupName 

Fields

TestT

class Monad m => MonadTest m where Source #

Minimal complete definition

liftTest

Methods

liftTest :: Test a -> m a Source #

Instances

MonadTest m => MonadTest (MaybeT m) Source # 

Methods

liftTest :: Test a -> MaybeT m a Source #

MonadTest m => MonadTest (ResourceT m) Source # 

Methods

liftTest :: Test a -> ResourceT m a Source #

Monad m => MonadTest (TestT m) Source # 

Methods

liftTest :: Test a -> TestT m a Source #

Monad m => MonadTest (PropertyT m) Source # 

Methods

liftTest :: Test a -> PropertyT m a Source #

(MonadTest m, Monoid w) => MonadTest (WriterT w m) Source # 

Methods

liftTest :: Test a -> WriterT w m a Source #

MonadTest m => MonadTest (StateT s m) Source # 

Methods

liftTest :: Test a -> StateT s m a Source #

MonadTest m => MonadTest (ExceptT x m) Source # 

Methods

liftTest :: Test a -> ExceptT x m a Source #

MonadTest m => MonadTest (IdentityT * m) Source # 

Methods

liftTest :: Test a -> IdentityT * m a Source #

MonadTest m => MonadTest (StateT s m) Source # 

Methods

liftTest :: Test a -> StateT s m a Source #

(MonadTest m, Monoid w) => MonadTest (WriterT w m) Source # 

Methods

liftTest :: Test a -> WriterT w m a Source #

MonadTest m => MonadTest (ReaderT * r m) Source # 

Methods

liftTest :: Test a -> ReaderT * r m a Source #

MonadTest m => MonadTest (ContT * r m) Source # 

Methods

liftTest :: Test a -> ContT * r m a Source #

(MonadTest m, Monoid w) => MonadTest (RWST r w s m) Source # 

Methods

liftTest :: Test a -> RWST r w s m a Source #

(MonadTest m, Monoid w) => MonadTest (RWST r w s m) Source # 

Methods

liftTest :: Test a -> RWST r w s m a Source #

type Test = TestT Identity Source #

A test monad allows the assertion of expectations.

newtype TestT m a Source #

A test monad transformer allows the assertion of expectations.

Constructors

TestT 

Fields

Instances

MonadTrans TestT Source # 

Methods

lift :: Monad m => m a -> TestT m a #

MonadTransControl TestT Source # 

Associated Types

type StT (TestT :: (* -> *) -> * -> *) a :: * #

Methods

liftWith :: Monad m => (Run TestT -> m a) -> TestT m a #

restoreT :: Monad m => m (StT TestT a) -> TestT m a #

Distributive TestT Source # 

Associated Types

type Transformer (f :: (* -> *) -> * -> *) (TestT :: (* -> *) -> * -> *) (m :: * -> *) :: Constraint Source #

Methods

distribute :: Transformer f TestT m => TestT (f m) a -> f (TestT m) a Source #

MonadBase b m => MonadBase b (TestT m) Source # 

Methods

liftBase :: b α -> TestT m α #

MonadBaseControl b m => MonadBaseControl b (TestT m) Source # 

Associated Types

type StM (TestT m :: * -> *) a :: * #

Methods

liftBaseWith :: (RunInBase (TestT m) b -> b a) -> TestT m a #

restoreM :: StM (TestT m) a -> TestT m a #

MonadState s m => MonadState s (TestT m) Source # 

Methods

get :: TestT m s #

put :: s -> TestT m () #

state :: (s -> (a, s)) -> TestT m a #

MonadReader r m => MonadReader r (TestT m) Source # 

Methods

ask :: TestT m r #

local :: (r -> r) -> TestT m a -> TestT m a #

reader :: (r -> a) -> TestT m a #

MonadError e m => MonadError e (TestT m) Source # 

Methods

throwError :: e -> TestT m a #

catchError :: TestT m a -> (e -> TestT m a) -> TestT m a #

Monad m => Monad (TestT m) Source # 

Methods

(>>=) :: TestT m a -> (a -> TestT m b) -> TestT m b #

(>>) :: TestT m a -> TestT m b -> TestT m b #

return :: a -> TestT m a #

fail :: String -> TestT m a #

Functor m => Functor (TestT m) Source # 

Methods

fmap :: (a -> b) -> TestT m a -> TestT m b #

(<$) :: a -> TestT m b -> TestT m a #

Monad m => Applicative (TestT m) Source # 

Methods

pure :: a -> TestT m a #

(<*>) :: TestT m (a -> b) -> TestT m a -> TestT m b #

liftA2 :: (a -> b -> c) -> TestT m a -> TestT m b -> TestT m c #

(*>) :: TestT m a -> TestT m b -> TestT m b #

(<*) :: TestT m a -> TestT m b -> TestT m a #

MonadIO m => MonadIO (TestT m) Source # 

Methods

liftIO :: IO a -> TestT m a #

MonadCatch m => MonadCatch (TestT m) Source # 

Methods

catch :: Exception e => TestT m a -> (e -> TestT m a) -> TestT m a #

MonadThrow m => MonadThrow (TestT m) Source # 

Methods

throwM :: Exception e => e -> TestT m a #

PrimMonad m => PrimMonad (TestT m) Source # 

Associated Types

type PrimState (TestT m :: * -> *) :: * #

Methods

primitive :: (State# (PrimState (TestT m)) -> (#TupleRep [RuntimeRep], LiftedRep, State# (PrimState (TestT m)), a#)) -> TestT m a #

MonadResource m => MonadResource (TestT m) Source # 

Methods

liftResourceT :: ResourceT IO a -> TestT m a #

Monad m => MonadTest (TestT m) Source # 

Methods

liftTest :: Test a -> TestT m a Source #

MFunctor * TestT Source # 

Methods

hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b #

type StT TestT a Source # 
type StT TestT a = (Either Failure a, [Log])
type Transformer t TestT m Source # 
type PrimState (TestT m) Source # 
type StM (TestT m) a Source # 
type StM (TestT m) a = ComposeSt TestT m a

data Log Source #

Log messages which are recorded during a test run.

Instances

Eq Log Source # 

Methods

(==) :: Log -> Log -> Bool #

(/=) :: Log -> Log -> Bool #

Show Log Source # 

Methods

showsPrec :: Int -> Log -> ShowS #

show :: Log -> String #

showList :: [Log] -> ShowS #

data Failure Source #

Details on where and why a test failed.

Constructors

Failure (Maybe Span) String (Maybe Diff) 

data Diff Source #

The difference between some expected and actual value.

Instances

Eq Diff Source # 

Methods

(==) :: Diff -> Diff -> Bool #

(/=) :: Diff -> Diff -> Bool #

Show Diff Source # 

Methods

showsPrec :: Int -> Diff -> ShowS #

show :: Diff -> String #

showList :: [Diff] -> ShowS #

annotate :: (MonadTest m, HasCallStack) => String -> m () Source #

Annotates the source code with a message that might be useful for debugging a test failure.

annotateShow :: (MonadTest m, Show a, HasCallStack) => a -> m () Source #

Annotates the source code with a value that might be useful for debugging a test failure.

footnote :: MonadTest m => String -> m () Source #

Logs a message to be displayed as additional information in the footer of the failure report.

footnoteShow :: (MonadTest m, Show a) => a -> m () Source #

Logs a value to be displayed as additional information in the footer of the failure report.

failure :: (MonadTest m, HasCallStack) => m a Source #

Causes a test to fail.

success :: MonadTest m => m () Source #

Another name for pure ().

assert :: (MonadTest m, HasCallStack) => Bool -> m () Source #

Fails the test if the condition provided is False.

(===) :: (MonadTest m, Eq a, Show a, HasCallStack) => a -> a -> m () infix 4 Source #

Fails the test if the two arguments provided are not equal.

eval :: (MonadTest m, HasCallStack) => a -> m a Source #

Fails the test if the value throws an exception when evaluated to weak head normal form (WHNF).

evalM :: (MonadTest m, MonadCatch m, HasCallStack) => m a -> m a Source #

Fails the test if the action throws an exception.

The benefit of using this over simply letting the exception bubble up is that the location of the closest evalM will be shown in the output.

evalIO :: (MonadTest m, MonadIO m, HasCallStack) => IO a -> m a Source #

Fails the test if the IO action throws an exception.

The benefit of using this over liftIO is that the location of the exception will be shown in the output.

evalEither :: (MonadTest m, Show x, HasCallStack) => Either x a -> m a Source #

Fails the test if the Either is Left, otherwise returns the value in the Right.

evalExceptT :: (MonadTest m, Show x, HasCallStack) => ExceptT x m a -> m a Source #

Fails the test if the ExceptT is Left, otherwise returns the value in the Right.

Internal

These functions are exported in case you need them in a pinch, but are not part of the public API and may change at any time, even as part of a minor update.

defaultConfig :: PropertyConfig Source #

The default configuration for a property test.

mapConfig :: (PropertyConfig -> PropertyConfig) -> Property -> Property Source #

Map a config modification function over a property.

failDiff :: (MonadTest m, Show a, Show b, HasCallStack) => a -> b -> m () Source #

Fails with an error which shows the difference between two values.

failException :: (MonadTest m, HasCallStack) => SomeException -> m a Source #

Fails with an error which renders the type of an exception and its error message.

failWith :: (MonadTest m, HasCallStack) => Maybe Diff -> String -> m a Source #

Fail the test with an error message, useful for building other failure combinators.

writeLog :: MonadTest m => Log -> m () Source #

Log some information which might be relevant to a potential test failure.

mkTestT :: m (Either Failure a, [Log]) -> TestT m a Source #

runTestT :: TestT m a -> m (Either Failure a, [Log]) Source #