Safe Haskell	Safe-Inferred
Language	Haskell2010

EasyTest

Synopsis

data Status
- = Failed
- | Passed !Int
- | Skipped
- | Pending
combineStatus :: Status -> Status -> Status
data Env = Env {
- rng :: TVar StdGen
- messages :: String
- results :: TBQueue (Maybe (TMVar (String, Status)))
- note_ :: String -> IO ()
- allow :: String
}
newtype Test a = Test (ReaderT Env IO (Maybe a))
io :: IO a -> Test a
atomicLogger :: IO (String -> IO ())
expect' :: HasCallStack => Bool -> Test ()
expect :: HasCallStack => Bool -> Test ()
expectEqual' :: (HasCallStack, Eq a, Show a) => a -> a -> Test ()
expectEqual :: (HasCallStack, Eq a, Show a) => a -> a -> Test ()
expectNotEqual :: (HasCallStack, Eq a, Show a) => a -> a -> Test ()
expectJust :: HasCallStack => Maybe a -> Test a
expectRight :: HasCallStack => Either e a -> Test a
expectLeft :: HasCallStack => Either e a -> Test e
tests :: [Test ()] -> Test ()
runOnly :: String -> Test a -> IO ()
rerunOnly :: Int -> String -> Test a -> IO ()
run :: Test a -> IO ()
rerun :: Int -> Test a -> IO ()
run' :: Int -> (String -> IO ()) -> String -> Test a -> IO ()
scope :: String -> Test a -> Test a
note :: String -> Test ()
note' :: Show s => s -> Test ()
random :: Random a => Test a
random' :: Random a => a -> a -> Test a
bool :: Test Bool
word8 :: Test Word8
char :: Test Char
int :: Test Int
double :: Test Double
word :: Test Word
int' :: Int -> Int -> Test Int
char' :: Char -> Char -> Test Char
double' :: Double -> Double -> Test Double
word' :: Word -> Word -> Test Word
word8' :: Word8 -> Word8 -> Test Word8
pick :: [a] -> Test a
picker :: Int -> [a] -> Int -> Maybe a
listOf :: Int -> Test a -> Test [a]
listsOf :: [Int] -> Test a -> Test [[a]]
pair :: Test a -> Test b -> Test (a, b)
tuple2 :: (Random a, Random b) => Test (a, b)
tuple3 :: (Random a, Random b, Random c) => Test (a, b, c)
tuple4 :: (Random a, Random b, Random c, Random d) => Test (a, b, c, d)
mapOf :: Ord k => Int -> Test k -> Test v -> Test (Map k v)
mapsOf :: Ord k => [Int] -> Test k -> Test v -> Test [Map k v]
wrap :: Test a -> Test a
runWrap :: Env -> ReaderT Env IO (Maybe a) -> IO (Maybe a)
using :: IO r -> (r -> IO ()) -> (r -> Test a) -> Test a
currentScope :: Test String
noteScoped :: String -> Test ()
ok :: Test ()
done :: Test a
skip :: Test ()
crash :: HasCallStack => String -> Test a
nologging :: HasCallStack => Test a -> Test a
attempt :: Test a -> Test (Maybe a)
pending :: HasCallStack => Test a -> Test a
putResult :: Status -> ReaderT Env IO ()
fork :: Test a -> Test ()
fork' :: Test a -> Test (Test a)

Documentation

data Status Source #

Constructors

Failed
Passed !Int
Skipped
Pending

combineStatus :: Status -> Status -> Status Source #

data Env Source #

Constructors

Env
Fields rng :: TVar StdGen messages :: String results :: TBQueue (Maybe (TMVar (String, Status))) note_ :: String -> IO () allow :: String

Instances

Instances details

MonadReader Env Test Source #
Instance details Defined in EasyTest Methods ask :: Test Env # local :: (Env -> Env) -> Test a -> Test a # reader :: (Env -> a) -> Test a #

newtype Test a Source #

Constructors

Test (ReaderT Env IO (Maybe a))

Instances

Instances details

MonadFail Test Source #
Instance details Defined in EasyTest Methods fail :: String -> Test a #
MonadIO Test Source #
Instance details Defined in EasyTest Methods liftIO :: IO a -> Test a #
Alternative Test Source #
Instance details Defined in EasyTest Methods empty :: Test a # (<\|>) :: Test a -> Test a -> Test a # some :: Test a -> Test [a] # many :: Test a -> Test [a] #
Applicative Test Source #
Instance details Defined in EasyTest Methods pure :: a -> Test a # (<>) :: Test (a -> b) -> Test a -> Test b # liftA2 :: (a -> b -> c) -> Test a -> Test b -> Test c # (>) :: Test a -> Test b -> Test b # (<*) :: Test a -> Test b -> Test a #
Functor Test Source #
Instance details Defined in EasyTest Methods fmap :: (a -> b) -> Test a -> Test b # (<$) :: a -> Test b -> Test a #
Monad Test Source #
Instance details Defined in EasyTest Methods (>>=) :: Test a -> (a -> Test b) -> Test b # (>>) :: Test a -> Test b -> Test b # return :: a -> Test a #
MonadPlus Test Source #
Instance details Defined in EasyTest Methods mzero :: Test a # mplus :: Test a -> Test a -> Test a #
MonadCatch Test Source #
Instance details Defined in EasyTest Methods catch :: (HasCallStack, Exception e) => Test a -> (e -> Test a) -> Test a #
MonadThrow Test Source #
Instance details Defined in EasyTest Methods throwM :: (HasCallStack, Exception e) => e -> Test a #
MonadReader Env Test Source #
Instance details Defined in EasyTest Methods ask :: Test Env # local :: (Env -> Env) -> Test a -> Test a # reader :: (Env -> a) -> Test a #

io :: IO a -> Test a Source #

atomicLogger :: IO (String -> IO ()) Source #

expect' :: HasCallStack => Bool -> Test () Source #

expect :: HasCallStack => Bool -> Test () Source #

expectEqual' :: (HasCallStack, Eq a, Show a) => a -> a -> Test () Source #

expectEqual :: (HasCallStack, Eq a, Show a) => a -> a -> Test () Source #

expectNotEqual :: (HasCallStack, Eq a, Show a) => a -> a -> Test () Source #

expectJust :: HasCallStack => Maybe a -> Test a Source #

expectRight :: HasCallStack => Either e a -> Test a Source #

expectLeft :: HasCallStack => Either e a -> Test e Source #

tests :: [Test ()] -> Test () Source #

runOnly :: String -> Test a -> IO () Source #

Run all tests whose scope starts with the given prefix

rerunOnly :: Int -> String -> Test a -> IO () Source #

Run all tests with the given seed and whose scope starts with the given prefix

run :: Test a -> IO () Source #

rerun :: Int -> Test a -> IO () Source #

run' :: Int -> (String -> IO ()) -> String -> Test a -> IO () Source #

scope :: String -> Test a -> Test a Source #

Label a test. Can be nested. A `.` is placed between nested scopes, so `scope "foo" . scope "bar"` is equivalent to `scope "foo.bar"`

note :: String -> Test () Source #

Log a message

note' :: Show s => s -> Test () Source #

Log a showable value

random :: Random a => Test a Source #

Generate a random value

random' :: Random a => a -> a -> Test a Source #

Generate a bounded random value. Inclusive on both sides.

bool :: Test Bool Source #

word8 :: Test Word8 Source #

char :: Test Char Source #

Generate a random Char

int :: Test Int Source #

Generate a random Int

double :: Test Double Source #

Generate a random Double

word :: Test Word Source #

Generate a random Word

int' :: Int -> Int -> Test Int Source #

Generate a random Int in the given range Note: int 0 5` includes both `0` and `5`

char' :: Char -> Char -> Test Char Source #

Generate a random Char in the given range Note: char a z' includes both `a' and `z'.

double' :: Double -> Double -> Test Double Source #

Generate a random Double in the given range Note: double 0 1` includes both `0` and `1`.

word' :: Word -> Word -> Test Word Source #

Generate a random Double in the given range Note: word 0 10` includes both `0` and `10`.

word8' :: Word8 -> Word8 -> Test Word8 Source #

Generate a random Double in the given range Note: word8 0 10` includes both `0` and `10`.

pick :: [a] -> Test a Source #

Sample uniformly from the given list of possibilities

picker :: Int -> [a] -> Int -> Maybe a Source #

listOf :: Int -> Test a -> Test [a] Source #

Alias for replicateM

listsOf :: [Int] -> Test a -> Test [[a]] Source #

Generate a list of lists of the given sizes, an alias for `sizes forM n -> listOf n gen`

pair :: Test a -> Test b -> Test (a, b) Source #

Alias for `liftA2 (,)`.

tuple2 :: (Random a, Random b) => Test (a, b) Source #

Alias for pair.

tuple3 :: (Random a, Random b, Random c) => Test (a, b, c) Source #

Generate a random 3-tuple.

tuple4 :: (Random a, Random b, Random c, Random d) => Test (a, b, c, d) Source #

Generate a random 4-tuple.

mapOf :: Ord k => Int -> Test k -> Test v -> Test (Map k v) Source #

Generate a `Data.Map k v` of the given size.

mapsOf :: Ord k => [Int] -> Test k -> Test v -> Test [Map k v] Source #

Generate a `[Data.Map k v]` of the given sizes.

wrap :: Test a -> Test a Source #

Catch all exceptions that could occur in the given Test

runWrap :: Env -> ReaderT Env IO (Maybe a) -> IO (Maybe a) Source #

using :: IO r -> (r -> IO ()) -> (r -> Test a) -> Test a Source #

A test with a setup and teardown

currentScope :: Test String Source #

The current scope

noteScoped :: String -> Test () Source #

Prepend the current scope to a logging message

ok :: Test () Source #

Record a successful test at the current scope

done :: Test a Source #

Skip any tests depending on the return value.

skip :: Test () Source #

Explicitly skip this test

crash :: HasCallStack => String -> Test a Source #

Record a failure at the current scope

nologging :: HasCallStack => Test a -> Test a Source #

Overwrites the env so that note_ (the logger) is a no op

attempt :: Test a -> Test (Maybe a) Source #

Run a test under a new scope, without logs and suppressing all output

pending :: HasCallStack => Test a -> Test a Source #

Placeholder wrapper for a failing test. The test being wrapped is expected/known to fail. Will produce a failure if the test being wrapped suddenly becomes a success.

putResult :: Status -> ReaderT Env IO () Source #

fork :: Test a -> Test () Source #

Run a test in a separate thread, not blocking for its result.

fork' :: Test a -> Test (Test a) Source #

Run a test in a separate thread, return a future which can be used to block on its result.