{-# LANGUAGE ScopedTypeVariables, RankNTypes #-}

import ModP

import Test.QuickCheck
import Test.Framework
import Test.Framework.Providers.QuickCheck2
import Data.Int (Int64)

main = defaultMain tests

testOptions = TestOptions { topt_seed = Nothing
                          , topt_maximum_generated_tests = Just 10000
                          , topt_maximum_unsuitable_generated_tests = Just 100000
                          , topt_timeout = Nothing
                          }

tests = [ plusTestOptions testOptions $ testGroup "basics"
          [ testProperty "add" prop_add
          , testProperty "sub" prop_sub
          , testProperty "mul" prop_mul
          , testProperty "pow2" prop_pow2
          , testProperty "inv" prop_inv
          , testProperty "int64" prop_int64
          ]
        ]

prop_add :: Integer -> Integer -> Positive Integer -> Bool
prop_add x y (Positive n) = (fromInteger x + fromInteger y) `modP` n == (x + y) `mod` n

prop_sub :: Integer -> Integer -> Positive Integer -> Bool
prop_sub x y (Positive n) = (fromInteger x - fromInteger y) `modP` n == (x - y) `mod` n

prop_mul :: Integer -> Integer -> Positive Integer -> Bool
prop_mul x y (Positive n) = (fromInteger x * fromInteger y) `modP` n == (x * y) `mod` n

prop_pow2 :: Integer -> NonNegative Integer -> Positive Integer -> Bool
prop_pow2 x (NonNegative y) (Positive n) = (fromInteger x ^ y) `modP` n == (x ^ y) `mod` n

prop_inv :: Integer -> Positive Integer -> Property
prop_inv x (Positive n) = gcd (abs x) n == 1 && n > 1 ==> ((1 / fromInteger x) `modP` n) * x `mod` n == 1

prop_int64 :: Integer -> Bool
prop_int64 n = n <= 0 || (2 ^ n) `modP` (10^9+7 :: Int64) == fromInteger ((2 ^ n) `mod` (10^9+7))