--------------------------------------------------------------------------------
-- | Simple tests for applicative laws of the Result type
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TypeSynonymInstances       #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Text.Digestive.Field.QTests
       ( tests
       ) where


--------------------------------------------------------------------------------
import           Test.Framework                       (Test, testGroup)
import           Test.Framework.Providers.QuickCheck2 (testProperty)
import           Test.QuickCheck                      hiding (Result, Success)


--------------------------------------------------------------------------------
import           Text.Digestive.Types


--------------------------------------------------------------------------------
import           Control.Applicative
import           Control.Monad


--------------------------------------------------------------------------------
tests :: Test
tests = testGroup "Text.Digestive.Field.QTests"
        [
           testProperty "Applicative identity for Result"
             prop_resappid
          ,testProperty "Applicative compositionality for Result"
             prop_resappcomp
        ]


--------------------------------------------------------------------------------
instance (Arbitrary v, Arbitrary a) => Arbitrary (Result a v) where
  arbitrary = oneof [liftM Success arbitrary, liftM Error arbitrary]


--------------------------------------------------------------------------------
-- Eq instance for convenience
instance (Eq a, Eq v) => Eq (Result a v)
   where (Success a) == (Success a') = a == a'
         (Error v)   == (Error v')   = v == v'
         _           == _            = False

--------------------------------------------------------------------------------
type ResFunc a = Result [Int] a


--------------------------------------------------------------------------------
instance Show (Int -> Int)
   where show _ = ""


--------------------------------------------------------------------------------
-- Identity (pure id <*> f == f)
prop_resappid :: Result [Int] Int -> Bool
prop_resappid f = (pure id <*> f) == f


--------------------------------------------------------------------------------
-- Compositionality (pure (.) <*> u <*> v <*> w == u<*>(v<*>w))
prop_resappcomp  ::  ResFunc (Int -> Int) -> ResFunc (Int -> Int) ->
                     Result [Int] (Int) -> Bool
prop_resappcomp u v w = (pure (.) <*> u <*> v <*> w) == (u <*> (v <*> w))