| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Test.Tasty.SmallCheck
Contents
Description
This module allows to use SmallCheck properties in tasty.
Synopsis
- testProperty :: Testable IO a => TestName -> a -> TestTree
- newtype SmallCheckDepth = SmallCheckDepth Int
- type Reason = String
- type Depth = Int
- class Monad m => Testable (m :: Type -> Type) a where
- data Property (m :: Type -> Type)
- (==>) :: forall (m :: Type -> Type) c a. (Testable m c, Testable m a) => c -> a -> Property m
- over :: forall a (m :: Type -> Type) b. (Show a, Testable m b) => Series m a -> (a -> b) -> Property m
- monadic :: Testable m a => m a -> Property m
- forAll :: forall (m :: Type -> Type) a. Testable m a => a -> Property m
- exists :: forall (m :: Type -> Type) a. Testable m a => a -> Property m
- existsUnique :: forall (m :: Type -> Type) a. Testable m a => a -> Property m
- changeDepth :: forall (m :: Type -> Type) a. Testable m a => (Depth -> Depth) -> a -> Property m
- changeDepth1 :: forall a (m :: Type -> Type) b. (Show a, Serial m a, Testable m b) => (Depth -> Depth) -> (a -> b) -> Property m
Documentation
testProperty :: Testable IO a => TestName -> a -> TestTree Source #
Create a Test for a SmallCheck Testable property
newtype SmallCheckDepth Source #
The "depth" parameter for SmallCheck
Constructors
| SmallCheckDepth Int |
Instances
Maximum depth of generated test values.
For data values, it is the depth of nested constructor applications.
For functional values, it is both the depth of nested case analysis and the depth of results.
Since: smallcheck-0.6
class Monad m => Testable (m :: Type -> Type) a where Source #
Class of tests that can be run in a monad. For pure tests, it is
recommended to keep their types polymorphic in m rather than
specialising it to Identity.
Since: smallcheck-1.0
Instances
| Monad m => Testable m Bool | |
| (Monad m, m ~ n) => Testable n (Property m) | |
| Monad m => Testable m (Either Reason Reason) | Works like the
Since: smallcheck-1.1 |
| (Serial m a, Show a, Testable m b) => Testable m (a -> b) | |
Defined in Test.SmallCheck.Property | |
data Property (m :: Type -> Type) Source #
The type of properties over the monad m.
Since: smallcheck-1.0
(==>) :: forall (m :: Type -> Type) c a. (Testable m c, Testable m a) => c -> a -> Property m infixr 0 Source #
over :: forall a (m :: Type -> Type) b. (Show a, Testable m b) => Series m a -> (a -> b) -> Property m Source #
over s $ \x -> p xx range over the Series s (by
default, all variables range over the series for their types).
Note that, unlike the quantification operators, this affects only the variable following the operator and not subsequent variables.
over does not affect the quantification context.
Since: smallcheck-1.0
forAll :: forall (m :: Type -> Type) a. Testable m a => a -> Property m Source #
Set the universal quantification context.
Since: smallcheck-1.0
exists :: forall (m :: Type -> Type) a. Testable m a => a -> Property m Source #
Set the existential quantification context.
Since: smallcheck-1.0
existsUnique :: forall (m :: Type -> Type) a. Testable m a => a -> Property m Source #
Set the uniqueness quantification context.
Bear in mind that \( \exists! x, y\colon p\, x \, y \) is not the same as \( \exists! x \colon \exists! y \colon p \, x \, y \).
For example, \( \exists! x \colon \exists! y \colon |x| = |y| \) is true (it holds only when \(x=y=0\)), but \( \exists! x, y \colon |x| = |y| \) is false (there are many such pairs).
As is customary in mathematics,
existsUnique $ \x y -> p x yexistsUnique $ \(x, y) -> p x yexistsUnique $ \x -> existsUnique $ \y -> p x y
That is, all the variables affected by the same uniqueness context are quantified simultaneously as a tuple.
Since: smallcheck-1.0
changeDepth :: forall (m :: Type -> Type) a. Testable m a => (Depth -> Depth) -> a -> Property m Source #
Run property with a modified depth. Affects all quantified variables in the property.
Since: smallcheck-1.0
changeDepth1 :: forall a (m :: Type -> Type) b. (Show a, Serial m a, Testable m b) => (Depth -> Depth) -> (a -> b) -> Property m Source #
Quantify the function's argument over its series, but adjust the
depth. This doesn't affect any subsequent variables.
Since: smallcheck-1.0