Hedgehog.Internal.Property

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

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

The name of a property.

Should be constructed using OverloadedStrings:

  "apples" :: PropertyName

Configuration for a property test.

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

The number of tests a property ran successfully.

The number of discards to allow before giving up.

Can be constructed using numeric literals:

  10000 :: DiscardLimit

The number of tests a property had to discard.

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

Can be constructed using numeric literals:

  1000 :: ShrinkLimit

The numbers of times a property was able to shrink after a failing test.

Where to start running a property's tests.

The path taken to reach a shrink state.

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

Set the number of 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.

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

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

Set the number of 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.

Set the target that a property will skip to before it starts to run.

Creates a property with the default configuration.

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.

An example where this is useful is parallel state machine testing, as executeParallel requires MonadBaseControl IO in order to be able to spawn threads in MonadTest.

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

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

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.

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.

The minimum amount of tests to run for a Property

Discards the current test entirely.

Compress a Skip into a hopefully-short alphanumeric string.

The bit that might be long is the ShrinkPath in SkipToShrink. For that, we encode the path components in base 26, alternating between uppercase and lowercase alphabets to distinguish list elements. Additionally when we have runs of equal components, we use the normal base 10 encoding to indicate the length.

This gives something which is hopefully quite short, but a human can roughly interpret it by eyeball.

Compress a ShrinkPath into a hopefully-short alphanumeric string.

We encode the path components in base 26, alternating between uppercase and lowercase alphabets to distinguish list elements. Additionally when we have runs of equal components, we use the normal base 10 encoding to indicate the length.

Decompress a Skip.

This satisfies

  skipDecompress (skipCompress a) == Just a

Decompress a ShrinkPath.

This satisfies

  shrinkPathDecompress (shrinkPathCompress a) == Just a

A named collection of property tests.

The name of a group of properties.

Should be constructed using OverloadedStrings:

  "fruit" :: GroupName

The number of properties in a group.

A test monad allows the assertion of expectations.

A test monad transformer allows the assertion of expectations.

Log messages which are recorded during a test run.

A record containing the details of a test run.

Details on where and why a test failed.

The difference between some expected and actual value.

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

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

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

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

Causes a test to fail.

Another name for pure ().

Fails the test if the condition provided is False.

Fails the test and shows a git-like diff if the comparison operation evaluates to False when applied to its arguments.

The comparison function is the second argument, which may be counter-intuitive to Haskell programmers. However, it allows operators to be written infix for easy reading:

  diff y (<) 87
  diff x (<=) r

This function behaves like the unix diff tool, which gives a 0 exit code if the compared files are identical, or a 1 exit code code otherwise. Like unix diff, if the arguments fail the comparison, a /diff is shown.

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

Fails the test if the two arguments provided are equal.

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

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

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.

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.

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

Fails the test if the action throws an exception, or if the Either is Left, otherwise returns the value in the Right.

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

Fails the test if the Maybe is Nothing, otherwise returns the value in the Just.

Fails the test if the action throws an exception, or if the Maybe is Nothing, otherwise returns the value in the Just.

The extent to which all classifiers cover a test.

When a given classification's coverage does not exceed the required minimum, the test will be failed.

The extent to which a test is covered by a classifier.

When a classifier's coverage does not exceed the required minimum, the test will be failed.

The name of a classifier.

Should be constructed using OverloadedStrings:

  "apples" :: LabelName

Require a certain percentage of the tests to be covered by the classifier.

   prop_with_coverage :: Property
   prop_with_coverage =
     property $ do
       match <- forAll Gen.bool
       cover 30 "True" $ match
       cover 30 "False" $ not match

The example above requires a minimum of 30% coverage for both classifiers. If these requirements are not met, it will fail the test.

Records the proportion of tests which satisfy a given condition.

   prop_with_classifier :: Property
   prop_with_classifier =
     property $ do
       xs <- forAll $ Gen.list (Range.linear 0 100) Gen.alpha
       for_ xs $ \x -> do
         classify "newborns" $ x == 0
         classify "children" $ x > 0 && x < 13
         classify "teens" $ x > 12 && x < 20

Add a label for each test run. It produces a table showing the percentage of test runs that produced each label.

Like label, but uses Show to render its argument for display.

All labels are covered

Whether a test is covered by a classifier, and therefore belongs to a Class.

The total number of tests which are covered by a classifier.

Can be constructed using numeric literals:

  30 :: CoverCount

The relative number of tests which are covered by a classifier.

Can be constructed using numeric literals:

  30 :: CoverPercentage

The acceptable occurrence of false positives

Example, Confidence 10^9 would mean that you'd accept a false positive for 1 in 10^9 tests.

Is true when the test coverage satisfies the specified Confidence contstraint for all 'Coverage CoverCount's

Is true when there exists a label that is sure to have failed according to the Confidence constraint

Make sure that the result is statistically significant in accordance to the passed Confidence

The default confidence allows one false positive in 10^9 tests

The default configuration for a property test.

Map a config modification function over a property.

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

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

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

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