Test.Simple

Test.Simple is yet another testing library for Haskell. It has testing primitives familiar to recovering Perl programmers :).

Having MonadPlus instance allows to cut tests early e.g using guard function.

Being monad transformer it includes integration with QuickCheck by declaring Testable instance on TestSimpleT Gen a.

Test.Simple also has the ability to run in pure context (see runTestSimple function).

Here is an example suitable for cabal test-suite integration. Note that TemplateHaskell usage is optional and is needed for test failure locations only.

{-# LANGUAGE TemplateHaskell #-}

import Test.Simple
import Control.Monad

main :: IO ()
main = testSimpleMain $ do
          plan 7
          ok True
          is 1 1
          isnt "a" "b"
          like "abcd" "bc"
          unlike "a" "b"
          diag "Successful so far, failures follow ..."
          $loc >> ok False -- location will be recorded
          is "a" "b" >>= guard
          diag "I am not being called" -- not reached because of the guard: MonadPlus FTW!
 

Types

data TestSimpleT m a

Test.Simple is implemented as monad transformer.

Instances

MonadTrans TestSimpleT

(Monad m, Functor m) => Alternative (TestSimpleT m)

Monad m => Monad (TestSimpleT m)

Functor m => Functor (TestSimpleT m)

Monad m => MonadPlus (TestSimpleT m)

(Monad m, Functor m) => Applicative (TestSimpleT m)

MonadIO m => MonadIO (TestSimpleT m)

Testable (TestSimpleT (PropertyM IO) a)

Testable (TestSimpleT Gen a)

class Likeable a b where

Is used in like, unlike tests.

Methods

isLike :: a -> b -> Bool

Returns True if a is like b

Instances

Eq a => Likeable [a] [a]

Main

testSimpleMain :: MonadIO m => TestSimpleT m a -> m ()

Runs TestSimpleT transformer in IO. Outputs results in TAP format. Exits with error on test failure.

runTestSimple :: Monad m => TestSimpleT m a -> m (Bool, [String])

Runs TestSimpleT transformer. Returns whether the tests where successful and resulting output.

qcTestSimpleWith :: (Testable (m a), Monad m) => (m a -> IO Result) -> m a -> IO ()

Run some Testable monad through QuickCheck function. Exit with failure on error.

qcTestSimpleMain :: (Testable (m a), Monad m) => m a -> IO ()

Run some Testable monad through QuickCheck. Exit with failure on error. Equivalent to qcTestSimpleWith quickCheckResult

Plan

plan :: Monad m => Int -> TestSimpleT m ()

Sets expected number of tests. Running more or less tests is considered failure. Note, that plans are composable, e.g:

(plan 1 >> ok True) >> (plan 1 >> ok True)

will expect 2 tests.

Test functions

ok :: Monad m => Bool -> TestSimpleT m Bool

Is Bool ok?

isnt :: (Eq a, Show a, Monad m) => a -> a -> TestSimpleT m Bool

Are values different?

is :: (Eq a, Show a, Monad m) => a -> a -> TestSimpleT m Bool

Are values equal?

like :: (Show a, Show b, Likeable a b, Monad m) => a -> b -> TestSimpleT m Bool

Is a like b?

unlike :: (Show a, Show b, Likeable a b, Monad m) => a -> b -> TestSimpleT m Bool

Is a unlike b?

isRight :: (Monad m, Show a) => Either a b -> TestSimpleT m Bool

Is Either right?

Diagnostics

loc :: Q Exp

Records current location to output in case of failures. Necessary caveat: failing later without updating location produces the last location recorded.

diag :: Monad m => String -> TestSimpleT m ()

Outputs diagnostics message.

diagen :: Show a => String -> Gen a -> TestSimpleT Gen a

Generates and logs (through diag) arbitrary value. Also outputs current location.