smallcheck-0.4: Another lightweight testing library in Haskell.

Test.SmallCheck

Documentation

smallCheck :: Testable a => Int -> a -> IO ()

smallCheckI :: Testable a => a -> IO ()

depthCheck :: Testable a => Int -> a -> IO ()

test :: Testable a => a -> IO ()

data Property

Instances

class Testable a

Instances

forAll :: (Show a, Testable b) => Series a -> (a -> b) -> Property

forAllElem :: (Show a, Testable b) => [a] -> (a -> b) -> Property

exists :: (Show a, Serial a, Testable b) => (a -> b) -> Property

existsDeeperBy :: (Show a, Serial a, Testable b) => (Int -> Int) -> (a -> b) -> Property

thereExists :: (Show a, Testable b) => Series a -> (a -> b) -> Property

thereExistsElem :: (Show a, Testable b) => [a] -> (a -> b) -> Property

exists1 :: (Show a, Serial a, Testable b) => (a -> b) -> Property

exists1DeeperBy :: (Show a, Serial a, Testable b) => (Int -> Int) -> (a -> b) -> Property

thereExists1 :: (Show a, Testable b) => Series a -> (a -> b) -> Property

thereExists1Elem :: (Show a, Testable b) => [a] -> (a -> b) -> Property

(==>) :: Testable a => Bool -> a -> Property

type Series a = Int -> [a]

class Serial a where

Methods

series :: Series a

coseries :: Series b -> Series (a -> b)

Instances

Serial Bool 
Serial Char 
Serial Double 
Serial Float 
Serial Int 
Serial Integer 
Serial () 
Serial a => Serial [a] 
Serial a => Serial (Maybe a) 
(Integral a, Serial a) => Serial (N a) 
(Serial a, Serial b) => Serial (a -> b) 
(Serial a, Serial b) => Serial (Either a b) 
(Serial a, Serial b) => Serial (a, b) 
(Serial a, Serial b, Serial c) => Serial (a, b, c) 
(Serial a, Serial b, Serial c, Serial d) => Serial (a, b, c, d) 

(\/) :: Series a -> Series a -> Series a

(><) :: Series a -> Series b -> Series (a, b)

two :: Series a -> Series (a, a)

three :: Series a -> Series (a, a, a)

four :: Series a -> Series (a, a, a, a)

cons0 :: a -> Series a

cons1 :: Serial a => (a -> b) -> Series b

cons2 :: (Serial a, Serial b) => (a -> b -> c) -> Series c

cons3 :: (Serial a, Serial b, Serial c) => (a -> b -> c -> d) -> Series d

cons4 :: (Serial a, Serial b, Serial c, Serial d) => (a -> b -> c -> d -> e) -> Series e

alts0 :: Series a -> Series a

alts1 :: Serial a => Series b -> Series (a -> b)

alts2 :: (Serial a, Serial b) => Series c -> Series (a -> b -> c)

alts3 :: (Serial a, Serial b, Serial c) => Series d -> Series (a -> b -> c -> d)

alts4 :: (Serial a, Serial b, Serial c, Serial d) => Series e -> Series (a -> b -> c -> d -> e)

newtype N a

Constructors

N a 

Instances

Eq a => Eq (N a) 
Ord a => Ord (N a) 
Show a => Show (N a) 
(Integral a, Serial a) => Serial (N a) 

type Nat = N Int

depth :: Int -> Int -> Int

inc :: Int -> Int

dec :: Int -> Int