Safe Haskell | Safe-Infered |
---|

This module exports everything that you need to be able to create your own framework test provider. To create a provider you need to:

- Create an instance of the
`Testlike`

class - Create an instance of the
`TestResultlike`

class - Expose a function that lets people construct
`Test`

values using your new instances

- class (Show i, Show r) => TestResultlike i r | r -> i where
- testSucceeded :: r -> Bool

- class TestResultlike i r => Testlike i r t | t -> i r, r -> i where
- runTest :: CompleteTestOptions -> t -> IO (i :~> r, IO ())
- testTypeName :: t -> TestTypeName

- type TestName = String
- type TestTypeName = String
- data Test
- testGroup :: TestName -> [Test] -> Test
- plusTestOptions :: TestOptions -> Test -> Test
- buildTest :: IO Test -> Test
- data MutuallyExcluded t = ME (MVar ()) t
- mutuallyExclusive :: Test -> Test
- data i :~> f
- bimapImproving :: (a -> c) -> (b -> d) -> (a :~> b) -> c :~> d
- improvingLast :: (a :~> b) -> b
- consumeImproving :: (a :~> b) -> [a :~> b]
- data ImprovingIO i f a
- yieldImprovement :: i -> ImprovingIO i f ()
- runImprovingIO :: ImprovingIO i f f -> IO (i :~> f, IO ())
- liftIO :: IO a -> ImprovingIO i f a
- timeoutImprovingIO :: Int -> ImprovingIO i f a -> ImprovingIO i f (Maybe a)
- maybeTimeoutImprovingIO :: Maybe Int -> ImprovingIO i f a -> ImprovingIO i f (Maybe a)
- module Test.Framework.Options
- module Test.Framework.Seed
- newtype K a = K {
- unK :: a

- secondsToMicroseconds :: Num a => a -> a
- microsecondsToPicoseconds :: Num a => a -> a
- listToMaybeLast :: [a] -> Maybe a
- mappendBy :: Monoid b => (a -> b) -> a -> a -> b
- orElse :: Maybe a -> a -> a
- onLeft :: (a -> c) -> (a, b) -> (c, b)
- onRight :: (b -> c) -> (a, b) -> (a, c)
- unlinesConcise :: [String] -> String
- mapAccumLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])
- padRight :: Int -> String -> String
- dropLast :: Int -> [a] -> [a]

# Documentation

class (Show i, Show r) => TestResultlike i r | r -> i whereSource

Something like the result of a test: works in concert with `Testlike`

.
The type parameters are the type that is used for progress reports and the
type of the final output of the test respectively.

testSucceeded :: r -> BoolSource

class TestResultlike i r => Testlike i r t | t -> i r, r -> i whereSource

Something test-like in its behaviour. The type parameters are the type that is used for progress reports, the type of the final output of the test and the data type encapsulating the whole potential to do a test respectively.

runTest :: CompleteTestOptions -> t -> IO (i :~> r, IO ())Source

testTypeName :: t -> TestTypeNameSource

Testlike i r t => Testlike i r (MutuallyExcluded t) |

type TestTypeName = StringSource

The name of a type of test, such as Properties or Test Cases. Tests of types of the same names will be grouped together in the test run summary.

Main test data type: builds up a list of tests to be run. Users should use the
utility functions in e.g. the test-framework-hunit and test-framework-quickcheck
packages to create instances of `Test`

, and then build them up into testsuites
by using `testGroup`

and lists.

For an example of how to use test-framework, please see http://github.com/batterseapower/test-framework/raw/master/example/Test/Framework/Example.lhs

plusTestOptions :: TestOptions -> Test -> TestSource

Add some options to child tests

mutuallyExclusive :: Test -> TestSource

Mark all tests in this portion of the tree as mutually exclusive, so only one runs at a time

bimapImproving :: (a -> c) -> (b -> d) -> (a :~> b) -> c :~> dSource

improvingLast :: (a :~> b) -> bSource

consumeImproving :: (a :~> b) -> [a :~> b]Source

data ImprovingIO i f a Source

Monad (ImprovingIO i f) | |

Functor (ImprovingIO i f) |

yieldImprovement :: i -> ImprovingIO i f ()Source

runImprovingIO :: ImprovingIO i f f -> IO (i :~> f, IO ())Source

liftIO :: IO a -> ImprovingIO i f aSource

timeoutImprovingIO :: Int -> ImprovingIO i f a -> ImprovingIO i f (Maybe a)Source

Given a number of microseconds and an improving IO action, run that improving IO action only
for at most the given period before giving up. See also `timeout`

.

maybeTimeoutImprovingIO :: Maybe Int -> ImprovingIO i f a -> ImprovingIO i f (Maybe a)Source

As `timeoutImprovingIO`

, but don't bother applying a timeout to the action if `Nothing`

is given
as the number of microseconds to apply the time out for.

module Test.Framework.Options

module Test.Framework.Seed

secondsToMicroseconds :: Num a => a -> aSource

microsecondsToPicoseconds :: Num a => a -> aSource

listToMaybeLast :: [a] -> Maybe aSource

unlinesConcise :: [String] -> StringSource

mapAccumLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])Source