-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Simple unit test library (or framework)
--   
--   Unit test writing and running with writer monads.
@package torch
@version 0.1

module Test.Torch.Types
class Test t
run :: (Test t, MonadIO io) => t -> io Result
class Failure f
describe :: (Failure f) => f -> FailReason
data Result
Pass :: Result
Fail :: f -> Result
type FailReason = String
data SomeTest
SomeTest :: t -> SomeTest
type Tests = [SomeTest]
data SomeFailure
SomeFailure :: f -> SomeFailure
type Failures = [SomeFailure]
data Report
Report :: Int -> Int -> Int -> Failures -> Report
planed :: Report -> Int
passed :: Report -> Int
failed :: Report -> Int
failures :: Report -> Failures
data Hook
Hook :: IO () -> (SomeFailure -> IO ()) -> (Tests -> IO ()) -> (Report -> IO ()) -> Hook
hook_Pass :: Hook -> IO ()
hook_Fail :: Hook -> SomeFailure -> IO ()
hook_Pre :: Hook -> Tests -> IO ()
hook_Post :: Hook -> Report -> IO ()

module Test.Torch.Types.Instances
data Ok
Ok :: Bool -> Ok
data Is
Is :: Bool -> a -> a -> Is
data Named
Named :: String -> t -> Named
data IsBottom
IsBottom :: Bool -> a -> IsBottom
data SimpleFailure
SimpleFailure :: SimpleFailure
data UnexpectedValue
UnexpectedValue :: Bool -> a -> a -> UnexpectedValue
data Bottom
Bottom :: SomeException -> Bottom
instance Failure SomeFailure
instance Failure Bottom
instance Failure NamedFailure
instance Failure UnexpectedValue
instance Failure SimpleFailure
instance Test IsBottom
instance Test Named
instance Test Is
instance Test Ok

module Test.Torch.Build
addTest :: (Test t) => t -> Builder ()
getTests :: Builder a -> IO Tests
ok :: Bool -> String -> Builder ()

-- | <a>ok</a> and <a>notOk</a> are test for assertion, take a Bool value,
--   and then check whether the value is equal to True or False.
--   
--   <pre>
--   ok    True  "'ok' succeeds if given value is True"
--   notOk False "'notOk' succeeds if given value is False"
--   </pre>
--   
--   Second String argument is the test's name, this is used for telling
--   you what test failed if test was failed usually (and every predefined
--   tests in this module, requires test's name).
notOk :: Bool -> String -> Builder ()
is :: (Eq a, Show a) => a -> a -> String -> Builder ()

-- | <a>is</a> and <a>isn't</a> are test for equality. First argument is
--   treated as gotten value, and second is expected value.
--   
--   <pre>
--   is    1 1 "test that checks 1 == 1"
--   isn't 1 2 "test that checks 1 /= 2"
--   is (fact 10) 3628800 "check if factorial function works..."
--   </pre>
isn't :: (Eq a, Show a) => a -> a -> String -> Builder ()
isBottom :: (NFData a) => a -> String -> Builder ()

-- | <a>isBottom</a> and <a>isn'tBottom</a> evaluates given value, and
--   check if it is Bottom (undefined, error, or some exeptions).
--   
--   <pre>
--   isBottom undefined "for example, this test succeeds"
--   </pre>
isn'tBottom :: (NFData a) => a -> String -> Builder ()
data Builder a
runBuilder :: Builder a -> WriterT Tests IO a
instance Monad Builder
instance MonadIO Builder
instance MonadWriter Tests Builder

module Test.Torch.Hook
asHook :: HookWriter a -> Hook
onPass :: IO () -> HookWriter ()
onFail :: (SomeFailure -> IO ()) -> HookWriter ()
beforeTest :: (Tests -> IO ()) -> HookWriter ()
afterTest :: (Report -> IO ()) -> HookWriter ()
zeroHook :: Hook
instance Monad HookWriter
instance MonadWriter Hook HookWriter
instance Monoid Hook

module Test.Torch.Report
data Report
Report :: Int -> Int -> Int -> Failures -> Report
planed :: Report -> Int
passed :: Report -> Int
failed :: Report -> Int
failures :: Report -> Failures
makeReportWithHook :: (MonadIO io) => Tests -> Hook -> io Report
zeroHook :: Hook

module Test.Torch.Run

-- | <a>run</a> takes a builder (do block contains some tests such as is or
--   notOk), and build test from builder, run it, and report to stdout.
--   
--   You can define your own <a>run</a>, see <a>makeReportWithHook</a>.
run :: Builder a -> IO ()


-- | Test.Torch is a simple library (or framework) for unit test.
--   
--   As Library:
--   
--   I assume You want to implement a function that can't find way to test
--   using QuickCheck because for example return type is wrapped by IO or
--   some monads, but for some arguments, you know collect return values.
--   It is time to use Test.Torch. let its function like this:
--   
--   <pre>
--   f :: Int -&gt; IO Bool
--   f n = some_complecated_process
--   </pre>
--   
--   And you know that <tt>f 1</tt> is same as <tt>return True</tt>, and
--   <tt>f 0</tt> is same as <tt>return False</tt>.
--   
--   You can write unit test monadic way (this monad is acutually Writer
--   monad, and Tests are treated as Monoid).
--   
--   <pre>
--   test_for_f = do
--     b &lt;- liftIO $ f 1 -- you can do IO Action in test using liftIO
--     ok b "f 1 is same as return True"
--     b' &lt;- liftIO $ f 0
--     notOk b' "f 2 is same as return False"
--   </pre>
--   
--   Then run it.
--   
--   <pre>
--   test = run test_for_f
--   </pre>
--   
--   Test report is displayed to terminal. If second test failed,
--   
--   <pre>
--   Running 2 tests.
--   .f
--   1 test(s) failed.
--   f 2 is same as return False: failed.
--   </pre>
--   
--   This output means that <tt>f 2</tt> returned True.
--   
--   If all tests are passed,
--   
--   <pre>
--   Running 2 tests.
--   ..
--   Ok, All tests passed.
--   </pre>
--   
--   Output this.
--   
--   As Framework:
--   
--   If you think this is not a good format, You can improve output format.
--   define some <a>Hook</a>, call it with your test by
--   <a>makeReportWithHook</a>. <a>Hook</a> also has monadic interface.
--   
--   And you can also create your own test constructor, with defining
--   <a>Test</a>, <a>Failure</a>, and some <a>Builder</a>.
module Test.Torch
ok :: Bool -> String -> Builder ()

-- | <a>ok</a> and <a>notOk</a> are test for assertion, take a Bool value,
--   and then check whether the value is equal to True or False.
--   
--   <pre>
--   ok    True  "'ok' succeeds if given value is True"
--   notOk False "'notOk' succeeds if given value is False"
--   </pre>
--   
--   Second String argument is the test's name, this is used for telling
--   you what test failed if test was failed usually (and every predefined
--   tests in this module, requires test's name).
notOk :: Bool -> String -> Builder ()
is :: (Eq a, Show a) => a -> a -> String -> Builder ()

-- | <a>is</a> and <a>isn't</a> are test for equality. First argument is
--   treated as gotten value, and second is expected value.
--   
--   <pre>
--   is    1 1 "test that checks 1 == 1"
--   isn't 1 2 "test that checks 1 /= 2"
--   is (fact 10) 3628800 "check if factorial function works..."
--   </pre>
isn't :: (Eq a, Show a) => a -> a -> String -> Builder ()
isBottom :: (NFData a) => a -> String -> Builder ()

-- | <a>isBottom</a> and <a>isn'tBottom</a> evaluates given value, and
--   check if it is Bottom (undefined, error, or some exeptions).
--   
--   <pre>
--   isBottom undefined "for example, this test succeeds"
--   </pre>
isn'tBottom :: (NFData a) => a -> String -> Builder ()

-- | <a>run</a> takes a builder (do block contains some tests such as is or
--   notOk), and build test from builder, run it, and report to stdout.
--   
--   You can define your own <a>run</a>, see <a>makeReportWithHook</a>.
run :: Builder a -> IO ()