mocks

package
v0.0.0-...-edd52d7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 28, 2024 License: MIT Imports: 6 Imported by: 0

Documentation

Overview

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Package mocks is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockConnectionFlowController 

type MockConnectionFlowController struct {
	// contains filtered or unexported fields
}

MockConnectionFlowController is a mock of ConnectionFlowController interface.

func NewMockConnectionFlowController 

func NewMockConnectionFlowController(ctrl *gomock.Controller) *MockConnectionFlowController

NewMockConnectionFlowController creates a new mock instance.

func (*MockConnectionFlowController) AddBytesRead 

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

AddBytesRead mocks base method.

func (*MockConnectionFlowController) AddBytesSent 

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

AddBytesSent mocks base method.

func (*MockConnectionFlowController) EXPECT 

func (m *MockConnectionFlowController) EXPECT() *MockConnectionFlowControllerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockConnectionFlowController) GetWindowUpdate 

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

GetWindowUpdate mocks base method.

func (*MockConnectionFlowController) IsNewlyBlocked 

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

IsNewlyBlocked mocks base method.

func (*MockConnectionFlowController) Reset 

func (m *MockConnectionFlowController) Reset() error

Reset mocks base method.

func (*MockConnectionFlowController) SendWindowSize 

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

SendWindowSize mocks base method.

func (*MockConnectionFlowController) UpdateSendWindow 

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

UpdateSendWindow mocks base method.

type MockConnectionFlowControllerAddBytesReadCall 

type MockConnectionFlowControllerAddBytesReadCall struct {
	*gomock.Call
}

MockConnectionFlowControllerAddBytesReadCall wrap *gomock.Call

func (*MockConnectionFlowControllerAddBytesReadCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerAddBytesReadCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerAddBytesReadCall) Return 

func (c *MockConnectionFlowControllerAddBytesReadCall) Return() *MockConnectionFlowControllerAddBytesReadCall

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerAddBytesSentCall 

type MockConnectionFlowControllerAddBytesSentCall struct {
	*gomock.Call
}

MockConnectionFlowControllerAddBytesSentCall wrap *gomock.Call

func (*MockConnectionFlowControllerAddBytesSentCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerAddBytesSentCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerAddBytesSentCall) Return 

func (c *MockConnectionFlowControllerAddBytesSentCall) Return() *MockConnectionFlowControllerAddBytesSentCall

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerGetWindowUpdateCall 

type MockConnectionFlowControllerGetWindowUpdateCall struct {
	*gomock.Call
}

MockConnectionFlowControllerGetWindowUpdateCall wrap *gomock.Call

func (*MockConnectionFlowControllerGetWindowUpdateCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerGetWindowUpdateCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerGetWindowUpdateCall) Return 

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

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerIsNewlyBlockedCall 

type MockConnectionFlowControllerIsNewlyBlockedCall struct {
	*gomock.Call
}

MockConnectionFlowControllerIsNewlyBlockedCall wrap *gomock.Call

func (*MockConnectionFlowControllerIsNewlyBlockedCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerIsNewlyBlockedCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerIsNewlyBlockedCall) Return 

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

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerMockRecorder 

type MockConnectionFlowControllerMockRecorder struct {
	// contains filtered or unexported fields
}

MockConnectionFlowControllerMockRecorder is the mock recorder for MockConnectionFlowController.

func (*MockConnectionFlowControllerMockRecorder) AddBytesRead 

func (mr *MockConnectionFlowControllerMockRecorder) AddBytesRead(arg0 any) *MockConnectionFlowControllerAddBytesReadCall

AddBytesRead indicates an expected call of AddBytesRead.

func (*MockConnectionFlowControllerMockRecorder) AddBytesSent 

func (mr *MockConnectionFlowControllerMockRecorder) AddBytesSent(arg0 any) *MockConnectionFlowControllerAddBytesSentCall

AddBytesSent indicates an expected call of AddBytesSent.

func (*MockConnectionFlowControllerMockRecorder) GetWindowUpdate 

func (mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *MockConnectionFlowControllerGetWindowUpdateCall

GetWindowUpdate indicates an expected call of GetWindowUpdate.

func (*MockConnectionFlowControllerMockRecorder) IsNewlyBlocked 

func (mr *MockConnectionFlowControllerMockRecorder) IsNewlyBlocked() *MockConnectionFlowControllerIsNewlyBlockedCall

IsNewlyBlocked indicates an expected call of IsNewlyBlocked.

func (*MockConnectionFlowControllerMockRecorder) Reset 

func (mr *MockConnectionFlowControllerMockRecorder) Reset() *MockConnectionFlowControllerResetCall

Reset indicates an expected call of Reset.

func (*MockConnectionFlowControllerMockRecorder) SendWindowSize 

func (mr *MockConnectionFlowControllerMockRecorder) SendWindowSize() *MockConnectionFlowControllerSendWindowSizeCall

SendWindowSize indicates an expected call of SendWindowSize.

func (*MockConnectionFlowControllerMockRecorder) UpdateSendWindow 

func (mr *MockConnectionFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *MockConnectionFlowControllerUpdateSendWindowCall

UpdateSendWindow indicates an expected call of UpdateSendWindow.

type MockConnectionFlowControllerResetCall 

type MockConnectionFlowControllerResetCall struct {
	*gomock.Call
}

MockConnectionFlowControllerResetCall wrap *gomock.Call

func (*MockConnectionFlowControllerResetCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerResetCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerResetCall) Return 

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

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerSendWindowSizeCall 

type MockConnectionFlowControllerSendWindowSizeCall struct {
	*gomock.Call
}

MockConnectionFlowControllerSendWindowSizeCall wrap *gomock.Call

func (*MockConnectionFlowControllerSendWindowSizeCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerSendWindowSizeCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerSendWindowSizeCall) Return 

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

Return rewrite *gomock.Call.Return

type MockConnectionFlowControllerUpdateSendWindowCall 

type MockConnectionFlowControllerUpdateSendWindowCall struct {
	*gomock.Call
}

MockConnectionFlowControllerUpdateSendWindowCall wrap *gomock.Call

func (*MockConnectionFlowControllerUpdateSendWindowCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockConnectionFlowControllerUpdateSendWindowCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockConnectionFlowControllerUpdateSendWindowCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetup 

type MockCryptoSetup struct {
	// contains filtered or unexported fields
}

MockCryptoSetup is a mock of CryptoSetup interface.

func NewMockCryptoSetup 

func NewMockCryptoSetup(ctrl *gomock.Controller) *MockCryptoSetup

NewMockCryptoSetup creates a new mock instance.

func (*MockCryptoSetup) ChangeConnectionID 

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

ChangeConnectionID mocks base method.

func (*MockCryptoSetup) Close 

func (m *MockCryptoSetup) Close() error

Close mocks base method.

func (*MockCryptoSetup) ConnectionState 

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

ConnectionState mocks base method.

func (*MockCryptoSetup) DiscardInitialKeys 

func (m *MockCryptoSetup) DiscardInitialKeys()

DiscardInitialKeys mocks base method.

func (*MockCryptoSetup) EXPECT 

func (m *MockCryptoSetup) EXPECT() *MockCryptoSetupMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockCryptoSetup) Get0RTTOpener 

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

Get0RTTOpener mocks base method.

func (*MockCryptoSetup) Get0RTTSealer 

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

Get0RTTSealer mocks base method.

func (*MockCryptoSetup) Get1RTTOpener 

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

Get1RTTOpener mocks base method.

func (*MockCryptoSetup) Get1RTTSealer 

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

Get1RTTSealer mocks base method.

func (*MockCryptoSetup) GetHandshakeOpener 

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

GetHandshakeOpener mocks base method.

func (*MockCryptoSetup) GetHandshakeSealer 

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

GetHandshakeSealer mocks base method.

func (*MockCryptoSetup) GetInitialOpener 

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

GetInitialOpener mocks base method.

func (*MockCryptoSetup) GetInitialSealer 

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

GetInitialSealer mocks base method.

func (*MockCryptoSetup) GetSessionTicket 

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

GetSessionTicket mocks base method.

func (*MockCryptoSetup) HandleMessage 

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

HandleMessage mocks base method.

func (*MockCryptoSetup) NextEvent 

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

NextEvent mocks base method.

func (*MockCryptoSetup) SetHandshakeConfirmed 

func (m *MockCryptoSetup) SetHandshakeConfirmed()

SetHandshakeConfirmed mocks base method.

func (*MockCryptoSetup) SetLargest1RTTAcked 

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

SetLargest1RTTAcked mocks base method.

func (*MockCryptoSetup) StartHandshake 

func (m *MockCryptoSetup) StartHandshake(arg0 context.Context) error

StartHandshake mocks base method.

type MockCryptoSetupChangeConnectionIDCall 

type MockCryptoSetupChangeConnectionIDCall struct {
	*gomock.Call
}

MockCryptoSetupChangeConnectionIDCall wrap *gomock.Call

func (*MockCryptoSetupChangeConnectionIDCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupChangeConnectionIDCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupChangeConnectionIDCall) Return 

func (c *MockCryptoSetupChangeConnectionIDCall) Return() *MockCryptoSetupChangeConnectionIDCall

Return rewrite *gomock.Call.Return

type MockCryptoSetupCloseCall 

type MockCryptoSetupCloseCall struct {
	*gomock.Call
}

MockCryptoSetupCloseCall wrap *gomock.Call

func (*MockCryptoSetupCloseCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupCloseCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupCloseCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupConnectionStateCall 

type MockCryptoSetupConnectionStateCall struct {
	*gomock.Call
}

MockCryptoSetupConnectionStateCall wrap *gomock.Call

func (*MockCryptoSetupConnectionStateCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupConnectionStateCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupConnectionStateCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupDiscardInitialKeysCall 

type MockCryptoSetupDiscardInitialKeysCall struct {
	*gomock.Call
}

MockCryptoSetupDiscardInitialKeysCall wrap *gomock.Call

func (*MockCryptoSetupDiscardInitialKeysCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupDiscardInitialKeysCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupDiscardInitialKeysCall) Return 

func (c *MockCryptoSetupDiscardInitialKeysCall) Return() *MockCryptoSetupDiscardInitialKeysCall

Return rewrite *gomock.Call.Return

type MockCryptoSetupGet0RTTOpenerCall 

type MockCryptoSetupGet0RTTOpenerCall struct {
	*gomock.Call
}

MockCryptoSetupGet0RTTOpenerCall wrap *gomock.Call

func (*MockCryptoSetupGet0RTTOpenerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGet0RTTOpenerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGet0RTTOpenerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGet0RTTSealerCall 

type MockCryptoSetupGet0RTTSealerCall struct {
	*gomock.Call
}

MockCryptoSetupGet0RTTSealerCall wrap *gomock.Call

func (*MockCryptoSetupGet0RTTSealerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGet0RTTSealerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGet0RTTSealerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGet1RTTOpenerCall 

type MockCryptoSetupGet1RTTOpenerCall struct {
	*gomock.Call
}

MockCryptoSetupGet1RTTOpenerCall wrap *gomock.Call

func (*MockCryptoSetupGet1RTTOpenerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGet1RTTOpenerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGet1RTTOpenerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGet1RTTSealerCall 

type MockCryptoSetupGet1RTTSealerCall struct {
	*gomock.Call
}

MockCryptoSetupGet1RTTSealerCall wrap *gomock.Call

func (*MockCryptoSetupGet1RTTSealerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGet1RTTSealerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGet1RTTSealerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGetHandshakeOpenerCall 

type MockCryptoSetupGetHandshakeOpenerCall struct {
	*gomock.Call
}

MockCryptoSetupGetHandshakeOpenerCall wrap *gomock.Call

func (*MockCryptoSetupGetHandshakeOpenerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGetHandshakeOpenerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGetHandshakeOpenerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGetHandshakeSealerCall 

type MockCryptoSetupGetHandshakeSealerCall struct {
	*gomock.Call
}

MockCryptoSetupGetHandshakeSealerCall wrap *gomock.Call

func (*MockCryptoSetupGetHandshakeSealerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGetHandshakeSealerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGetHandshakeSealerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGetInitialOpenerCall 

type MockCryptoSetupGetInitialOpenerCall struct {
	*gomock.Call
}

MockCryptoSetupGetInitialOpenerCall wrap *gomock.Call

func (*MockCryptoSetupGetInitialOpenerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGetInitialOpenerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGetInitialOpenerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGetInitialSealerCall 

type MockCryptoSetupGetInitialSealerCall struct {
	*gomock.Call
}

MockCryptoSetupGetInitialSealerCall wrap *gomock.Call

func (*MockCryptoSetupGetInitialSealerCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGetInitialSealerCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGetInitialSealerCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupGetSessionTicketCall 

type MockCryptoSetupGetSessionTicketCall struct {
	*gomock.Call
}

MockCryptoSetupGetSessionTicketCall wrap *gomock.Call

func (*MockCryptoSetupGetSessionTicketCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupGetSessionTicketCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupGetSessionTicketCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupHandleMessageCall 

type MockCryptoSetupHandleMessageCall struct {
	*gomock.Call
}

MockCryptoSetupHandleMessageCall wrap *gomock.Call

func (*MockCryptoSetupHandleMessageCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupHandleMessageCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupHandleMessageCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupMockRecorder 

type MockCryptoSetupMockRecorder struct {
	// contains filtered or unexported fields
}

MockCryptoSetupMockRecorder is the mock recorder for MockCryptoSetup.

func (*MockCryptoSetupMockRecorder) ChangeConnectionID 

func (mr *MockCryptoSetupMockRecorder) ChangeConnectionID(arg0 any) *MockCryptoSetupChangeConnectionIDCall

ChangeConnectionID indicates an expected call of ChangeConnectionID.

func (*MockCryptoSetupMockRecorder) Close 

func (mr *MockCryptoSetupMockRecorder) Close() *MockCryptoSetupCloseCall

Close indicates an expected call of Close.

func (*MockCryptoSetupMockRecorder) ConnectionState 

func (mr *MockCryptoSetupMockRecorder) ConnectionState() *MockCryptoSetupConnectionStateCall

ConnectionState indicates an expected call of ConnectionState.

func (*MockCryptoSetupMockRecorder) DiscardInitialKeys 

func (mr *MockCryptoSetupMockRecorder) DiscardInitialKeys() *MockCryptoSetupDiscardInitialKeysCall

DiscardInitialKeys indicates an expected call of DiscardInitialKeys.

func (*MockCryptoSetupMockRecorder) Get0RTTOpener 

func (mr *MockCryptoSetupMockRecorder) Get0RTTOpener() *MockCryptoSetupGet0RTTOpenerCall

Get0RTTOpener indicates an expected call of Get0RTTOpener.

func (*MockCryptoSetupMockRecorder) Get0RTTSealer 

func (mr *MockCryptoSetupMockRecorder) Get0RTTSealer() *MockCryptoSetupGet0RTTSealerCall

Get0RTTSealer indicates an expected call of Get0RTTSealer.

func (*MockCryptoSetupMockRecorder) Get1RTTOpener 

func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *MockCryptoSetupGet1RTTOpenerCall

Get1RTTOpener indicates an expected call of Get1RTTOpener.

func (*MockCryptoSetupMockRecorder) Get1RTTSealer 

func (mr *MockCryptoSetupMockRecorder) Get1RTTSealer() *MockCryptoSetupGet1RTTSealerCall

Get1RTTSealer indicates an expected call of Get1RTTSealer.

func (*MockCryptoSetupMockRecorder) GetHandshakeOpener 

func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *MockCryptoSetupGetHandshakeOpenerCall

GetHandshakeOpener indicates an expected call of GetHandshakeOpener.

func (*MockCryptoSetupMockRecorder) GetHandshakeSealer 

func (mr *MockCryptoSetupMockRecorder) GetHandshakeSealer() *MockCryptoSetupGetHandshakeSealerCall

GetHandshakeSealer indicates an expected call of GetHandshakeSealer.

func (*MockCryptoSetupMockRecorder) GetInitialOpener 

func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *MockCryptoSetupGetInitialOpenerCall

GetInitialOpener indicates an expected call of GetInitialOpener.

func (*MockCryptoSetupMockRecorder) GetInitialSealer 

func (mr *MockCryptoSetupMockRecorder) GetInitialSealer() *MockCryptoSetupGetInitialSealerCall

GetInitialSealer indicates an expected call of GetInitialSealer.

func (*MockCryptoSetupMockRecorder) GetSessionTicket 

func (mr *MockCryptoSetupMockRecorder) GetSessionTicket() *MockCryptoSetupGetSessionTicketCall

GetSessionTicket indicates an expected call of GetSessionTicket.

func (*MockCryptoSetupMockRecorder) HandleMessage 

func (mr *MockCryptoSetupMockRecorder) HandleMessage(arg0, arg1 any) *MockCryptoSetupHandleMessageCall

HandleMessage indicates an expected call of HandleMessage.

func (*MockCryptoSetupMockRecorder) NextEvent 

func (mr *MockCryptoSetupMockRecorder) NextEvent() *MockCryptoSetupNextEventCall

NextEvent indicates an expected call of NextEvent.

func (*MockCryptoSetupMockRecorder) SetHandshakeConfirmed 

func (mr *MockCryptoSetupMockRecorder) SetHandshakeConfirmed() *MockCryptoSetupSetHandshakeConfirmedCall

SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed.

func (*MockCryptoSetupMockRecorder) SetLargest1RTTAcked 

func (mr *MockCryptoSetupMockRecorder) SetLargest1RTTAcked(arg0 any) *MockCryptoSetupSetLargest1RTTAckedCall

SetLargest1RTTAcked indicates an expected call of SetLargest1RTTAcked.

func (*MockCryptoSetupMockRecorder) StartHandshake 

func (mr *MockCryptoSetupMockRecorder) StartHandshake(arg0 any) *MockCryptoSetupStartHandshakeCall

StartHandshake indicates an expected call of StartHandshake.

type MockCryptoSetupNextEventCall 

type MockCryptoSetupNextEventCall struct {
	*gomock.Call
}

MockCryptoSetupNextEventCall wrap *gomock.Call

func (*MockCryptoSetupNextEventCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupNextEventCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupNextEventCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupSetHandshakeConfirmedCall 

type MockCryptoSetupSetHandshakeConfirmedCall struct {
	*gomock.Call
}

MockCryptoSetupSetHandshakeConfirmedCall wrap *gomock.Call

func (*MockCryptoSetupSetHandshakeConfirmedCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupSetHandshakeConfirmedCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupSetHandshakeConfirmedCall) Return 

func (c *MockCryptoSetupSetHandshakeConfirmedCall) Return() *MockCryptoSetupSetHandshakeConfirmedCall

Return rewrite *gomock.Call.Return

type MockCryptoSetupSetLargest1RTTAckedCall 

type MockCryptoSetupSetLargest1RTTAckedCall struct {
	*gomock.Call
}

MockCryptoSetupSetLargest1RTTAckedCall wrap *gomock.Call

func (*MockCryptoSetupSetLargest1RTTAckedCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupSetLargest1RTTAckedCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupSetLargest1RTTAckedCall) Return 

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

Return rewrite *gomock.Call.Return

type MockCryptoSetupStartHandshakeCall 

type MockCryptoSetupStartHandshakeCall struct {
	*gomock.Call
}

MockCryptoSetupStartHandshakeCall wrap *gomock.Call

func (*MockCryptoSetupStartHandshakeCall) Do 

func (c *MockCryptoSetupStartHandshakeCall) Do(f func(context.Context) error) *MockCryptoSetupStartHandshakeCall

Do rewrite *gomock.Call.Do

func (*MockCryptoSetupStartHandshakeCall) DoAndReturn 

func (c *MockCryptoSetupStartHandshakeCall) DoAndReturn(f func(context.Context) error) *MockCryptoSetupStartHandshakeCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCryptoSetupStartHandshakeCall) Return 

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

Return rewrite *gomock.Call.Return

type MockLongHeaderOpener 

type MockLongHeaderOpener struct {
	// contains filtered or unexported fields
}

MockLongHeaderOpener is a mock of LongHeaderOpener interface.

func NewMockLongHeaderOpener 

func NewMockLongHeaderOpener(ctrl *gomock.Controller) *MockLongHeaderOpener

NewMockLongHeaderOpener creates a new mock instance.

func (*MockLongHeaderOpener) DecodePacketNumber 

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

DecodePacketNumber mocks base method.

func (*MockLongHeaderOpener) DecryptHeader 

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

DecryptHeader mocks base method.

func (*MockLongHeaderOpener) EXPECT 

func (m *MockLongHeaderOpener) EXPECT() *MockLongHeaderOpenerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockLongHeaderOpener) Open 

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

Open mocks base method.

type MockLongHeaderOpenerDecodePacketNumberCall 

type MockLongHeaderOpenerDecodePacketNumberCall struct {
	*gomock.Call
}

MockLongHeaderOpenerDecodePacketNumberCall wrap *gomock.Call

func (*MockLongHeaderOpenerDecodePacketNumberCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockLongHeaderOpenerDecodePacketNumberCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockLongHeaderOpenerDecodePacketNumberCall) Return 

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

Return rewrite *gomock.Call.Return

type MockLongHeaderOpenerDecryptHeaderCall 

type MockLongHeaderOpenerDecryptHeaderCall struct {
	*gomock.Call
}

MockLongHeaderOpenerDecryptHeaderCall wrap *gomock.Call

func (*MockLongHeaderOpenerDecryptHeaderCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockLongHeaderOpenerDecryptHeaderCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockLongHeaderOpenerDecryptHeaderCall) Return 

func (c *MockLongHeaderOpenerDecryptHeaderCall) Return() *MockLongHeaderOpenerDecryptHeaderCall

Return rewrite *gomock.Call.Return

type MockLongHeaderOpenerMockRecorder 

type MockLongHeaderOpenerMockRecorder struct {
	// contains filtered or unexported fields
}

MockLongHeaderOpenerMockRecorder is the mock recorder for MockLongHeaderOpener.

func (*MockLongHeaderOpenerMockRecorder) DecodePacketNumber 

func (mr *MockLongHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *MockLongHeaderOpenerDecodePacketNumberCall

DecodePacketNumber indicates an expected call of DecodePacketNumber.

func (*MockLongHeaderOpenerMockRecorder) DecryptHeader 

func (mr *MockLongHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *MockLongHeaderOpenerDecryptHeaderCall

DecryptHeader indicates an expected call of DecryptHeader.

func (*MockLongHeaderOpenerMockRecorder) Open 

func (mr *MockLongHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 any) *MockLongHeaderOpenerOpenCall

Open indicates an expected call of Open.

type MockLongHeaderOpenerOpenCall 

type MockLongHeaderOpenerOpenCall struct {
	*gomock.Call
}

MockLongHeaderOpenerOpenCall wrap *gomock.Call

func (*MockLongHeaderOpenerOpenCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockLongHeaderOpenerOpenCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockLongHeaderOpenerOpenCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfos 

type MockSendAlgorithmWithDebugInfos struct {
	// contains filtered or unexported fields
}

MockSendAlgorithmWithDebugInfos is a mock of SendAlgorithmWithDebugInfos interface.

func NewMockSendAlgorithmWithDebugInfos 

func NewMockSendAlgorithmWithDebugInfos(ctrl *gomock.Controller) *MockSendAlgorithmWithDebugInfos

NewMockSendAlgorithmWithDebugInfos creates a new mock instance.

func (*MockSendAlgorithmWithDebugInfos) CanSend 

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

CanSend mocks base method.

func (*MockSendAlgorithmWithDebugInfos) EXPECT 

func (m *MockSendAlgorithmWithDebugInfos) EXPECT() *MockSendAlgorithmWithDebugInfosMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockSendAlgorithmWithDebugInfos) GetCongestionWindow 

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

GetCongestionWindow mocks base method.

func (*MockSendAlgorithmWithDebugInfos) HasPacingBudget 

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

HasPacingBudget mocks base method.

func (*MockSendAlgorithmWithDebugInfos) InRecovery 

func (m *MockSendAlgorithmWithDebugInfos) InRecovery() bool

InRecovery mocks base method.

func (*MockSendAlgorithmWithDebugInfos) InSlowStart 

func (m *MockSendAlgorithmWithDebugInfos) InSlowStart() bool

InSlowStart mocks base method.

func (*MockSendAlgorithmWithDebugInfos) MaybeExitSlowStart 

func (m *MockSendAlgorithmWithDebugInfos) MaybeExitSlowStart()

MaybeExitSlowStart mocks base method.

func (*MockSendAlgorithmWithDebugInfos) OnCongestionEvent 

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

OnCongestionEvent mocks base method.

func (*MockSendAlgorithmWithDebugInfos) OnPacketAcked 

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

OnPacketAcked mocks base method.

func (*MockSendAlgorithmWithDebugInfos) OnPacketSent 

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

OnPacketSent mocks base method.

func (*MockSendAlgorithmWithDebugInfos) OnRetransmissionTimeout 

func (m *MockSendAlgorithmWithDebugInfos) OnRetransmissionTimeout(arg0 bool)

OnRetransmissionTimeout mocks base method.

func (*MockSendAlgorithmWithDebugInfos) SetMaxDatagramSize 

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

SetMaxDatagramSize mocks base method.

func (*MockSendAlgorithmWithDebugInfos) TimeUntilSend 

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

TimeUntilSend mocks base method.

type MockSendAlgorithmWithDebugInfosCanSendCall 

type MockSendAlgorithmWithDebugInfosCanSendCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosCanSendCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosCanSendCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosCanSendCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosCanSendCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosGetCongestionWindowCall 

type MockSendAlgorithmWithDebugInfosGetCongestionWindowCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosGetCongestionWindowCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosHasPacingBudgetCall 

type MockSendAlgorithmWithDebugInfosHasPacingBudgetCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosHasPacingBudgetCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosInRecoveryCall 

type MockSendAlgorithmWithDebugInfosInRecoveryCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosInRecoveryCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosInRecoveryCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosInRecoveryCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosInRecoveryCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosInSlowStartCall 

type MockSendAlgorithmWithDebugInfosInSlowStartCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosInSlowStartCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosInSlowStartCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosInSlowStartCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosInSlowStartCall) Return 

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

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall 

type MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Return 

func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Return() *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosMockRecorder 

type MockSendAlgorithmWithDebugInfosMockRecorder struct {
	// contains filtered or unexported fields
}

MockSendAlgorithmWithDebugInfosMockRecorder is the mock recorder for MockSendAlgorithmWithDebugInfos.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) CanSend 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) CanSend(arg0 any) *MockSendAlgorithmWithDebugInfosCanSendCall

CanSend indicates an expected call of CanSend.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow() *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall

GetCongestionWindow indicates an expected call of GetCongestionWindow.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget(arg0 any) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall

HasPacingBudget indicates an expected call of HasPacingBudget.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery() *MockSendAlgorithmWithDebugInfosInRecoveryCall

InRecovery indicates an expected call of InRecovery.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart() *MockSendAlgorithmWithDebugInfosInSlowStartCall

InSlowStart indicates an expected call of InSlowStart.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart() *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall

MaybeExitSlowStart indicates an expected call of MaybeExitSlowStart.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) OnCongestionEvent 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnCongestionEvent(arg0, arg1, arg2 any) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall

OnCongestionEvent indicates an expected call of OnCongestionEvent.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 any) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

OnPacketAcked indicates an expected call of OnPacketAcked.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 any) *MockSendAlgorithmWithDebugInfosOnPacketSentCall

OnPacketSent indicates an expected call of OnPacketSent.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout(arg0 any) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall

OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) SetMaxDatagramSize 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) SetMaxDatagramSize(arg0 any) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall

SetMaxDatagramSize indicates an expected call of SetMaxDatagramSize.

func (*MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend 

func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend(arg0 any) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall

TimeUntilSend indicates an expected call of TimeUntilSend.

type MockSendAlgorithmWithDebugInfosOnCongestionEventCall 

type MockSendAlgorithmWithDebugInfosOnCongestionEventCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosOnCongestionEventCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosOnCongestionEventCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Return 

func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Return() *MockSendAlgorithmWithDebugInfosOnCongestionEventCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosOnPacketAckedCall 

type MockSendAlgorithmWithDebugInfosOnPacketAckedCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosOnPacketAckedCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Do 

func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosOnPacketAckedCall) DoAndReturn 

func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Return 

func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketAckedCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosOnPacketSentCall 

type MockSendAlgorithmWithDebugInfosOnPacketSentCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosOnPacketSentCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosOnPacketSentCall) Do 

func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Do(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *MockSendAlgorithmWithDebugInfosOnPacketSentCall

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosOnPacketSentCall) DoAndReturn 

func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) DoAndReturn(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *MockSendAlgorithmWithDebugInfosOnPacketSentCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosOnPacketSentCall) Return 

func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketSentCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall 

type MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Return 

func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Return() *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall 

type MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Return 

func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Return() *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall

Return rewrite *gomock.Call.Return

type MockSendAlgorithmWithDebugInfosTimeUntilSendCall 

type MockSendAlgorithmWithDebugInfosTimeUntilSendCall struct {
	*gomock.Call
}

MockSendAlgorithmWithDebugInfosTimeUntilSendCall wrap *gomock.Call

func (*MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockSendAlgorithmWithDebugInfosTimeUntilSendCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Return 

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

Return rewrite *gomock.Call.Return

type MockShortHeaderOpener 

type MockShortHeaderOpener struct {
	// contains filtered or unexported fields
}

MockShortHeaderOpener is a mock of ShortHeaderOpener interface.

func NewMockShortHeaderOpener 

func NewMockShortHeaderOpener(ctrl *gomock.Controller) *MockShortHeaderOpener

NewMockShortHeaderOpener creates a new mock instance.

func (*MockShortHeaderOpener) DecodePacketNumber 

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

DecodePacketNumber mocks base method.

func (*MockShortHeaderOpener) DecryptHeader 

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

DecryptHeader mocks base method.

func (*MockShortHeaderOpener) EXPECT 

func (m *MockShortHeaderOpener) EXPECT() *MockShortHeaderOpenerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockShortHeaderOpener) Open 

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

Open mocks base method.

type MockShortHeaderOpenerDecodePacketNumberCall 

type MockShortHeaderOpenerDecodePacketNumberCall struct {
	*gomock.Call
}

MockShortHeaderOpenerDecodePacketNumberCall wrap *gomock.Call

func (*MockShortHeaderOpenerDecodePacketNumberCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderOpenerDecodePacketNumberCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderOpenerDecodePacketNumberCall) Return 

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

Return rewrite *gomock.Call.Return

type MockShortHeaderOpenerDecryptHeaderCall 

type MockShortHeaderOpenerDecryptHeaderCall struct {
	*gomock.Call
}

MockShortHeaderOpenerDecryptHeaderCall wrap *gomock.Call

func (*MockShortHeaderOpenerDecryptHeaderCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderOpenerDecryptHeaderCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderOpenerDecryptHeaderCall) Return 

func (c *MockShortHeaderOpenerDecryptHeaderCall) Return() *MockShortHeaderOpenerDecryptHeaderCall

Return rewrite *gomock.Call.Return

type MockShortHeaderOpenerMockRecorder 

type MockShortHeaderOpenerMockRecorder struct {
	// contains filtered or unexported fields
}

MockShortHeaderOpenerMockRecorder is the mock recorder for MockShortHeaderOpener.

func (*MockShortHeaderOpenerMockRecorder) DecodePacketNumber 

func (mr *MockShortHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *MockShortHeaderOpenerDecodePacketNumberCall

DecodePacketNumber indicates an expected call of DecodePacketNumber.

func (*MockShortHeaderOpenerMockRecorder) DecryptHeader 

func (mr *MockShortHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *MockShortHeaderOpenerDecryptHeaderCall

DecryptHeader indicates an expected call of DecryptHeader.

func (*MockShortHeaderOpenerMockRecorder) Open 

func (mr *MockShortHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4, arg5 any) *MockShortHeaderOpenerOpenCall

Open indicates an expected call of Open.

type MockShortHeaderOpenerOpenCall 

type MockShortHeaderOpenerOpenCall struct {
	*gomock.Call
}

MockShortHeaderOpenerOpenCall wrap *gomock.Call

func (*MockShortHeaderOpenerOpenCall) Do 

func (c *MockShortHeaderOpenerOpenCall) Do(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *MockShortHeaderOpenerOpenCall

Do rewrite *gomock.Call.Do

func (*MockShortHeaderOpenerOpenCall) DoAndReturn 

func (c *MockShortHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *MockShortHeaderOpenerOpenCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderOpenerOpenCall) Return 

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

Return rewrite *gomock.Call.Return

type MockShortHeaderSealer 

type MockShortHeaderSealer struct {
	// contains filtered or unexported fields
}

MockShortHeaderSealer is a mock of ShortHeaderSealer interface.

func NewMockShortHeaderSealer 

func NewMockShortHeaderSealer(ctrl *gomock.Controller) *MockShortHeaderSealer

NewMockShortHeaderSealer creates a new mock instance.

func (*MockShortHeaderSealer) EXPECT 

func (m *MockShortHeaderSealer) EXPECT() *MockShortHeaderSealerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockShortHeaderSealer) EncryptHeader 

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

EncryptHeader mocks base method.

func (*MockShortHeaderSealer) KeyPhase 

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

KeyPhase mocks base method.

func (*MockShortHeaderSealer) Overhead 

func (m *MockShortHeaderSealer) Overhead() int

Overhead mocks base method.

func (*MockShortHeaderSealer) Seal 

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

Seal mocks base method.

type MockShortHeaderSealerEncryptHeaderCall 

type MockShortHeaderSealerEncryptHeaderCall struct {
	*gomock.Call
}

MockShortHeaderSealerEncryptHeaderCall wrap *gomock.Call

func (*MockShortHeaderSealerEncryptHeaderCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderSealerEncryptHeaderCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderSealerEncryptHeaderCall) Return 

func (c *MockShortHeaderSealerEncryptHeaderCall) Return() *MockShortHeaderSealerEncryptHeaderCall

Return rewrite *gomock.Call.Return

type MockShortHeaderSealerKeyPhaseCall 

type MockShortHeaderSealerKeyPhaseCall struct {
	*gomock.Call
}

MockShortHeaderSealerKeyPhaseCall wrap *gomock.Call

func (*MockShortHeaderSealerKeyPhaseCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderSealerKeyPhaseCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderSealerKeyPhaseCall) Return 

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

Return rewrite *gomock.Call.Return

type MockShortHeaderSealerMockRecorder 

type MockShortHeaderSealerMockRecorder struct {
	// contains filtered or unexported fields
}

MockShortHeaderSealerMockRecorder is the mock recorder for MockShortHeaderSealer.

func (*MockShortHeaderSealerMockRecorder) EncryptHeader 

func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 any) *MockShortHeaderSealerEncryptHeaderCall

EncryptHeader indicates an expected call of EncryptHeader.

func (*MockShortHeaderSealerMockRecorder) KeyPhase 

func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *MockShortHeaderSealerKeyPhaseCall

KeyPhase indicates an expected call of KeyPhase.

func (*MockShortHeaderSealerMockRecorder) Overhead 

func (mr *MockShortHeaderSealerMockRecorder) Overhead() *MockShortHeaderSealerOverheadCall

Overhead indicates an expected call of Overhead.

func (*MockShortHeaderSealerMockRecorder) Seal 

func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 any) *MockShortHeaderSealerSealCall

Seal indicates an expected call of Seal.

type MockShortHeaderSealerOverheadCall 

type MockShortHeaderSealerOverheadCall struct {
	*gomock.Call
}

MockShortHeaderSealerOverheadCall wrap *gomock.Call

func (*MockShortHeaderSealerOverheadCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderSealerOverheadCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderSealerOverheadCall) Return 

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

Return rewrite *gomock.Call.Return

type MockShortHeaderSealerSealCall 

type MockShortHeaderSealerSealCall struct {
	*gomock.Call
}

MockShortHeaderSealerSealCall wrap *gomock.Call

func (*MockShortHeaderSealerSealCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockShortHeaderSealerSealCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockShortHeaderSealerSealCall) Return 

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

Return rewrite *gomock.Call.Return

type MockStreamFlowController 

type MockStreamFlowController struct {
	// contains filtered or unexported fields
}

MockStreamFlowController is a mock of StreamFlowController interface.

func NewMockStreamFlowController 

func NewMockStreamFlowController(ctrl *gomock.Controller) *MockStreamFlowController

NewMockStreamFlowController creates a new mock instance.

func (*MockStreamFlowController) Abandon 

func (m *MockStreamFlowController) Abandon()

Abandon mocks base method.

func (*MockStreamFlowController) AddBytesRead 

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

AddBytesRead mocks base method.

func (*MockStreamFlowController) AddBytesSent 

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

AddBytesSent mocks base method.

func (*MockStreamFlowController) EXPECT 

func (m *MockStreamFlowController) EXPECT() *MockStreamFlowControllerMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockStreamFlowController) GetWindowUpdate 

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

GetWindowUpdate mocks base method.

func (*MockStreamFlowController) IsNewlyBlocked 

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

IsNewlyBlocked mocks base method.

func (*MockStreamFlowController) SendWindowSize 

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

SendWindowSize mocks base method.

func (*MockStreamFlowController) UpdateHighestReceived 

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

UpdateHighestReceived mocks base method.

func (*MockStreamFlowController) UpdateSendWindow 

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

UpdateSendWindow mocks base method.

type MockStreamFlowControllerAbandonCall 

type MockStreamFlowControllerAbandonCall struct {
	*gomock.Call
}

MockStreamFlowControllerAbandonCall wrap *gomock.Call

func (*MockStreamFlowControllerAbandonCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerAbandonCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerAbandonCall) Return 

func (c *MockStreamFlowControllerAbandonCall) Return() *MockStreamFlowControllerAbandonCall

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerAddBytesReadCall 

type MockStreamFlowControllerAddBytesReadCall struct {
	*gomock.Call
}

MockStreamFlowControllerAddBytesReadCall wrap *gomock.Call

func (*MockStreamFlowControllerAddBytesReadCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerAddBytesReadCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerAddBytesReadCall) Return 

func (c *MockStreamFlowControllerAddBytesReadCall) Return() *MockStreamFlowControllerAddBytesReadCall

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerAddBytesSentCall 

type MockStreamFlowControllerAddBytesSentCall struct {
	*gomock.Call
}

MockStreamFlowControllerAddBytesSentCall wrap *gomock.Call

func (*MockStreamFlowControllerAddBytesSentCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerAddBytesSentCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerAddBytesSentCall) Return 

func (c *MockStreamFlowControllerAddBytesSentCall) Return() *MockStreamFlowControllerAddBytesSentCall

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerGetWindowUpdateCall 

type MockStreamFlowControllerGetWindowUpdateCall struct {
	*gomock.Call
}

MockStreamFlowControllerGetWindowUpdateCall wrap *gomock.Call

func (*MockStreamFlowControllerGetWindowUpdateCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerGetWindowUpdateCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerGetWindowUpdateCall) Return 

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

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerIsNewlyBlockedCall 

type MockStreamFlowControllerIsNewlyBlockedCall struct {
	*gomock.Call
}

MockStreamFlowControllerIsNewlyBlockedCall wrap *gomock.Call

func (*MockStreamFlowControllerIsNewlyBlockedCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerIsNewlyBlockedCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerIsNewlyBlockedCall) Return 

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

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerMockRecorder 

type MockStreamFlowControllerMockRecorder struct {
	// contains filtered or unexported fields
}

MockStreamFlowControllerMockRecorder is the mock recorder for MockStreamFlowController.

func (*MockStreamFlowControllerMockRecorder) Abandon 

func (mr *MockStreamFlowControllerMockRecorder) Abandon() *MockStreamFlowControllerAbandonCall

Abandon indicates an expected call of Abandon.

func (*MockStreamFlowControllerMockRecorder) AddBytesRead 

func (mr *MockStreamFlowControllerMockRecorder) AddBytesRead(arg0 any) *MockStreamFlowControllerAddBytesReadCall

AddBytesRead indicates an expected call of AddBytesRead.

func (*MockStreamFlowControllerMockRecorder) AddBytesSent 

func (mr *MockStreamFlowControllerMockRecorder) AddBytesSent(arg0 any) *MockStreamFlowControllerAddBytesSentCall

AddBytesSent indicates an expected call of AddBytesSent.

func (*MockStreamFlowControllerMockRecorder) GetWindowUpdate 

func (mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *MockStreamFlowControllerGetWindowUpdateCall

GetWindowUpdate indicates an expected call of GetWindowUpdate.

func (*MockStreamFlowControllerMockRecorder) IsNewlyBlocked 

func (mr *MockStreamFlowControllerMockRecorder) IsNewlyBlocked() *MockStreamFlowControllerIsNewlyBlockedCall

IsNewlyBlocked indicates an expected call of IsNewlyBlocked.

func (*MockStreamFlowControllerMockRecorder) SendWindowSize 

func (mr *MockStreamFlowControllerMockRecorder) SendWindowSize() *MockStreamFlowControllerSendWindowSizeCall

SendWindowSize indicates an expected call of SendWindowSize.

func (*MockStreamFlowControllerMockRecorder) UpdateHighestReceived 

func (mr *MockStreamFlowControllerMockRecorder) UpdateHighestReceived(arg0, arg1 any) *MockStreamFlowControllerUpdateHighestReceivedCall

UpdateHighestReceived indicates an expected call of UpdateHighestReceived.

func (*MockStreamFlowControllerMockRecorder) UpdateSendWindow 

func (mr *MockStreamFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *MockStreamFlowControllerUpdateSendWindowCall

UpdateSendWindow indicates an expected call of UpdateSendWindow.

type MockStreamFlowControllerSendWindowSizeCall 

type MockStreamFlowControllerSendWindowSizeCall struct {
	*gomock.Call
}

MockStreamFlowControllerSendWindowSizeCall wrap *gomock.Call

func (*MockStreamFlowControllerSendWindowSizeCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerSendWindowSizeCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerSendWindowSizeCall) Return 

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

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerUpdateHighestReceivedCall 

type MockStreamFlowControllerUpdateHighestReceivedCall struct {
	*gomock.Call
}

MockStreamFlowControllerUpdateHighestReceivedCall wrap *gomock.Call

func (*MockStreamFlowControllerUpdateHighestReceivedCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerUpdateHighestReceivedCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerUpdateHighestReceivedCall) Return 

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

Return rewrite *gomock.Call.Return

type MockStreamFlowControllerUpdateSendWindowCall 

type MockStreamFlowControllerUpdateSendWindowCall struct {
	*gomock.Call
}

MockStreamFlowControllerUpdateSendWindowCall wrap *gomock.Call

func (*MockStreamFlowControllerUpdateSendWindowCall) Do 

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

Do rewrite *gomock.Call.Do

func (*MockStreamFlowControllerUpdateSendWindowCall) DoAndReturn 

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

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockStreamFlowControllerUpdateSendWindowCall) Return 

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

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Directories

Path Synopsis
Package mockackhandler is a generated GoMock package.
 Package mockackhandler is a generated GoMock package.
internal
Package internal is a generated GoMock package.
 Package internal is a generated GoMock package.
Package mockquic is a generated GoMock package.
 Package mockquic is a generated GoMock package.
Package mocktls is a generated GoMock package.
 Package mocktls is a generated GoMock package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.