content: {-# LANGUAGE OverloadedStrings #-}
  {-# LANGUAGE ScopedTypeVariables #-}
  {-# LANGUAGE PackageImports #-}
  {-# LANGUAGE TemplateHaskell #-}
  
  module Snap.Snaplet.Internal.RST.Tests
    ( tests ) where
  
  import           Control.Applicative
  import           Control.Monad.Identity
  import           Control.Monad.Reader
  import           Control.Monad.State
  import           Prelude hiding (catch, (.))
  import           Test.Framework
  import           Test.Framework.Providers.HUnit
  import           Test.Framework.Providers.QuickCheck2
  import           Test.HUnit hiding (Test, path)
  
  import           Snap.Snaplet.Internal.RST
  
  
  tests :: Test
  tests = testGroup "Snap.Snaplet.Internal.RST"
      [ testExec
      , testEval
      , testFail
      , testAlternative
      ]
  
  
  testEval :: Test
  testEval = testProperty "RST/execRST" prop
    where
      prop x = runIdentity (evalRST m x undefined) == x
      m :: RST Int () Identity Int
      m = ask
  
  testExec :: Test
  testExec = testProperty "RST/execRST" prop
    where
      prop x = runIdentity (execRST m undefined x) == x
      m :: RST () Int Identity Int
      m = get
  
  testFail :: Test
  testFail = testCase "RST/fail" $
      assertEqual "RST fail" rstFail Nothing
  
  testAlternative :: Test
  testAlternative = testCase "RST/Alternative" $ do
      assertEqual "Alternative instance" rstAlt (Just (5, 1))
      assertEqual "Alternative instance" rstAlt2 (Just (5, 1))
  
  addEnv :: Monad m => RST Int Int m ()
  addEnv = do
      v <- ask
      modify (+v)
  
  rstAlt :: Maybe (Int, Int)
  rstAlt = runRST (addEnv >> (empty <|> (return 5))) 1 0
  
  rstAlt2 :: Maybe (Int, Int)
  rstAlt2 = runRST (addEnv >> ((return 5) <|> empty)) 1 0
  
  rstFail :: Maybe Int
  rstFail = evalRST (fail "foo") (0 :: Int) (0 :: Int)
  
  