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


-- | A set of assertion for writing more readable tests cases
--   
--   Please see the README on GitHub at
--   <a>https://github.com/paweln1986/assert4hs#readme</a>
@package assert4hs-core
@version 0.1.0


-- | This module provide an assertion for check if expected Exception has
--   been throw by IO action.
module Test.Fluent.Assertions.Exceptions

-- | Select all exceptions.
anyException :: ExceptionSelector SomeException

-- | Select all IOException.
anyIOException :: ExceptionSelector IOException

-- | Select all an Exception of given type. This selector should be used
--   with <tt>TypeApplications</tt>
--   
--   <pre>
--   data MyException = ThisException | ThatException
--    deriving (Show)
--   
--   instance Exception MyException
--   
--   selectMyException = exceptionType @MyException
--   </pre>
exceptionOfType :: Exception e => ExceptionSelector e
type ExceptionSelector a = a -> a

module Test.Fluent.Diff
pretty :: Show a => a -> a -> String

module Test.Fluent.Internal.AssertionConfig
newtype AssertionConfig
AssertionConfig :: Int -> AssertionConfig
[assertionTimeout] :: AssertionConfig -> Int

-- | Default configuration used for <tt>assertThat</tt> and
--   <tt>assertThatIO</tt>. - default timeout is set to 5 seconds
defaultConfig :: AssertionConfig

-- | Allow to modify timeout of single assertion
setAssertionTimeout :: Int -> AssertionConfig -> AssertionConfig
instance GHC.Show.Show Test.Fluent.Internal.AssertionConfig.AssertionConfig


-- | This library aims to provide a set of combinators to assert arbitrary
--   nested data structures. The inspiration of this library is AssertJ for
--   Java, the composition of assertions was inspired by <tt>lens</tt>
--   library.
--   
--   Example:
--   
--   <pre>
--   data Foo = Foo {name :: String, age :: Int} deriving (Show, Eq)
--   
--   assertThat (Foo "someName" 15) $
--        isEqualTo (Foo "someN1ame" 15)
--        . focus age
--        . tag "age"
--        . isGreaterThan 20
--   </pre>
--   
--   result in
--   
--   <pre>
--   given Foo {name = "someName", age = 15} should be equal to Foo {name = "someN1ame", age = 15}
--   Foo {name = "someName", age = 15}
--   ╷
--   │
--   ╵
--   Foo {name = "someN1ame", age = 15}
--                     ▲
--   [age] given 15 should be greater than 20
--   </pre>
module Test.Fluent.Assertions

-- | The <a>simpleAssertion</a> function is a building block of more
--   complicated assertions.
--   
--   It takes one predicate and function to format error message.
--   
--   <pre>
--   myIsEqual x = simpleAssertion (== x) (\x' -&gt; show x' &lt;&gt; " is not equal to " &lt;&gt; show x)
--   </pre>
simpleAssertion :: HasCallStack => (a -> Bool) -> (a -> String) -> Assertion a

-- | assert if subject under test is equal to given value
--   
--   <pre>
--   assertThat 15 $ isEqualTo 16
--   </pre>
--   
--   result
--   
--   <pre>
--   given 15 should be equal to 16
--    ▼
--   15
--   ╷
--   │
--   ╵
--   16
--    ▲
--   </pre>
isEqualTo :: (Eq a, Show a, HasCallStack) => a -> Assertion a
isNotEqualTo :: (Eq a, Show a, HasCallStack) => a -> Assertion a

-- | assert if the subject under test is greater than given value
--   
--   <pre>
--   assertThat 15 $ isGreaterThan 16
--   </pre>
--   
--   result
--   
--   <pre>
--   given 15 should be greater than 16
--   </pre>
isGreaterThan :: (Ord a, Show a, HasCallStack) => a -> Assertion a
isGreaterEqualThan :: (Ord a, Show a, HasCallStack) => a -> Assertion a

-- | assert if the subject under test is lower than given value
--   
--   <pre>
--   assertThat 16 $ isLowerThan 15
--   </pre>
--   
--   result
--   
--   <pre>
--   given 16 should be lower than 15
--   </pre>
isLowerThan :: (Ord a, Show a, HasCallStack) => a -> Assertion a
isLowerEqualThan :: (Ord a, Show a, HasCallStack) => a -> Assertion a
shouldSatisfy :: (Show a, HasCallStack) => (a -> Bool) -> Assertion a
hasSize :: (Foldable t, HasCallStack) => Int -> Assertion (t a)
isEmpty :: (Foldable t, HasCallStack) => Assertion (t a)
isNotEmpty :: (Foldable t, HasCallStack) => Assertion (t a)
contains :: (Foldable t, Eq a, Show a, HasCallStack) => a -> Assertion (t a)

-- | allow changing subject under test using a transformation function
--   
--   <pre>
--   assertThat "1    " $
--             isNotEqualTo ""
--               . focus length
--               . isEqualTo 10
--   </pre>
--   
--   result
--   
--   <pre>
--   given 5 should be equal to 10
--   ▼
--   5
--   ╷
--   │
--   ╵
--   10
--   ▲▲
--   </pre>
focus :: (a -> b) -> Assertion' a b

-- | like <a>focus</a>, this function allow changing subject under test, it
--   takes an assertion for modified value, then it allows us to continue
--   assertion on the original value
--   
--   <pre>
--   assertThat (Foo "someName" 15) $
--                 isEqualTo (Foo "someN1ame" 15)
--               . inside age (tag "age" . isGreaterThan 20 . isLowerThan 10)
--               . isEqualTo (Foo "someName" 15)
--   </pre>
--   
--   result
--   
--   <pre>
--   given Foo {name = "someName", age = 15} should be equal to Foo {name = "someN1ame", age = 15}
--         Foo {name = "someName", age = 15}
--         ╷
--         │
--         ╵
--         Foo {name = "someN1ame", age = 15}
--                           ▲
--         [age] given 15 should be greater than 20
--         [age] given 15 should be lower than 10
--   </pre>
inside :: (b -> a) -> Assertion a -> Assertion b

-- | this combinator allows marking following assertion with a given prefix
--   
--   <pre>
--   assertThat (Foo "someName" 15) $
--     tag "foo" . isEqualTo (Foo "someN1ame" 15)
--       . inside age (tag "age" . isGreaterThan 20 . isLowerThan 10)
--       . tag "foo not equal"
--       . isNotEqualTo (Foo "someName" 15)
--   </pre>
--   
--   result
--   
--   <pre>
--   [foo] given Foo {name = "someName", age = 15} should be equal to Foo {name = "someN1ame", age = 15}
--   Foo {name = "someName", age = 15}
--   ╷
--   │
--   ╵
--   Foo {name = "someN1ame", age = 15}
--                     ▲
--   [foo.age] given 15 should be greater than 20
--   [foo.age] given 15 should be lower than 10
--   [foo.not equal to] given Foo {name = "someName", age = 15} should be not equal to Foo {name = "someName", age = 15}
--   Foo {name = "someName", age = 15}
--   ╷
--   │
--   ╵
--   Foo {name = "someName", age = 15}
--   </pre>
tag :: String -> Assertion a

-- | Sometimes it is handy to stop the assertions chain.
--   
--   This combinator gets an assertion that should be forced, any following
--   assertion will be not executed then
--   
--   <pre>
--   extracting :: HasCallStack =&gt; Assertion' (Maybe a) a
--   extracting = forceError isJust . focus Maybe.fromJust
--   </pre>
forceError :: Assertion a -> Assertion a
data AssertionConfig

-- | Default configuration used for <tt>assertThat</tt> and
--   <tt>assertThatIO</tt>. - default timeout is set to 5 seconds
defaultConfig :: AssertionConfig

-- | Allow to modify timeout of single assertion
setAssertionTimeout :: Int -> AssertionConfig -> AssertionConfig
type Assertion a = Assertion' a a
type Assertion' a b = Assertion'' a a b b
data FluentTestFailure
FluentTestFailure :: !Maybe SrcLoc -> ![(String, Maybe SrcLoc)] -> !Int -> !Int -> FluentTestFailure
[srcLoc] :: FluentTestFailure -> !Maybe SrcLoc
[msg] :: FluentTestFailure -> ![(String, Maybe SrcLoc)]
[errorsCount] :: FluentTestFailure -> !Int
[successCount] :: FluentTestFailure -> !Int


-- | This library aims to provide a set of combinators to assert Maybe
--   type.
module Test.Fluent.Assertions.Maybe

-- | assert if subject under is empty
--   
--   <pre>
--   assertThat (Just 10) isNothing
--   </pre>
isNothing :: HasCallStack => Assertion (Maybe a)

-- | assert if subject under is not empty
--   
--   <pre>
--   assertThat (Just 10) isJust
--   </pre>
isJust :: HasCallStack => Assertion (Maybe a)

-- | assert if subject under is not empty and extract contained value
--   
--   <pre>
--   assertThat (Just 10) extracting
--   </pre>
extracting :: HasCallStack => Assertion' (Maybe a) a


-- | This library aims to provide a set of combinators to assert List type.
module Test.Fluent.Assertions.List

-- | assert if given list has same length as expected list
--   
--   <pre>
--   assertThat [1..10] $ shouldHaveSameSizeAs [0..10]
--   </pre>
shouldHaveSameSizeAs :: HasCallStack => [a] -> Assertion [a]

-- | verify if the given list has a length lower or equal to expected value
--   
--   <pre>
--   assertThat [1..10] $ shouldHaveSizeLowerOrEqual 10
--   </pre>
shouldHaveSizeLowerOrEqual :: HasCallStack => Int -> Assertion [a]

-- | verify if the given list has expected prefix
--   
--   <pre>
--   assertThat [1..10] $ shouldStartWith [0..4]
--   </pre>
shouldStartWith :: (Eq a, Show a, HasCallStack) => [a] -> Assertion [a]

-- | verify if the given list does not start with prefix
--   
--   <pre>
--   assertThat [1..10] $ shouldNotStartWith [1..4]
--   </pre>
shouldNotStartWith :: (Eq a, Show a, HasCallStack) => [a] -> Assertion [a]
shouldBeSameAs :: (Eq a, HasCallStack, Show a) => [a] -> Assertion [a]
shouldContain :: (Eq a, HasCallStack, Show a) => a -> Assertion [a]
shouldNotContain :: (Eq a, HasCallStack, Show a) => a -> Assertion [a]

-- | verify if the given list contains same elements as expected list in
--   any order
--   
--   <pre>
--   assertThat [1..10] $ shouldNotStartWith [1..4]
--   </pre>
shouldHaveSameElements :: (HasCallStack, Eq a, Show a) => [a] -> Assertion [a]


-- | This module provide a set of combinators to assert Either type.
module Test.Fluent.Assertions.Either

-- | assert if subject under test is Left
--   
--   <pre>
--   assertThat (Left 10) isLeft
--   </pre>
isLeft :: HasCallStack => Assertion (Either a b)

-- | assert if subject under test is Right
--   
--   <pre>
--   assertThat (Left 10) isRight
--   </pre>
isRight :: HasCallStack => Assertion (Either a b)

-- | assert if subject under test is Right and extract contained value
--   
--   <pre>
--   assertThat (Left 10) extractingRight
--   </pre>
extractingRight :: HasCallStack => Assertion' (Either a b) b

-- | assert if subject under test is Left and extract contained value
--   
--   <pre>
--   assertThat (Left 10) extractingLeft
--   </pre>
extractingLeft :: HasCallStack => Assertion' (Either a b) a

module Test.Fluent.Assertions.Core

-- | Execute assertions against given subject under test.
assertThat :: HasCallStack => a -> Assertion' a b -> IO ()

-- | Execute assertions against given subject under test extracted from IO
--   action.
assertThatIO :: HasCallStack => IO a -> Assertion' a b -> IO ()

-- | A variant of <a>assertThat</a> which allow to pass additional
--   configuration.
assertThat' :: HasCallStack => AssertionConfig -> a -> Assertion' a b -> IO ()

-- | A variant of <a>assertThatIO</a> which allow to pass additional
--   configuration.
assertThatIO' :: HasCallStack => AssertionConfig -> IO a -> Assertion' a c -> IO ()

-- | Execute assertions against selected exception
assertThrown :: (HasCallStack, Exception e) => IO a -> ExceptionSelector e -> Assertion' e b -> IO ()
assertThrown' :: (HasCallStack, Exception e) => AssertionConfig -> IO a -> ExceptionSelector e -> Assertion' e b -> IO ()
assertThrows' :: (HasCallStack, Exception e) => AssertionConfig -> IO a -> ExceptionSelector e -> IO ()

-- | Module : Test.Fluent.Assertions.Core Description : Set util function
--   to execute assertions against given value Copyright : (c) Pawel Nosal,
--   2021 License : MIT Maintainer : p.nosal1986@gmail.com Stability :
--   experimental
--   
--   Verify if given <a>IO</a> action throws expected exception.
assertThrows :: (HasCallStack, Exception e) => IO a -> ExceptionSelector e -> IO ()