Test.LeanCheck.Basic

This module is part of LeanCheck, a simple enumerative property-based testing library.

This module exports Test.LeanCheck.Core along with:

• support for Listable 6-tuples up to 12-tuples;
• tiers constructors (consN) with arities from 6 up to 12;
• a Listable Word instance;
• a Listable Ratio instance (consequently Listable Rational);
• a Listable Complex instance;
• Listable 'Int81632/64' instances;
• Listable 'Word81632/64' instances;
• Listable instances for Foreign.C types;
• a Listable ExitCode instance;
• a Listable GeneralCategory instance;
• Listable 'BufferIOSeekMode' instances;
• the operators addWeight and ofWeight.

The above includes all types defined in the Haskell 2010 Report with the exception of Array, IO, Handle, HandlePosn, IOErrorType.

Test.LeanCheck already exports everything from this module. You are probably better off importing it.

You should only import Test.LeanCheck.Basic if you only want the above basic functionality.

Documentation

module Test.LeanCheck.Core

cons6 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f) => (a -> b -> c -> d -> e -> f -> g) -> [[g]]

Returns tiers of applications of a 6-argument constructor.

cons7 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g) => (a -> b -> c -> d -> e -> f -> g -> h) -> [[h]]

Returns tiers of applications of a 7-argument constructor.

cons8 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => (a -> b -> c -> d -> e -> f -> g -> h -> i) -> [[i]]

Returns tiers of applications of a 8-argument constructor.

cons9 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> [[j]]

Returns tiers of applications of a 9-argument constructor.

cons10 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> [[k]]

Returns tiers of applications of a 10-argument constructor.

cons11 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l) -> [[l]]

Returns tiers of applications of a 11-argument constructor.

cons12 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m) -> [[m]]

Returns tiers of applications of a 12-argument constructor.

ofWeight :: [[a]] -> Int -> [[a]]

Resets the weight of a constructor or tiers.

> [ [], [], ..., xs, ys, zs, ... ] `ofWeight` 1
[ [], xs, ys, zs, ... ]

> [ xs, ys, zs, ... ] `ofWeight` 2
[ [], [], xs, ys, zs, ... ]

> [ [], xs, ys, zs, ... ] `ofWeight` 3
[ [], [], [], xs, ys, zs, ... ]

Typically used as an infix operator when defining Listable instances:

instance Listable <Type> where
  tiers  =  ...
         \/ cons<N> <Cons>  `ofWeight`  <W>
         \/ ...

Warning: do not apply `ofWeight` 0 to recursive data structure constructors. In general this will make the list of size 0 infinite, breaking the tier invariant (each tier must be finite).

`ofWeight` n is equivalent to reset followed by n applications of delay.

addWeight :: [[a]] -> Int -> [[a]]

Adds to the weight of a constructor or tiers.

instance Listable <Type> where
  tiers  =  ...
         \/ cons<N> <Cons>  `addWeight`  <W>
         \/ ...

Typically used as an infix operator when defining Listable instances:

> [ xs, ys, zs, ... ] `addWeight` 1
[ [], xs, ys, zs, ... ]

> [ xs, ys, zs, ... ] `addWeight` 2
[ [], [], xs, ys, zs, ... ]

> [ [], xs, ys, zs, ... ] `addWeight` 3
[ [], [], [], [], xs, ys, zs, ... ]

`addWeight` n is equivalent to n applications of delay.

Orphan instances

Listable CBool

Methods

tiers :: [[CBool]]

list :: [CBool]

Listable CChar

Methods

tiers :: [[CChar]]

list :: [CChar]

Listable CClock

Methods

tiers :: [[CClock]]

list :: [CClock]

Listable CDouble

Methods

tiers :: [[CDouble]]

list :: [CDouble]

Listable CFloat

Methods

tiers :: [[CFloat]]

list :: [CFloat]

Listable CInt

Methods

tiers :: [[CInt]]

list :: [CInt]

Listable CIntMax

Methods

tiers :: [[CIntMax]]

list :: [CIntMax]

Listable CIntPtr

Methods

tiers :: [[CIntPtr]]

list :: [CIntPtr]

Listable CLLong

Methods

tiers :: [[CLLong]]

list :: [CLLong]

Listable CLong

Methods

tiers :: [[CLong]]

list :: [CLong]

Listable CPtrdiff

Methods

tiers :: [[CPtrdiff]]

list :: [CPtrdiff]

Listable CSChar

Methods

tiers :: [[CSChar]]

list :: [CSChar]

Listable CSUSeconds

Methods

tiers :: [[CSUSeconds]]

list :: [CSUSeconds]

Listable CShort

Methods

tiers :: [[CShort]]

list :: [CShort]

Listable CSigAtomic

Methods

tiers :: [[CSigAtomic]]

list :: [CSigAtomic]

Listable CSize

Methods

tiers :: [[CSize]]

list :: [CSize]

Listable CTime

Methods

tiers :: [[CTime]]

list :: [CTime]

Listable CUChar

Methods

tiers :: [[CUChar]]

list :: [CUChar]

Listable CUInt

Methods

tiers :: [[CUInt]]

list :: [CUInt]

Listable CUIntMax

Methods

tiers :: [[CUIntMax]]

list :: [CUIntMax]

Listable CUIntPtr

Methods

tiers :: [[CUIntPtr]]

list :: [CUIntPtr]

Listable CULLong

Methods

tiers :: [[CULLong]]

list :: [CULLong]

Listable CULong

Methods

tiers :: [[CULong]]

list :: [CULong]

Listable CUSeconds

Methods

tiers :: [[CUSeconds]]

list :: [CUSeconds]

Listable CUShort

Methods

tiers :: [[CUShort]]

list :: [CUShort]

Listable CWchar

Methods

tiers :: [[CWchar]]

list :: [CWchar]

Listable SeekMode

Methods

tiers :: [[SeekMode]]

list :: [SeekMode]

Listable ExitCode

Only includes valid POSIX exit codes

> list :: [ExitCode]
[ExitSuccess, ExitFailure 1, ExitFailure 2, ..., ExitFailure 255]

Methods

tiers :: [[ExitCode]]

list :: [ExitCode]

Listable BufferMode

Methods

tiers :: [[BufferMode]]

list :: [BufferMode]

Listable IOMode

Methods

tiers :: [[IOMode]]

list :: [IOMode]

Listable Int16

list :: [Int16]  =  [0, 1, -1, 2, -2, ..., 32767, -32767, -32768]

Methods

tiers :: [[Int16]]

list :: [Int16]

Listable Int32

list :: [Int32]  =  [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Methods

tiers :: [[Int32]]

list :: [Int32]

Listable Int64

list :: [Int64]  =  [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Methods

tiers :: [[Int64]]

list :: [Int64]

Listable Int8

list :: [Int8]  =  [0, 1, -1, 2, -2, 3, -3, ..., 127, -127, -128]

Methods

tiers :: [[Int8]]

list :: [Int8]

Listable GeneralCategory

Methods

tiers :: [[GeneralCategory]]

list :: [GeneralCategory]

Listable Word16

list :: [Word16]  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ..., 65535]

Methods

tiers :: [[Word16]]

list :: [Word16]

Listable Word32

list :: [Word32]  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Methods

tiers :: [[Word32]]

list :: [Word32]

Listable Word64

list :: [Word64]  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Methods

tiers :: [[Word64]]

list :: [Word64]

Listable Word8

list :: [Word8]  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ..., 255]

Methods

tiers :: [[Word8]]

list :: [Word8]

Listable Word

list :: [Word]  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Methods

tiers :: [[Word]]

list :: [Word]

(RealFloat a, Listable a) => Listable (Complex a)

Methods

tiers :: [[Complex a]]

list :: [Complex a]

(Integral a, Listable a) => Listable (Ratio a)

list :: [Rational]  =
  [   0  % 1
  ,   1  % 1
  , (-1) % 1
  ,   1  % 2,   2  % 1
  , (-1) % 2, (-2) % 1
  ,   1  % 3,   3  % 1
  , (-1) % 3, (-3) % 1
  ,   1  % 4,   2  % 3,   3  % 2,   4  % 1
  , (-1) % 4, (-2) % 3, (-3) % 2, (-4) % 1
  ,   1  % 5,   5  % 1
  , (-1) % 5, (-5) % 1
  , ...
  ]

Methods

tiers :: [[Ratio a]]

list :: [Ratio a]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f) => Listable (a, b, c, d, e, f)

Methods

tiers :: [[(a, b, c, d, e, f)]]

list :: [(a, b, c, d, e, f)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g) => Listable (a, b, c, d, e, f, g)

Methods

tiers :: [[(a, b, c, d, e, f, g)]]

list :: [(a, b, c, d, e, f, g)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => Listable (a, b, c, d, e, f, g, h)

Methods

tiers :: [[(a, b, c, d, e, f, g, h)]]

list :: [(a, b, c, d, e, f, g, h)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => Listable (a, b, c, d, e, f, g, h, i)

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i)]]

list :: [(a, b, c, d, e, f, g, h, i)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => Listable (a, b, c, d, e, f, g, h, i, j)

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j)]]

list :: [(a, b, c, d, e, f, g, h, i, j)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => Listable (a, b, c, d, e, f, g, h, i, j, k)

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j, k)]]

list :: [(a, b, c, d, e, f, g, h, i, j, k)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => Listable (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j, k, l)]]

list :: [(a, b, c, d, e, f, g, h, i, j, k, l)]