test-framework-0.3.2: Framework for running and organising tests, with HUnit and QuickCheck supportSource codeContentsIndex
Test.Framework.Providers.API
Description

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
Synopsis
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
= Finished f
| Improving i (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.
Methods
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.
Methods
runTest :: CompleteTestOptions -> t -> IO (i :~> r, IO ())Source
testTypeName :: t -> TestTypeNameSource
type TestName = StringSource
Test names or descriptions. These are shown to the user
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.
data Test Source

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

Constructors
forall i r t . Testlike i r t => Test TestName tA single test of some particular type.
TestGroup TestName [Test]
PlusTestOptions TestOptions Test
testGroup :: TestName -> [Test] -> TestSource
Assemble a number of tests into a cohesive group
plusTestOptions :: TestOptions -> Test -> TestSource
data i :~> f Source
Constructors
Finished f
Improving i (i :~> f)
show/hide Instances
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
show/hide Instances
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
newtype K a Source
Constructors
K
unK :: a
secondsToMicroseconds :: Num a => a -> aSource
microsecondsToPicoseconds :: Num a => a -> aSource
listToMaybeLast :: [a] -> Maybe aSource
mappendBy :: Monoid b => (a -> b) -> a -> a -> bSource
orElse :: Maybe a -> a -> aSource
onLeft :: (a -> c) -> (a, b) -> (c, b)Source
onRight :: (b -> c) -> (a, b) -> (a, c)Source
unlinesConcise :: [String] -> StringSource

Like unlines, but does not append a trailing newline if there is at least one line. For example:

 unlinesConcise ["A", "B"] == "A\nB"
 unlinesConcise [] == ""

Whereas:

 unlines ["A", "B"] == "A\nB\n"
 unlines [] == ""

This is closer to the behaviour of unwords, which does not append a trailing space.

mapAccumLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y])Source
padRight :: Int -> String -> StringSource
dropLast :: Int -> [a] -> [a]Source
Produced by Haddock version 2.4.2