{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Test.Cardano.Ledger.UMapSpec where

import Cardano.Ledger.BaseTypes (StrictMaybe (SJust, SNothing))
import Cardano.Ledger.Coin (Coin, CompactForm, addCompactCoin)
import Cardano.Ledger.Compactible (fromCompact)
import Cardano.Ledger.Credential (Credential, Ptr)
import Cardano.Ledger.DRep (DRep)
import Cardano.Ledger.Keys (KeyHash, KeyRole (StakePool, Staking))
import Cardano.Ledger.UMap (
  RDPair (RDPair, rdReward),
  StakeCredentials (..),
  UMElem (UMElem),
  UMap (UMap, umElems, umPtrs),
  UView (DRepUView, PtrUView, RewDepUView, SPoolUView),
  compactRewardMap,
  dRepMap,
  delete,
  delete',
  depositMap,
  domRestrict,
  domRestrictedMap,
  domRestrictedStakeCredentials,
  domain,
  empty,
  insert,
  insert',
  invPtrMap,
  member,
  nullUView,
  ptrMap,
  range,
  rdDeposit,
  rdPairMap,
  rewardMap,
  sPoolMap,
  size,
  toStakeCredentials,
  umInvariant,
  unUView,
  unUnify,
  unify,
  (∪),
  (∪+),
  (⋪),
  (⋫),
  (⨃),
 )
import qualified Cardano.Ledger.UMap as UMap (lookup)
import Control.Exception (assert)
import Data.Foldable (Foldable (fold))
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import qualified Data.Set as Set
import Test.Cardano.Ledger.Common
import Test.Cardano.Ledger.Core.Arbitrary (
  genInsertDeleteRoundtripDRep,
  genInsertDeleteRoundtripPtr,
  genInsertDeleteRoundtripRDPair,
  genInsertDeleteRoundtripSPool,
  genInvariantNonEmpty,
  genRightPreferenceUMap,
  genValidTuples,
  genValidUMap,
  genValidUMapWithCreds,
 )

data Action
  = InsertRDPair (Credential 'Staking) RDPair
  | InsertPtr Ptr (Credential 'Staking)
  | InsertSPool (Credential 'Staking) (KeyHash 'StakePool)
  | InsertDRep (Credential 'Staking) DRep
  | DeleteRDPair (Credential 'Staking)
  | DeletePtr Ptr
  | DeleteSPool (Credential 'Staking)
  | DeleteDRep (Credential 'Staking)
  deriving (Int -> Action -> ShowS
[Action] -> ShowS
Action -> String
(Int -> Action -> ShowS)
-> (Action -> String) -> ([Action] -> ShowS) -> Show Action
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Action -> ShowS
showsPrec :: Int -> Action -> ShowS
$cshow :: Action -> String
show :: Action -> String
$cshowList :: [Action] -> ShowS
showList :: [Action] -> ShowS
Show)

instance Arbitrary Action where
  arbitrary :: Gen Action
arbitrary =
    [Gen Action] -> Gen Action
forall a. HasCallStack => [Gen a] -> Gen a
oneof
      [ Credential 'Staking -> RDPair -> Action
InsertRDPair (Credential 'Staking -> RDPair -> Action)
-> Gen (Credential 'Staking) -> Gen (RDPair -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary Gen (RDPair -> Action) -> Gen RDPair -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen RDPair
forall a. Arbitrary a => Gen a
arbitrary
      , Ptr -> Credential 'Staking -> Action
InsertPtr (Ptr -> Credential 'Staking -> Action)
-> Gen Ptr -> Gen (Credential 'Staking -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ptr
forall a. Arbitrary a => Gen a
arbitrary Gen (Credential 'Staking -> Action)
-> Gen (Credential 'Staking) -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary
      , Credential 'Staking -> KeyHash 'StakePool -> Action
InsertSPool (Credential 'Staking -> KeyHash 'StakePool -> Action)
-> Gen (Credential 'Staking) -> Gen (KeyHash 'StakePool -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary Gen (KeyHash 'StakePool -> Action)
-> Gen (KeyHash 'StakePool) -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (KeyHash 'StakePool)
forall a. Arbitrary a => Gen a
arbitrary
      , Credential 'Staking -> Action
DeleteRDPair (Credential 'Staking -> Action)
-> Gen (Credential 'Staking) -> Gen Action
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary
      , Ptr -> Action
DeletePtr (Ptr -> Action) -> Gen Ptr -> Gen Action
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ptr
forall a. Arbitrary a => Gen a
arbitrary
      , Credential 'Staking -> Action
DeleteSPool (Credential 'Staking -> Action)
-> Gen (Credential 'Staking) -> Gen Action
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary
      , Credential 'Staking -> Action
DeleteDRep (Credential 'Staking -> Action)
-> Gen (Credential 'Staking) -> Gen Action
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary
      ]

genRDPair :: Gen Action
genRDPair :: Gen Action
genRDPair = Credential 'Staking -> RDPair -> Action
InsertRDPair (Credential 'Staking -> RDPair -> Action)
-> Gen (Credential 'Staking) -> Gen (RDPair -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary Gen (RDPair -> Action) -> Gen RDPair -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen RDPair
forall a. Arbitrary a => Gen a
arbitrary

genPtr :: Gen Action
genPtr :: Gen Action
genPtr = Ptr -> Credential 'Staking -> Action
InsertPtr (Ptr -> Credential 'Staking -> Action)
-> Gen Ptr -> Gen (Credential 'Staking -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Ptr
forall a. Arbitrary a => Gen a
arbitrary Gen (Credential 'Staking -> Action)
-> Gen (Credential 'Staking) -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary

genSPool :: Gen Action
genSPool :: Gen Action
genSPool = Credential 'Staking -> KeyHash 'StakePool -> Action
InsertSPool (Credential 'Staking -> KeyHash 'StakePool -> Action)
-> Gen (Credential 'Staking) -> Gen (KeyHash 'StakePool -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary Gen (KeyHash 'StakePool -> Action)
-> Gen (KeyHash 'StakePool) -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (KeyHash 'StakePool)
forall a. Arbitrary a => Gen a
arbitrary

genDRep :: Gen Action
genDRep :: Gen Action
genDRep = Credential 'Staking -> DRep -> Action
InsertDRep (Credential 'Staking -> DRep -> Action)
-> Gen (Credential 'Staking) -> Gen (DRep -> Action)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking)
forall a. Arbitrary a => Gen a
arbitrary Gen (DRep -> Action) -> Gen DRep -> Gen Action
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen DRep
forall a. Arbitrary a => Gen a
arbitrary

reify :: Action -> UMap -> UMap
reify :: Action -> UMap -> UMap
reify = \case
  InsertRDPair Credential 'Staking
k RDPair
v -> Credential 'Staking
-> RDPair -> UView (Credential 'Staking) RDPair -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k RDPair
v (UView (Credential 'Staking) RDPair -> UMap)
-> (UMap -> UView (Credential 'Staking) RDPair) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) RDPair
RewDepUView
  InsertPtr Ptr
k Credential 'Staking
v -> Ptr
-> Credential 'Staking -> UView Ptr (Credential 'Staking) -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Ptr
k Credential 'Staking
v (UView Ptr (Credential 'Staking) -> UMap)
-> (UMap -> UView Ptr (Credential 'Staking)) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView Ptr (Credential 'Staking)
PtrUView
  InsertSPool Credential 'Staking
k KeyHash 'StakePool
v -> Credential 'Staking
-> KeyHash 'StakePool
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k KeyHash 'StakePool
v (UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap)
-> (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap
-> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView
  InsertDRep Credential 'Staking
k DRep
v -> Credential 'Staking
-> DRep -> UView (Credential 'Staking) DRep -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k DRep
v (UView (Credential 'Staking) DRep -> UMap)
-> (UMap -> UView (Credential 'Staking) DRep) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) DRep
DRepUView
  DeleteRDPair Credential 'Staking
k -> Credential 'Staking -> UView (Credential 'Staking) RDPair -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) RDPair -> UMap)
-> (UMap -> UView (Credential 'Staking) RDPair) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) RDPair
RewDepUView
  DeletePtr Ptr
k -> Ptr -> UView Ptr (Credential 'Staking) -> UMap
forall k v. k -> UView k v -> UMap
delete Ptr
k (UView Ptr (Credential 'Staking) -> UMap)
-> (UMap -> UView Ptr (Credential 'Staking)) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView Ptr (Credential 'Staking)
PtrUView
  DeleteSPool Credential 'Staking
k -> Credential 'Staking
-> UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap)
-> (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap
-> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView
  DeleteDRep Credential 'Staking
k -> Credential 'Staking -> UView (Credential 'Staking) DRep -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) DRep -> UMap)
-> (UMap -> UView (Credential 'Staking) DRep) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) DRep
DRepUView

reifyRDPair :: Action -> UMap -> UMap
reifyRDPair :: Action -> UMap -> UMap
reifyRDPair = \case
  InsertRDPair Credential 'Staking
k RDPair
v -> Credential 'Staking
-> RDPair -> UView (Credential 'Staking) RDPair -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k RDPair
v (UView (Credential 'Staking) RDPair -> UMap)
-> (UMap -> UView (Credential 'Staking) RDPair) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) RDPair
RewDepUView
  DeleteRDPair Credential 'Staking
k -> Credential 'Staking -> UView (Credential 'Staking) RDPair -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) RDPair -> UMap)
-> (UMap -> UView (Credential 'Staking) RDPair) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) RDPair
RewDepUView
  Action
_ -> UMap -> UMap
forall a. a -> a
id

reifyPtr :: Action -> UMap -> UMap
reifyPtr :: Action -> UMap -> UMap
reifyPtr = \case
  InsertPtr Ptr
k Credential 'Staking
v -> Ptr
-> Credential 'Staking -> UView Ptr (Credential 'Staking) -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Ptr
k Credential 'Staking
v (UView Ptr (Credential 'Staking) -> UMap)
-> (UMap -> UView Ptr (Credential 'Staking)) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView Ptr (Credential 'Staking)
PtrUView
  DeletePtr Ptr
k -> Ptr -> UView Ptr (Credential 'Staking) -> UMap
forall k v. k -> UView k v -> UMap
delete Ptr
k (UView Ptr (Credential 'Staking) -> UMap)
-> (UMap -> UView Ptr (Credential 'Staking)) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView Ptr (Credential 'Staking)
PtrUView
  Action
_ -> UMap -> UMap
forall a. a -> a
id

reifySPool :: Action -> UMap -> UMap
reifySPool :: Action -> UMap -> UMap
reifySPool = \case
  InsertSPool Credential 'Staking
k KeyHash 'StakePool
v -> Credential 'Staking
-> KeyHash 'StakePool
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k KeyHash 'StakePool
v (UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap)
-> (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap
-> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView
  DeleteSPool Credential 'Staking
k -> Credential 'Staking
-> UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap)
-> (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap
-> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView
  Action
_ -> UMap -> UMap
forall a. a -> a
id

reifyDRep :: Action -> UMap -> UMap
reifyDRep :: Action -> UMap -> UMap
reifyDRep = \case
  InsertDRep Credential 'Staking
k DRep
v -> Credential 'Staking
-> DRep -> UView (Credential 'Staking) DRep -> UMap
forall k v. k -> v -> UView k v -> UMap
insert Credential 'Staking
k DRep
v (UView (Credential 'Staking) DRep -> UMap)
-> (UMap -> UView (Credential 'Staking) DRep) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) DRep
DRepUView
  DeleteDRep Credential 'Staking
k -> Credential 'Staking -> UView (Credential 'Staking) DRep -> UMap
forall k v. k -> UView k v -> UMap
delete Credential 'Staking
k (UView (Credential 'Staking) DRep -> UMap)
-> (UMap -> UView (Credential 'Staking) DRep) -> UMap -> UMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UMap -> UView (Credential 'Staking) DRep
DRepUView
  Action
_ -> UMap -> UMap
forall a. a -> a
id

runActions :: [Action] -> UMap -> UMap
runActions :: [Action] -> UMap -> UMap
runActions [Action]
actions UMap
umap = (Action -> UMap -> UMap) -> UMap -> [Action] -> UMap
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Action -> UMap -> UMap
reify UMap
umap [Action]
actions

runRDPairs :: [Action] -> UMap -> UMap
runRDPairs :: [Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
umap = (Action -> UMap -> UMap) -> UMap -> [Action] -> UMap
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Action -> UMap -> UMap
reifyRDPair UMap
umap [Action]
actions

runPtrs :: [Action] -> UMap -> UMap
runPtrs :: [Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
umap = (Action -> UMap -> UMap) -> UMap -> [Action] -> UMap
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Action -> UMap -> UMap
reifyPtr UMap
umap [Action]
actions

runSPools :: [Action] -> UMap -> UMap
runSPools :: [Action] -> UMap -> UMap
runSPools [Action]
actions UMap
umap = (Action -> UMap -> UMap) -> UMap -> [Action] -> UMap
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Action -> UMap -> UMap
reifySPool UMap
umap [Action]
actions

runDReps :: [Action] -> UMap -> UMap
runDReps :: [Action] -> UMap -> UMap
runDReps [Action]
actions UMap
umap = (Action -> UMap -> UMap) -> UMap -> [Action] -> UMap
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Action -> UMap -> UMap
reifyDRep UMap
umap [Action]
actions

sizeTest ::
  ( Map.Map (Credential 'Staking) RDPair
  , Map.Map Ptr (Credential 'Staking)
  , Map.Map (Credential 'Staking) (KeyHash 'StakePool)
  , Map.Map (Credential 'Staking) DRep
  ) ->
  IO ()
sizeTest :: (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
 Map (Credential 'Staking) (KeyHash 'StakePool),
 Map (Credential 'Staking) DRep)
-> IO ()
sizeTest (Map (Credential 'Staking) RDPair
rdPairs, Map Ptr (Credential 'Staking)
ptrs, Map (Credential 'Staking) (KeyHash 'StakePool)
sPools, Map (Credential 'Staking) DRep
dReps) = do
  let
    umap :: UMap
umap = Map (Credential 'Staking) RDPair
-> Map Ptr (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> UMap
unify Map (Credential 'Staking) RDPair
rdPairs Map Ptr (Credential 'Staking)
ptrs Map (Credential 'Staking) (KeyHash 'StakePool)
sPools Map (Credential 'Staking) DRep
dReps
    rdPairsSize :: Int
rdPairsSize = UView (Credential 'Staking) RDPair -> Int
forall k v. UView k v -> Int
size (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap)
    ptrsSize :: Int
ptrsSize = UView Ptr (Credential 'Staking) -> Int
forall k v. UView k v -> Int
size (UMap -> UView Ptr (Credential 'Staking)
PtrUView UMap
umap)
    sPoolSize :: Int
sPoolSize = UView (Credential 'Staking) (KeyHash 'StakePool) -> Int
forall k v. UView k v -> Int
size (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView UMap
umap)
    dRepSize :: Int
dRepSize = UView (Credential 'Staking) DRep -> Int
forall k v. UView k v -> Int
size (UMap -> UView (Credential 'Staking) DRep
DRepUView UMap
umap)
  Map (Credential 'Staking) RDPair -> Int
forall k a. Map k a -> Int
Map.size Map (Credential 'Staking) RDPair
rdPairs Int -> Int -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Int
rdPairsSize
  Map Ptr (Credential 'Staking) -> Int
forall k a. Map k a -> Int
Map.size Map Ptr (Credential 'Staking)
ptrs Int -> Int -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Int
ptrsSize
  Map (Credential 'Staking) (KeyHash 'StakePool) -> Int
forall k a. Map k a -> Int
Map.size Map (Credential 'Staking) (KeyHash 'StakePool)
sPools Int -> Int -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Int
sPoolSize
  Map (Credential 'Staking) DRep -> Int
forall k a. Map k a -> Int
Map.size Map (Credential 'Staking) DRep
dReps Int -> Int -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Int
dRepSize

unifyRoundTripTo ::
  ( Map.Map (Credential 'Staking) RDPair
  , Map.Map Ptr (Credential 'Staking)
  , Map.Map (Credential 'Staking) (KeyHash 'StakePool)
  , Map.Map (Credential 'Staking) DRep
  ) ->
  IO ()
unifyRoundTripTo :: (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
 Map (Credential 'Staking) (KeyHash 'StakePool),
 Map (Credential 'Staking) DRep)
-> IO ()
unifyRoundTripTo (Map (Credential 'Staking) RDPair
rdPairs, Map Ptr (Credential 'Staking)
ptrs, Map (Credential 'Staking) (KeyHash 'StakePool)
sPools, Map (Credential 'Staking) DRep
dReps) = do
  let umap :: UMap
umap = Map (Credential 'Staking) RDPair
-> Map Ptr (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> UMap
unify Map (Credential 'Staking) RDPair
rdPairs Map Ptr (Credential 'Staking)
ptrs Map (Credential 'Staking) (KeyHash 'StakePool)
sPools Map (Credential 'Staking) DRep
dReps
  UMap -> Map (Credential 'Staking) RDPair
rdPairMap UMap
umap Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Map (Credential 'Staking) RDPair
rdPairs
  UMap -> Map Ptr (Credential 'Staking)
ptrMap UMap
umap Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Map Ptr (Credential 'Staking)
ptrs
  UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap UMap
umap Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Map (Credential 'Staking) (KeyHash 'StakePool)
sPools
  UMap -> Map (Credential 'Staking) DRep
dRepMap UMap
umap Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Map (Credential 'Staking) DRep
dReps

unifyRoundTripFrom :: [Action] -> Property
unifyRoundTripFrom :: [Action] -> Property
unifyRoundTripFrom [Action]
actions =
  let
    umap :: UMap
umap = [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty
    rdPairs :: Map (Credential 'Staking) RDPair
rdPairs = UMap -> Map (Credential 'Staking) RDPair
rdPairMap UMap
umap
    ptrs :: Map Ptr (Credential 'Staking)
ptrs = UMap -> Map Ptr (Credential 'Staking)
ptrMap UMap
umap
    sPools :: Map (Credential 'Staking) (KeyHash 'StakePool)
sPools = UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap UMap
umap
    dReps :: Map (Credential 'Staking) DRep
dReps = UMap -> Map (Credential 'Staking) DRep
dRepMap UMap
umap
   in
    UMap
umap UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Map (Credential 'Staking) RDPair
-> Map Ptr (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) DRep
-> UMap
unify Map (Credential 'Staking) RDPair
rdPairs Map Ptr (Credential 'Staking)
ptrs Map (Credential 'Staking) (KeyHash 'StakePool)
sPools Map (Credential 'Staking) DRep
dReps

oldUnionRewAgg ::
  UView (Credential 'Staking) RDPair ->
  Map (Credential 'Staking) (CompactForm Coin) ->
  UMap
(RewDepUView UMap {Map (Credential 'Staking) UMElem
umElems :: UMap -> Map (Credential 'Staking) UMElem
umElems :: Map (Credential 'Staking) UMElem
umElems, Map Ptr (Credential 'Staking)
umPtrs :: UMap -> Map Ptr (Credential 'Staking)
umPtrs :: Map Ptr (Credential 'Staking)
umPtrs}) oldUnionRewAgg :: UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin) -> UMap
`oldUnionRewAgg` Map (Credential 'Staking) (CompactForm Coin)
aggRewMap = Map (Credential 'Staking) UMElem
-> Map Ptr (Credential 'Staking) -> UMap
UMap Map (Credential 'Staking) UMElem
newUmElem Map Ptr (Credential 'Staking)
umPtrs
  where
    newUmElem :: Map (Credential 'Staking) UMElem
newUmElem =
      let
        result :: Map (Credential 'Staking) UMElem
result = (Credential 'Staking -> UMElem -> CompactForm Coin -> Maybe UMElem)
-> (Map (Credential 'Staking) UMElem
    -> Map (Credential 'Staking) UMElem)
-> (Map (Credential 'Staking) (CompactForm Coin)
    -> Map (Credential 'Staking) UMElem)
-> Map (Credential 'Staking) UMElem
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) UMElem
forall k a b c.
Ord k =>
(k -> a -> b -> Maybe c)
-> (Map k a -> Map k c)
-> (Map k b -> Map k c)
-> Map k a
-> Map k b
-> Map k c
Map.mergeWithKey Credential 'Staking -> UMElem -> CompactForm Coin -> Maybe UMElem
forall {p}. p -> UMElem -> CompactForm Coin -> Maybe UMElem
f Map (Credential 'Staking) UMElem
-> Map (Credential 'Staking) UMElem
forall a. a -> a
id (Map (Credential 'Staking) UMElem
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) UMElem
forall a b. a -> b -> a
const Map (Credential 'Staking) UMElem
forall k a. Map k a
Map.empty) Map (Credential 'Staking) UMElem
umElems Map (Credential 'Staking) (CompactForm Coin)
aggRewMap
        f :: p -> UMElem -> CompactForm Coin -> Maybe UMElem
f p
_k (UMElem StrictMaybe RDPair
p1 Set Ptr
s StrictMaybe (KeyHash 'StakePool)
deposit StrictMaybe DRep
drep) CompactForm Coin
delta = UMElem -> Maybe UMElem
forall a. a -> Maybe a
Just (StrictMaybe RDPair
-> Set Ptr
-> StrictMaybe (KeyHash 'StakePool)
-> StrictMaybe DRep
-> UMElem
UMElem (CompactForm Coin -> StrictMaybe RDPair -> StrictMaybe RDPair
addC CompactForm Coin
delta StrictMaybe RDPair
p1) Set Ptr
s StrictMaybe (KeyHash 'StakePool)
deposit StrictMaybe DRep
drep)
       in
        -- We use Map.empty below because aggRewMap is a subset of umElems, we never add anything here.
        Bool
-> Map (Credential 'Staking) UMElem
-> Map (Credential 'Staking) UMElem
forall a. HasCallStack => Bool -> a -> a
assert (Map (Credential 'Staking) UMElem -> Bool
forall k a. Ord k => Map k a -> Bool
Map.valid Map (Credential 'Staking) UMElem
result) Map (Credential 'Staking) UMElem
result
    addC :: CompactForm Coin -> StrictMaybe RDPair -> StrictMaybe RDPair
    addC :: CompactForm Coin -> StrictMaybe RDPair -> StrictMaybe RDPair
addC CompactForm Coin
newR = \case
      StrictMaybe RDPair
SNothing -> StrictMaybe RDPair
forall a. StrictMaybe a
SNothing
      SJust (RDPair CompactForm Coin
r CompactForm Coin
d) -> RDPair -> StrictMaybe RDPair
forall a. a -> StrictMaybe a
SJust (RDPair -> StrictMaybe RDPair) -> RDPair -> StrictMaybe RDPair
forall a b. (a -> b) -> a -> b
$ CompactForm Coin -> CompactForm Coin -> RDPair
RDPair (CompactForm Coin -> CompactForm Coin -> CompactForm Coin
addCompactCoin CompactForm Coin
r CompactForm Coin
newR) CompactForm Coin
d

spec :: Spec
spec :: Spec
spec = do
  String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"UMap" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Invariant" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> (Credential 'Staking -> Ptr -> Bool) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"Empty" (\(Credential 'Staking
cred :: Credential 'Staking) Ptr
ptr -> Credential 'Staking -> Ptr -> UMap -> Bool
umInvariant Credential 'Staking
cred Ptr
ptr UMap
empty)
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"Non-empty" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (Credential 'Staking, Ptr, UMap)
-> ((Credential 'Staking, Ptr, UMap) -> Bool) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (Credential 'Staking, Ptr, UMap)
genInvariantNonEmpty
          (\(Credential 'Staking
cred, Ptr
ptr, UMap
umap) -> Credential 'Staking -> Ptr -> UMap -> Bool
umInvariant Credential 'Staking
cred Ptr
ptr UMap
umap)
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
xprop String
"Non-empty with insert and delete actions" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen ((Credential 'Staking, Ptr, UMap), [Action])
-> (((Credential 'Staking, Ptr, UMap), [Action]) -> Bool)
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          ((,) ((Credential 'Staking, Ptr, UMap)
 -> [Action] -> ((Credential 'Staking, Ptr, UMap), [Action]))
-> Gen (Credential 'Staking, Ptr, UMap)
-> Gen ([Action] -> ((Credential 'Staking, Ptr, UMap), [Action]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Credential 'Staking, Ptr, UMap)
genInvariantNonEmpty Gen ([Action] -> ((Credential 'Staking, Ptr, UMap), [Action]))
-> Gen [Action] -> Gen ((Credential 'Staking, Ptr, UMap), [Action])
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen [Action]
forall a. Arbitrary a => Gen a
arbitrary)
          (\((Credential 'Staking
cred, Ptr
ptr, UMap
umap), [Action]
actions) -> Credential 'Staking -> Ptr -> UMap -> Bool
umInvariant Credential 'Staking
cred Ptr
ptr (UMap -> Bool) -> UMap -> Bool
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
umap)
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Unify roundtrip" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"To" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen
  (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
   Map (Credential 'Staking) (KeyHash 'StakePool),
   Map (Credential 'Staking) DRep)
-> ((Map (Credential 'Staking) RDPair,
     Map Ptr (Credential 'Staking),
     Map (Credential 'Staking) (KeyHash 'StakePool),
     Map (Credential 'Staking) DRep)
    -> IO ())
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll Gen
  (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
   Map (Credential 'Staking) (KeyHash 'StakePool),
   Map (Credential 'Staking) DRep)
genValidTuples (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
 Map (Credential 'Staking) (KeyHash 'StakePool),
 Map (Credential 'Staking) DRep)
-> IO ()
unifyRoundTripTo
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"From" [Action] -> Property
unifyRoundTripFrom
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Insert-delete roundtrip" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"RDPair" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (UMap, Credential 'Staking, RDPair)
-> ((UMap, Credential 'Staking, RDPair) -> Property) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Credential 'Staking, RDPair)
genInsertDeleteRoundtripRDPair
          (\(UMap
umap, Credential 'Staking
k, RDPair
v) -> UMap
umap UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair -> UMap
forall k v. UView k v -> UMap
unUView (Credential 'Staking
-> UView (Credential 'Staking) RDPair
-> UView (Credential 'Staking) RDPair
forall k v. k -> UView k v -> UView k v
delete' Credential 'Staking
k (Credential 'Staking
-> RDPair
-> UView (Credential 'Staking) RDPair
-> UView (Credential 'Staking) RDPair
forall k v. k -> v -> UView k v -> UView k v
insert' Credential 'Staking
k RDPair
v (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap))))
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"PtrUView" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (UMap, Ptr, Credential 'Staking)
-> ((UMap, Ptr, Credential 'Staking) -> Property) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Ptr, Credential 'Staking)
genInsertDeleteRoundtripPtr
          (\(UMap
umap, Ptr
k, Credential 'Staking
v) -> UMap
umap UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> UMap
forall k v. UView k v -> UMap
unUView (Ptr
-> UView Ptr (Credential 'Staking)
-> UView Ptr (Credential 'Staking)
forall k v. k -> UView k v -> UView k v
delete' Ptr
k (Ptr
-> Credential 'Staking
-> UView Ptr (Credential 'Staking)
-> UView Ptr (Credential 'Staking)
forall k v. k -> v -> UView k v -> UView k v
insert' Ptr
k Credential 'Staking
v (UMap -> UView Ptr (Credential 'Staking)
PtrUView UMap
umap))))
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"SPoolUView" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (UMap, Credential 'Staking, KeyHash 'StakePool)
-> ((UMap, Credential 'Staking, KeyHash 'StakePool) -> Property)
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Credential 'Staking, KeyHash 'StakePool)
genInsertDeleteRoundtripSPool
          (\(UMap
umap, Credential 'Staking
k, KeyHash 'StakePool
v) -> UMap
umap UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap
forall k v. UView k v -> UMap
unUView (Credential 'Staking
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> UView (Credential 'Staking) (KeyHash 'StakePool)
forall k v. k -> UView k v -> UView k v
delete' Credential 'Staking
k (Credential 'Staking
-> KeyHash 'StakePool
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> UView (Credential 'Staking) (KeyHash 'StakePool)
forall k v. k -> v -> UView k v -> UView k v
insert' Credential 'Staking
k KeyHash 'StakePool
v (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView UMap
umap))))
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"DRepUView" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (UMap, Credential 'Staking, DRep)
-> ((UMap, Credential 'Staking, DRep) -> Property) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Credential 'Staking, DRep)
genInsertDeleteRoundtripDRep
          (\(UMap
umap, Credential 'Staking
k, DRep
v) -> UMap
umap UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> UMap
forall k v. UView k v -> UMap
unUView (Credential 'Staking
-> UView (Credential 'Staking) DRep
-> UView (Credential 'Staking) DRep
forall k v. k -> UView k v -> UView k v
delete' Credential 'Staking
k (Credential 'Staking
-> DRep
-> UView (Credential 'Staking) DRep
-> UView (Credential 'Staking) DRep
forall k v. k -> v -> UView k v -> UView k v
insert' Credential 'Staking
k DRep
v (UMap -> UView (Credential 'Staking) DRep
DRepUView UMap
umap))))
    String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"Size" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen
  (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
   Map (Credential 'Staking) (KeyHash 'StakePool),
   Map (Credential 'Staking) DRep)
-> ((Map (Credential 'Staking) RDPair,
     Map Ptr (Credential 'Staking),
     Map (Credential 'Staking) (KeyHash 'StakePool),
     Map (Credential 'Staking) DRep)
    -> IO ())
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll Gen
  (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
   Map (Credential 'Staking) (KeyHash 'StakePool),
   Map (Credential 'Staking) DRep)
genValidTuples (Map (Credential 'Staking) RDPair, Map Ptr (Credential 'Staking),
 Map (Credential 'Staking) (KeyHash 'StakePool),
 Map (Credential 'Staking) DRep)
-> IO ()
sizeTest
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Membership" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ((UMap, Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \(UMap
umap :: UMap, Credential 'Staking
cred) ->
            Credential 'Staking -> UView (Credential 'Staking) RDPair -> Bool
forall k v. k -> UView k v -> Bool
member Credential 'Staking
cred (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap) Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking -> Map (Credential 'Staking) RDPair -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Credential 'Staking
cred (UMap -> Map (Credential 'Staking) RDPair
rdPairMap UMap
umap)
        )
      String -> ((UMap, Ptr) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUViews"
        ( \(UMap
umap :: UMap, Ptr
ptr) ->
            Ptr -> UView Ptr (Credential 'Staking) -> Bool
forall k v. k -> UView k v -> Bool
member Ptr
ptr (UMap -> UView Ptr (Credential 'Staking)
PtrUView UMap
umap) Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Ptr -> Map Ptr (Credential 'Staking) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Ptr
ptr (UMap -> Map Ptr (Credential 'Staking)
ptrMap UMap
umap)
        )
      String -> ((UMap, Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \(UMap
umap :: UMap, Credential 'Staking
cred) ->
            Credential 'Staking
-> UView (Credential 'Staking) (KeyHash 'StakePool) -> Bool
forall k v. k -> UView k v -> Bool
member Credential 'Staking
cred (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView UMap
umap) Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Credential 'Staking
cred (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap UMap
umap)
        )
      String -> ((UMap, Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \(UMap
umap :: UMap, Credential 'Staking
cred) ->
            Credential 'Staking -> UView (Credential 'Staking) DRep -> Bool
forall k v. k -> UView k v -> Bool
member Credential 'Staking
cred (UMap -> UView (Credential 'Staking) DRep
DRepUView UMap
umap) Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking -> Map (Credential 'Staking) DRep -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Credential 'Staking
cred (UMap -> Map (Credential 'Staking) DRep
dRepMap UMap
umap)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Bisimulation" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions ->
            UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty)
              Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions ->
            UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty)
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions ->
            UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty)
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions ->
            UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty)
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Null" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) RDPair -> Bool
forall k a. Map k a -> Bool
Map.null (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty))
              Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair -> Bool
forall k v. UView k v -> Bool
nullUView (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair)
-> UMap -> UView (Credential 'Staking) RDPair
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions ->
            Map Ptr (Credential 'Staking) -> Bool
forall k a. Map k a -> Bool
Map.null (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty))
              Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Bool
forall k v. UView k v -> Bool
nullUView (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking))
-> UMap -> UView Ptr (Credential 'Staking)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) (KeyHash 'StakePool) -> Bool
forall k a. Map k a -> Bool
Map.null (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty))
              Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool) -> Bool
forall k v. UView k v -> Bool
nullUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) DRep -> Bool
forall k a. Map k a -> Bool
Map.null (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty))
              Bool -> Bool -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Bool
forall k v. UView k v -> Bool
nullUView (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep)
-> UMap -> UView (Credential 'Staking) DRep
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Lookup" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Credential 'Staking -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions Credential 'Staking
cred ->
            Credential 'Staking
-> Map (Credential 'Staking) RDPair -> Maybe RDPair
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Credential 'Staking
cred (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty))
              Maybe RDPair -> Maybe RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking
-> UView (Credential 'Staking) RDPair -> Maybe RDPair
forall k v. k -> UView k v -> Maybe v
UMap.lookup Credential 'Staking
cred (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair)
-> UMap -> UView (Credential 'Staking) RDPair
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Ptr -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtruView"
        ( \[Action]
actions Ptr
ptr ->
            Ptr -> Map Ptr (Credential 'Staking) -> Maybe (Credential 'Staking)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Ptr
ptr (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty))
              Maybe (Credential 'Staking)
-> Maybe (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Ptr
-> UView Ptr (Credential 'Staking) -> Maybe (Credential 'Staking)
forall k v. k -> UView k v -> Maybe v
UMap.lookup Ptr
ptr (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking))
-> UMap -> UView Ptr (Credential 'Staking)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Credential 'Staking -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions Credential 'Staking
cred ->
            Credential 'Staking
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Maybe (KeyHash 'StakePool)
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Credential 'Staking
cred (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty))
              Maybe (KeyHash 'StakePool)
-> Maybe (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> Maybe (KeyHash 'StakePool)
forall k v. k -> UView k v -> Maybe v
UMap.lookup Credential 'Staking
cred (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Credential 'Staking -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions Credential 'Staking
cred ->
            Credential 'Staking -> Map (Credential 'Staking) DRep -> Maybe DRep
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Credential 'Staking
cred (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty))
              Maybe DRep -> Maybe DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== Credential 'Staking
-> UView (Credential 'Staking) DRep -> Maybe DRep
forall k v. k -> UView k v -> Maybe v
UMap.lookup Credential 'Staking
cred (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep)
-> UMap -> UView (Credential 'Staking) DRep
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Domain" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) RDPair -> Set (Credential 'Staking)
forall k a. Map k a -> Set k
Map.keysSet (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty))
              Set (Credential 'Staking) -> Set (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair -> Set (Credential 'Staking)
forall k v. UView k v -> Set k
domain (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair)
-> UMap -> UView (Credential 'Staking) RDPair
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions ->
            Map Ptr (Credential 'Staking) -> Set Ptr
forall k a. Map k a -> Set k
Map.keysSet (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty))
              Set Ptr -> Set Ptr -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Set Ptr
forall k v. UView k v -> Set k
domain (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking))
-> UMap -> UView Ptr (Credential 'Staking)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) (KeyHash 'StakePool)
-> Set (Credential 'Staking)
forall k a. Map k a -> Set k
Map.keysSet (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty))
              Set (Credential 'Staking) -> Set (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Set (Credential 'Staking)
forall k v. UView k v -> Set k
domain (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions ->
            Map (Credential 'Staking) DRep -> Set (Credential 'Staking)
forall k a. Map k a -> Set k
Map.keysSet (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty))
              Set (Credential 'Staking) -> Set (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Set (Credential 'Staking)
forall k v. UView k v -> Set k
domain (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep)
-> UMap -> UView (Credential 'Staking) DRep
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Range" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions ->
            [RDPair] -> Set RDPair
forall a. Ord a => [a] -> Set a
Set.fromList (Map (Credential 'Staking) RDPair -> [RDPair]
forall k a. Map k a -> [a]
Map.elems (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty)))
              Set RDPair -> Set RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair -> Set RDPair
forall k v. UView k v -> Set v
range (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair)
-> UMap -> UView (Credential 'Staking) RDPair
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions ->
            [Credential 'Staking] -> Set (Credential 'Staking)
forall a. Ord a => [a] -> Set a
Set.fromList (Map Ptr (Credential 'Staking) -> [Credential 'Staking]
forall k a. Map k a -> [a]
Map.elems (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty)))
              Set (Credential 'Staking) -> Set (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Set (Credential 'Staking)
forall k v. UView k v -> Set v
range (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking))
-> UMap -> UView Ptr (Credential 'Staking)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions ->
            [KeyHash 'StakePool] -> Set (KeyHash 'StakePool)
forall a. Ord a => [a] -> Set a
Set.fromList (Map (Credential 'Staking) (KeyHash 'StakePool)
-> [KeyHash 'StakePool]
forall k a. Map k a -> [a]
Map.elems (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty)))
              Set (KeyHash 'StakePool) -> Set (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Set (KeyHash 'StakePool)
forall k v. UView k v -> Set v
range (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool))
-> UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
      String -> ([Action] -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions ->
            [DRep] -> Set DRep
forall a. Ord a => [a] -> Set a
Set.fromList (Map (Credential 'Staking) DRep -> [DRep]
forall k a. Map k a -> [a]
Map.elems (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty)))
              Set DRep -> Set DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Set DRep
forall k v. UView k v -> Set v
range (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep)
-> UMap -> UView (Credential 'Staking) DRep
forall a b. (a -> b) -> a -> b
$ [Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Union (left preference)" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String
-> ([Action] -> Credential 'Staking -> RDPair -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions Credential 'Staking
cred RDPair
rdPair ->
            (RDPair -> RDPair -> RDPair)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith RDPair -> RDPair -> RDPair
forall a b. a -> b -> a
const (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty)) (Credential 'Staking -> RDPair -> Map (Credential 'Staking) RDPair
forall k a. k -> a -> Map k a
Map.singleton Credential 'Staking
cred RDPair
rdPair)
              Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair
RewDepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) RDPair
-> (Credential 'Staking, RDPair) -> UMap
forall k v. UView k v -> (k, v) -> UMap
∪ (Credential 'Staking
cred, RDPair
rdPair)))
        )
      String
-> ([Action] -> Ptr -> Credential 'Staking -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions Ptr
cred Credential 'Staking
ptr ->
            (Credential 'Staking -> Credential 'Staking -> Credential 'Staking)
-> Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith Credential 'Staking -> Credential 'Staking -> Credential 'Staking
forall a b. a -> b -> a
const (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty)) (Ptr -> Credential 'Staking -> Map Ptr (Credential 'Staking)
forall k a. k -> a -> Map k a
Map.singleton Ptr
cred Credential 'Staking
ptr)
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking)
PtrUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView Ptr (Credential 'Staking)
-> (Ptr, Credential 'Staking) -> UMap
forall k v. UView k v -> (k, v) -> UMap
∪ (Ptr
cred, Credential 'Staking
ptr)))
        )
      String
-> ([Action]
    -> Credential 'Staking -> KeyHash 'StakePool -> Property)
-> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions Credential 'Staking
cred KeyHash 'StakePool
pool ->
            (KeyHash 'StakePool -> KeyHash 'StakePool -> KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith KeyHash 'StakePool -> KeyHash 'StakePool -> KeyHash 'StakePool
forall a b. a -> b -> a
const (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty)) (Credential 'Staking
-> KeyHash 'StakePool
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. k -> a -> Map k a
Map.singleton Credential 'Staking
cred KeyHash 'StakePool
pool)
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) (KeyHash 'StakePool)
-> (Credential 'Staking, KeyHash 'StakePool) -> UMap
forall k v. UView k v -> (k, v) -> UMap
∪ (Credential 'Staking
cred, KeyHash 'StakePool
pool)))
        )
      String
-> ([Action] -> Credential 'Staking -> DRep -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions Credential 'Staking
cred DRep
pool ->
            (DRep -> DRep -> DRep)
-> Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith DRep -> DRep -> DRep
forall a b. a -> b -> a
const (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty)) (Credential 'Staking -> DRep -> Map (Credential 'Staking) DRep
forall k a. k -> a -> Map k a
Map.singleton Credential 'Staking
cred DRep
pool)
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep
DRepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) DRep
-> (Credential 'Staking, DRep) -> UMap
forall k v. UView k v -> (k, v) -> UMap
∪ (Credential 'Staking
cred, DRep
pool)))
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Union (right preference)" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView (domain of map on the right has to be subset of RewDepUView View)"
        (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen (UMap, Map (Credential 'Staking) RDPair)
-> ((UMap, Map (Credential 'Staking) RDPair) -> Property)
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Map (Credential 'Staking) RDPair)
genRightPreferenceUMap
          ( \(UMap
umap, Map (Credential 'Staking) RDPair
m) ->
              (RDPair -> RDPair -> RDPair)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith
                (\(RDPair CompactForm Coin
_ CompactForm Coin
leftDep) (RDPair CompactForm Coin
rightRD CompactForm Coin
_) -> CompactForm Coin -> CompactForm Coin -> RDPair
RDPair CompactForm Coin
rightRD CompactForm Coin
leftDep)
                (UMap -> Map (Credential 'Staking) RDPair
rdPairMap UMap
umap)
                Map (Credential 'Staking) RDPair
m
                Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map (Credential 'Staking) RDPair
rdPairMap (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> UMap
forall k v. UView k v -> Map k v -> UMap
⨃ Map (Credential 'Staking) RDPair
m)
          )
      String
-> ([Action] -> Map Ptr (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions Map Ptr (Credential 'Staking)
m ->
            (Credential 'Staking -> Credential 'Staking -> Credential 'Staking)
-> Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (\Credential 'Staking
_ Credential 'Staking
x -> Credential 'Staking
x) (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty)) Map Ptr (Credential 'Staking)
m
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking)
PtrUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> UMap
forall k v. UView k v -> Map k v -> UMap
⨃ Map Ptr (Credential 'Staking)
m))
        )
      String
-> ([Action]
    -> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property)
-> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions Map (Credential 'Staking) (KeyHash 'StakePool)
m ->
            (KeyHash 'StakePool -> KeyHash 'StakePool -> KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (\KeyHash 'StakePool
_ KeyHash 'StakePool
x -> KeyHash 'StakePool
x) (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty)) Map (Credential 'Staking) (KeyHash 'StakePool)
m
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> UMap
forall k v. UView k v -> Map k v -> UMap
⨃ Map (Credential 'Staking) (KeyHash 'StakePool)
m))
        )
      String
-> ([Action] -> Map (Credential 'Staking) DRep -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions Map (Credential 'Staking) DRep
m ->
            (DRep -> DRep -> DRep)
-> Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (\DRep
_ DRep
x -> DRep
x) (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty)) Map (Credential 'Staking) DRep
m
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep
DRepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> UMap
forall k v. UView k v -> Map k v -> UMap
⨃ Map (Credential 'Staking) DRep
m))
        )
    String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
      String
"Monoidal Rewards (domain of map on the right has to be subset of RewDepUView View)"
      (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen (UMap, Map (Credential 'Staking) RDPair)
-> ((UMap, Map (Credential 'Staking) RDPair) -> Property)
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
        Gen (UMap, Map (Credential 'Staking) RDPair)
genRightPreferenceUMap
        ( \(UMap
umap, Map (Credential 'Staking) RDPair
m) ->
            (CompactForm Coin -> CompactForm Coin -> CompactForm Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) (CompactForm Coin)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith CompactForm Coin -> CompactForm Coin -> CompactForm Coin
forall a. Semigroup a => a -> a -> a
(<>) (UMap -> Map (Credential 'Staking) (CompactForm Coin)
compactRewardMap UMap
umap) (RDPair -> CompactForm Coin
rdReward (RDPair -> CompactForm Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map (Credential 'Staking) RDPair
m)
              Map (Credential 'Staking) (CompactForm Coin)
-> Map (Credential 'Staking) (CompactForm Coin) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> Map (Credential 'Staking) (CompactForm Coin)
compactRewardMap (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin) -> UMap
∪+ (RDPair -> CompactForm Coin
rdReward (RDPair -> CompactForm Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map (Credential 'Staking) RDPair
m))
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Domain exclusion" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String
-> ([Action] -> Set (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions Set (Credential 'Staking)
dom ->
            Map (Credential 'Staking) RDPair
-> Set (Credential 'Staking) -> Map (Credential 'Staking) RDPair
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty)) Set (Credential 'Staking)
dom
              Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (Set (Credential 'Staking)
dom Set (Credential 'Staking)
-> UView (Credential 'Staking) RDPair -> UMap
forall k v. Set k -> UView k v -> UMap
⋪ UMap -> UView (Credential 'Staking) RDPair
RewDepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)))
        )
      String -> ([Action] -> Set Ptr -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions Set Ptr
dom ->
            Map Ptr (Credential 'Staking)
-> Set Ptr -> Map Ptr (Credential 'Staking)
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty)) Set Ptr
dom
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView Ptr (Credential 'Staking)
PtrUView (Set Ptr
dom Set Ptr -> UView Ptr (Credential 'Staking) -> UMap
forall k v. Set k -> UView k v -> UMap
⋪ UMap -> UView Ptr (Credential 'Staking)
PtrUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)))
        )
      String
-> ([Action] -> Set (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions Set (Credential 'Staking)
dom ->
            Map (Credential 'Staking) (KeyHash 'StakePool)
-> Set (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty)) Set (Credential 'Staking)
dom
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (Set (Credential 'Staking)
dom Set (Credential 'Staking)
-> UView (Credential 'Staking) (KeyHash 'StakePool) -> UMap
forall k v. Set k -> UView k v -> UMap
⋪ UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)))
        )
      String
-> ([Action] -> Set (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions Set (Credential 'Staking)
dom ->
            Map (Credential 'Staking) DRep
-> Set (Credential 'Staking) -> Map (Credential 'Staking) DRep
forall k a. Ord k => Map k a -> Set k -> Map k a
Map.withoutKeys (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty)) Set (Credential 'Staking)
dom
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) DRep
DRepUView (Set (Credential 'Staking)
dom Set (Credential 'Staking)
-> UView (Credential 'Staking) DRep -> UMap
forall k v. Set k -> UView k v -> UMap
⋪ UMap -> UView (Credential 'Staking) DRep
DRepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)))
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Range exclusion" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> ([Action] -> Set RDPair -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions Set RDPair
rng ->
            (RDPair -> Bool)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Bool -> Bool
not (Bool -> Bool) -> (RDPair -> Bool) -> RDPair -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RDPair -> Set RDPair -> Bool) -> Set RDPair -> RDPair -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip RDPair -> Set RDPair -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member Set RDPair
rng) (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty))
              Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) RDPair
RewDepUView (UMap -> UView (Credential 'Staking) RDPair
RewDepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) RDPair -> Set RDPair -> UMap
forall k v. UView k v -> Set v -> UMap
⋫ Set RDPair
rng))
        )
      String
-> ([Action] -> Set (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions Set (Credential 'Staking)
rng ->
            (Credential 'Staking -> Bool)
-> Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Bool -> Bool
not (Bool -> Bool)
-> (Credential 'Staking -> Bool) -> Credential 'Staking -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Credential 'Staking -> Set (Credential 'Staking) -> Bool)
-> Set (Credential 'Staking) -> Credential 'Staking -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Credential 'Staking -> Set (Credential 'Staking) -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member Set (Credential 'Staking)
rng) (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty))
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView Ptr (Credential 'Staking)
PtrUView (UMap -> UView Ptr (Credential 'Staking)
PtrUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView Ptr (Credential 'Staking)
-> Set (Credential 'Staking) -> UMap
forall k v. UView k v -> Set v -> UMap
⋫ Set (Credential 'Staking)
rng))
        )
      String
-> ([Action] -> Set (KeyHash 'StakePool) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions Set (KeyHash 'StakePool)
rng ->
            (KeyHash 'StakePool -> Bool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Bool -> Bool
not (Bool -> Bool)
-> (KeyHash 'StakePool -> Bool) -> KeyHash 'StakePool -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (KeyHash 'StakePool -> Set (KeyHash 'StakePool) -> Bool)
-> Set (KeyHash 'StakePool) -> KeyHash 'StakePool -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip KeyHash 'StakePool -> Set (KeyHash 'StakePool) -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member Set (KeyHash 'StakePool)
rng) (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty))
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) (KeyHash 'StakePool)
-> Set (KeyHash 'StakePool) -> UMap
forall k v. UView k v -> Set v -> UMap
⋫ Set (KeyHash 'StakePool)
rng))
        )
      String -> ([Action] -> Set DRep -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions Set DRep
rng ->
            (DRep -> Bool)
-> Map (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Bool -> Bool
not (Bool -> Bool) -> (DRep -> Bool) -> DRep -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DRep -> Set DRep -> Bool) -> Set DRep -> DRep -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip DRep -> Set DRep -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member Set DRep
rng) (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty))
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k v. UView k v -> Map k v
unUnify (UMap -> UView (Credential 'Staking) DRep
DRepUView (UMap -> UView (Credential 'Staking) DRep
DRepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty) UView (Credential 'Staking) DRep -> Set DRep -> UMap
forall k v. UView k v -> Set v -> UMap
⋫ Set DRep
rng))
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Domain restriction" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String
-> ([Action] -> Map (Credential 'Staking) RDPair -> Property)
-> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"RewDepUView"
        ( \[Action]
actions (Map (Credential 'Staking) RDPair
m :: Map.Map (Credential 'Staking) RDPair) ->
            Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map (Credential 'Staking) RDPair
m (UMap -> Map (Credential 'Staking) RDPair
rdPairMap ([Action] -> UMap -> UMap
runRDPairs [Action]
actions UMap
empty))
              Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k v u. UView k v -> Map k u -> Map k u
domRestrict (UMap -> UView (Credential 'Staking) RDPair
RewDepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)) Map (Credential 'Staking) RDPair
m
        )
      String
-> ([Action] -> Map Ptr (Credential 'Staking) -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"PtrUView"
        ( \[Action]
actions (Map Ptr (Credential 'Staking)
m :: Map.Map Ptr (Credential 'Staking)) ->
            Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map Ptr (Credential 'Staking)
m (UMap -> Map Ptr (Credential 'Staking)
ptrMap ([Action] -> UMap -> UMap
runPtrs [Action]
actions UMap
empty))
              Map Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView Ptr (Credential 'Staking)
-> Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v u. UView k v -> Map k u -> Map k u
domRestrict (UMap -> UView Ptr (Credential 'Staking)
PtrUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)) Map Ptr (Credential 'Staking)
m
        )
      String
-> ([Action]
    -> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property)
-> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"SPoolUView"
        ( \[Action]
actions (Map (Credential 'Staking) (KeyHash 'StakePool)
m :: Map.Map (Credential 'Staking) (KeyHash 'StakePool)) ->
            Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map (Credential 'Staking) (KeyHash 'StakePool)
m (UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap ([Action] -> UMap -> UMap
runSPools [Action]
actions UMap
empty))
              Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool) -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v u. UView k v -> Map k u -> Map k u
domRestrict (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)) Map (Credential 'Staking) (KeyHash 'StakePool)
m
        )
      String
-> ([Action] -> Map (Credential 'Staking) DRep -> Property) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"DRepUView"
        ( \[Action]
actions (Map (Credential 'Staking) DRep
m :: Map.Map (Credential 'Staking) DRep) ->
            Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Map.intersection Map (Credential 'Staking) DRep
m (UMap -> Map (Credential 'Staking) DRep
dRepMap ([Action] -> UMap -> UMap
runDReps [Action]
actions UMap
empty))
              Map (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UView (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep -> Map (Credential 'Staking) DRep
forall k v u. UView k v -> Map k u -> Map k u
domRestrict (UMap -> UView (Credential 'Staking) DRep
DRepUView ([Action] -> UMap -> UMap
runActions [Action]
actions UMap
empty)) Map (Credential 'Staking) DRep
m
        )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"Old and new implementation is equivalent" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop
        String
"unionRewAgg or ∪+ === oldUnionRewAgg"
        (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen (UMap, Map (Credential 'Staking) RDPair)
-> ((UMap, Map (Credential 'Staking) RDPair) -> Property)
-> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll
          Gen (UMap, Map (Credential 'Staking) RDPair)
genRightPreferenceUMap
          ( \(UMap
umap, Map (Credential 'Staking) RDPair
m) ->
              UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin) -> UMap
∪+ (RDPair -> CompactForm Coin
rdReward (RDPair -> CompactForm Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map (Credential 'Staking) RDPair
m) UMap -> UMap -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin) -> UMap
`oldUnionRewAgg` (RDPair -> CompactForm Coin
rdReward (RDPair -> CompactForm Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) (CompactForm Coin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map (Credential 'Staking) RDPair
m)
          )
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"StakeCredentials" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"toStakeCredentials as full domRestrictedStakeCredentials" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen UMap -> (UMap -> IO ()) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll Gen UMap
genValidUMap ((UMap -> IO ()) -> Property) -> (UMap -> IO ()) -> Property
forall a b. (a -> b) -> a -> b
$ \UMap
umap ->
          UMap -> StakeCredentials
toStakeCredentials UMap
umap
            StakeCredentials -> StakeCredentials -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Set (Credential 'Staking) -> UMap -> StakeCredentials
domRestrictedStakeCredentials (Map (Credential 'Staking) UMElem -> Set (Credential 'Staking)
forall k a. Map k a -> Set k
Map.keysSet (UMap -> Map (Credential 'Staking) UMElem
umElems UMap
umap)) UMap
umap

      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"domRestrictedStakeCredentials" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$ Gen (UMap, Set (Credential 'Staking))
-> ((UMap, Set (Credential 'Staking)) -> IO ()) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll Gen (UMap, Set (Credential 'Staking))
genValidUMapWithCreds (((UMap, Set (Credential 'Staking)) -> IO ()) -> Property)
-> ((UMap, Set (Credential 'Staking)) -> IO ()) -> Property
forall a b. (a -> b) -> a -> b
$ \(UMap
umap, Set (Credential 'Staking)
creds) ->
        Set (Credential 'Staking) -> UMap -> StakeCredentials
domRestrictedStakeCredentials Set (Credential 'Staking)
creds UMap
umap
          StakeCredentials -> StakeCredentials -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` StakeCredentials
            { scRewards :: Map (Credential 'Staking) Coin
scRewards = UMap -> Map (Credential 'Staking) Coin
rewardMap UMap
umap Map (Credential 'Staking) Coin
-> Set (Credential 'Staking) -> Map (Credential 'Staking) Coin
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
            , scDeposits :: Map (Credential 'Staking) Coin
scDeposits = UMap -> Map (Credential 'Staking) Coin
depositMap UMap
umap Map (Credential 'Staking) Coin
-> Set (Credential 'Staking) -> Map (Credential 'Staking) Coin
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
            , scSPools :: Map (Credential 'Staking) (KeyHash 'StakePool)
scSPools = UMap -> Map (Credential 'Staking) (KeyHash 'StakePool)
sPoolMap UMap
umap Map (Credential 'Staking) (KeyHash 'StakePool)
-> Set (Credential 'Staking)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
            , scDReps :: Map (Credential 'Staking) DRep
scDReps = UMap -> Map (Credential 'Staking) DRep
dRepMap UMap
umap Map (Credential 'Staking) DRep
-> Set (Credential 'Staking) -> Map (Credential 'Staking) DRep
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
            , scPtrs :: Map Ptr (Credential 'Staking)
scPtrs = (Credential 'Staking -> Bool)
-> Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Credential 'Staking -> Set (Credential 'Staking) -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set (Credential 'Staking)
creds) (Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking))
-> Map Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall a b. (a -> b) -> a -> b
$ UMap -> Map Ptr (Credential 'Staking)
ptrMap UMap
umap
            , scPtrsInverse :: Map (Credential 'Staking) (Set Ptr)
scPtrsInverse = UMap -> Map (Credential 'Staking) (Set Ptr)
invPtrMap UMap
umap Map (Credential 'Staking) (Set Ptr)
-> Set (Credential 'Staking) -> Map (Credential 'Staking) (Set Ptr)
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
            }
      String -> Property -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"domRestrictedStakeCredentials with domRestrictedMap" (Property -> Spec) -> Property -> Spec
forall a b. (a -> b) -> a -> b
$
        Gen (UMap, Set (Credential 'Staking))
-> ((UMap, Set (Credential 'Staking)) -> IO ()) -> Property
forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> prop) -> Property
forAll Gen (UMap, Set (Credential 'Staking))
genValidUMapWithCreds (((UMap, Set (Credential 'Staking)) -> IO ()) -> Property)
-> ((UMap, Set (Credential 'Staking)) -> IO ()) -> Property
forall a b. (a -> b) -> a -> b
$ \(UMap
umap, Set (Credential 'Staking)
creds) ->
          let rdmap :: Map (Credential 'Staking) RDPair
rdmap = Set (Credential 'Staking)
-> UView (Credential 'Staking) RDPair
-> Map (Credential 'Staking) RDPair
forall k v. Set k -> UView k v -> Map k v
domRestrictedMap Set (Credential 'Staking)
creds (UMap -> UView (Credential 'Staking) RDPair
RewDepUView UMap
umap)
              ptrs :: Map (Credential 'Staking) (Set Ptr)
ptrs = UMap -> Map (Credential 'Staking) (Set Ptr)
invPtrMap UMap
umap Map (Credential 'Staking) (Set Ptr)
-> Set (Credential 'Staking) -> Map (Credential 'Staking) (Set Ptr)
forall k a. Ord k => Map k a -> Set k -> Map k a
`Map.restrictKeys` Set (Credential 'Staking)
creds
           in Set (Credential 'Staking) -> UMap -> StakeCredentials
domRestrictedStakeCredentials Set (Credential 'Staking)
creds UMap
umap
                StakeCredentials -> StakeCredentials -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` StakeCredentials
                  { scRewards :: Map (Credential 'Staking) Coin
scRewards = (RDPair -> Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) Coin
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin)
-> (RDPair -> CompactForm Coin) -> RDPair -> Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RDPair -> CompactForm Coin
rdReward) Map (Credential 'Staking) RDPair
rdmap
                  , scDeposits :: Map (Credential 'Staking) Coin
scDeposits = (RDPair -> Coin)
-> Map (Credential 'Staking) RDPair
-> Map (Credential 'Staking) Coin
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (CompactForm Coin -> Coin
forall a. Compactible a => CompactForm a -> a
fromCompact (CompactForm Coin -> Coin)
-> (RDPair -> CompactForm Coin) -> RDPair -> Coin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RDPair -> CompactForm Coin
rdDeposit) Map (Credential 'Staking) RDPair
rdmap
                  , scSPools :: Map (Credential 'Staking) (KeyHash 'StakePool)
scSPools = Set (Credential 'Staking)
-> UView (Credential 'Staking) (KeyHash 'StakePool)
-> Map (Credential 'Staking) (KeyHash 'StakePool)
forall k v. Set k -> UView k v -> Map k v
domRestrictedMap Set (Credential 'Staking)
creds (UMap -> UView (Credential 'Staking) (KeyHash 'StakePool)
SPoolUView UMap
umap)
                  , scDReps :: Map (Credential 'Staking) DRep
scDReps = Set (Credential 'Staking)
-> UView (Credential 'Staking) DRep
-> Map (Credential 'Staking) DRep
forall k v. Set k -> UView k v -> Map k v
domRestrictedMap Set (Credential 'Staking)
creds (UMap -> UView (Credential 'Staking) DRep
DRepUView UMap
umap)
                  , scPtrs :: Map Ptr (Credential 'Staking)
scPtrs = Set Ptr
-> UView Ptr (Credential 'Staking) -> Map Ptr (Credential 'Staking)
forall k v. Set k -> UView k v -> Map k v
domRestrictedMap (Map (Credential 'Staking) (Set Ptr) -> Set Ptr
forall m. Monoid m => Map (Credential 'Staking) m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold Map (Credential 'Staking) (Set Ptr)
ptrs) (UMap -> UView Ptr (Credential 'Staking)
PtrUView UMap
umap)
                  , scPtrsInverse :: Map (Credential 'Staking) (Set Ptr)
scPtrsInverse = Map (Credential 'Staking) (Set Ptr)
ptrs
                  }