mocks

package

Go to main page

Versions in this module

v0

v0.0.6

May 6, 2024

Changes in this version

+ type MockConnectionFlowControllerAddBytesReadCall struct

+ func (c *MockConnectionFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesReadCall

+ func (c *MockConnectionFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesReadCall

+ func (c *MockConnectionFlowControllerAddBytesReadCall) Return() *MockConnectionFlowControllerAddBytesReadCall

+ type MockConnectionFlowControllerAddBytesSentCall struct

+ func (c *MockConnectionFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesSentCall

+ func (c *MockConnectionFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesSentCall

+ func (c *MockConnectionFlowControllerAddBytesSentCall) Return() *MockConnectionFlowControllerAddBytesSentCall

+ type MockConnectionFlowControllerGetWindowUpdateCall struct

+ func (c *MockConnectionFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall

+ func (c *MockConnectionFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall

+ func (c *MockConnectionFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall

+ type MockConnectionFlowControllerIsNewlyBlockedCall struct

+ func (c *MockConnectionFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *MockConnectionFlowControllerIsNewlyBlockedCall

+ func (c *MockConnectionFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *MockConnectionFlowControllerIsNewlyBlockedCall

+ func (c *MockConnectionFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *MockConnectionFlowControllerIsNewlyBlockedCall

+ type MockConnectionFlowControllerResetCall struct

+ func (c *MockConnectionFlowControllerResetCall) Do(f func() error) *MockConnectionFlowControllerResetCall

+ func (c *MockConnectionFlowControllerResetCall) DoAndReturn(f func() error) *MockConnectionFlowControllerResetCall

+ func (c *MockConnectionFlowControllerResetCall) Return(arg0 error) *MockConnectionFlowControllerResetCall

+ type MockConnectionFlowControllerSendWindowSizeCall struct

+ func (c *MockConnectionFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall

+ func (c *MockConnectionFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall

+ func (c *MockConnectionFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall

+ type MockConnectionFlowControllerUpdateSendWindowCall struct

+ func (c *MockConnectionFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *MockConnectionFlowControllerUpdateSendWindowCall

+ func (c *MockConnectionFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockConnectionFlowControllerUpdateSendWindowCall

+ func (c *MockConnectionFlowControllerUpdateSendWindowCall) Return(arg0 bool) *MockConnectionFlowControllerUpdateSendWindowCall

+ type MockCryptoSetupChangeConnectionIDCall struct

+ func (c *MockCryptoSetupChangeConnectionIDCall) Do(f func(protocol.ConnectionID)) *MockCryptoSetupChangeConnectionIDCall

+ func (c *MockCryptoSetupChangeConnectionIDCall) DoAndReturn(f func(protocol.ConnectionID)) *MockCryptoSetupChangeConnectionIDCall

+ func (c *MockCryptoSetupChangeConnectionIDCall) Return() *MockCryptoSetupChangeConnectionIDCall

+ type MockCryptoSetupCloseCall struct

+ func (c *MockCryptoSetupCloseCall) Do(f func() error) *MockCryptoSetupCloseCall

+ func (c *MockCryptoSetupCloseCall) DoAndReturn(f func() error) *MockCryptoSetupCloseCall

+ func (c *MockCryptoSetupCloseCall) Return(arg0 error) *MockCryptoSetupCloseCall

+ type MockCryptoSetupConnectionStateCall struct

+ func (c *MockCryptoSetupConnectionStateCall) Do(f func() handshake.ConnectionState) *MockCryptoSetupConnectionStateCall

+ func (c *MockCryptoSetupConnectionStateCall) DoAndReturn(f func() handshake.ConnectionState) *MockCryptoSetupConnectionStateCall

+ func (c *MockCryptoSetupConnectionStateCall) Return(arg0 handshake.ConnectionState) *MockCryptoSetupConnectionStateCall

+ type MockCryptoSetupDiscardInitialKeysCall struct

+ func (c *MockCryptoSetupDiscardInitialKeysCall) Do(f func()) *MockCryptoSetupDiscardInitialKeysCall

+ func (c *MockCryptoSetupDiscardInitialKeysCall) DoAndReturn(f func()) *MockCryptoSetupDiscardInitialKeysCall

+ func (c *MockCryptoSetupDiscardInitialKeysCall) Return() *MockCryptoSetupDiscardInitialKeysCall

+ type MockCryptoSetupGet0RTTOpenerCall struct

+ func (c *MockCryptoSetupGet0RTTOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGet0RTTOpenerCall

+ func (c *MockCryptoSetupGet0RTTOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGet0RTTOpenerCall

+ func (c *MockCryptoSetupGet0RTTOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGet0RTTOpenerCall

+ type MockCryptoSetupGet0RTTSealerCall struct

+ func (c *MockCryptoSetupGet0RTTSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGet0RTTSealerCall

+ func (c *MockCryptoSetupGet0RTTSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGet0RTTSealerCall

+ func (c *MockCryptoSetupGet0RTTSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGet0RTTSealerCall

+ type MockCryptoSetupGet1RTTOpenerCall struct

+ func (c *MockCryptoSetupGet1RTTOpenerCall) Do(f func() (handshake.ShortHeaderOpener, error)) *MockCryptoSetupGet1RTTOpenerCall

+ func (c *MockCryptoSetupGet1RTTOpenerCall) DoAndReturn(f func() (handshake.ShortHeaderOpener, error)) *MockCryptoSetupGet1RTTOpenerCall

+ func (c *MockCryptoSetupGet1RTTOpenerCall) Return(arg0 handshake.ShortHeaderOpener, arg1 error) *MockCryptoSetupGet1RTTOpenerCall

+ type MockCryptoSetupGet1RTTSealerCall struct

+ func (c *MockCryptoSetupGet1RTTSealerCall) Do(f func() (handshake.ShortHeaderSealer, error)) *MockCryptoSetupGet1RTTSealerCall

+ func (c *MockCryptoSetupGet1RTTSealerCall) DoAndReturn(f func() (handshake.ShortHeaderSealer, error)) *MockCryptoSetupGet1RTTSealerCall

+ func (c *MockCryptoSetupGet1RTTSealerCall) Return(arg0 handshake.ShortHeaderSealer, arg1 error) *MockCryptoSetupGet1RTTSealerCall

+ type MockCryptoSetupGetHandshakeOpenerCall struct

+ func (c *MockCryptoSetupGetHandshakeOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetHandshakeOpenerCall

+ func (c *MockCryptoSetupGetHandshakeOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetHandshakeOpenerCall

+ func (c *MockCryptoSetupGetHandshakeOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGetHandshakeOpenerCall

+ type MockCryptoSetupGetHandshakeSealerCall struct

+ func (c *MockCryptoSetupGetHandshakeSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetHandshakeSealerCall

+ func (c *MockCryptoSetupGetHandshakeSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetHandshakeSealerCall

+ func (c *MockCryptoSetupGetHandshakeSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGetHandshakeSealerCall

+ type MockCryptoSetupGetInitialOpenerCall struct

+ func (c *MockCryptoSetupGetInitialOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetInitialOpenerCall

+ func (c *MockCryptoSetupGetInitialOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetInitialOpenerCall

+ func (c *MockCryptoSetupGetInitialOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGetInitialOpenerCall

+ type MockCryptoSetupGetInitialSealerCall struct

+ func (c *MockCryptoSetupGetInitialSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetInitialSealerCall

+ func (c *MockCryptoSetupGetInitialSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetInitialSealerCall

+ func (c *MockCryptoSetupGetInitialSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGetInitialSealerCall

+ type MockCryptoSetupGetSessionTicketCall struct

+ func (c *MockCryptoSetupGetSessionTicketCall) Do(f func() ([]byte, error)) *MockCryptoSetupGetSessionTicketCall

+ func (c *MockCryptoSetupGetSessionTicketCall) DoAndReturn(f func() ([]byte, error)) *MockCryptoSetupGetSessionTicketCall

+ func (c *MockCryptoSetupGetSessionTicketCall) Return(arg0 []byte, arg1 error) *MockCryptoSetupGetSessionTicketCall

+ type MockCryptoSetupHandleMessageCall struct

+ func (c *MockCryptoSetupHandleMessageCall) Do(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoSetupHandleMessageCall

+ func (c *MockCryptoSetupHandleMessageCall) DoAndReturn(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoSetupHandleMessageCall

+ func (c *MockCryptoSetupHandleMessageCall) Return(arg0 error) *MockCryptoSetupHandleMessageCall

+ type MockCryptoSetupNextEventCall struct

+ func (c *MockCryptoSetupNextEventCall) Do(f func() handshake.Event) *MockCryptoSetupNextEventCall

+ func (c *MockCryptoSetupNextEventCall) DoAndReturn(f func() handshake.Event) *MockCryptoSetupNextEventCall

+ func (c *MockCryptoSetupNextEventCall) Return(arg0 handshake.Event) *MockCryptoSetupNextEventCall

+ type MockCryptoSetupSetHandshakeConfirmedCall struct

+ func (c *MockCryptoSetupSetHandshakeConfirmedCall) Do(f func()) *MockCryptoSetupSetHandshakeConfirmedCall

+ func (c *MockCryptoSetupSetHandshakeConfirmedCall) DoAndReturn(f func()) *MockCryptoSetupSetHandshakeConfirmedCall

+ func (c *MockCryptoSetupSetHandshakeConfirmedCall) Return() *MockCryptoSetupSetHandshakeConfirmedCall

+ type MockCryptoSetupSetLargest1RTTAckedCall struct

+ func (c *MockCryptoSetupSetLargest1RTTAckedCall) Do(f func(protocol.PacketNumber) error) *MockCryptoSetupSetLargest1RTTAckedCall

+ func (c *MockCryptoSetupSetLargest1RTTAckedCall) DoAndReturn(f func(protocol.PacketNumber) error) *MockCryptoSetupSetLargest1RTTAckedCall

+ func (c *MockCryptoSetupSetLargest1RTTAckedCall) Return(arg0 error) *MockCryptoSetupSetLargest1RTTAckedCall

+ type MockCryptoSetupStartHandshakeCall struct

+ func (c *MockCryptoSetupStartHandshakeCall) Do(f func() error) *MockCryptoSetupStartHandshakeCall

+ func (c *MockCryptoSetupStartHandshakeCall) DoAndReturn(f func() error) *MockCryptoSetupStartHandshakeCall

+ func (c *MockCryptoSetupStartHandshakeCall) Return(arg0 error) *MockCryptoSetupStartHandshakeCall

+ type MockLongHeaderOpenerDecodePacketNumberCall struct

+ func (c *MockLongHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall

+ func (c *MockLongHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall

+ func (c *MockLongHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall

+ type MockLongHeaderOpenerDecryptHeaderCall struct

+ func (c *MockLongHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockLongHeaderOpenerDecryptHeaderCall

+ func (c *MockLongHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockLongHeaderOpenerDecryptHeaderCall

+ func (c *MockLongHeaderOpenerDecryptHeaderCall) Return() *MockLongHeaderOpenerDecryptHeaderCall

+ type MockLongHeaderOpenerOpenCall struct

+ func (c *MockLongHeaderOpenerOpenCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *MockLongHeaderOpenerOpenCall

+ func (c *MockLongHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *MockLongHeaderOpenerOpenCall

+ func (c *MockLongHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *MockLongHeaderOpenerOpenCall

+ type MockSendAlgorithmWithDebugInfosCanSendCall struct

+ func (c *MockSendAlgorithmWithDebugInfosCanSendCall) Do(f func(protocol.ByteCount) bool) *MockSendAlgorithmWithDebugInfosCanSendCall

+ func (c *MockSendAlgorithmWithDebugInfosCanSendCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockSendAlgorithmWithDebugInfosCanSendCall

+ func (c *MockSendAlgorithmWithDebugInfosCanSendCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosCanSendCall

+ type MockSendAlgorithmWithDebugInfosGetCongestionWindowCall struct

+ func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Do(f func() protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall

+ func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) DoAndReturn(f func() protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall

+ func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Return(arg0 protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall

+ type MockSendAlgorithmWithDebugInfosHasPacingBudgetCall struct

+ func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Do(f func(time.Time) bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall

+ func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) DoAndReturn(f func(time.Time) bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall

+ func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall

+ type MockSendAlgorithmWithDebugInfosInRecoveryCall struct

+ func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) Do(f func() bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall

+ func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) DoAndReturn(f func() bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall

+ func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall

+ type MockSendAlgorithmWithDebugInfosInSlowStartCall struct

+ func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) Do(f func() bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall

+ func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) DoAndReturn(f func() bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall

+ func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall

+ type MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall struct

+ func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Do(f func()) *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall

+ func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) DoAndReturn(f func()) *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall

+ func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Return() *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall

+ type MockSendAlgorithmWithDebugInfosOnCongestionEventCall struct

+ func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall

+ func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall

+ func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Return() *MockSendAlgorithmWithDebugInfosOnCongestionEventCall

+ type MockSendAlgorithmWithDebugInfosOnPacketAckedCall struct

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Do(...) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) DoAndReturn(...) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

+ type MockSendAlgorithmWithDebugInfosOnPacketSentCall struct

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Do(...) *MockSendAlgorithmWithDebugInfosOnPacketSentCall

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) DoAndReturn(...) *MockSendAlgorithmWithDebugInfosOnPacketSentCall

+ func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketSentCall

+ type MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall struct

+ func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Do(f func(bool)) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall

+ func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) DoAndReturn(f func(bool)) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall

+ func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Return() *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall

+ type MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall struct

+ func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Do(f func(protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall

+ func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) DoAndReturn(f func(protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall

+ func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Return() *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall

+ type MockSendAlgorithmWithDebugInfosTimeUntilSendCall struct

+ func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Do(f func(protocol.ByteCount) time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall

+ func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) DoAndReturn(f func(protocol.ByteCount) time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall

+ func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Return(arg0 time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall

+ type MockShortHeaderOpenerDecodePacketNumberCall struct

+ func (c *MockShortHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall

+ func (c *MockShortHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall

+ func (c *MockShortHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall

+ type MockShortHeaderOpenerDecryptHeaderCall struct

+ func (c *MockShortHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockShortHeaderOpenerDecryptHeaderCall

+ func (c *MockShortHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockShortHeaderOpenerDecryptHeaderCall

+ func (c *MockShortHeaderOpenerDecryptHeaderCall) Return() *MockShortHeaderOpenerDecryptHeaderCall

+ type MockShortHeaderOpenerOpenCall struct

+ func (c *MockShortHeaderOpenerOpenCall) Do(...) *MockShortHeaderOpenerOpenCall

+ func (c *MockShortHeaderOpenerOpenCall) DoAndReturn(...) *MockShortHeaderOpenerOpenCall

+ func (c *MockShortHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *MockShortHeaderOpenerOpenCall

+ type MockShortHeaderSealerEncryptHeaderCall struct

+ func (c *MockShortHeaderSealerEncryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockShortHeaderSealerEncryptHeaderCall

+ func (c *MockShortHeaderSealerEncryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockShortHeaderSealerEncryptHeaderCall

+ func (c *MockShortHeaderSealerEncryptHeaderCall) Return() *MockShortHeaderSealerEncryptHeaderCall

+ type MockShortHeaderSealerKeyPhaseCall struct

+ func (c *MockShortHeaderSealerKeyPhaseCall) Do(f func() protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall

+ func (c *MockShortHeaderSealerKeyPhaseCall) DoAndReturn(f func() protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall

+ func (c *MockShortHeaderSealerKeyPhaseCall) Return(arg0 protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall

+ type MockShortHeaderSealerOverheadCall struct

+ func (c *MockShortHeaderSealerOverheadCall) Do(f func() int) *MockShortHeaderSealerOverheadCall

+ func (c *MockShortHeaderSealerOverheadCall) DoAndReturn(f func() int) *MockShortHeaderSealerOverheadCall

+ func (c *MockShortHeaderSealerOverheadCall) Return(arg0 int) *MockShortHeaderSealerOverheadCall

+ type MockShortHeaderSealerSealCall struct

+ func (c *MockShortHeaderSealerSealCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *MockShortHeaderSealerSealCall

+ func (c *MockShortHeaderSealerSealCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *MockShortHeaderSealerSealCall

+ func (c *MockShortHeaderSealerSealCall) Return(arg0 []byte) *MockShortHeaderSealerSealCall

+ type MockStreamFlowControllerAbandonCall struct

+ func (c *MockStreamFlowControllerAbandonCall) Do(f func()) *MockStreamFlowControllerAbandonCall

+ func (c *MockStreamFlowControllerAbandonCall) DoAndReturn(f func()) *MockStreamFlowControllerAbandonCall

+ func (c *MockStreamFlowControllerAbandonCall) Return() *MockStreamFlowControllerAbandonCall

+ type MockStreamFlowControllerAddBytesReadCall struct

+ func (c *MockStreamFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesReadCall

+ func (c *MockStreamFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesReadCall

+ func (c *MockStreamFlowControllerAddBytesReadCall) Return() *MockStreamFlowControllerAddBytesReadCall

+ type MockStreamFlowControllerAddBytesSentCall struct

+ func (c *MockStreamFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesSentCall

+ func (c *MockStreamFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesSentCall

+ func (c *MockStreamFlowControllerAddBytesSentCall) Return() *MockStreamFlowControllerAddBytesSentCall

+ type MockStreamFlowControllerGetWindowUpdateCall struct

+ func (c *MockStreamFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall

+ func (c *MockStreamFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall

+ func (c *MockStreamFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall

+ type MockStreamFlowControllerIsNewlyBlockedCall struct

+ func (c *MockStreamFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *MockStreamFlowControllerIsNewlyBlockedCall

+ func (c *MockStreamFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *MockStreamFlowControllerIsNewlyBlockedCall

+ func (c *MockStreamFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *MockStreamFlowControllerIsNewlyBlockedCall

+ type MockStreamFlowControllerSendWindowSizeCall struct

+ func (c *MockStreamFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall

+ func (c *MockStreamFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall

+ func (c *MockStreamFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall

+ type MockStreamFlowControllerUpdateHighestReceivedCall struct

+ func (c *MockStreamFlowControllerUpdateHighestReceivedCall) Do(f func(protocol.ByteCount, bool) error) *MockStreamFlowControllerUpdateHighestReceivedCall

+ func (c *MockStreamFlowControllerUpdateHighestReceivedCall) DoAndReturn(f func(protocol.ByteCount, bool) error) *MockStreamFlowControllerUpdateHighestReceivedCall

+ func (c *MockStreamFlowControllerUpdateHighestReceivedCall) Return(arg0 error) *MockStreamFlowControllerUpdateHighestReceivedCall

+ type MockStreamFlowControllerUpdateSendWindowCall struct

+ func (c *MockStreamFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *MockStreamFlowControllerUpdateSendWindowCall

+ func (c *MockStreamFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockStreamFlowControllerUpdateSendWindowCall

+ func (c *MockStreamFlowControllerUpdateSendWindowCall) Return(arg0 bool) *MockStreamFlowControllerUpdateSendWindowCall

v0.0.5

Oct 27, 2023

Changes in this version

type MockSendAlgorithmWithDebugInfos

+ func (m *MockSendAlgorithmWithDebugInfos) OnCongestionEvent(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount)

type MockSendAlgorithmWithDebugInfosMockRecorder

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnCongestionEvent(arg0, arg1, arg2 any) *gomock.Call

v0.0.4

Aug 28, 2023

v0.0.3

Aug 11, 2023

v0.0.2

Aug 9, 2023

v0.0.1

Aug 6, 2023

Changes in this version

+ type MockConnectionFlowController struct

+ func NewMockConnectionFlowController(ctrl *gomock.Controller) *MockConnectionFlowController

+ func (m *MockConnectionFlowController) AddBytesRead(arg0 protocol.ByteCount)

+ func (m *MockConnectionFlowController) AddBytesSent(arg0 protocol.ByteCount)

+ func (m *MockConnectionFlowController) EXPECT() *MockConnectionFlowControllerMockRecorder

+ func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount

+ func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCount)

+ func (m *MockConnectionFlowController) Reset() error

+ func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount

+ func (m *MockConnectionFlowController) UpdateSendWindow(arg0 protocol.ByteCount)

+ type MockConnectionFlowControllerMockRecorder struct

+ func (mr *MockConnectionFlowControllerMockRecorder) AddBytesRead(arg0 interface{}) *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) AddBytesSent(arg0 interface{}) *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) IsNewlyBlocked() *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) Reset() *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) SendWindowSize() *gomock.Call

+ func (mr *MockConnectionFlowControllerMockRecorder) UpdateSendWindow(arg0 interface{}) *gomock.Call

+ type MockCryptoSetup struct

+ func NewMockCryptoSetup(ctrl *gomock.Controller) *MockCryptoSetup

+ func (m *MockCryptoSetup) ChangeConnectionID(arg0 protocol.ConnectionID)

+ func (m *MockCryptoSetup) Close() error

+ func (m *MockCryptoSetup) ConnectionState() handshake.ConnectionState

+ func (m *MockCryptoSetup) DiscardInitialKeys()

+ func (m *MockCryptoSetup) EXPECT() *MockCryptoSetupMockRecorder

+ func (m *MockCryptoSetup) Get0RTTOpener() (handshake.LongHeaderOpener, error)

+ func (m *MockCryptoSetup) Get0RTTSealer() (handshake.LongHeaderSealer, error)

+ func (m *MockCryptoSetup) Get1RTTOpener() (handshake.ShortHeaderOpener, error)

+ func (m *MockCryptoSetup) Get1RTTSealer() (handshake.ShortHeaderSealer, error)

+ func (m *MockCryptoSetup) GetHandshakeOpener() (handshake.LongHeaderOpener, error)

+ func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.LongHeaderSealer, error)

+ func (m *MockCryptoSetup) GetInitialOpener() (handshake.LongHeaderOpener, error)

+ func (m *MockCryptoSetup) GetInitialSealer() (handshake.LongHeaderSealer, error)

+ func (m *MockCryptoSetup) GetSessionTicket() ([]byte, error)

+ func (m *MockCryptoSetup) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLevel) error

+ func (m *MockCryptoSetup) NextEvent() handshake.Event

+ func (m *MockCryptoSetup) SetHandshakeConfirmed()

+ func (m *MockCryptoSetup) SetLargest1RTTAcked(arg0 protocol.PacketNumber) error

+ func (m *MockCryptoSetup) StartHandshake() error

+ type MockCryptoSetupMockRecorder struct

+ func (mr *MockCryptoSetupMockRecorder) ChangeConnectionID(arg0 interface{}) *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) Close() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) ConnectionState() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) DiscardInitialKeys() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) Get0RTTOpener() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) Get0RTTSealer() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) Get1RTTSealer() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) GetHandshakeSealer() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) GetInitialSealer() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) GetSessionTicket() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) HandleMessage(arg0, arg1 interface{}) *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) NextEvent() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) SetHandshakeConfirmed() *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) SetLargest1RTTAcked(arg0 interface{}) *gomock.Call

+ func (mr *MockCryptoSetupMockRecorder) StartHandshake() *gomock.Call

+ type MockLongHeaderOpener struct

+ func NewMockLongHeaderOpener(ctrl *gomock.Controller) *MockLongHeaderOpener

+ func (m *MockLongHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) protocol.PacketNumber

+ func (m *MockLongHeaderOpener) DecryptHeader(arg0 []byte, arg1 *byte, arg2 []byte)

+ func (m *MockLongHeaderOpener) EXPECT() *MockLongHeaderOpenerMockRecorder

+ func (m *MockLongHeaderOpener) Open(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) ([]byte, error)

+ type MockLongHeaderOpenerMockRecorder struct

+ func (mr *MockLongHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 interface{}) *gomock.Call

+ func (mr *MockLongHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call

+ func (mr *MockLongHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 interface{}) *gomock.Call

+ type MockSendAlgorithmWithDebugInfos struct

+ func NewMockSendAlgorithmWithDebugInfos(ctrl *gomock.Controller) *MockSendAlgorithmWithDebugInfos

+ func (m *MockSendAlgorithmWithDebugInfos) CanSend(arg0 protocol.ByteCount) bool

+ func (m *MockSendAlgorithmWithDebugInfos) EXPECT() *MockSendAlgorithmWithDebugInfosMockRecorder

+ func (m *MockSendAlgorithmWithDebugInfos) GetCongestionWindow() protocol.ByteCount

+ func (m *MockSendAlgorithmWithDebugInfos) HasPacingBudget(arg0 time.Time) bool

+ func (m *MockSendAlgorithmWithDebugInfos) InRecovery() bool

+ func (m *MockSendAlgorithmWithDebugInfos) InSlowStart() bool

+ func (m *MockSendAlgorithmWithDebugInfos) MaybeExitSlowStart()

+ func (m *MockSendAlgorithmWithDebugInfos) OnPacketAcked(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount, arg3 time.Time)

+ func (m *MockSendAlgorithmWithDebugInfos) OnPacketLost(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount)

+ func (m *MockSendAlgorithmWithDebugInfos) OnPacketSent(arg0 time.Time, arg1 protocol.ByteCount, arg2 protocol.PacketNumber, ...)

+ func (m *MockSendAlgorithmWithDebugInfos) OnRetransmissionTimeout(arg0 bool)

+ func (m *MockSendAlgorithmWithDebugInfos) SetMaxDatagramSize(arg0 protocol.ByteCount)

+ func (m *MockSendAlgorithmWithDebugInfos) TimeUntilSend(arg0 protocol.ByteCount) time.Time

+ type MockSendAlgorithmWithDebugInfosMockRecorder struct

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) CanSend(arg0 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow() *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget(arg0 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery() *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart() *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart() *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketLost(arg0, arg1, arg2 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout(arg0 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) SetMaxDatagramSize(arg0 interface{}) *gomock.Call

+ func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend(arg0 interface{}) *gomock.Call

+ type MockShortHeaderOpener struct

+ func NewMockShortHeaderOpener(ctrl *gomock.Controller) *MockShortHeaderOpener

+ func (m *MockShortHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) protocol.PacketNumber

+ func (m *MockShortHeaderOpener) DecryptHeader(arg0 []byte, arg1 *byte, arg2 []byte)

+ func (m *MockShortHeaderOpener) EXPECT() *MockShortHeaderOpenerMockRecorder

+ func (m *MockShortHeaderOpener) Open(arg0, arg1 []byte, arg2 time.Time, arg3 protocol.PacketNumber, ...) ([]byte, error)

+ type MockShortHeaderOpenerMockRecorder struct

+ func (mr *MockShortHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 interface{}) *gomock.Call

+ func (mr *MockShortHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call

+ func (mr *MockShortHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call

+ type MockShortHeaderSealer struct

+ func NewMockShortHeaderSealer(ctrl *gomock.Controller) *MockShortHeaderSealer

+ func (m *MockShortHeaderSealer) EXPECT() *MockShortHeaderSealerMockRecorder

+ func (m *MockShortHeaderSealer) EncryptHeader(arg0 []byte, arg1 *byte, arg2 []byte)

+ func (m *MockShortHeaderSealer) KeyPhase() protocol.KeyPhaseBit

+ func (m *MockShortHeaderSealer) Overhead() int

+ func (m *MockShortHeaderSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) []byte

+ type MockShortHeaderSealerMockRecorder struct

+ func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call

+ func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *gomock.Call

+ func (mr *MockShortHeaderSealerMockRecorder) Overhead() *gomock.Call

+ func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call

+ type MockStreamFlowController struct

+ func NewMockStreamFlowController(ctrl *gomock.Controller) *MockStreamFlowController

+ func (m *MockStreamFlowController) Abandon()

+ func (m *MockStreamFlowController) AddBytesRead(arg0 protocol.ByteCount)

+ func (m *MockStreamFlowController) AddBytesSent(arg0 protocol.ByteCount)

+ func (m *MockStreamFlowController) EXPECT() *MockStreamFlowControllerMockRecorder

+ func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount

+ func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount)

+ func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount

+ func (m *MockStreamFlowController) UpdateHighestReceived(arg0 protocol.ByteCount, arg1 bool) error

+ func (m *MockStreamFlowController) UpdateSendWindow(arg0 protocol.ByteCount)

+ type MockStreamFlowControllerMockRecorder struct

+ func (mr *MockStreamFlowControllerMockRecorder) Abandon() *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) AddBytesRead(arg0 interface{}) *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) AddBytesSent(arg0 interface{}) *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) IsNewlyBlocked() *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) SendWindowSize() *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) UpdateHighestReceived(arg0, arg1 interface{}) *gomock.Call

+ func (mr *MockStreamFlowControllerMockRecorder) UpdateSendWindow(arg0 interface{}) *gomock.Call

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL