mod-0.1.0.0: test/Test.hs

{-# LANGUAGE CPP       #-}
{-# LANGUAGE DataKinds #-}

{-# OPTIONS_GHC -fno-warn-orphans #-}

module Main where

import Data.Mod
import Data.Proxy
import Test.Tasty
import Test.Tasty.QuickCheck
import Test.QuickCheck.Classes.Base

#ifdef MIN_VERSION_semirings
import Data.Semiring (Ring)
import Test.QuickCheck.Classes
#endif

#if MIN_VERSION_base(4,11,0)
import GHC.TypeNats hiding (Mod)
#elif MIN_VERSION_base(4,10,0)
import GHC.TypeNats
#else
import GHC.TypeLits
#endif

main :: IO ()
main = defaultMain $ testGroup "All"
  [ testGroup "Mod 1" $
    map lawsToTest $ laws1 (Proxy :: Proxy (Mod 1))
  , testGroup "Mod 2310" $
    map lawsToTest $ laws (Proxy :: Proxy (Mod 2310))
  , testGroup "Mod 18446744073709551626" $
    map lawsToTest $ laws (Proxy :: Proxy (Mod 18446744073709551626))
  , testGroup "Mod 123456789012345678901234567890" $
    map lawsToTest $ laws (Proxy :: Proxy (Mod 123456789012345678901234567890))
  ]

#ifdef MIN_VERSION_semirings
laws1 :: (Eq a, Ord a, Show a, Num a, Ring a, Arbitrary a) => Proxy a -> [Laws]
#else
laws1 :: (Eq a, Ord a, Show a, Num a, Arbitrary a) => Proxy a -> [Laws]
#endif
laws1 p =
    [ eqLaws          p
    , ordLaws         p
    , numLaws         p
    , showLaws        p
#ifdef MIN_VERSION_semirings
    , semiringLaws    p
    , ringLaws        p
#endif
    ]

#ifdef MIN_VERSION_semirings
laws :: (Eq a, Ord a, Show a, Num a, Ring a, Enum a, Bounded a, Arbitrary a) => Proxy a -> [Laws]
#else
laws :: (Eq a, Ord a, Show a, Num a, Enum a, Bounded a, Arbitrary a) => Proxy a -> [Laws]
#endif
laws p = boundedEnumLaws p : laws1 p

lawsToTest :: Laws -> TestTree
lawsToTest (Laws name props) =
  testGroup name $ map (uncurry testProperty) props

instance KnownNat m => Arbitrary (Mod m) where
  arbitrary = oneof [arbitraryBoundedEnum, fromInteger <$> arbitrary]