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
- = forall i r t . Testlike i r t => Test TestName t
- | TestGroup TestName [Test]
- | PlusTestOptions TestOptions Test
- testGroup :: TestName -> [Test] -> Test
- plusTestOptions :: TestOptions -> 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
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
forall i r t . Testlike i r t => Test TestName t | A single test of some particular type. |
TestGroup TestName [Test] | |
PlusTestOptions TestOptions Test |
plusTestOptions :: TestOptions -> Test -> TestSource
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