content: {-# LANGUAGE CPP       #-}
  {-# LANGUAGE MagicHash #-}
  
  module Main where
  
  import Control.Exception
  import Data.Bit
  import Test.Tasty
  import Test.Tasty.QuickCheck
  
  #ifdef MIN_VERSION_quickcheck_classes_base
  import Data.Proxy
  import Test.QuickCheck.Classes.Base
  import Support
  #endif
  
  import Tests.Conc (concTests)
  import Tests.F2Poly (f2polyTests)
  import Tests.MVector (mvectorTests)
  import qualified Tests.MVectorTS as TS (mvectorTests)
  import Tests.SetOps (setOpTests)
  import qualified Tests.SetOpsTS as TS (setOpTests)
  import Tests.Vector (vectorTests)
  
  main :: IO ()
  main = defaultMain $ testGroup "All"
    [ lawsTests
    , f2polyTests
    , mvectorTests
    , TS.mvectorTests
    , setOpTests
    , TS.setOpTests
    , vectorTests
    , concTests
    ]
  
  lawsTests :: TestTree
  lawsTests = adjustOption (const $ QuickCheckTests 100)
    $ testGroup "Bit"
  #ifdef MIN_VERSION_quickcheck_classes_base
    $ map lawsToTest
    [ bitsLaws        (Proxy :: Proxy Bit)
    , eqLaws          (Proxy :: Proxy Bit)
    , ordLaws         (Proxy :: Proxy Bit)
    , boundedEnumLaws (Proxy :: Proxy Bit)
    , showLaws        (Proxy :: Proxy Bit)
    , showReadLaws    (Proxy :: Proxy Bit)
    , numLaws         (Proxy :: Proxy Bit)
    , integralLaws    (Proxy :: Proxy Bit)
    ] ++
  #endif
    [ testProperty "divideByZero" prop_bitDivideByZero
    , testProperty "toRational"   prop_bitToRational
    ]
  
  prop_bitToRational :: Bit -> Property
  prop_bitToRational x = fromRational (toRational x) === x
  
  prop_bitDivideByZero :: Bit -> Property
  prop_bitDivideByZero x =
    ioProperty ((=== Left DivideByZero) <$> try (evaluate (x / 0)))
  