Module

Test.QuickCheck

Package: purescript-quickcheck
Repository: purescript/purescript-quickcheck

This module is a partial port of the Haskell QuickCheck library.

QuickCheck provides a way to write property-based tests.

The Arbitrary and CoArbitrary type classes allow us to create random data with which we can run our tests. This module provides instances of both classes for PureScript's core data structures, as well as functions for writing new instances.

Test suites can use the quickCheck and quickCheckPure functions to test properties.

For example:

main = quickCheck \n -> n + 1 > n

#QC Source

type QC eff a = Eff (console :: CONSOLE, exception :: EXCEPTION, random :: RANDOM | eff) a

A type synonym which represents the effects used by the quickCheck function.

#quickCheck Source

quickCheck :: forall prop eff. Testable prop => prop -> QC eff Unit

Test a property.

This function generates a new random seed, runs 100 tests and prints the test results to the console.

#quickCheckGen Source

quickCheckGen :: forall prop eff. Testable prop => Gen prop -> QC eff Unit

A version of quickCheck with the property specialized to Gen.

The quickCheckGen variants are useful for writing property tests where a MonadGen constraint (or QuickCheck's Gen directly) is being used, rather than relying on Arbitrary instances. Especially useful for the MonadGen-constrained properties as they will not infer correctly when used with the quickCheck functions unless an explicit type annotation is used.

#quickCheck' Source

quickCheck' :: forall prop eff. Testable prop => Int -> prop -> QC eff Unit

A variant of the quickCheck function which accepts an extra parameter representing the number of tests which should be run.

#quickCheckGen' Source

quickCheckGen' :: forall prop eff. Testable prop => Int -> Gen prop -> QC eff Unit

A version of quickCheck' with the property specialized to Gen.

#quickCheckWithSeed Source

quickCheckWithSeed :: forall prop eff. Testable prop => Seed -> Int -> prop -> QC eff Unit

A variant of the quickCheck' function that accepts a specific seed as well as the number tests that should be run.

#quickCheckGenWithSeed Source

quickCheckGenWithSeed :: forall prop eff. Testable prop => Seed -> Int -> Gen prop -> QC eff Unit

A version of quickCheckWithSeed with the property specialized to Gen.

#quickCheckPure Source

quickCheckPure :: forall prop. Testable prop => Seed -> Int -> prop -> List Result

Test a property, returning all test results as a List.

The first argument is the random seed to be passed to the random generator. The second argument is the number of tests to run.

#quickCheckGenPure Source

quickCheckGenPure :: forall prop. Testable prop => Seed -> Int -> Gen prop -> List Result

A version of quickCheckPure with the property specialized to Gen.

#Testable Source

class Testable prop  where

The Testable class represents testable properties.

A testable property is a function of zero or more Arbitrary arguments, returning a Boolean or Result.

Testable properties can be passed to the quickCheck function.

Members

test :: prop -> Gen Result

Instances

Testable Result
Testable Boolean
(Arbitrary t, Testable prop) => Testable (t -> prop)
(Testable prop) => Testable (Gen prop)

#Result Source

data Result

The result of a test: success or failure (with an error message).

Constructors

Success
Failed String

Instances

Testable Result
Show Result

#withHelp Source

withHelp :: Boolean -> String -> Result

This operator attaches an error message to a failed test.

For example:

test x = myProperty x <?> ("myProperty did not hold for " <> show x)

#(<?>) Source

Operator alias for Test.QuickCheck.withHelp (non-associative / precedence 2)

#assertEquals Source

assertEquals :: forall a. Eq a => Show a => a -> a -> Result

Self-documenting equality assertion

#(===) Source

Operator alias for Test.QuickCheck.assertEquals (non-associative / precedence 2)

#(==?) Source

Operator alias for Test.QuickCheck.assertEquals (non-associative / precedence 2)

#assertNotEquals Source

assertNotEquals :: forall a. Eq a => Show a => a -> a -> Result

Self-documenting inequality assertion

#(/==) Source

Operator alias for Test.QuickCheck.assertNotEquals (non-associative / precedence 2)

#(/=?) Source

Operator alias for Test.QuickCheck.assertNotEquals (non-associative / precedence 2)

#assertLessThan Source

assertLessThan :: forall a. Ord a => Show a => a -> a -> Result

#(<?) Source

Operator alias for Test.QuickCheck.assertLessThan (non-associative / precedence 2)

#assertLessThanEq Source

assertLessThanEq :: forall a. Ord a => Show a => a -> a -> Result

#(<=?) Source

Operator alias for Test.QuickCheck.assertLessThanEq (non-associative / precedence 2)

#assertGreaterThan Source

assertGreaterThan :: forall a. Ord a => Show a => a -> a -> Result

#(>?) Source

Operator alias for Test.QuickCheck.assertGreaterThan (non-associative / precedence 2)

#assertGreaterThanEq Source

assertGreaterThanEq :: forall a. Ord a => Show a => a -> a -> Result

#(>=?) Source

Operator alias for Test.QuickCheck.assertGreaterThanEq (non-associative / precedence 2)

Re-exports from Test.QuickCheck.Arbitrary

#Arbitrary Source

class Arbitrary t  where

The Arbitrary class represents those types whose values can be randomly-generated.

arbitrary uses the Gen monad to express a random generator for the type t. Combinators in the Test.QuickCheck.Gen module can be used to construct random generators.

Members

arbitrary :: Gen t

Instances

Arbitrary Boolean
Arbitrary Number
Arbitrary Int
Arbitrary String
Arbitrary NonEmptyString
Arbitrary Char
Arbitrary Unit
Arbitrary Ordering
(Arbitrary a) => Arbitrary (Array a)
(Arbitrary a) => Arbitrary (NonEmptyArray a)
(Coarbitrary a, Arbitrary b) => Arbitrary (a -> b)
(Arbitrary a, Arbitrary b) => Arbitrary (Tuple a b)
(Arbitrary a) => Arbitrary (Maybe a)
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)
(Arbitrary a) => Arbitrary (List a)
(Arbitrary a) => Arbitrary (Identity a)
(Arbitrary a) => Arbitrary (Lazy a)
(Arbitrary (f a), Arbitrary a) => Arbitrary (NonEmpty f a)
(Arbitrary a) => Arbitrary (NonEmptyList a)
Arbitrary NoArguments
(Arbitrary l, ArbitraryGenericSum r) => Arbitrary (Sum l r)
(Arbitrary l, Arbitrary r) => Arbitrary (Product l r)
(Arbitrary a) => Arbitrary (Constructor s a)
(Arbitrary a) => Arbitrary (Argument a)
(Arbitrary a) => Arbitrary (Rec a)
(Arbitrary a) => Arbitrary (Field s a)
(RowToList row list, ArbitraryRowList list row) => Arbitrary (Record row)

#Coarbitrary Source

class Coarbitrary t  where

The Coarbitrary class represents types which appear on the left of an Arbitrary function arrow.

To construct an Arbitrary instance for the type a -> b, we need to use the input of type a to perturb a random generator for b. This is the role of the coarbitrary function.

Coarbitrary instances can be written using the perturbGen function.

Members

coarbitrary :: forall r. t -> Gen r -> Gen r

Instances

Coarbitrary Boolean
Coarbitrary Number
Coarbitrary Int
Coarbitrary String
Coarbitrary NonEmptyString
Coarbitrary Char
Coarbitrary Unit
Coarbitrary Ordering
(Coarbitrary a) => Coarbitrary (Array a)
(Coarbitrary a) => Coarbitrary (NonEmptyArray a)
(Arbitrary a, Coarbitrary b) => Coarbitrary (a -> b)
(Coarbitrary a, Coarbitrary b) => Coarbitrary (Tuple a b)
(Coarbitrary a) => Coarbitrary (Maybe a)
(Coarbitrary a, Coarbitrary b) => Coarbitrary (Either a b)
(Coarbitrary a) => Coarbitrary (List a)
(Coarbitrary a) => Coarbitrary (Identity a)
(Coarbitrary a) => Coarbitrary (Lazy a)
(Coarbitrary (f a), Coarbitrary a) => Coarbitrary (NonEmpty f a)
(Coarbitrary a) => Coarbitrary (NonEmptyList a)
Coarbitrary NoArguments
(Coarbitrary l, Coarbitrary r) => Coarbitrary (Sum l r)
(Coarbitrary l, Coarbitrary r) => Coarbitrary (Product l r)
(Coarbitrary a) => Coarbitrary (Constructor s a)
(Coarbitrary a) => Coarbitrary (Argument a)
(Coarbitrary a) => Coarbitrary (Rec a)
(Coarbitrary a) => Coarbitrary (Field s a)

Re-exports from Test.QuickCheck.LCG

#Seed Source

newtype Seed

A seed for the linear congruential generator. We omit a Semiring instance because there is no zero value, as 0 is not an acceptable seed for the generator.

Instances

Show Seed
Eq Seed

#runSeed Source

runSeed :: Seed -> Int

#randomSeed Source

randomSeed :: forall e. Eff (random :: RANDOM | e) Seed

Create a random seed

Modules: Test.QuickCheck; Test.QuickCheck.Arbitrary; Test.QuickCheck.Data.AlphaNumString; Test.QuickCheck.Gen; Test.QuickCheck.LCG