{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Test.Byron.Spec.Ledger.Relation.Properties (testRelation) where

import Byron.Spec.Ledger.Core hiding ((<|))
import Data.Bimap (Bimap)
import qualified Data.Bimap as Bimap
import Data.Map.Strict (Map)
import Data.Set (Set, union, (\\))
import Hedgehog (Gen, MonadTest, Property, PropertyT, forAll, property, withTests, (===))
import qualified Hedgehog.Gen as Gen
import Hedgehog.Internal.Property (PropertyName (..))
import qualified Hedgehog.Range as Range
import Test.Tasty (TestName, TestTree, testGroup)
import Test.Tasty.Hedgehog hiding (testProperty)

-- | testProperty has been deprecated. We make our own version here.
testProperty :: TestName -> Property -> TestTree
testProperty :: TestName -> Property -> TestTree
testProperty TestName
s Property
p = TestName -> PropertyName -> Property -> TestTree
testPropertyNamed TestName
s (TestName -> PropertyName
Hedgehog.Internal.Property.PropertyName TestName
s) Property
p

--------------------------------------------------------------------------------
-- Properties on Relations
--------------------------------------------------------------------------------

-- | (dom r) ∩ s == dom (s ◁ r)
--
--  By restricting the domain of 'Relation r' to 's', the new 'Domain r'
--  is an intersection of the original 'Domain r' with 's'
propDomainRestrictionAndIntersection ::
  (MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
  Set (Domain r) ->
  r ->
  m ()
propDomainRestrictionAndIntersection :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersection Set (Domain r)
s r
r =
  r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom r
r Set (Domain r) -> Set (Domain r) -> Set (Domain r)
forall a. Ord a => Set a -> Set a -> Set a
∩ Set (Domain r)
s Set (Domain r) -> Set (Domain r) -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom (Set (Domain r)
s Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
◁ r
r)

-- | (dom r ∩ s) ◁ r == s ◁ r
--
--  Restricting the domain of 'Relation r' to 's'
--  is the same as restricting the domain to 'dom r ∩ s'.
propDomainRestrictionAndIntersectionB ::
  (MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
  Set (Domain r) ->
  r ->
  m ()
propDomainRestrictionAndIntersectionB :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersectionB Set (Domain r)
s r
r =
  (r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom r
r Set (Domain r) -> Set (Domain r) -> Set (Domain r)
forall a. Ord a => Set a -> Set a -> Set a
∩ Set (Domain r)
s) Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
◁ r
r r -> r -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Set (Domain r)
s Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
◁ r
r

-- | r ▷ (range r ∩ s) == r ▷ s
--
--  By restricting the range of 'Relation r' to 's', the new 'Range r'
--  is an intersection of the original 'Range r' with 's'
propRangeRestrictionAndIntersection ::
  (MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
  Set (Range r) ->
  r ->
  m ()
propRangeRestrictionAndIntersection :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersection Set (Range r)
s r
r =
  r
r r -> Set (Range r) -> r
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m) -> m
▷ (r -> Set (Range r)
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m)
range r
r Set (Range r) -> Set (Range r) -> Set (Range r)
forall a. Ord a => Set a -> Set a -> Set a
∩ Set (Range r)
s) r -> r -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== r
r r -> Set (Range r) -> r
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m) -> m
▷ Set (Range r)
s

-- | (range r) ∩ s == range (r ▷ s)
--
--  By restricting the range of 'Relation r' to 's', the new 'Range r'
--  is an intersection of the original 'Range r' with 's'
propRangeRestrictionAndIntersectionB ::
  (MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
  Set (Range r) ->
  r ->
  m ()
propRangeRestrictionAndIntersectionB :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersectionB Set (Range r)
s r
r =
  (r -> Set (Range r)
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m)
range r
r) Set (Range r) -> Set (Range r) -> Set (Range r)
forall a. Ord a => Set a -> Set a -> Set a
∩ Set (Range r)
s Set (Range r) -> Set (Range r) -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== r -> Set (Range r)
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m)
range (r
r r -> Set (Range r) -> r
forall m. (Relation m, Ord (Range m)) => m -> Set (Range m) -> m
▷ Set (Range r)
s)

-- | (dom r \\ s) ◁ r == s ⋪ r
--
--  Excluding a set 's' from the domain of 'Relation r'
--  is the same as restricting the domain to 'dom r \\ s'.
propDomainExclusionAndSetDifference ::
  (MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
  Set (Domain r) ->
  r ->
  m ()
propDomainExclusionAndSetDifference :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainExclusionAndSetDifference Set (Domain r)
s r
r =
  (r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom r
r Set (Domain r) -> Set (Domain r) -> Set (Domain r)
forall a. Ord a => Set a -> Set a -> Set a
\\ Set (Domain r)
s) Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
◁ r
r r -> r -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Set (Domain r)
s Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
⋪ r
r

-- | (dom r1 ∪ s) ⋪ (r1 ∪ r2) == (dom r1 ∪ s) ⋪ r2
--
--  Excluding 'dom r1 ∪ s' from the domain of 'r1 ∪ r2'
--  is the same as excluding 'dom r1 ∪ s' from the domain of just r2
--  (since 'dom r1 ⋪ r1' gives an empty relation)
propDomainExclusionAndUnion ::
  ( MonadTest m
  , Relation r
  , Eq r
  , Show r
  , Ord (Domain r)
  , Ord (Range r)
  ) =>
  Set (Domain r) ->
  r ->
  r ->
  m ()
propDomainExclusionAndUnion :: forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r),
 Ord (Range r)) =>
Set (Domain r) -> r -> r -> m ()
propDomainExclusionAndUnion Set (Domain r)
s r
r1 r
r2 =
  (r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom r
r1 Set (Domain r) -> Set (Domain r) -> Set (Domain r)
forall a. Ord a => Set a -> Set a -> Set a
`union` Set (Domain r)
s)
    Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
⋪ (r
r1 r -> r -> r
forall m.
(Relation m, Ord (Domain m), Ord (Range m)) =>
m -> m -> m
∪ r
r2)
    r -> r -> m ()
forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (r -> Set (Domain r)
forall m. (Relation m, Ord (Domain m)) => m -> Set (Domain m)
dom r
r1 Set (Domain r) -> Set (Domain r) -> Set (Domain r)
forall a. Ord a => Set a -> Set a -> Set a
`union` Set (Domain r)
s)
      Set (Domain r) -> r -> r
forall m (f :: * -> *).
(Relation m, Ord (Domain m), Foldable f) =>
f (Domain m) -> m -> m
forall (f :: * -> *).
(Ord (Domain r), Foldable f) =>
f (Domain r) -> r -> r
⋪ r
r2

--------------------------------------------------------------------------------
-- Property helpers
--------------------------------------------------------------------------------

propRelation ::
  (Show r, Show (Domain r)) =>
  Gen (Set (Domain r)) ->
  Gen r ->
  (Set (Domain r) -> r -> PropertyT IO ()) ->
  Property
propRelation :: forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set (Domain r))
genS Gen r
genR Set (Domain r) -> r -> PropertyT IO ()
prop =
  TestLimit -> Property -> Property
withTests TestLimit
500 (Property -> Property) -> Property -> Property
forall a b. (a -> b) -> a -> b
$
    HasCallStack => PropertyT IO () -> Property
PropertyT IO () -> Property
property (PropertyT IO () -> Property) -> PropertyT IO () -> Property
forall a b. (a -> b) -> a -> b
$ do
      (Set (Domain r)
s, r
r) <- (,) (Set (Domain r) -> r -> (Set (Domain r), r))
-> PropertyT IO (Set (Domain r))
-> PropertyT IO (r -> (Set (Domain r), r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Set (Domain r)) -> PropertyT IO (Set (Domain r))
forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen (Set (Domain r))
genS PropertyT IO (r -> (Set (Domain r), r))
-> PropertyT IO r -> PropertyT IO (Set (Domain r), r)
forall a b.
PropertyT IO (a -> b) -> PropertyT IO a -> PropertyT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen r -> PropertyT IO r
forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen r
genR
      Set (Domain r) -> r -> PropertyT IO ()
prop Set (Domain r)
s r
r

propRelations ::
  (Show r, Show (Domain r)) =>
  Gen (Set (Domain r)) ->
  Gen r ->
  (Set (Domain r) -> r -> r -> PropertyT IO ()) ->
  Property
propRelations :: forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r
-> (Set (Domain r) -> r -> r -> PropertyT IO ())
-> Property
propRelations Gen (Set (Domain r))
genS Gen r
genR Set (Domain r) -> r -> r -> PropertyT IO ()
prop =
  TestLimit -> Property -> Property
withTests TestLimit
500 (Property -> Property) -> Property -> Property
forall a b. (a -> b) -> a -> b
$
    HasCallStack => PropertyT IO () -> Property
PropertyT IO () -> Property
property (PropertyT IO () -> Property) -> PropertyT IO () -> Property
forall a b. (a -> b) -> a -> b
$ do
      (Set (Domain r)
s, r
r1, r
r2) <- (,,) (Set (Domain r) -> r -> r -> (Set (Domain r), r, r))
-> PropertyT IO (Set (Domain r))
-> PropertyT IO (r -> r -> (Set (Domain r), r, r))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Set (Domain r)) -> PropertyT IO (Set (Domain r))
forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen (Set (Domain r))
genS PropertyT IO (r -> r -> (Set (Domain r), r, r))
-> PropertyT IO r -> PropertyT IO (r -> (Set (Domain r), r, r))
forall a b.
PropertyT IO (a -> b) -> PropertyT IO a -> PropertyT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen r -> PropertyT IO r
forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen r
genR PropertyT IO (r -> (Set (Domain r), r, r))
-> PropertyT IO r -> PropertyT IO (Set (Domain r), r, r)
forall a b.
PropertyT IO (a -> b) -> PropertyT IO a -> PropertyT IO b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen r -> PropertyT IO r
forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen r
genR
      Set (Domain r) -> r -> r -> PropertyT IO ()
prop Set (Domain r)
s r
r1 r
r2

genInt :: Gen Int
genInt :: Gen Int
genInt = Range Int -> Gen Int
forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
100)

genSetOf :: Ord a => Gen a -> Gen (Set a)
genSetOf :: forall a. Ord a => Gen a -> Gen (Set a)
genSetOf Gen a
genA = Range Int -> Gen a -> GenT Identity (Set a)
forall (m :: * -> *) a.
(MonadGen m, Ord a) =>
Range Int -> m a -> m (Set a)
Gen.set Range Int
aRange Gen a
genA

aRange :: Range.Range Int
aRange :: Range Int
aRange = Int -> Int -> Range Int
forall a. a -> a -> Range a
Range.constant Int
0 Int
50

genIntS :: Gen (Set Int)
genIntS :: Gen (Set Int)
genIntS = Gen Int -> Gen (Set Int)
forall a. Ord a => Gen a -> Gen (Set a)
genSetOf Gen Int
genInt

genMap :: Gen (Map Int Int)
genMap :: Gen (Map Int Int)
genMap = Range Int -> GenT Identity (Int, Int) -> Gen (Map Int Int)
forall (m :: * -> *) k v.
(MonadGen m, Ord k) =>
Range Int -> m (k, v) -> m (Map k v)
Gen.map Range Int
aRange (GenT Identity (Int, Int) -> Gen (Map Int Int))
-> GenT Identity (Int, Int) -> Gen (Map Int Int)
forall a b. (a -> b) -> a -> b
$ (,) (Int -> Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int -> (Int, Int))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Int
genInt GenT Identity (Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int, Int)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Int
genInt

genSet :: Gen (Set (Int, Int))
genSet :: Gen (Set (Int, Int))
genSet = GenT Identity (Int, Int) -> Gen (Set (Int, Int))
forall a. Ord a => Gen a -> Gen (Set a)
genSetOf ((,) (Int -> Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int -> (Int, Int))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Int
genInt GenT Identity (Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int, Int)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Int
genInt)

genPairsList :: Gen [(Int, Int)]
genPairsList :: Gen [(Int, Int)]
genPairsList = Range Int -> GenT Identity (Int, Int) -> Gen [(Int, Int)]
forall (m :: * -> *) a. MonadGen m => Range Int -> m a -> m [a]
Gen.list Range Int
aRange ((,) (Int -> Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int -> (Int, Int))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Int
genInt GenT Identity (Int -> (Int, Int))
-> Gen Int -> GenT Identity (Int, Int)
forall a b.
GenT Identity (a -> b) -> GenT Identity a -> GenT Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Int
genInt)

genBimap :: Gen (Bimap Int Int)
genBimap :: Gen (Bimap Int Int)
genBimap = [(Int, Int)] -> Bimap Int Int
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
Bimap.fromList ([(Int, Int)] -> Bimap Int Int)
-> Gen [(Int, Int)] -> Gen (Bimap Int Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [(Int, Int)]
genPairsList

--------------------------------------------------------------------------------
-- Property Tests
--------------------------------------------------------------------------------

testRelation :: TestTree
testRelation :: TestTree
testRelation =
  TestName -> [TestTree] -> TestTree
testGroup
    TestName
"Test Relation instances"
    [ TestName -> [TestTree] -> TestTree
testGroup
        TestName
"Relation - Set"
        [ TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersection"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersectionB"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersectionB)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainExclusionAndSetDifference"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainExclusionAndSetDifference)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersection"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
Set (Range (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersectionB"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
Set (Range (Set (Int, Int))) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersectionB)
        ]
    , TestName -> [TestTree] -> TestTree
testGroup
        TestName
"Relation - Map"
        [ TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersection"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersectionB"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersectionB)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainExclusionAndSetDifference"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainExclusionAndSetDifference)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersection"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ()
Set (Range (Map Int Int)) -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersectionB"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int)) -> Map Int Int -> PropertyT IO ()
Set (Range (Map Int Int)) -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersectionB)
        ]
    , TestName -> [TestTree] -> TestTree
testGroup
        TestName
"Relation - Bimap"
        [ TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersection"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersectionB"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersectionB)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainExclusionAndSetDifference"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainExclusionAndSetDifference)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersection"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
Set (Range (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersectionB"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
Set (Range (Bimap Int Int)) -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersectionB)
        ]
    , TestName -> [TestTree] -> TestTree
testGroup
        TestName
"Relation - Pairs list"
        [ TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersection"
            (Gen (Set (Domain [(Int, Int)]))
-> Gen [(Int, Int)]
-> (Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain [(Int, Int)]))
genIntS Gen [(Int, Int)]
genPairsList Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Domain r), Show (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainRestrictionAndIntersectionB"
            (Gen (Set (Domain [(Int, Int)]))
-> Gen [(Int, Int)]
-> (Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain [(Int, Int)]))
genIntS Gen [(Int, Int)]
genPairsList Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainRestrictionAndIntersectionB)
        , TestName -> Property -> TestTree
testProperty
            TestName
"DomainExclusionAndSetDifference"
            (Gen (Set (Domain [(Int, Int)]))
-> Gen [(Int, Int)]
-> (Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain [(Int, Int)]))
genIntS Gen [(Int, Int)]
genPairsList Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r)) =>
Set (Domain r) -> r -> m ()
propDomainExclusionAndSetDifference)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersection"
            (Gen (Set (Domain [(Int, Int)]))
-> Gen [(Int, Int)]
-> (Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain [(Int, Int)]))
genIntS Gen [(Int, Int)]
genPairsList Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
Set (Range [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersection)
        , TestName -> Property -> TestTree
testProperty
            TestName
"RangeRestrictionAndIntersectionB"
            (Gen (Set (Domain [(Int, Int)]))
-> Gen [(Int, Int)]
-> (Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r -> (Set (Domain r) -> r -> PropertyT IO ()) -> Property
propRelation Gen (Set Int)
Gen (Set (Domain [(Int, Int)]))
genIntS Gen [(Int, Int)]
genPairsList Set (Domain [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
Set (Range [(Int, Int)]) -> [(Int, Int)] -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Ord (Range r), Show (Range r)) =>
Set (Range r) -> r -> m ()
propRangeRestrictionAndIntersectionB)
        ]
    , TestName -> [TestTree] -> TestTree
testGroup
        TestName
"Relations"
        [ TestName -> Property -> TestTree
testProperty
            TestName
"Set instance"
            (Gen (Set (Domain (Set (Int, Int))))
-> Gen (Set (Int, Int))
-> (Set (Domain (Set (Int, Int)))
    -> Set (Int, Int) -> Set (Int, Int) -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r
-> (Set (Domain r) -> r -> r -> PropertyT IO ())
-> Property
propRelations Gen (Set Int)
Gen (Set (Domain (Set (Int, Int))))
genIntS Gen (Set (Int, Int))
genSet Set (Domain (Set (Int, Int)))
-> Set (Int, Int) -> Set (Int, Int) -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r),
 Ord (Range r)) =>
Set (Domain r) -> r -> r -> m ()
propDomainExclusionAndUnion)
        , TestName -> Property -> TestTree
testProperty
            TestName
"Map instance"
            (Gen (Set (Domain (Map Int Int)))
-> Gen (Map Int Int)
-> (Set (Domain (Map Int Int))
    -> Map Int Int -> Map Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r
-> (Set (Domain r) -> r -> r -> PropertyT IO ())
-> Property
propRelations Gen (Set Int)
Gen (Set (Domain (Map Int Int)))
genIntS Gen (Map Int Int)
genMap Set (Domain (Map Int Int))
-> Map Int Int -> Map Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r),
 Ord (Range r)) =>
Set (Domain r) -> r -> r -> m ()
propDomainExclusionAndUnion)
        , TestName -> Property -> TestTree
testProperty
            TestName
"Bimap instance"
            (Gen (Set (Domain (Bimap Int Int)))
-> Gen (Bimap Int Int)
-> (Set (Domain (Bimap Int Int))
    -> Bimap Int Int -> Bimap Int Int -> PropertyT IO ())
-> Property
forall r.
(Show r, Show (Domain r)) =>
Gen (Set (Domain r))
-> Gen r
-> (Set (Domain r) -> r -> r -> PropertyT IO ())
-> Property
propRelations Gen (Set Int)
Gen (Set (Domain (Bimap Int Int)))
genIntS Gen (Bimap Int Int)
genBimap Set (Domain (Bimap Int Int))
-> Bimap Int Int -> Bimap Int Int -> PropertyT IO ()
forall (m :: * -> *) r.
(MonadTest m, Relation r, Eq r, Show r, Ord (Domain r),
 Ord (Range r)) =>
Set (Domain r) -> r -> r -> m ()
propDomainExclusionAndUnion)
        ]
    ]