module Main where

import Test.SmallCheck
import Test.SmallCheck.Series
import Test.Tasty
import Test.Tasty.SmallCheck

import Data.N  as N
import Data.Q  as Q
import Data.Qp as Qp
import Data.Z  as Z

main :: IO ()
main = defaultMain $ testGroup ""
    [testGroup "N"
     [testProperty "conversion" $ \ a ->
      a == N.toNatural (N.fromNatural a),
      testProperty "comparison" $ \ a b ->
      compare a b == compare (N.fromNatural a :: N) (N.fromNatural b :: N)
     ],
     testGroup "Z"
     [testProperty "conversion" $ \ a ->
      a == toInteger (fromIntegral a :: Z),
      testProperty "comparison" $ \ a b ->
      compare a b == compare (fromInteger a :: Z) (fromInteger b :: Z),
      testProperty "addition" $ \ a b ->
      a + b == toInteger (fromInteger a + fromInteger b :: Z),
      testProperty "subtraction" $ \ a b ->
      a - b == toInteger (fromInteger a - fromInteger b :: Z),
      testProperty "multiplication" $ \ a b ->
      a * b == toInteger (fromInteger a * fromInteger b :: Z)
     ],
     testGroup "Qp"
     [testProperty "conversion" $ \ (Positive a) ->
      a == Qp.toRatio (Qp.fromRatio a),
      testProperty "comparison" $ \ (Positive a) (Positive b) ->
      compare a b == compare (Qp.fromRatio a) (Qp.fromRatio b)
     ],
     testGroup "Q"
     [testProperty "conversion" $ \ a ->
      a == toRational (fromRational a :: Q),
      testProperty "comparison" $ \ a b ->
      compare a b == compare (fromRational a :: Q) (fromRational b :: Q),
      testProperty "addition" $ \ a b ->
      a + b == toRational (fromRational a + fromRational b :: Q),
      testProperty "subtraction" $ \ a b ->
      a - b == toRational (fromRational a - fromRational b :: Q),
      testProperty "multiplication" $ \ a b ->
      a * b == toRational (fromRational a * fromRational b :: Q),
      testProperty "division" $ \ a b ->
      0 /= b ==>
      a / b == toRational (fromRational a / fromRational b :: Q)
     ]
    ]