{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE DerivingVia         #-}
{-# LANGUAGE FlexibleContexts    #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE GADTs               #-}
{-# LANGUAGE NamedFieldPuns      #-}
{-# LANGUAGE PolyKinds           #-}
{-# LANGUAGE ScopedTypeVariables #-}

-- TODO: Needed for PeerSharing arbitrary instance see
-- todo there.
{-# OPTIONS_GHC -Wno-orphans #-}

module Cardano.Network.Protocol.Handshake.Test where

import Data.ByteString.Lazy (ByteString)
import Data.Map qualified as Map
import Data.Text (Text)

import Codec.CBOR.Read qualified as CBOR
import Codec.CBOR.Term qualified as CBOR

import Control.Monad.Class.MonadAsync
import Control.Monad.Class.MonadThrow
import Control.Monad.IOSim (runSimOrThrow)
import Control.Tracer (nullTracer)

import Network.TypedProtocol.Codec

import Cardano.Network.NodeToClient.Version as NTC
import Cardano.Network.NodeToNode.Version as NTN

import Ouroboros.Network.Channel
import Ouroboros.Network.CodecCBORTerm
import Ouroboros.Network.Driver.Simple (runConnectedPeers)
import Ouroboros.Network.Magic
import Ouroboros.Network.PeerSelection.PeerSharing (PeerSharing (..))

import Ouroboros.Network.Protocol.Handshake.Client
import Ouroboros.Network.Protocol.Handshake.Codec
import Ouroboros.Network.Protocol.Handshake.Server
import Ouroboros.Network.Protocol.Handshake.Test hiding (tests)
import Ouroboros.Network.Protocol.Handshake.Type
import Ouroboros.Network.Protocol.Handshake.Version

import Test.QuickCheck
import Test.Tasty (TestTree, testGroup)
import Test.Tasty.QuickCheck (testProperty)

tests :: TestTree
tests :: TestTree
tests =
  TestName -> [TestTree] -> TestTree
testGroup TestName
"Ouroboros.Network.Protocol"
    [ TestName -> [TestTree] -> TestTree
testGroup TestName
"Handshake"
      [ TestName -> [TestTree] -> TestTree
testGroup TestName
"NodeToNode"
        [ TestName
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData -> Bool)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"acceptable_symmetric"
            ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData -> Bool
prop_acceptable_symmetric_NodeToNode
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"acceptOrRefuse"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_acceptOrRefuse_symmetric_NodeToNode
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open ST"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_ST
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open IO"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_IO
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open SimNet"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_SimNet
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version ST"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_ST
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version IO"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_IO
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version SimNet"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_SimNet
        , TestName
-> (ArbitraryNodeToNodeVersions
    -> ArbitraryNodeToNodeVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"peerSharing symmetry"
            ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_peerSharing_symmetric_NodeToNode_SimNet
        ]

      , TestName -> [TestTree] -> TestTree
testGroup TestName
"NodeToClient"
        [ TestName
-> (ArbitraryNodeToClientVersionData
    -> ArbitraryNodeToClientVersionData -> Bool)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"acceptable_symmetric"
            ArbitraryNodeToClientVersionData
-> ArbitraryNodeToClientVersionData -> Bool
prop_acceptable_symmetric_NodeToClient
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"acceptOrRefuse"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_acceptOrRefuse_symmetric_NodeToClient
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open ST"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_ST
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open IO"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_IO
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"simultaneous open SimNet"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_SimNet
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version ST"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_ST
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version IO"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_IO
        , TestName
-> (ArbitraryNodeToClientVersions
    -> ArbitraryNodeToClientVersions -> Property)
-> TestTree
forall a. Testable a => TestName -> a -> TestTree
testProperty TestName
"query version SimNet"
            ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_SimNet
        ]
      ]
    ]




--
-- NodeToNode generators
--

newtype ArbitraryNodeToNodeVersion =
        ArbitraryNodeToNodeVersion { ArbitraryNodeToNodeVersion -> NodeToNodeVersion
getNodeToNodeVersion :: NodeToNodeVersion }
  deriving Int -> ArbitraryNodeToNodeVersion -> ShowS
[ArbitraryNodeToNodeVersion] -> ShowS
ArbitraryNodeToNodeVersion -> TestName
(Int -> ArbitraryNodeToNodeVersion -> ShowS)
-> (ArbitraryNodeToNodeVersion -> TestName)
-> ([ArbitraryNodeToNodeVersion] -> ShowS)
-> Show ArbitraryNodeToNodeVersion
forall a.
(Int -> a -> ShowS) -> (a -> TestName) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArbitraryNodeToNodeVersion -> ShowS
showsPrec :: Int -> ArbitraryNodeToNodeVersion -> ShowS
$cshow :: ArbitraryNodeToNodeVersion -> TestName
show :: ArbitraryNodeToNodeVersion -> TestName
$cshowList :: [ArbitraryNodeToNodeVersion] -> ShowS
showList :: [ArbitraryNodeToNodeVersion] -> ShowS
Show

instance Arbitrary ArbitraryNodeToNodeVersion where
    arbitrary :: Gen ArbitraryNodeToNodeVersion
arbitrary = [ArbitraryNodeToNodeVersion] -> Gen ArbitraryNodeToNodeVersion
forall a. HasCallStack => [a] -> Gen a
elements (NodeToNodeVersion -> ArbitraryNodeToNodeVersion
ArbitraryNodeToNodeVersion (NodeToNodeVersion -> ArbitraryNodeToNodeVersion)
-> [NodeToNodeVersion] -> [ArbitraryNodeToNodeVersion]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NodeToNodeVersion
forall a. Bounded a => a
minBound .. NodeToNodeVersion
forall a. Bounded a => a
maxBound])

newtype ArbitraryNodeToNodeVersionData =
        ArbitraryNodeToNodeVersionData
          { ArbitraryNodeToNodeVersionData -> NodeToNodeVersionData
getNodeToNodeVersionData :: NodeToNodeVersionData }
    deriving Int -> ArbitraryNodeToNodeVersionData -> ShowS
[ArbitraryNodeToNodeVersionData] -> ShowS
ArbitraryNodeToNodeVersionData -> TestName
(Int -> ArbitraryNodeToNodeVersionData -> ShowS)
-> (ArbitraryNodeToNodeVersionData -> TestName)
-> ([ArbitraryNodeToNodeVersionData] -> ShowS)
-> Show ArbitraryNodeToNodeVersionData
forall a.
(Int -> a -> ShowS) -> (a -> TestName) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArbitraryNodeToNodeVersionData -> ShowS
showsPrec :: Int -> ArbitraryNodeToNodeVersionData -> ShowS
$cshow :: ArbitraryNodeToNodeVersionData -> TestName
show :: ArbitraryNodeToNodeVersionData -> TestName
$cshowList :: [ArbitraryNodeToNodeVersionData] -> ShowS
showList :: [ArbitraryNodeToNodeVersionData] -> ShowS
Show
    deriving ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData
-> Accept ArbitraryNodeToNodeVersionData
(ArbitraryNodeToNodeVersionData
 -> ArbitraryNodeToNodeVersionData
 -> Accept ArbitraryNodeToNodeVersionData)
-> Acceptable ArbitraryNodeToNodeVersionData
forall v. (v -> v -> Accept v) -> Acceptable v
$cacceptableVersion :: ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData
-> Accept ArbitraryNodeToNodeVersionData
acceptableVersion :: ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData
-> Accept ArbitraryNodeToNodeVersionData
Acceptable via NodeToNodeVersionData

-- | With the introduction of PeerSharing to 'NodeToNodeVersionData' this type's
-- 'Acceptable' instance is no longer symmetric. Because when handshake is
-- performed we keep only the remote's side PeerSharing information. Due to this,
-- the 'ArbitraryNodeToNodeVersionData' needs to have a custom 'Eq' type that
-- ignores this parameter. We also ignore the query field which may differ
-- between parties.
--
instance Eq ArbitraryNodeToNodeVersionData where
  == :: ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData -> Bool
(==) (ArbitraryNodeToNodeVersionData (NodeToNodeVersionData NetworkMagic
nm DiffusionMode
dm PeerSharing
ps Bool
_))
       (ArbitraryNodeToNodeVersionData (NodeToNodeVersionData NetworkMagic
nm' DiffusionMode
dm' PeerSharing
ps' Bool
_))
    = NetworkMagic
nm NetworkMagic -> NetworkMagic -> Bool
forall a. Eq a => a -> a -> Bool
== NetworkMagic
nm' Bool -> Bool -> Bool
&& DiffusionMode
dm DiffusionMode -> DiffusionMode -> Bool
forall a. Eq a => a -> a -> Bool
== DiffusionMode
dm' Bool -> Bool -> Bool
&& PeerSharing
ps PeerSharing -> PeerSharing -> Bool
forall a. Eq a => a -> a -> Bool
== PeerSharing
ps'

instance Queryable ArbitraryNodeToNodeVersionData where
    queryVersion :: ArbitraryNodeToNodeVersionData -> Bool
queryVersion = NodeToNodeVersionData -> Bool
forall v. Queryable v => v -> Bool
queryVersion (NodeToNodeVersionData -> Bool)
-> (ArbitraryNodeToNodeVersionData -> NodeToNodeVersionData)
-> ArbitraryNodeToNodeVersionData
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArbitraryNodeToNodeVersionData -> NodeToNodeVersionData
getNodeToNodeVersionData

instance Arbitrary ArbitraryNodeToNodeVersionData where
    arbitrary :: Gen ArbitraryNodeToNodeVersionData
arbitrary = ((PeerSharing -> Bool -> NodeToNodeVersionData)
 -> PeerSharing -> Bool -> ArbitraryNodeToNodeVersionData)
-> (DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData)
-> DiffusionMode
-> PeerSharing
-> Bool
-> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> (DiffusionMode -> a) -> DiffusionMode -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (((Bool -> NodeToNodeVersionData)
 -> Bool -> ArbitraryNodeToNodeVersionData)
-> (PeerSharing -> Bool -> NodeToNodeVersionData)
-> PeerSharing
-> Bool
-> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> (PeerSharing -> a) -> PeerSharing -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData)
-> (Bool -> NodeToNodeVersionData)
-> Bool
-> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> (Bool -> a) -> Bool -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData))
              ((DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData)
 -> DiffusionMode
 -> PeerSharing
 -> Bool
 -> ArbitraryNodeToNodeVersionData)
-> (NetworkMagic
    -> DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData)
-> NetworkMagic
-> DiffusionMode
-> PeerSharing
-> Bool
-> ArbitraryNodeToNodeVersionData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NetworkMagic
-> DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData
NodeToNodeVersionData
             (NetworkMagic
 -> DiffusionMode
 -> PeerSharing
 -> Bool
 -> ArbitraryNodeToNodeVersionData)
-> Gen NetworkMagic
-> Gen
     (DiffusionMode
      -> PeerSharing -> Bool -> ArbitraryNodeToNodeVersionData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word32 -> NetworkMagic
NetworkMagic (Word32 -> NetworkMagic) -> Gen Word32 -> Gen NetworkMagic
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word32
forall a. Arbitrary a => Gen a
arbitrary)
             Gen
  (DiffusionMode
   -> PeerSharing -> Bool -> ArbitraryNodeToNodeVersionData)
-> Gen DiffusionMode
-> Gen (PeerSharing -> Bool -> ArbitraryNodeToNodeVersionData)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [DiffusionMode] -> Gen DiffusionMode
forall a. HasCallStack => [a] -> Gen a
elements [ DiffusionMode
InitiatorOnlyDiffusionMode
                          , DiffusionMode
InitiatorAndResponderDiffusionMode
                          ]
             Gen (PeerSharing -> Bool -> ArbitraryNodeToNodeVersionData)
-> Gen PeerSharing -> Gen (Bool -> ArbitraryNodeToNodeVersionData)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [PeerSharing] -> Gen PeerSharing
forall a. HasCallStack => [a] -> Gen a
elements [ PeerSharing
PeerSharingDisabled
                          , PeerSharing
PeerSharingEnabled
                          ]
             Gen (Bool -> ArbitraryNodeToNodeVersionData)
-> Gen Bool -> Gen ArbitraryNodeToNodeVersionData
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
    shrink :: ArbitraryNodeToNodeVersionData -> [ArbitraryNodeToNodeVersionData]
shrink (ArbitraryNodeToNodeVersionData
             (NodeToNodeVersionData NetworkMagic
magic DiffusionMode
mode PeerSharing
peerSharing Bool
query)) =
        [ NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NetworkMagic
-> DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData
NodeToNodeVersionData NetworkMagic
magic' DiffusionMode
mode PeerSharing
peerSharing' Bool
query)
        | NetworkMagic
magic' <- Word32 -> NetworkMagic
NetworkMagic (Word32 -> NetworkMagic) -> [Word32] -> [NetworkMagic]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word32 -> [Word32]
forall a. Arbitrary a => a -> [a]
shrink (NetworkMagic -> Word32
unNetworkMagic NetworkMagic
magic)
        , PeerSharing
peerSharing' <- PeerSharing -> [PeerSharing]
shrinkPeerSharing PeerSharing
peerSharing
        ]
        [ArbitraryNodeToNodeVersionData]
-> [ArbitraryNodeToNodeVersionData]
-> [ArbitraryNodeToNodeVersionData]
forall a. [a] -> [a] -> [a]
++
        [ NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NetworkMagic
-> DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData
NodeToNodeVersionData NetworkMagic
magic DiffusionMode
mode' PeerSharing
peerSharing' Bool
query)
        | DiffusionMode
mode' <- DiffusionMode -> [DiffusionMode]
shrinkMode DiffusionMode
mode
        , PeerSharing
peerSharing' <- PeerSharing -> [PeerSharing]
shrinkPeerSharing PeerSharing
peerSharing
        ]
        [ArbitraryNodeToNodeVersionData]
-> [ArbitraryNodeToNodeVersionData]
-> [ArbitraryNodeToNodeVersionData]
forall a. [a] -> [a] -> [a]
++
        [ NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NetworkMagic
-> DiffusionMode -> PeerSharing -> Bool -> NodeToNodeVersionData
NodeToNodeVersionData NetworkMagic
magic DiffusionMode
mode PeerSharing
peerSharing' Bool
query')
        | Bool
query' <- Bool -> [Bool]
forall a. Arbitrary a => a -> [a]
shrink Bool
query
        , PeerSharing
peerSharing' <- PeerSharing -> [PeerSharing]
shrinkPeerSharing PeerSharing
peerSharing
        ]
      where
        shrinkMode :: DiffusionMode -> [DiffusionMode]
        shrinkMode :: DiffusionMode -> [DiffusionMode]
shrinkMode DiffusionMode
InitiatorOnlyDiffusionMode = []
        shrinkMode DiffusionMode
InitiatorAndResponderDiffusionMode = [DiffusionMode
InitiatorOnlyDiffusionMode]

        shrinkPeerSharing :: PeerSharing -> [PeerSharing]
shrinkPeerSharing PeerSharing
PeerSharingDisabled = []
        shrinkPeerSharing PeerSharing
PeerSharingEnabled  = [PeerSharing
PeerSharingDisabled]

newtype ArbitraryNodeToNodeVersions =
        ArbitraryNodeToNodeVersions
          { ArbitraryNodeToNodeVersions
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
getArbitraryNodeToNodeVersiosn :: Versions NodeToNodeVersion
                                                       ArbitraryNodeToNodeVersionData Bool }

instance Show ArbitraryNodeToNodeVersions where
    show :: ArbitraryNodeToNodeVersions -> TestName
show (ArbitraryNodeToNodeVersions (Versions Map NodeToNodeVersion (Version ArbitraryNodeToNodeVersionData Bool)
vs))
      = TestName
"ArbitraryNodeToNodeVersions " TestName -> ShowS
forall a. [a] -> [a] -> [a]
++ Map NodeToNodeVersion ArbitraryNodeToNodeVersionData -> TestName
forall a. Show a => a -> TestName
show ((Version ArbitraryNodeToNodeVersionData Bool
 -> ArbitraryNodeToNodeVersionData)
-> Map
     NodeToNodeVersion (Version ArbitraryNodeToNodeVersionData Bool)
-> Map NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map Version ArbitraryNodeToNodeVersionData Bool
-> ArbitraryNodeToNodeVersionData
forall vData r. Version vData r -> vData
versionData Map NodeToNodeVersion (Version ArbitraryNodeToNodeVersionData Bool)
vs)

instance Arbitrary ArbitraryNodeToNodeVersions where
    arbitrary :: Gen ArbitraryNodeToNodeVersions
arbitrary = do
      vs <- Gen NodeToNodeVersion -> Gen [NodeToNodeVersion]
forall a. Gen a -> Gen [a]
listOf (ArbitraryNodeToNodeVersion -> NodeToNodeVersion
getNodeToNodeVersion (ArbitraryNodeToNodeVersion -> NodeToNodeVersion)
-> Gen ArbitraryNodeToNodeVersion -> Gen NodeToNodeVersion
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ArbitraryNodeToNodeVersion
forall a. Arbitrary a => Gen a
arbitrary)
      ds <- vectorOf (length vs) arbitrary
      r  <- arbitrary
      return $ ArbitraryNodeToNodeVersions
             $ Versions
             $ Map.fromList
                [ (v, Version (const r) d)
                | (v, d) <- zip vs ds
                ]
    -- TODO: shrink (issue #3407)


--
-- NodeToClient generators
--

newtype ArbitraryNodeToClientVersion =
        ArbitraryNodeToClientVersion { ArbitraryNodeToClientVersion -> NodeToClientVersion
getNodeToClientVersion :: NodeToClientVersion }
    deriving Int -> ArbitraryNodeToClientVersion -> ShowS
[ArbitraryNodeToClientVersion] -> ShowS
ArbitraryNodeToClientVersion -> TestName
(Int -> ArbitraryNodeToClientVersion -> ShowS)
-> (ArbitraryNodeToClientVersion -> TestName)
-> ([ArbitraryNodeToClientVersion] -> ShowS)
-> Show ArbitraryNodeToClientVersion
forall a.
(Int -> a -> ShowS) -> (a -> TestName) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArbitraryNodeToClientVersion -> ShowS
showsPrec :: Int -> ArbitraryNodeToClientVersion -> ShowS
$cshow :: ArbitraryNodeToClientVersion -> TestName
show :: ArbitraryNodeToClientVersion -> TestName
$cshowList :: [ArbitraryNodeToClientVersion] -> ShowS
showList :: [ArbitraryNodeToClientVersion] -> ShowS
Show

instance Arbitrary ArbitraryNodeToClientVersion where
    arbitrary :: Gen ArbitraryNodeToClientVersion
arbitrary = [ArbitraryNodeToClientVersion] -> Gen ArbitraryNodeToClientVersion
forall a. HasCallStack => [a] -> Gen a
elements (NodeToClientVersion -> ArbitraryNodeToClientVersion
ArbitraryNodeToClientVersion (NodeToClientVersion -> ArbitraryNodeToClientVersion)
-> [NodeToClientVersion] -> [ArbitraryNodeToClientVersion]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [NodeToClientVersion
forall a. Bounded a => a
minBound .. NodeToClientVersion
forall a. Bounded a => a
maxBound])

newtype ArbitraryNodeToClientVersionData =
        ArbitraryNodeToClientVersionData
          { ArbitraryNodeToClientVersionData -> NodeToClientVersionData
getNodeToClientVersionData :: NodeToClientVersionData }
    deriving Int -> ArbitraryNodeToClientVersionData -> ShowS
[ArbitraryNodeToClientVersionData] -> ShowS
ArbitraryNodeToClientVersionData -> TestName
(Int -> ArbitraryNodeToClientVersionData -> ShowS)
-> (ArbitraryNodeToClientVersionData -> TestName)
-> ([ArbitraryNodeToClientVersionData] -> ShowS)
-> Show ArbitraryNodeToClientVersionData
forall a.
(Int -> a -> ShowS) -> (a -> TestName) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArbitraryNodeToClientVersionData -> ShowS
showsPrec :: Int -> ArbitraryNodeToClientVersionData -> ShowS
$cshow :: ArbitraryNodeToClientVersionData -> TestName
show :: ArbitraryNodeToClientVersionData -> TestName
$cshowList :: [ArbitraryNodeToClientVersionData] -> ShowS
showList :: [ArbitraryNodeToClientVersionData] -> ShowS
Show

instance Arbitrary ArbitraryNodeToClientVersionData where
    arbitrary :: Gen ArbitraryNodeToClientVersionData
arbitrary = ( (NodeToClientVersionData -> ArbitraryNodeToClientVersionData
ArbitraryNodeToClientVersionData (NodeToClientVersionData -> ArbitraryNodeToClientVersionData)
-> (Bool -> NodeToClientVersionData)
-> Bool
-> ArbitraryNodeToClientVersionData
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)
                ((Bool -> NodeToClientVersionData)
 -> Bool -> ArbitraryNodeToClientVersionData)
-> (NetworkMagic -> Bool -> NodeToClientVersionData)
-> NetworkMagic
-> Bool
-> ArbitraryNodeToClientVersionData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NetworkMagic -> Bool -> NodeToClientVersionData
NodeToClientVersionData
                )
            (NetworkMagic -> Bool -> ArbitraryNodeToClientVersionData)
-> Gen NetworkMagic
-> Gen (Bool -> ArbitraryNodeToClientVersionData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Word32 -> NetworkMagic
NetworkMagic (Word32 -> NetworkMagic) -> Gen Word32 -> Gen NetworkMagic
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Word32
forall a. Arbitrary a => Gen a
arbitrary)
            Gen (Bool -> ArbitraryNodeToClientVersionData)
-> Gen Bool -> Gen ArbitraryNodeToClientVersionData
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
    shrink :: ArbitraryNodeToClientVersionData
-> [ArbitraryNodeToClientVersionData]
shrink (ArbitraryNodeToClientVersionData
             (NodeToClientVersionData NetworkMagic
magic Bool
query)) =
        [ NodeToClientVersionData -> ArbitraryNodeToClientVersionData
ArbitraryNodeToClientVersionData (NetworkMagic -> Bool -> NodeToClientVersionData
NodeToClientVersionData NetworkMagic
magic' Bool
query)
        | NetworkMagic
magic' <- Word32 -> NetworkMagic
NetworkMagic (Word32 -> NetworkMagic) -> [Word32] -> [NetworkMagic]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word32 -> [Word32]
forall a. Arbitrary a => a -> [a]
shrink (NetworkMagic -> Word32
unNetworkMagic NetworkMagic
magic)
        ]
        [ArbitraryNodeToClientVersionData]
-> [ArbitraryNodeToClientVersionData]
-> [ArbitraryNodeToClientVersionData]
forall a. [a] -> [a] -> [a]
++
        [ NodeToClientVersionData -> ArbitraryNodeToClientVersionData
ArbitraryNodeToClientVersionData (NetworkMagic -> Bool -> NodeToClientVersionData
NodeToClientVersionData NetworkMagic
magic Bool
query')
        | Bool
query' <- Bool -> [Bool]
forall a. Arbitrary a => a -> [a]
shrink Bool
query
        ]

newtype ArbitraryNodeToClientVersions =
        ArbitraryNodeToClientVersions
          { ArbitraryNodeToClientVersions
-> Versions NodeToClientVersion NodeToClientVersionData Bool
getArbitraryNodeToClientVersiosn :: Versions NodeToClientVersion
                                                       NodeToClientVersionData Bool }

instance Show ArbitraryNodeToClientVersions where
    show :: ArbitraryNodeToClientVersions -> TestName
show (ArbitraryNodeToClientVersions (Versions Map NodeToClientVersion (Version NodeToClientVersionData Bool)
vs))
      = TestName
"ArbitraryNodeToClientVersions " TestName -> ShowS
forall a. [a] -> [a] -> [a]
++ Map NodeToClientVersion NodeToClientVersionData -> TestName
forall a. Show a => a -> TestName
show ((Version NodeToClientVersionData Bool -> NodeToClientVersionData)
-> Map NodeToClientVersion (Version NodeToClientVersionData Bool)
-> Map NodeToClientVersion NodeToClientVersionData
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map Version NodeToClientVersionData Bool -> NodeToClientVersionData
forall vData r. Version vData r -> vData
versionData Map NodeToClientVersion (Version NodeToClientVersionData Bool)
vs)

instance Arbitrary ArbitraryNodeToClientVersions where
    arbitrary :: Gen ArbitraryNodeToClientVersions
arbitrary = do
      vs <- Gen NodeToClientVersion -> Gen [NodeToClientVersion]
forall a. Gen a -> Gen [a]
listOf (ArbitraryNodeToClientVersion -> NodeToClientVersion
getNodeToClientVersion (ArbitraryNodeToClientVersion -> NodeToClientVersion)
-> Gen ArbitraryNodeToClientVersion -> Gen NodeToClientVersion
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ArbitraryNodeToClientVersion
forall a. Arbitrary a => Gen a
arbitrary)
      ds <- vectorOf (length vs) (getNodeToClientVersionData <$> arbitrary)
      r  <- arbitrary
      return $ ArbitraryNodeToClientVersions
             $ Versions
             $ Map.fromList
                [ (v, Version (const r) d)
                | (v, d) <- zip vs ds
                ]
    -- TODO: shrink (issue #3407)


prop_acceptable_symmetric_NodeToNode
  :: ArbitraryNodeToNodeVersionData
  -> ArbitraryNodeToNodeVersionData
  -> Bool
prop_acceptable_symmetric_NodeToNode :: ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData -> Bool
prop_acceptable_symmetric_NodeToNode ArbitraryNodeToNodeVersionData
a ArbitraryNodeToNodeVersionData
b =
    ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData -> Bool
forall vData.
(Acceptable vData, Eq vData) =>
vData -> vData -> Bool
prop_acceptable_symmetric ArbitraryNodeToNodeVersionData
a ArbitraryNodeToNodeVersionData
b


prop_acceptable_symmetric_NodeToClient
  :: ArbitraryNodeToClientVersionData
  -> ArbitraryNodeToClientVersionData
  -> Bool
prop_acceptable_symmetric_NodeToClient :: ArbitraryNodeToClientVersionData
-> ArbitraryNodeToClientVersionData -> Bool
prop_acceptable_symmetric_NodeToClient (ArbitraryNodeToClientVersionData NodeToClientVersionData
a)
                                       (ArbitraryNodeToClientVersionData NodeToClientVersionData
b) =
    NodeToClientVersionData -> NodeToClientVersionData -> Bool
forall vData.
(Acceptable vData, Eq vData) =>
vData -> vData -> Bool
prop_acceptable_symmetric NodeToClientVersionData
a NodeToClientVersionData
b


-- | Run 'prop_query_version' in the simulation monad.
--
prop_query_version_NodeToNode_ST :: ArbitraryNodeToNodeVersions
                                 -> ArbitraryNodeToNodeVersions
                                 -> Property
prop_query_version_NodeToNode_ST :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_ST
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
   (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData)
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions
                    (\(ArbitraryNodeToNodeVersionData NodeToNodeVersionData
vd) ->
                      NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData)
-> NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$
                        NodeToNodeVersionData
vd { NTN.query = True
                           , NTN.peerSharing = PeerSharingEnabled
                           })

-- | Run 'prop_query_version' in the IO monad.
--
prop_query_version_NodeToNode_IO :: ArbitraryNodeToNodeVersions
                                 -> ArbitraryNodeToNodeVersions
                                 -> Property
prop_query_version_NodeToNode_IO :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_IO
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
   IO Property -> Property
forall prop. Testable prop => IO prop -> Property
ioProperty (IO Property -> Property) -> IO Property -> Property
forall a b. (a -> b) -> a -> b
$ IO (Channel IO ByteString, Channel IO ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure IO ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData)
-> IO Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IO (Channel IO ByteString, Channel IO ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure IO ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions
                    (\(ArbitraryNodeToNodeVersionData NodeToNodeVersionData
vd) ->
                      NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData)
-> NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$
                        NodeToNodeVersionData
vd { NTN.query = True
                           , NTN.peerSharing = PeerSharingEnabled
                           })

-- | Run 'prop_query_version' with SimNet.
--
prop_query_version_NodeToNode_SimNet :: ArbitraryNodeToNodeVersions
                                     -> ArbitraryNodeToNodeVersions
                                     -> Property
prop_query_version_NodeToNode_SimNet :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_query_version_NodeToNode_SimNet
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
   (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData)
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions
                    (\(ArbitraryNodeToNodeVersionData NodeToNodeVersionData
vd) ->
                      NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData (NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData)
-> NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> a -> b
$
                        NodeToNodeVersionData
vd { NTN.query = True
                           , NTN.peerSharing = PeerSharingEnabled
                           })

-- | Run 'prop_query_version' in the simulation monad.
--
prop_query_version_NodeToClient_ST :: ArbitraryNodeToClientVersions
                                   -> ArbitraryNodeToClientVersions
                                   -> Property
prop_query_version_NodeToClient_ST :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_ST
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
   (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> (NodeToClientVersionData -> NodeToClientVersionData)
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
                    ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
                    Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
                    Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions
                    (\NodeToClientVersionData
vd -> NodeToClientVersionData
vd {NTC.query = True})

-- | Run 'prop_query_version' in the IO monad.
--
prop_query_version_NodeToClient_IO :: ArbitraryNodeToClientVersions
                                   -> ArbitraryNodeToClientVersions
                                   -> Property
prop_query_version_NodeToClient_IO :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_IO
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
   IO Property -> Property
forall prop. Testable prop => IO prop -> Property
ioProperty (IO Property -> Property) -> IO Property -> Property
forall a b. (a -> b) -> a -> b
$ IO (Channel IO ByteString, Channel IO ByteString)
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     IO
     ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> (NodeToClientVersionData -> NodeToClientVersionData)
-> IO Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IO (Channel IO ByteString, Channel IO ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     IO
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
                    ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
                    Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
                    Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions
                    (\NodeToClientVersionData
vd -> NodeToClientVersionData
vd {NTC.query = True})

-- | Run 'prop_query_version' with SimNet.
--
prop_query_version_NodeToClient_SimNet :: ArbitraryNodeToClientVersions
                                       -> ArbitraryNodeToClientVersions
                                       -> Property
prop_query_version_NodeToClient_SimNet :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_query_version_NodeToClient_SimNet
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
     (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
   (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> (NodeToClientVersionData -> NodeToClientVersionData)
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Eq vData, Acceptable vData,
 Queryable vData, Show vData, Ord vNumber, Show vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> (vData -> vData)
-> m Property
prop_query_version
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
                    ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
                    Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
                    Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions
                    (\NodeToClientVersionData
vd -> NodeToClientVersionData
vd {NTC.query = True})


-- | Run a query for the server's supported version.
--
prop_peerSharing_symmetric ::
                           ( MonadAsync m
                           , MonadCatch m
                           )
                           => m (Channel m ByteString, Channel m ByteString)
                           -> Codec (Handshake NodeToNodeVersion CBOR.Term)
                                     CBOR.DeserialiseFailure m ByteString
                           -> VersionDataCodec CBOR.Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
                           -> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
                           -> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
                           -> m Property
prop_peerSharing_symmetric :: forall (m :: * -> *).
(MonadAsync m, MonadCatch m) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure m ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> m Property
prop_peerSharing_symmetric m (Channel m ByteString, Channel m ByteString)
createChannels Codec
  (Handshake NodeToNodeVersion Term) DeserialiseFailure m ByteString
codec VersionDataCodec
  Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
versionDataCodec Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions = do
  (clientRes, serverRes) <-
    m (Channel m ByteString, Channel m ByteString)
-> Tracer
     m (Role, TraceSendRecv (Handshake NodeToNodeVersion Term))
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure m ByteString
-> Peer
     (Handshake NodeToNodeVersion Term)
     'AsClient
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
-> Peer
     (Handshake NodeToNodeVersion Term)
     (FlipAgency 'AsClient)
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
-> m (Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData),
      Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
forall ps (pr :: PeerRole) (st :: ps) failure bytes (m :: * -> *) a
       b.
(MonadAsync m, MonadThrow m, ShowProxy ps,
 forall (st' :: ps) stok. (stok ~ StateToken st') => Show stok,
 Show failure) =>
m (Channel m bytes, Channel m bytes)
-> Tracer m (Role, TraceSendRecv ps)
-> Codec ps failure m bytes
-> Peer ps pr 'NonPipelined st m a
-> Peer ps (FlipAgency pr) 'NonPipelined st m b
-> m (a, b)
runConnectedPeers
      m (Channel m ByteString, Channel m ByteString)
createChannels Tracer m (Role, TraceSendRecv (Handshake NodeToNodeVersion Term))
forall (m :: * -> *) a. Applicative m => Tracer m a
nullTracer Codec
  (Handshake NodeToNodeVersion Term) DeserialiseFailure m ByteString
codec
      (VersionDataCodec
  Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData
    -> Accept ArbitraryNodeToNodeVersionData)
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Peer
     (Handshake NodeToNodeVersion Term)
     'AsClient
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
forall vNumber vData r (m :: * -> *).
Ord vNumber =>
VersionDataCodec Term vNumber vData
-> (vData -> vData -> Accept vData)
-> Versions vNumber vData r
-> Client
     (Handshake vNumber Term)
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError vNumber) (HandshakeResult r vNumber vData))
handshakeClientPeer
        VersionDataCodec
  Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
versionDataCodec
        ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData
-> Accept ArbitraryNodeToNodeVersionData
forall v. Acceptable v => v -> v -> Accept v
acceptableVersion
        Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
      (VersionDataCodec
  Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> (ArbitraryNodeToNodeVersionData
    -> ArbitraryNodeToNodeVersionData
    -> Accept ArbitraryNodeToNodeVersionData)
-> (ArbitraryNodeToNodeVersionData -> Bool)
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Server
     (Handshake NodeToNodeVersion Term)
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError NodeToNodeVersion)
        (HandshakeResult
           Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
forall vNumber vData r (m :: * -> *).
Ord vNumber =>
VersionDataCodec Term vNumber vData
-> (vData -> vData -> Accept vData)
-> (vData -> Bool)
-> Versions vNumber vData r
-> Server
     (Handshake vNumber Term)
     'NonPipelined
     'StPropose
     m
     (Either
        (HandshakeProtocolError vNumber) (HandshakeResult r vNumber vData))
handshakeServerPeer
        VersionDataCodec
  Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
versionDataCodec
        ArbitraryNodeToNodeVersionData
-> ArbitraryNodeToNodeVersionData
-> Accept ArbitraryNodeToNodeVersionData
forall v. Acceptable v => v -> v -> Accept v
acceptableVersion
        ArbitraryNodeToNodeVersionData -> Bool
forall v. Queryable v => v -> Bool
queryVersion
        Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions)
  pure $ case (clientRes, serverRes) of
    -- TODO: make this return ArbitraryNodeToNodeVersionData rather than a pair
    -- of NodeToNodeVersionData
    (  Right (HandshakeNegotiationResult Bool
_ NodeToNodeVersion
v (ArbitraryNodeToNodeVersionData NodeToNodeVersionData
clientResult))
     , Right (HandshakeNegotiationResult Bool
_ NodeToNodeVersion
v' (ArbitraryNodeToNodeVersionData NodeToNodeVersionData
serverResult))
     ) | NodeToNodeVersion
v NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Eq a => a -> a -> Bool
== NodeToNodeVersion
v'
       , NodeToNodeVersion
v NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= NodeToNodeVersion
NodeToNodeV_14 ->
         TestName -> Property -> Property
forall prop. Testable prop => TestName -> prop -> Property
counterexample
              (TestName
"VersionNumber: " TestName -> ShowS
forall a. [a] -> [a] -> [a]
++ NodeToNodeVersion -> TestName
forall a. Show a => a -> TestName
show NodeToNodeVersion
v)
          (Property -> Property) -> Property -> Property
forall a b. (a -> b) -> a -> b
$ NodeToNodeVersionData
clientResult NodeToNodeVersionData -> NodeToNodeVersionData -> Property
forall a. (Eq a, Show a) => a -> a -> Property
=== NodeToNodeVersionData
serverResult
       | NodeToNodeVersion
v NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Eq a => a -> a -> Bool
== NodeToNodeVersion
v'
       , NodeToNodeVersion
v NodeToNodeVersion -> NodeToNodeVersion -> Bool
forall a. Ord a => a -> a -> Bool
< NodeToNodeVersion
NodeToNodeV_14  -> Bool -> Property
forall prop. Testable prop => prop -> Property
property Bool
True
       | Bool
otherwise  -> TestName -> Bool -> Property
forall prop. Testable prop => TestName -> prop -> Property
counterexample TestName
"Version mismatch" Bool
False
    (Right HandshakeResult
  Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData
_, Left HandshakeProtocolError NodeToNodeVersion
_) -> TestName -> Bool -> Property
forall prop. Testable prop => TestName -> prop -> Property
counterexample TestName
"Acceptance mismatch" Bool
False
    (Left HandshakeProtocolError NodeToNodeVersion
_, Right HandshakeResult
  Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData
_) -> TestName -> Bool -> Property
forall prop. Testable prop => TestName -> prop -> Property
counterexample TestName
"Acceptance mismatch" Bool
False
    (Either
   (HandshakeProtocolError NodeToNodeVersion)
   (HandshakeResult
      Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData),
 Either
   (HandshakeProtocolError NodeToNodeVersion)
   (HandshakeResult
      Bool NodeToNodeVersion ArbitraryNodeToNodeVersionData))
_ -> Bool -> Property
forall prop. Testable prop => prop -> Property
property Bool
True

-- | Run 'prop_peerSharing_symmetric' with SimNet.
--
prop_peerSharing_symmetric_NodeToNode_SimNet
  :: ArbitraryNodeToNodeVersions
  -> ArbitraryNodeToNodeVersions
  -> Property
prop_peerSharing_symmetric_NodeToNode_SimNet :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_peerSharing_symmetric_NodeToNode_SimNet
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
     (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
   (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> IOSim s Property
forall (m :: * -> *).
(MonadAsync m, MonadCatch m) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure m ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> m Property
prop_peerSharing_symmetric
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions


prop_acceptOrRefuse_symmetric_NodeToNode
  :: ArbitraryNodeToNodeVersions
  -> ArbitraryNodeToNodeVersions
  -> Property
prop_acceptOrRefuse_symmetric_NodeToNode :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_acceptOrRefuse_symmetric_NodeToNode (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
a)
                                         (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
b) =

  Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Property
forall vNumber vData r.
(Acceptable vData, Eq vData, Show vData, Ord vNumber,
 Show vNumber) =>
Versions vNumber vData r -> Versions vNumber vData r -> Property
prop_acceptOrRefuse_symmetric Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
a Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
b


prop_acceptOrRefuse_symmetric_NodeToClient
  :: ArbitraryNodeToClientVersions
  -> ArbitraryNodeToClientVersions
  -> Property
prop_acceptOrRefuse_symmetric_NodeToClient :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_acceptOrRefuse_symmetric_NodeToClient (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
a)
                                           (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
b) =

  Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Property
forall vNumber vData r.
(Acceptable vData, Eq vData, Show vData, Ord vNumber,
 Show vNumber) =>
Versions vNumber vData r -> Versions vNumber vData r -> Property
prop_acceptOrRefuse_symmetric Versions NodeToClientVersion NodeToClientVersionData Bool
a Versions NodeToClientVersion NodeToClientVersionData Bool
b


prop_channel_simultaneous_open_NodeToNode_ST :: ArbitraryNodeToNodeVersions
                                             -> ArbitraryNodeToNodeVersions
                                             -> Property
prop_channel_simultaneous_open_NodeToNode_ST :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_ST
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
  (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Acceptable vData, Ord vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions

transformNodeToNodeVersionData :: CodecCBORTerm Text NodeToNodeVersionData
          -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData :: CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData (CodecCBORTerm NodeToNodeVersionData -> Term
g Term -> Either Text NodeToNodeVersionData
h) =
  CodecCBORTerm { encodeTerm :: ArbitraryNodeToNodeVersionData -> Term
encodeTerm = \(ArbitraryNodeToNodeVersionData NodeToNodeVersionData
a) -> NodeToNodeVersionData -> Term
g NodeToNodeVersionData
a
                , decodeTerm :: Term -> Either Text ArbitraryNodeToNodeVersionData
decodeTerm = (Either Text NodeToNodeVersionData
 -> Either Text ArbitraryNodeToNodeVersionData)
-> (Term -> Either Text NodeToNodeVersionData)
-> Term
-> Either Text ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> (Term -> a) -> Term -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData)
-> Either Text NodeToNodeVersionData
-> Either Text ArbitraryNodeToNodeVersionData
forall a b. (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NodeToNodeVersionData -> ArbitraryNodeToNodeVersionData
ArbitraryNodeToNodeVersionData) Term -> Either Text NodeToNodeVersionData
h
                }


prop_channel_simultaneous_open_NodeToNode_IO :: ArbitraryNodeToNodeVersions
                                             -> ArbitraryNodeToNodeVersions
                                             -> Property
prop_channel_simultaneous_open_NodeToNode_IO :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_IO
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
  IO Property -> Property
forall prop. Testable prop => IO prop -> Property
ioProperty (IO Property -> Property) -> IO Property -> Property
forall a b. (a -> b) -> a -> b
$ IO (Channel IO ByteString, Channel IO ByteString)
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure IO ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> IO Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Acceptable vData, Ord vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open
                    IO (Channel IO ByteString, Channel IO ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term) DeserialiseFailure IO ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
                    ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
                    Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions


prop_channel_simultaneous_open_NodeToClient_ST :: ArbitraryNodeToClientVersions
                                               -> ArbitraryNodeToClientVersions
                                               -> Property
prop_channel_simultaneous_open_NodeToClient_ST :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_ST
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
  (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> IOSim s Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Acceptable vData, Ord vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open
                    IOSim
  s (Channel (IOSim s) ByteString, Channel (IOSim s) ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
                    ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
                    Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
                    Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions


prop_channel_simultaneous_open_NodeToClient_IO :: ArbitraryNodeToClientVersions
                                               -> ArbitraryNodeToClientVersions
                                               -> Property
prop_channel_simultaneous_open_NodeToClient_IO :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_IO
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
  IO Property -> Property
forall prop. Testable prop => IO prop -> Property
ioProperty (IO Property -> Property) -> IO Property -> Property
forall a b. (a -> b) -> a -> b
$ IO (Channel IO ByteString, Channel IO ByteString)
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     IO
     ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> IO Property
forall (m :: * -> *) vData vNumber.
(MonadAsync m, MonadCatch m, Acceptable vData, Ord vNumber) =>
m (Channel m ByteString, Channel m ByteString)
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open
                    IO (Channel IO ByteString, Channel IO ByteString)
forall (m :: * -> *) a. MonadSTM m => m (Channel m a, Channel m a)
createConnectedChannels
                    (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     IO
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
                    ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
                    Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
                    Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions


prop_channel_simultaneous_open_NodeToNode_SimNet :: ArbitraryNodeToNodeVersions
                                                 -> ArbitraryNodeToNodeVersions
                                                 -> Property
prop_channel_simultaneous_open_NodeToNode_SimNet :: ArbitraryNodeToNodeVersions
-> ArbitraryNodeToNodeVersions -> Property
prop_channel_simultaneous_open_NodeToNode_SimNet
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions)
    (ArbitraryNodeToNodeVersions Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions) =
      (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ Codec
  (Handshake NodeToNodeVersion Term)
  DeserialiseFailure
  (IOSim s)
  ByteString
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
-> IOSim s Property
forall vNumber vData (m :: * -> *).
(Alternative (STM m), MonadAsync m, MonadDelay m,
 MonadLabelledSTM m, MonadMask m, MonadThrow (STM m), MonadTime m,
 MonadTimer m, Acceptable vData, Ord vNumber) =>
Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open_sim
        (CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
-> Codec
     (Handshake NodeToNodeVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToNodeVersion
nodeToNodeVersionCodec)
        ((NodeToNodeVersion
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> VersionDataCodec
     Term NodeToNodeVersion ArbitraryNodeToNodeVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec ((CodecCBORTerm Text NodeToNodeVersionData
 -> CodecCBORTerm Text ArbitraryNodeToNodeVersionData)
-> (NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData)
-> NodeToNodeVersion
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
forall a b.
(a -> b) -> (NodeToNodeVersion -> a) -> NodeToNodeVersion -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CodecCBORTerm Text NodeToNodeVersionData
-> CodecCBORTerm Text ArbitraryNodeToNodeVersionData
transformNodeToNodeVersionData NodeToNodeVersion -> CodecCBORTerm Text NodeToNodeVersionData
nodeToNodeCodecCBORTerm))
        Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
clientVersions
        Versions NodeToNodeVersion ArbitraryNodeToNodeVersionData Bool
serverVersions

prop_channel_simultaneous_open_NodeToClient_SimNet :: ArbitraryNodeToClientVersions
                                                   -> ArbitraryNodeToClientVersions
                                                   -> Property
prop_channel_simultaneous_open_NodeToClient_SimNet :: ArbitraryNodeToClientVersions
-> ArbitraryNodeToClientVersions -> Property
prop_channel_simultaneous_open_NodeToClient_SimNet
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions)
    (ArbitraryNodeToClientVersions Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions) =
      (forall s. IOSim s Property) -> Property
forall a. (forall s. IOSim s a) -> a
runSimOrThrow ((forall s. IOSim s Property) -> Property)
-> (forall s. IOSim s Property) -> Property
forall a b. (a -> b) -> a -> b
$ Codec
  (Handshake NodeToClientVersion Term)
  DeserialiseFailure
  (IOSim s)
  ByteString
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> Versions NodeToClientVersion NodeToClientVersionData Bool
-> IOSim s Property
forall vNumber vData (m :: * -> *).
(Alternative (STM m), MonadAsync m, MonadDelay m,
 MonadLabelledSTM m, MonadMask m, MonadThrow (STM m), MonadTime m,
 MonadTimer m, Acceptable vData, Ord vNumber) =>
Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
-> VersionDataCodec Term vNumber vData
-> Versions vNumber vData Bool
-> Versions vNumber vData Bool
-> m Property
prop_channel_simultaneous_open_sim
        (CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
-> Codec
     (Handshake NodeToClientVersion Term)
     DeserialiseFailure
     (IOSim s)
     ByteString
forall vNumber (m :: * -> *) failure.
(MonadST m, Ord vNumber, Show failure) =>
CodecCBORTerm (failure, Maybe Int) vNumber
-> Codec (Handshake vNumber Term) DeserialiseFailure m ByteString
codecHandshake CodecCBORTerm (Text, Maybe Int) NodeToClientVersion
nodeToClientVersionCodec)
        ((NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData)
-> VersionDataCodec
     Term NodeToClientVersion NodeToClientVersionData
forall vNumber vData.
(vNumber -> CodecCBORTerm Text vData)
-> VersionDataCodec Term vNumber vData
cborTermVersionDataCodec NodeToClientVersion -> CodecCBORTerm Text NodeToClientVersionData
nodeToClientCodecCBORTerm)
        Versions NodeToClientVersion NodeToClientVersionData Bool
clientVersions
        Versions NodeToClientVersion NodeToClientVersionData Bool
serverVersions