| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Test.HUnitPlus.Base
Contents
Description
Basic definitions for the HUnitPlus library.
This module contains what you need to create assertions and test cases and combine them into test suites.
The assertion and test definition operators are the same as those found in the HUnit library. However, an important note is that the behavior of assertions in HUnit-Plus differs from those in HUnit. HUnit-Plus assertions do not stop executing a test if they fail, and are designed so that multiple assertions can be made by a single test. HUnit-Plus contains several "abort" functions, which can be used to terminate a test immediately.
HUnit-Plus test execution handles exceptions. An uncaught exception will cause the test to report an error (along with any failures and/or errors that have occurred so far), and test execution and reporting will continue.
The data structures for describing tests are the same as those in
the Distribution.TestSuite module used by cabal's testing
facilities. This allows for easy interfacing with cabal's
detailed testing scheme.
This gives rise to a grid possible use cases: creating a test using
the HUnit-Plus facilities vs. executing an existing
Distribution.TestSuite test which was not created by the
facilities in this module, and executing a test with HUnit-Plus vs
executing it with another test framework. The executeTest
function is designed to cope with either possible origin of a test,
and the Testable instances are designed to produce tests which
work as expected in either possible execution environment.
- data Test :: *
- = Test TestInstance
- | Group {
- groupName :: String
- concurrently :: Bool
- groupTests :: [Test]
- | ExtraOptions [OptionDescr] Test
- data TestInstance :: * = TestInstance {}
- data TestSuite = TestSuite {
- suiteName :: !Text
- suiteConcurrently :: !Bool
- suiteOptions :: ![(Text, Text)]
- suiteTests :: ![Test]
- testSuite :: String -> [Test] -> TestSuite
- class Testable t where
- (~=?) :: (Eq a, Show a) => a -> a -> Test
- (~?=) :: (Eq a, Show a) => a -> a -> Test
- (~:) :: Testable t => String -> t -> Test
- (~?) :: Assertable t => t -> String -> Test
- type Assertion = IO ()
- assertSuccess :: Assertion
- assertFailure :: Text -> Assertion
- abortFailure :: Text -> Assertion
- abortError :: Text -> Assertion
- assertBool :: Text -> Bool -> Assertion
- assertString :: String -> Assertion
- assertStringWithPrefix :: Text -> String -> Assertion
- assertEqual :: (Eq a, Show a) => Text -> a -> a -> Assertion
- assertThrows :: (Exception e, Show e) => (e -> Assertion) -> IO a -> Assertion
- assertThrowsExact :: (Exception e, Show e, Eq e) => e -> IO a -> Assertion
- class Assertable t where
- (@=?) :: (Eq a, Show a) => a -> a -> Assertion
- (@?=) :: (Eq a, Show a) => a -> a -> Assertion
- (@?) :: Assertable t => t -> String -> Assertion
- heartbeat :: IO ()
- executeTest :: Reporter us -> State -> us -> IO Progress -> IO (Double, State, us)
- logSyserr :: Text -> IO ()
- logSysout :: Text -> IO ()
- logAssert :: IO ()
- logFailure :: Text -> IO ()
- logError :: Text -> IO ()
- withPrefix :: Text -> IO () -> IO ()
- getErrors :: IO (Maybe Text)
- getFailures :: IO (Maybe Text)
Test Definition
Constructors
| Test TestInstance | |
| Group | |
Fields
| |
| ExtraOptions [OptionDescr] Test | |
data TestInstance :: * #
Constructors
| TestInstance | |
Fields
| |
Definition for a test suite. This is intended to be a top-level
(ie. non-nestable) container for tests. Test suites have a name, a
list of options with default values (which can be overridden either
at runtime or statically using ExtraOptions), and a set of
Tests to be run.
Individual tests are described using definitions found in cabal's Distribution.TestSuite module, to allow for straightforward integration with cabal testing facilities.
Constructors
| TestSuite | |
Fields
| |
Create a test suite from a name and a list of tests.
Extended Test Creation
class Testable t where Source #
Provides a way to convert data into a Test or set of Test.
Minimal complete definition
Methods
testNameTags :: String -> [String] -> t -> Test Source #
Create a test with a given name and tag set from a Testable value
testName :: String -> t -> Test Source #
Create a test with a given name and no tags from a Testable value
testTags :: [String] -> t -> Test Source #
Create a test with a given name and no tags from a Testable value
Create a test with a synthetic name and no tags from a Testable value
Shorthand for a test case that asserts equality (with the expected value on the left-hand side, and the actual value on the right-hand side).
Shorthand for a test case that asserts equality (with the actual value on the left-hand side, and the expected value on the right-hand side).
Arguments
| :: Assertable t | |
| => t | A value of which the asserted condition is predicated |
| -> String | A message that is displayed on test failure |
| -> Test |
Creates a test case resulting from asserting the condition obtained
from the specified AssertionPredicable.
Assertions
assertSuccess :: Assertion Source #
Signal that an assertion succeeded. This will log that an assertion has been made.
Unconditionally signal that a failure has occurred. This will not stop execution, but will record the failure, resulting in a failed test.
abortFailure :: Text -> Assertion Source #
Signal that a failure has occurred and stop the test immediately. Note that if an error has been logged already, the test will be reported as an error.
abortError :: Text -> Assertion Source #
Signal than an error has occurred and stop the test immediately.
Arguments
| :: Text | The message that is displayed if the assertion fails |
| -> Bool | The condition |
| -> Assertion |
Asserts that the specified condition holds.
Signals an assertion failure if a non-empty message (i.e., a message
other than "") is passed.
assertStringWithPrefix Source #
Arguments
| :: Text | Prefix to attach to the string if not null |
| -> String | String to assert is null |
| -> Assertion |
Signals an assertion failure if a non-empty message (i.e., a
message other than "") is passed. Allows a prefix to be
supplied for the assertion failure message.
Arguments
| :: (Eq a, Show a) | |
| => Text | The message prefix |
| -> a | The expected value |
| -> a | The actual value |
| -> Assertion |
Asserts that the specified actual value is equal to the expected value. The output message will contain the prefix, the expected value, and the actual value.
If the prefix is the empty string (i.e., ""), then the prefix is omitted
and only the expected and actual values are output.
Arguments
| :: (Exception e, Show e) | |
| => (e -> Assertion) | Exception to be caught |
| -> IO a | Computation that should throw the exception |
| -> Assertion |
Assert that the given computation throws an exception that matches a predicate.
Arguments
| :: (Exception e, Show e, Eq e) | |
| => e | Exception to be caught |
| -> IO a | Computation that should throw the exception |
| -> Assertion |
Assert that the given computation throws a specific exception.
Extended Assertion Functionality
class Assertable t where Source #
Allows the extension of the assertion mechanism.
Since an Assertion can be a sequence of Assertions and IO
actions, there is a fair amount of flexibility of what can be
achieved. As a rule, the resulting Assertion should not assert
multiple, independent conditions.
If more complex arrangements of assertions are needed, Tests and
Testable should be used.
Minimal complete definition
Methods
assertWithMsg :: String -> t -> Assertion Source #
Assertion with a failure message
assert :: t -> Assertion Source #
Assertion with no failure message
Instances
| Assertable Bool Source # | |
| Assertable () Source # | |
| Assertable Progress Source # | |
| Assertable Result Source # | |
| ListAssertable t => Assertable [t] Source # | |
| Assertable t => Assertable (IO t) Source # | |
Asserts that the specified actual value is equal to the expected value (with the expected value on the left-hand side).
Asserts that the specified actual value is equal to the expected value (with the actual value on the left-hand side).
Arguments
| :: Assertable t | |
| => t | A value of which the asserted condition is predicated |
| -> String | A message that is displayed if the assertion fails |
| -> Assertion |
Shorthand for assertBool.
Low-level Test Functions
Arguments
| :: Reporter us | The reporter to use for reporting results. |
| -> State | The HUnit internal state. |
| -> us | The reporter state. |
| -> IO Progress | The test to run. |
| -> IO (Double, State, us) |
Does the actual work of executing a test. This maintains the necessary bookkeeping recording assertions and failures, It also sets up exception handlers and times the test.
logFailure :: Text -> IO () Source #
Record a failure, along with a message.