From 5e34cb1d7152866d15795f0244bc388de2c291f6 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Tue, 5 Mar 2019 13:42:56 +0900 Subject: [PATCH] run go generate ./... --- .../ackhandler/received_packet_handler.go | 8 ++++ .../mocks/ackhandler/sent_packet_handler.go | 30 +++++++++++++++ internal/mocks/congestion.go | 20 ++++++++++ internal/mocks/connection_flow_controller.go | 12 ++++++ internal/mocks/crypto_setup.go | 16 ++++++++ internal/mocks/opener.go | 4 ++ internal/mocks/sealer.go | 6 +++ internal/mocks/stream_flow_controller.go | 16 ++++++++ mock_ack_frame_source_test.go | 2 + mock_crypto_data_handler_test.go | 2 + mock_crypto_stream_test.go | 12 ++++++ mock_frame_source_test.go | 4 ++ mock_multiplexer_test.go | 4 ++ mock_packer_test.go | 14 +++++++ mock_packet_handler_manager_test.go | 12 ++++++ mock_packet_handler_test.go | 8 ++++ mock_quic_session_test.go | 38 +++++++++++++++++++ mock_receive_stream_internal_test.go | 16 ++++++++ mock_sealing_manager_test.go | 4 ++ mock_send_stream_internal_test.go | 22 +++++++++++ mock_session_runner_test.go | 6 +++ mock_stream_getter_test.go | 4 ++ mock_stream_internal_test.go | 36 ++++++++++++++++++ mock_stream_manager_test.go | 24 ++++++++++++ mock_stream_sender_test.go | 6 +++ mock_unknown_packet_handler_test.go | 4 ++ mock_unpacker_test.go | 2 + 27 files changed, 332 insertions(+) diff --git a/internal/mocks/ackhandler/received_packet_handler.go b/internal/mocks/ackhandler/received_packet_handler.go index 9e25010c..4c395f27 100644 --- a/internal/mocks/ackhandler/received_packet_handler.go +++ b/internal/mocks/ackhandler/received_packet_handler.go @@ -38,6 +38,7 @@ func (m *MockReceivedPacketHandler) EXPECT() *MockReceivedPacketHandlerMockRecor // GetAckFrame mocks base method func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel) *wire.AckFrame { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAckFrame", arg0) ret0, _ := ret[0].(*wire.AckFrame) return ret0 @@ -45,11 +46,13 @@ func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel) * // GetAckFrame indicates an expected call of GetAckFrame func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0) } // GetAlarmTimeout mocks base method func (m *MockReceivedPacketHandler) GetAlarmTimeout() time.Time { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAlarmTimeout") ret0, _ := ret[0].(time.Time) return ret0 @@ -57,21 +60,25 @@ func (m *MockReceivedPacketHandler) GetAlarmTimeout() time.Time { // GetAlarmTimeout indicates an expected call of GetAlarmTimeout func (mr *MockReceivedPacketHandlerMockRecorder) GetAlarmTimeout() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmTimeout", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAlarmTimeout)) } // IgnoreBelow mocks base method func (m *MockReceivedPacketHandler) IgnoreBelow(arg0 protocol.PacketNumber) { + m.ctrl.T.Helper() m.ctrl.Call(m, "IgnoreBelow", arg0) } // IgnoreBelow indicates an expected call of IgnoreBelow func (mr *MockReceivedPacketHandlerMockRecorder) IgnoreBelow(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IgnoreBelow", reflect.TypeOf((*MockReceivedPacketHandler)(nil).IgnoreBelow), arg0) } // ReceivedPacket mocks base method func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, arg1 protocol.EncryptionLevel, arg2 time.Time, arg3 bool) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 @@ -79,5 +86,6 @@ func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, a // ReceivedPacket indicates an expected call of ReceivedPacket func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockReceivedPacketHandler)(nil).ReceivedPacket), arg0, arg1, arg2, arg3) } diff --git a/internal/mocks/ackhandler/sent_packet_handler.go b/internal/mocks/ackhandler/sent_packet_handler.go index 208909b7..fc289f5e 100644 --- a/internal/mocks/ackhandler/sent_packet_handler.go +++ b/internal/mocks/ackhandler/sent_packet_handler.go @@ -39,6 +39,7 @@ func (m *MockSentPacketHandler) EXPECT() *MockSentPacketHandlerMockRecorder { // DequeuePacketForRetransmission mocks base method func (m *MockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Packet { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DequeuePacketForRetransmission") ret0, _ := ret[0].(*ackhandler.Packet) return ret0 @@ -46,11 +47,13 @@ func (m *MockSentPacketHandler) DequeuePacketForRetransmission() *ackhandler.Pac // DequeuePacketForRetransmission indicates an expected call of DequeuePacketForRetransmission func (mr *MockSentPacketHandlerMockRecorder) DequeuePacketForRetransmission() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DequeuePacketForRetransmission", reflect.TypeOf((*MockSentPacketHandler)(nil).DequeuePacketForRetransmission)) } // DequeueProbePacket mocks base method func (m *MockSentPacketHandler) DequeueProbePacket() (*ackhandler.Packet, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DequeueProbePacket") ret0, _ := ret[0].(*ackhandler.Packet) ret1, _ := ret[1].(error) @@ -59,11 +62,13 @@ func (m *MockSentPacketHandler) DequeueProbePacket() (*ackhandler.Packet, error) // DequeueProbePacket indicates an expected call of DequeueProbePacket func (mr *MockSentPacketHandlerMockRecorder) DequeueProbePacket() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DequeueProbePacket", reflect.TypeOf((*MockSentPacketHandler)(nil).DequeueProbePacket)) } // GetAlarmTimeout mocks base method func (m *MockSentPacketHandler) GetAlarmTimeout() time.Time { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAlarmTimeout") ret0, _ := ret[0].(time.Time) return ret0 @@ -71,11 +76,13 @@ func (m *MockSentPacketHandler) GetAlarmTimeout() time.Time { // GetAlarmTimeout indicates an expected call of GetAlarmTimeout func (mr *MockSentPacketHandlerMockRecorder) GetAlarmTimeout() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).GetAlarmTimeout)) } // GetLowestPacketNotConfirmedAcked mocks base method func (m *MockSentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.PacketNumber { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLowestPacketNotConfirmedAcked") ret0, _ := ret[0].(protocol.PacketNumber) return ret0 @@ -83,11 +90,13 @@ func (m *MockSentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.Pack // GetLowestPacketNotConfirmedAcked indicates an expected call of GetLowestPacketNotConfirmedAcked func (mr *MockSentPacketHandlerMockRecorder) GetLowestPacketNotConfirmedAcked() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLowestPacketNotConfirmedAcked", reflect.TypeOf((*MockSentPacketHandler)(nil).GetLowestPacketNotConfirmedAcked)) } // OnAlarm mocks base method func (m *MockSentPacketHandler) OnAlarm() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OnAlarm") ret0, _ := ret[0].(error) return ret0 @@ -95,11 +104,13 @@ func (m *MockSentPacketHandler) OnAlarm() error { // OnAlarm indicates an expected call of OnAlarm func (mr *MockSentPacketHandlerMockRecorder) OnAlarm() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnAlarm", reflect.TypeOf((*MockSentPacketHandler)(nil).OnAlarm)) } // PeekPacketNumber mocks base method func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PeekPacketNumber", arg0) ret0, _ := ret[0].(protocol.PacketNumber) ret1, _ := ret[1].(protocol.PacketNumberLen) @@ -108,11 +119,13 @@ func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) // PeekPacketNumber indicates an expected call of PeekPacketNumber func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeekPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PeekPacketNumber), arg0) } // PopPacketNumber mocks base method func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) protocol.PacketNumber { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PopPacketNumber", arg0) ret0, _ := ret[0].(protocol.PacketNumber) return ret0 @@ -120,11 +133,13 @@ func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) p // PopPacketNumber indicates an expected call of PopPacketNumber func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PopPacketNumber), arg0) } // ReceivedAck mocks base method func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.PacketNumber, arg2 protocol.EncryptionLevel, arg3 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2, arg3) ret0, _ := ret[0].(error) return ret0 @@ -132,11 +147,13 @@ func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.P // ReceivedAck indicates an expected call of ReceivedAck func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2, arg3) } // ResetForRetry mocks base method func (m *MockSentPacketHandler) ResetForRetry() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResetForRetry") ret0, _ := ret[0].(error) return ret0 @@ -144,11 +161,13 @@ func (m *MockSentPacketHandler) ResetForRetry() error { // ResetForRetry indicates an expected call of ResetForRetry func (mr *MockSentPacketHandlerMockRecorder) ResetForRetry() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetForRetry", reflect.TypeOf((*MockSentPacketHandler)(nil).ResetForRetry)) } // SendMode mocks base method func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendMode") ret0, _ := ret[0].(ackhandler.SendMode) return ret0 @@ -156,41 +175,49 @@ func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode { // SendMode indicates an expected call of SendMode func (mr *MockSentPacketHandlerMockRecorder) SendMode() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMode", reflect.TypeOf((*MockSentPacketHandler)(nil).SendMode)) } // SentPacket mocks base method func (m *MockSentPacketHandler) SentPacket(arg0 *ackhandler.Packet) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SentPacket", arg0) } // SentPacket indicates an expected call of SentPacket func (mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacket), arg0) } // SentPacketsAsRetransmission mocks base method func (m *MockSentPacketHandler) SentPacketsAsRetransmission(arg0 []*ackhandler.Packet, arg1 protocol.PacketNumber) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SentPacketsAsRetransmission", arg0, arg1) } // SentPacketsAsRetransmission indicates an expected call of SentPacketsAsRetransmission func (mr *MockSentPacketHandlerMockRecorder) SentPacketsAsRetransmission(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacketsAsRetransmission", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacketsAsRetransmission), arg0, arg1) } // SetHandshakeComplete mocks base method func (m *MockSentPacketHandler) SetHandshakeComplete() { + m.ctrl.T.Helper() m.ctrl.Call(m, "SetHandshakeComplete") } // SetHandshakeComplete indicates an expected call of SetHandshakeComplete func (mr *MockSentPacketHandlerMockRecorder) SetHandshakeComplete() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeComplete", reflect.TypeOf((*MockSentPacketHandler)(nil).SetHandshakeComplete)) } // ShouldSendNumPackets mocks base method func (m *MockSentPacketHandler) ShouldSendNumPackets() int { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ShouldSendNumPackets") ret0, _ := ret[0].(int) return ret0 @@ -198,11 +225,13 @@ func (m *MockSentPacketHandler) ShouldSendNumPackets() int { // ShouldSendNumPackets indicates an expected call of ShouldSendNumPackets func (mr *MockSentPacketHandlerMockRecorder) ShouldSendNumPackets() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldSendNumPackets", reflect.TypeOf((*MockSentPacketHandler)(nil).ShouldSendNumPackets)) } // TimeUntilSend mocks base method func (m *MockSentPacketHandler) TimeUntilSend() time.Time { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TimeUntilSend") ret0, _ := ret[0].(time.Time) return ret0 @@ -210,5 +239,6 @@ func (m *MockSentPacketHandler) TimeUntilSend() time.Time { // TimeUntilSend indicates an expected call of TimeUntilSend func (mr *MockSentPacketHandlerMockRecorder) TimeUntilSend() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeUntilSend", reflect.TypeOf((*MockSentPacketHandler)(nil).TimeUntilSend)) } diff --git a/internal/mocks/congestion.go b/internal/mocks/congestion.go index d0749252..774930ea 100644 --- a/internal/mocks/congestion.go +++ b/internal/mocks/congestion.go @@ -37,6 +37,7 @@ func (m *MockSendAlgorithm) EXPECT() *MockSendAlgorithmMockRecorder { // GetCongestionWindow mocks base method func (m *MockSendAlgorithm) GetCongestionWindow() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCongestionWindow") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -44,91 +45,109 @@ func (m *MockSendAlgorithm) GetCongestionWindow() protocol.ByteCount { // GetCongestionWindow indicates an expected call of GetCongestionWindow func (mr *MockSendAlgorithmMockRecorder) GetCongestionWindow() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCongestionWindow", reflect.TypeOf((*MockSendAlgorithm)(nil).GetCongestionWindow)) } // MaybeExitSlowStart mocks base method func (m *MockSendAlgorithm) MaybeExitSlowStart() { + m.ctrl.T.Helper() m.ctrl.Call(m, "MaybeExitSlowStart") } // MaybeExitSlowStart indicates an expected call of MaybeExitSlowStart func (mr *MockSendAlgorithmMockRecorder) MaybeExitSlowStart() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybeExitSlowStart", reflect.TypeOf((*MockSendAlgorithm)(nil).MaybeExitSlowStart)) } // OnConnectionMigration mocks base method func (m *MockSendAlgorithm) OnConnectionMigration() { + m.ctrl.T.Helper() m.ctrl.Call(m, "OnConnectionMigration") } // OnConnectionMigration indicates an expected call of OnConnectionMigration func (mr *MockSendAlgorithmMockRecorder) OnConnectionMigration() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnConnectionMigration", reflect.TypeOf((*MockSendAlgorithm)(nil).OnConnectionMigration)) } // OnPacketAcked mocks base method func (m *MockSendAlgorithm) OnPacketAcked(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount, arg3 time.Time) { + m.ctrl.T.Helper() m.ctrl.Call(m, "OnPacketAcked", arg0, arg1, arg2, arg3) } // OnPacketAcked indicates an expected call of OnPacketAcked func (mr *MockSendAlgorithmMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketAcked", reflect.TypeOf((*MockSendAlgorithm)(nil).OnPacketAcked), arg0, arg1, arg2, arg3) } // OnPacketLost mocks base method func (m *MockSendAlgorithm) OnPacketLost(arg0 protocol.PacketNumber, arg1, arg2 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "OnPacketLost", arg0, arg1, arg2) } // OnPacketLost indicates an expected call of OnPacketLost func (mr *MockSendAlgorithmMockRecorder) OnPacketLost(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketLost", reflect.TypeOf((*MockSendAlgorithm)(nil).OnPacketLost), arg0, arg1, arg2) } // OnPacketSent mocks base method func (m *MockSendAlgorithm) OnPacketSent(arg0 time.Time, arg1 protocol.ByteCount, arg2 protocol.PacketNumber, arg3 protocol.ByteCount, arg4 bool) { + m.ctrl.T.Helper() m.ctrl.Call(m, "OnPacketSent", arg0, arg1, arg2, arg3, arg4) } // OnPacketSent indicates an expected call of OnPacketSent func (mr *MockSendAlgorithmMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketSent", reflect.TypeOf((*MockSendAlgorithm)(nil).OnPacketSent), arg0, arg1, arg2, arg3, arg4) } // OnRetransmissionTimeout mocks base method func (m *MockSendAlgorithm) OnRetransmissionTimeout(arg0 bool) { + m.ctrl.T.Helper() m.ctrl.Call(m, "OnRetransmissionTimeout", arg0) } // OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout func (mr *MockSendAlgorithmMockRecorder) OnRetransmissionTimeout(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetransmissionTimeout", reflect.TypeOf((*MockSendAlgorithm)(nil).OnRetransmissionTimeout), arg0) } // SetNumEmulatedConnections mocks base method func (m *MockSendAlgorithm) SetNumEmulatedConnections(arg0 int) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SetNumEmulatedConnections", arg0) } // SetNumEmulatedConnections indicates an expected call of SetNumEmulatedConnections func (mr *MockSendAlgorithmMockRecorder) SetNumEmulatedConnections(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNumEmulatedConnections", reflect.TypeOf((*MockSendAlgorithm)(nil).SetNumEmulatedConnections), arg0) } // SetSlowStartLargeReduction mocks base method func (m *MockSendAlgorithm) SetSlowStartLargeReduction(arg0 bool) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SetSlowStartLargeReduction", arg0) } // SetSlowStartLargeReduction indicates an expected call of SetSlowStartLargeReduction func (mr *MockSendAlgorithmMockRecorder) SetSlowStartLargeReduction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSlowStartLargeReduction", reflect.TypeOf((*MockSendAlgorithm)(nil).SetSlowStartLargeReduction), arg0) } // TimeUntilSend mocks base method func (m *MockSendAlgorithm) TimeUntilSend(arg0 protocol.ByteCount) time.Duration { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TimeUntilSend", arg0) ret0, _ := ret[0].(time.Duration) return ret0 @@ -136,5 +155,6 @@ func (m *MockSendAlgorithm) TimeUntilSend(arg0 protocol.ByteCount) time.Duration // TimeUntilSend indicates an expected call of TimeUntilSend func (mr *MockSendAlgorithmMockRecorder) TimeUntilSend(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeUntilSend", reflect.TypeOf((*MockSendAlgorithm)(nil).TimeUntilSend), arg0) } diff --git a/internal/mocks/connection_flow_controller.go b/internal/mocks/connection_flow_controller.go index ae10e785..14892c1b 100644 --- a/internal/mocks/connection_flow_controller.go +++ b/internal/mocks/connection_flow_controller.go @@ -36,26 +36,31 @@ func (m *MockConnectionFlowController) EXPECT() *MockConnectionFlowControllerMoc // AddBytesRead mocks base method func (m *MockConnectionFlowController) AddBytesRead(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "AddBytesRead", arg0) } // AddBytesRead indicates an expected call of AddBytesRead func (mr *MockConnectionFlowControllerMockRecorder) AddBytesRead(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesRead", reflect.TypeOf((*MockConnectionFlowController)(nil).AddBytesRead), arg0) } // AddBytesSent mocks base method func (m *MockConnectionFlowController) AddBytesSent(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "AddBytesSent", arg0) } // AddBytesSent indicates an expected call of AddBytesSent func (mr *MockConnectionFlowControllerMockRecorder) AddBytesSent(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesSent", reflect.TypeOf((*MockConnectionFlowController)(nil).AddBytesSent), arg0) } // GetWindowUpdate mocks base method func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetWindowUpdate") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -63,11 +68,13 @@ func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount { // GetWindowUpdate indicates an expected call of GetWindowUpdate func (mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWindowUpdate", reflect.TypeOf((*MockConnectionFlowController)(nil).GetWindowUpdate)) } // IsNewlyBlocked mocks base method func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsNewlyBlocked") ret0, _ := ret[0].(bool) ret1, _ := ret[1].(protocol.ByteCount) @@ -76,11 +83,13 @@ func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCoun // IsNewlyBlocked indicates an expected call of IsNewlyBlocked func (mr *MockConnectionFlowControllerMockRecorder) IsNewlyBlocked() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNewlyBlocked", reflect.TypeOf((*MockConnectionFlowController)(nil).IsNewlyBlocked)) } // SendWindowSize mocks base method func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendWindowSize") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -88,15 +97,18 @@ func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount { // SendWindowSize indicates an expected call of SendWindowSize func (mr *MockConnectionFlowControllerMockRecorder) SendWindowSize() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWindowSize", reflect.TypeOf((*MockConnectionFlowController)(nil).SendWindowSize)) } // UpdateSendWindow mocks base method func (m *MockConnectionFlowController) UpdateSendWindow(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "UpdateSendWindow", arg0) } // UpdateSendWindow indicates an expected call of UpdateSendWindow func (mr *MockConnectionFlowControllerMockRecorder) UpdateSendWindow(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSendWindow", reflect.TypeOf((*MockConnectionFlowController)(nil).UpdateSendWindow), arg0) } diff --git a/internal/mocks/crypto_setup.go b/internal/mocks/crypto_setup.go index 0e1c1890..cc5bd66c 100644 --- a/internal/mocks/crypto_setup.go +++ b/internal/mocks/crypto_setup.go @@ -37,6 +37,7 @@ func (m *MockCryptoSetup) EXPECT() *MockCryptoSetupMockRecorder { // ChangeConnectionID mocks base method func (m *MockCryptoSetup) ChangeConnectionID(arg0 protocol.ConnectionID) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChangeConnectionID", arg0) ret0, _ := ret[0].(error) return ret0 @@ -44,11 +45,13 @@ func (m *MockCryptoSetup) ChangeConnectionID(arg0 protocol.ConnectionID) error { // ChangeConnectionID indicates an expected call of ChangeConnectionID func (mr *MockCryptoSetupMockRecorder) ChangeConnectionID(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeConnectionID", reflect.TypeOf((*MockCryptoSetup)(nil).ChangeConnectionID), arg0) } // Close mocks base method func (m *MockCryptoSetup) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -56,11 +59,13 @@ func (m *MockCryptoSetup) Close() error { // Close indicates an expected call of Close func (mr *MockCryptoSetupMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCryptoSetup)(nil).Close)) } // ConnectionState mocks base method func (m *MockCryptoSetup) ConnectionState() handshake.ConnectionState { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ConnectionState") ret0, _ := ret[0].(handshake.ConnectionState) return ret0 @@ -68,11 +73,13 @@ func (m *MockCryptoSetup) ConnectionState() handshake.ConnectionState { // ConnectionState indicates an expected call of ConnectionState func (mr *MockCryptoSetupMockRecorder) ConnectionState() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockCryptoSetup)(nil).ConnectionState)) } // GetOpener mocks base method func (m *MockCryptoSetup) GetOpener(arg0 protocol.EncryptionLevel) (handshake.Opener, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOpener", arg0) ret0, _ := ret[0].(handshake.Opener) ret1, _ := ret[1].(error) @@ -81,11 +88,13 @@ func (m *MockCryptoSetup) GetOpener(arg0 protocol.EncryptionLevel) (handshake.Op // GetOpener indicates an expected call of GetOpener func (mr *MockCryptoSetupMockRecorder) GetOpener(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOpener", reflect.TypeOf((*MockCryptoSetup)(nil).GetOpener), arg0) } // GetSealer mocks base method func (m *MockCryptoSetup) GetSealer() (protocol.EncryptionLevel, handshake.Sealer) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSealer") ret0, _ := ret[0].(protocol.EncryptionLevel) ret1, _ := ret[1].(handshake.Sealer) @@ -94,11 +103,13 @@ func (m *MockCryptoSetup) GetSealer() (protocol.EncryptionLevel, handshake.Seale // GetSealer indicates an expected call of GetSealer func (mr *MockCryptoSetupMockRecorder) GetSealer() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSealer", reflect.TypeOf((*MockCryptoSetup)(nil).GetSealer)) } // GetSealerWithEncryptionLevel mocks base method func (m *MockCryptoSetup) GetSealerWithEncryptionLevel(arg0 protocol.EncryptionLevel) (handshake.Sealer, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSealerWithEncryptionLevel", arg0) ret0, _ := ret[0].(handshake.Sealer) ret1, _ := ret[1].(error) @@ -107,11 +118,13 @@ func (m *MockCryptoSetup) GetSealerWithEncryptionLevel(arg0 protocol.EncryptionL // GetSealerWithEncryptionLevel indicates an expected call of GetSealerWithEncryptionLevel func (mr *MockCryptoSetupMockRecorder) GetSealerWithEncryptionLevel(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSealerWithEncryptionLevel", reflect.TypeOf((*MockCryptoSetup)(nil).GetSealerWithEncryptionLevel), arg0) } // HandleMessage mocks base method func (m *MockCryptoSetup) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLevel) bool { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1) ret0, _ := ret[0].(bool) return ret0 @@ -119,11 +132,13 @@ func (m *MockCryptoSetup) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLev // HandleMessage indicates an expected call of HandleMessage func (mr *MockCryptoSetupMockRecorder) HandleMessage(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockCryptoSetup)(nil).HandleMessage), arg0, arg1) } // RunHandshake mocks base method func (m *MockCryptoSetup) RunHandshake() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RunHandshake") ret0, _ := ret[0].(error) return ret0 @@ -131,5 +146,6 @@ func (m *MockCryptoSetup) RunHandshake() error { // RunHandshake indicates an expected call of RunHandshake func (mr *MockCryptoSetupMockRecorder) RunHandshake() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunHandshake", reflect.TypeOf((*MockCryptoSetup)(nil).RunHandshake)) } diff --git a/internal/mocks/opener.go b/internal/mocks/opener.go index dd927289..2fc399e4 100644 --- a/internal/mocks/opener.go +++ b/internal/mocks/opener.go @@ -36,16 +36,19 @@ func (m *MockOpener) EXPECT() *MockOpenerMockRecorder { // DecryptHeader mocks base method func (m *MockOpener) DecryptHeader(arg0 []byte, arg1 *byte, arg2 []byte) { + m.ctrl.T.Helper() m.ctrl.Call(m, "DecryptHeader", arg0, arg1, arg2) } // DecryptHeader indicates an expected call of DecryptHeader func (mr *MockOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptHeader", reflect.TypeOf((*MockOpener)(nil).DecryptHeader), arg0, arg1, arg2) } // Open mocks base method func (m *MockOpener) Open(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) ([]byte, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", arg0, arg1, arg2, arg3) ret0, _ := ret[0].([]byte) ret1, _ := ret[1].(error) @@ -54,5 +57,6 @@ func (m *MockOpener) Open(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 [] // Open indicates an expected call of Open func (mr *MockOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockOpener)(nil).Open), arg0, arg1, arg2, arg3) } diff --git a/internal/mocks/sealer.go b/internal/mocks/sealer.go index de309e16..63a9ceb6 100644 --- a/internal/mocks/sealer.go +++ b/internal/mocks/sealer.go @@ -36,16 +36,19 @@ func (m *MockSealer) EXPECT() *MockSealerMockRecorder { // EncryptHeader mocks base method func (m *MockSealer) EncryptHeader(arg0 []byte, arg1 *byte, arg2 []byte) { + m.ctrl.T.Helper() m.ctrl.Call(m, "EncryptHeader", arg0, arg1, arg2) } // EncryptHeader indicates an expected call of EncryptHeader func (mr *MockSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptHeader", reflect.TypeOf((*MockSealer)(nil).EncryptHeader), arg0, arg1, arg2) } // Overhead mocks base method func (m *MockSealer) Overhead() int { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Overhead") ret0, _ := ret[0].(int) return ret0 @@ -53,11 +56,13 @@ func (m *MockSealer) Overhead() int { // Overhead indicates an expected call of Overhead func (mr *MockSealerMockRecorder) Overhead() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Overhead", reflect.TypeOf((*MockSealer)(nil).Overhead)) } // Seal mocks base method func (m *MockSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) []byte { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Seal", arg0, arg1, arg2, arg3) ret0, _ := ret[0].([]byte) return ret0 @@ -65,5 +70,6 @@ func (m *MockSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 [] // Seal indicates an expected call of Seal func (mr *MockSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockSealer)(nil).Seal), arg0, arg1, arg2, arg3) } diff --git a/internal/mocks/stream_flow_controller.go b/internal/mocks/stream_flow_controller.go index 65e9d5f7..819dbc09 100644 --- a/internal/mocks/stream_flow_controller.go +++ b/internal/mocks/stream_flow_controller.go @@ -36,36 +36,43 @@ func (m *MockStreamFlowController) EXPECT() *MockStreamFlowControllerMockRecorde // Abandon mocks base method func (m *MockStreamFlowController) Abandon() { + m.ctrl.T.Helper() m.ctrl.Call(m, "Abandon") } // Abandon indicates an expected call of Abandon func (mr *MockStreamFlowControllerMockRecorder) Abandon() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Abandon", reflect.TypeOf((*MockStreamFlowController)(nil).Abandon)) } // AddBytesRead mocks base method func (m *MockStreamFlowController) AddBytesRead(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "AddBytesRead", arg0) } // AddBytesRead indicates an expected call of AddBytesRead func (mr *MockStreamFlowControllerMockRecorder) AddBytesRead(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesRead", reflect.TypeOf((*MockStreamFlowController)(nil).AddBytesRead), arg0) } // AddBytesSent mocks base method func (m *MockStreamFlowController) AddBytesSent(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "AddBytesSent", arg0) } // AddBytesSent indicates an expected call of AddBytesSent func (mr *MockStreamFlowControllerMockRecorder) AddBytesSent(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesSent", reflect.TypeOf((*MockStreamFlowController)(nil).AddBytesSent), arg0) } // GetWindowUpdate mocks base method func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetWindowUpdate") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -73,11 +80,13 @@ func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount { // GetWindowUpdate indicates an expected call of GetWindowUpdate func (mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWindowUpdate", reflect.TypeOf((*MockStreamFlowController)(nil).GetWindowUpdate)) } // IsNewlyBlocked mocks base method func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "IsNewlyBlocked") ret0, _ := ret[0].(bool) ret1, _ := ret[1].(protocol.ByteCount) @@ -86,11 +95,13 @@ func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) { // IsNewlyBlocked indicates an expected call of IsNewlyBlocked func (mr *MockStreamFlowControllerMockRecorder) IsNewlyBlocked() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNewlyBlocked", reflect.TypeOf((*MockStreamFlowController)(nil).IsNewlyBlocked)) } // SendWindowSize mocks base method func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SendWindowSize") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -98,11 +109,13 @@ func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount { // SendWindowSize indicates an expected call of SendWindowSize func (mr *MockStreamFlowControllerMockRecorder) SendWindowSize() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWindowSize", reflect.TypeOf((*MockStreamFlowController)(nil).SendWindowSize)) } // UpdateHighestReceived mocks base method func (m *MockStreamFlowController) UpdateHighestReceived(arg0 protocol.ByteCount, arg1 bool) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateHighestReceived", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -110,15 +123,18 @@ func (m *MockStreamFlowController) UpdateHighestReceived(arg0 protocol.ByteCount // UpdateHighestReceived indicates an expected call of UpdateHighestReceived func (mr *MockStreamFlowControllerMockRecorder) UpdateHighestReceived(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHighestReceived", reflect.TypeOf((*MockStreamFlowController)(nil).UpdateHighestReceived), arg0, arg1) } // UpdateSendWindow mocks base method func (m *MockStreamFlowController) UpdateSendWindow(arg0 protocol.ByteCount) { + m.ctrl.T.Helper() m.ctrl.Call(m, "UpdateSendWindow", arg0) } // UpdateSendWindow indicates an expected call of UpdateSendWindow func (mr *MockStreamFlowControllerMockRecorder) UpdateSendWindow(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSendWindow", reflect.TypeOf((*MockStreamFlowController)(nil).UpdateSendWindow), arg0) } diff --git a/mock_ack_frame_source_test.go b/mock_ack_frame_source_test.go index f1362124..c088a947 100644 --- a/mock_ack_frame_source_test.go +++ b/mock_ack_frame_source_test.go @@ -37,6 +37,7 @@ func (m *MockAckFrameSource) EXPECT() *MockAckFrameSourceMockRecorder { // GetAckFrame mocks base method func (m *MockAckFrameSource) GetAckFrame(arg0 protocol.EncryptionLevel) *wire.AckFrame { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAckFrame", arg0) ret0, _ := ret[0].(*wire.AckFrame) return ret0 @@ -44,5 +45,6 @@ func (m *MockAckFrameSource) GetAckFrame(arg0 protocol.EncryptionLevel) *wire.Ac // GetAckFrame indicates an expected call of GetAckFrame func (mr *MockAckFrameSourceMockRecorder) GetAckFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockAckFrameSource)(nil).GetAckFrame), arg0) } diff --git a/mock_crypto_data_handler_test.go b/mock_crypto_data_handler_test.go index 37a40800..5cfb10fd 100644 --- a/mock_crypto_data_handler_test.go +++ b/mock_crypto_data_handler_test.go @@ -36,6 +36,7 @@ func (m *MockCryptoDataHandler) EXPECT() *MockCryptoDataHandlerMockRecorder { // HandleMessage mocks base method func (m *MockCryptoDataHandler) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLevel) bool { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1) ret0, _ := ret[0].(bool) return ret0 @@ -43,5 +44,6 @@ func (m *MockCryptoDataHandler) HandleMessage(arg0 []byte, arg1 protocol.Encrypt // HandleMessage indicates an expected call of HandleMessage func (mr *MockCryptoDataHandlerMockRecorder) HandleMessage(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockCryptoDataHandler)(nil).HandleMessage), arg0, arg1) } diff --git a/mock_crypto_stream_test.go b/mock_crypto_stream_test.go index 0465e7e2..dfdea27b 100644 --- a/mock_crypto_stream_test.go +++ b/mock_crypto_stream_test.go @@ -37,6 +37,7 @@ func (m *MockCryptoStream) EXPECT() *MockCryptoStreamMockRecorder { // Finish mocks base method func (m *MockCryptoStream) Finish() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Finish") ret0, _ := ret[0].(error) return ret0 @@ -44,11 +45,13 @@ func (m *MockCryptoStream) Finish() error { // Finish indicates an expected call of Finish func (mr *MockCryptoStreamMockRecorder) Finish() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finish", reflect.TypeOf((*MockCryptoStream)(nil).Finish)) } // GetCryptoData mocks base method func (m *MockCryptoStream) GetCryptoData() []byte { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCryptoData") ret0, _ := ret[0].([]byte) return ret0 @@ -56,11 +59,13 @@ func (m *MockCryptoStream) GetCryptoData() []byte { // GetCryptoData indicates an expected call of GetCryptoData func (mr *MockCryptoStreamMockRecorder) GetCryptoData() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCryptoData", reflect.TypeOf((*MockCryptoStream)(nil).GetCryptoData)) } // HandleCryptoFrame mocks base method func (m *MockCryptoStream) HandleCryptoFrame(arg0 *wire.CryptoFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HandleCryptoFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -68,11 +73,13 @@ func (m *MockCryptoStream) HandleCryptoFrame(arg0 *wire.CryptoFrame) error { // HandleCryptoFrame indicates an expected call of HandleCryptoFrame func (mr *MockCryptoStreamMockRecorder) HandleCryptoFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCryptoFrame", reflect.TypeOf((*MockCryptoStream)(nil).HandleCryptoFrame), arg0) } // HasData mocks base method func (m *MockCryptoStream) HasData() bool { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HasData") ret0, _ := ret[0].(bool) return ret0 @@ -80,11 +87,13 @@ func (m *MockCryptoStream) HasData() bool { // HasData indicates an expected call of HasData func (mr *MockCryptoStreamMockRecorder) HasData() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasData", reflect.TypeOf((*MockCryptoStream)(nil).HasData)) } // PopCryptoFrame mocks base method func (m *MockCryptoStream) PopCryptoFrame(arg0 protocol.ByteCount) *wire.CryptoFrame { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PopCryptoFrame", arg0) ret0, _ := ret[0].(*wire.CryptoFrame) return ret0 @@ -92,11 +101,13 @@ func (m *MockCryptoStream) PopCryptoFrame(arg0 protocol.ByteCount) *wire.CryptoF // PopCryptoFrame indicates an expected call of PopCryptoFrame func (mr *MockCryptoStreamMockRecorder) PopCryptoFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopCryptoFrame", reflect.TypeOf((*MockCryptoStream)(nil).PopCryptoFrame), arg0) } // Write mocks base method func (m *MockCryptoStream) Write(arg0 []byte) (int, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) @@ -105,5 +116,6 @@ func (m *MockCryptoStream) Write(arg0 []byte) (int, error) { // Write indicates an expected call of Write func (mr *MockCryptoStreamMockRecorder) Write(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockCryptoStream)(nil).Write), arg0) } diff --git a/mock_frame_source_test.go b/mock_frame_source_test.go index ff757c88..e2f682a8 100644 --- a/mock_frame_source_test.go +++ b/mock_frame_source_test.go @@ -37,6 +37,7 @@ func (m *MockFrameSource) EXPECT() *MockFrameSourceMockRecorder { // AppendControlFrames mocks base method func (m *MockFrameSource) AppendControlFrames(arg0 []wire.Frame, arg1 protocol.ByteCount) ([]wire.Frame, protocol.ByteCount) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AppendControlFrames", arg0, arg1) ret0, _ := ret[0].([]wire.Frame) ret1, _ := ret[1].(protocol.ByteCount) @@ -45,11 +46,13 @@ func (m *MockFrameSource) AppendControlFrames(arg0 []wire.Frame, arg1 protocol.B // AppendControlFrames indicates an expected call of AppendControlFrames func (mr *MockFrameSourceMockRecorder) AppendControlFrames(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendControlFrames", reflect.TypeOf((*MockFrameSource)(nil).AppendControlFrames), arg0, arg1) } // AppendStreamFrames mocks base method func (m *MockFrameSource) AppendStreamFrames(arg0 []wire.Frame, arg1 protocol.ByteCount) []wire.Frame { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AppendStreamFrames", arg0, arg1) ret0, _ := ret[0].([]wire.Frame) return ret0 @@ -57,5 +60,6 @@ func (m *MockFrameSource) AppendStreamFrames(arg0 []wire.Frame, arg1 protocol.By // AppendStreamFrames indicates an expected call of AppendStreamFrames func (mr *MockFrameSourceMockRecorder) AppendStreamFrames(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendStreamFrames", reflect.TypeOf((*MockFrameSource)(nil).AppendStreamFrames), arg0, arg1) } diff --git a/mock_multiplexer_test.go b/mock_multiplexer_test.go index 921dfaae..52731b5a 100644 --- a/mock_multiplexer_test.go +++ b/mock_multiplexer_test.go @@ -36,6 +36,7 @@ func (m *MockMultiplexer) EXPECT() *MockMultiplexerMockRecorder { // AddConn mocks base method func (m *MockMultiplexer) AddConn(arg0 net.PacketConn, arg1 int) (packetHandlerManager, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddConn", arg0, arg1) ret0, _ := ret[0].(packetHandlerManager) ret1, _ := ret[1].(error) @@ -44,11 +45,13 @@ func (m *MockMultiplexer) AddConn(arg0 net.PacketConn, arg1 int) (packetHandlerM // AddConn indicates an expected call of AddConn func (mr *MockMultiplexerMockRecorder) AddConn(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConn", reflect.TypeOf((*MockMultiplexer)(nil).AddConn), arg0, arg1) } // RemoveConn mocks base method func (m *MockMultiplexer) RemoveConn(arg0 net.PacketConn) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveConn", arg0) ret0, _ := ret[0].(error) return ret0 @@ -56,5 +59,6 @@ func (m *MockMultiplexer) RemoveConn(arg0 net.PacketConn) error { // RemoveConn indicates an expected call of RemoveConn func (mr *MockMultiplexerMockRecorder) RemoveConn(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveConn", reflect.TypeOf((*MockMultiplexer)(nil).RemoveConn), arg0) } diff --git a/mock_packer_test.go b/mock_packer_test.go index d628c2f9..805d8df8 100644 --- a/mock_packer_test.go +++ b/mock_packer_test.go @@ -39,26 +39,31 @@ func (m *MockPacker) EXPECT() *MockPackerMockRecorder { // ChangeDestConnectionID mocks base method func (m *MockPacker) ChangeDestConnectionID(arg0 protocol.ConnectionID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "ChangeDestConnectionID", arg0) } // ChangeDestConnectionID indicates an expected call of ChangeDestConnectionID func (mr *MockPackerMockRecorder) ChangeDestConnectionID(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeDestConnectionID", reflect.TypeOf((*MockPacker)(nil).ChangeDestConnectionID), arg0) } // HandleTransportParameters mocks base method func (m *MockPacker) HandleTransportParameters(arg0 *handshake.TransportParameters) { + m.ctrl.T.Helper() m.ctrl.Call(m, "HandleTransportParameters", arg0) } // HandleTransportParameters indicates an expected call of HandleTransportParameters func (mr *MockPackerMockRecorder) HandleTransportParameters(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleTransportParameters", reflect.TypeOf((*MockPacker)(nil).HandleTransportParameters), arg0) } // MaybePackAckPacket mocks base method func (m *MockPacker) MaybePackAckPacket() (*packedPacket, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MaybePackAckPacket") ret0, _ := ret[0].(*packedPacket) ret1, _ := ret[1].(error) @@ -67,11 +72,13 @@ func (m *MockPacker) MaybePackAckPacket() (*packedPacket, error) { // MaybePackAckPacket indicates an expected call of MaybePackAckPacket func (mr *MockPackerMockRecorder) MaybePackAckPacket() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackAckPacket", reflect.TypeOf((*MockPacker)(nil).MaybePackAckPacket)) } // PackConnectionClose mocks base method func (m *MockPacker) PackConnectionClose(arg0 *wire.ConnectionCloseFrame) (*packedPacket, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PackConnectionClose", arg0) ret0, _ := ret[0].(*packedPacket) ret1, _ := ret[1].(error) @@ -80,11 +87,13 @@ func (m *MockPacker) PackConnectionClose(arg0 *wire.ConnectionCloseFrame) (*pack // PackConnectionClose indicates an expected call of PackConnectionClose func (mr *MockPackerMockRecorder) PackConnectionClose(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackConnectionClose", reflect.TypeOf((*MockPacker)(nil).PackConnectionClose), arg0) } // PackPacket mocks base method func (m *MockPacker) PackPacket() (*packedPacket, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PackPacket") ret0, _ := ret[0].(*packedPacket) ret1, _ := ret[1].(error) @@ -93,11 +102,13 @@ func (m *MockPacker) PackPacket() (*packedPacket, error) { // PackPacket indicates an expected call of PackPacket func (mr *MockPackerMockRecorder) PackPacket() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackPacket", reflect.TypeOf((*MockPacker)(nil).PackPacket)) } // PackRetransmission mocks base method func (m *MockPacker) PackRetransmission(arg0 *ackhandler.Packet) ([]*packedPacket, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PackRetransmission", arg0) ret0, _ := ret[0].([]*packedPacket) ret1, _ := ret[1].(error) @@ -106,15 +117,18 @@ func (m *MockPacker) PackRetransmission(arg0 *ackhandler.Packet) ([]*packedPacke // PackRetransmission indicates an expected call of PackRetransmission func (mr *MockPackerMockRecorder) PackRetransmission(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackRetransmission", reflect.TypeOf((*MockPacker)(nil).PackRetransmission), arg0) } // SetToken mocks base method func (m *MockPacker) SetToken(arg0 []byte) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SetToken", arg0) } // SetToken indicates an expected call of SetToken func (mr *MockPackerMockRecorder) SetToken(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockPacker)(nil).SetToken), arg0) } diff --git a/mock_packet_handler_manager_test.go b/mock_packet_handler_manager_test.go index 056fa28e..257af2c7 100644 --- a/mock_packet_handler_manager_test.go +++ b/mock_packet_handler_manager_test.go @@ -36,16 +36,19 @@ func (m *MockPacketHandlerManager) EXPECT() *MockPacketHandlerManagerMockRecorde // Add mocks base method func (m *MockPacketHandlerManager) Add(arg0 protocol.ConnectionID, arg1 packetHandler) { + m.ctrl.T.Helper() m.ctrl.Call(m, "Add", arg0, arg1) } // Add indicates an expected call of Add func (mr *MockPacketHandlerManagerMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockPacketHandlerManager)(nil).Add), arg0, arg1) } // Close mocks base method func (m *MockPacketHandlerManager) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -53,45 +56,54 @@ func (m *MockPacketHandlerManager) Close() error { // Close indicates an expected call of Close func (mr *MockPacketHandlerManagerMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPacketHandlerManager)(nil).Close)) } // CloseServer mocks base method func (m *MockPacketHandlerManager) CloseServer() { + m.ctrl.T.Helper() m.ctrl.Call(m, "CloseServer") } // CloseServer indicates an expected call of CloseServer func (mr *MockPacketHandlerManagerMockRecorder) CloseServer() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseServer", reflect.TypeOf((*MockPacketHandlerManager)(nil).CloseServer)) } // Remove mocks base method func (m *MockPacketHandlerManager) Remove(arg0 protocol.ConnectionID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "Remove", arg0) } // Remove indicates an expected call of Remove func (mr *MockPacketHandlerManagerMockRecorder) Remove(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockPacketHandlerManager)(nil).Remove), arg0) } // Retire mocks base method func (m *MockPacketHandlerManager) Retire(arg0 protocol.ConnectionID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "Retire", arg0) } // Retire indicates an expected call of Retire func (mr *MockPacketHandlerManagerMockRecorder) Retire(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retire", reflect.TypeOf((*MockPacketHandlerManager)(nil).Retire), arg0) } // SetServer mocks base method func (m *MockPacketHandlerManager) SetServer(arg0 unknownPacketHandler) { + m.ctrl.T.Helper() m.ctrl.Call(m, "SetServer", arg0) } // SetServer indicates an expected call of SetServer func (mr *MockPacketHandlerManagerMockRecorder) SetServer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetServer", reflect.TypeOf((*MockPacketHandlerManager)(nil).SetServer), arg0) } diff --git a/mock_packet_handler_test.go b/mock_packet_handler_test.go index 812e7dcc..92e3964f 100644 --- a/mock_packet_handler_test.go +++ b/mock_packet_handler_test.go @@ -36,6 +36,7 @@ func (m *MockPacketHandler) EXPECT() *MockPacketHandlerMockRecorder { // Close mocks base method func (m *MockPacketHandler) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -43,21 +44,25 @@ func (m *MockPacketHandler) Close() error { // Close indicates an expected call of Close func (mr *MockPacketHandlerMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPacketHandler)(nil).Close)) } // destroy mocks base method func (m *MockPacketHandler) destroy(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "destroy", arg0) } // destroy indicates an expected call of destroy func (mr *MockPacketHandlerMockRecorder) destroy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "destroy", reflect.TypeOf((*MockPacketHandler)(nil).destroy), arg0) } // getPerspective mocks base method func (m *MockPacketHandler) getPerspective() protocol.Perspective { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "getPerspective") ret0, _ := ret[0].(protocol.Perspective) return ret0 @@ -65,15 +70,18 @@ func (m *MockPacketHandler) getPerspective() protocol.Perspective { // getPerspective indicates an expected call of getPerspective func (mr *MockPacketHandlerMockRecorder) getPerspective() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getPerspective", reflect.TypeOf((*MockPacketHandler)(nil).getPerspective)) } // handlePacket mocks base method func (m *MockPacketHandler) handlePacket(arg0 *receivedPacket) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handlePacket", arg0) } // handlePacket indicates an expected call of handlePacket func (mr *MockPacketHandlerMockRecorder) handlePacket(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handlePacket", reflect.TypeOf((*MockPacketHandler)(nil).handlePacket), arg0) } diff --git a/mock_quic_session_test.go b/mock_quic_session_test.go index 201b1495..90f1e6d9 100644 --- a/mock_quic_session_test.go +++ b/mock_quic_session_test.go @@ -39,6 +39,7 @@ func (m *MockQuicSession) EXPECT() *MockQuicSessionMockRecorder { // AcceptStream mocks base method func (m *MockQuicSession) AcceptStream() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AcceptStream") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -47,11 +48,13 @@ func (m *MockQuicSession) AcceptStream() (Stream, error) { // AcceptStream indicates an expected call of AcceptStream func (mr *MockQuicSessionMockRecorder) AcceptStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockQuicSession)(nil).AcceptStream)) } // AcceptUniStream mocks base method func (m *MockQuicSession) AcceptUniStream() (ReceiveStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AcceptUniStream") ret0, _ := ret[0].(ReceiveStream) ret1, _ := ret[1].(error) @@ -60,11 +63,13 @@ func (m *MockQuicSession) AcceptUniStream() (ReceiveStream, error) { // AcceptUniStream indicates an expected call of AcceptUniStream func (mr *MockQuicSessionMockRecorder) AcceptUniStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockQuicSession)(nil).AcceptUniStream)) } // Close mocks base method func (m *MockQuicSession) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -72,11 +77,13 @@ func (m *MockQuicSession) Close() error { // Close indicates an expected call of Close func (mr *MockQuicSessionMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockQuicSession)(nil).Close)) } // CloseWithError mocks base method func (m *MockQuicSession) CloseWithError(arg0 protocol.ApplicationErrorCode, arg1 error) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -84,11 +91,13 @@ func (m *MockQuicSession) CloseWithError(arg0 protocol.ApplicationErrorCode, arg // CloseWithError indicates an expected call of CloseWithError func (mr *MockQuicSessionMockRecorder) CloseWithError(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockQuicSession)(nil).CloseWithError), arg0, arg1) } // ConnectionState mocks base method func (m *MockQuicSession) ConnectionState() handshake.ConnectionState { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ConnectionState") ret0, _ := ret[0].(handshake.ConnectionState) return ret0 @@ -96,11 +105,13 @@ func (m *MockQuicSession) ConnectionState() handshake.ConnectionState { // ConnectionState indicates an expected call of ConnectionState func (mr *MockQuicSessionMockRecorder) ConnectionState() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockQuicSession)(nil).ConnectionState)) } // Context mocks base method func (m *MockQuicSession) Context() context.Context { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) return ret0 @@ -108,11 +119,13 @@ func (m *MockQuicSession) Context() context.Context { // Context indicates an expected call of Context func (mr *MockQuicSessionMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockQuicSession)(nil).Context)) } // GetVersion mocks base method func (m *MockQuicSession) GetVersion() protocol.VersionNumber { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetVersion") ret0, _ := ret[0].(protocol.VersionNumber) return ret0 @@ -120,11 +133,13 @@ func (m *MockQuicSession) GetVersion() protocol.VersionNumber { // GetVersion indicates an expected call of GetVersion func (mr *MockQuicSessionMockRecorder) GetVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockQuicSession)(nil).GetVersion)) } // LocalAddr mocks base method func (m *MockQuicSession) LocalAddr() net.Addr { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LocalAddr") ret0, _ := ret[0].(net.Addr) return ret0 @@ -132,11 +147,13 @@ func (m *MockQuicSession) LocalAddr() net.Addr { // LocalAddr indicates an expected call of LocalAddr func (mr *MockQuicSessionMockRecorder) LocalAddr() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockQuicSession)(nil).LocalAddr)) } // OpenStream mocks base method func (m *MockQuicSession) OpenStream() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenStream") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -145,11 +162,13 @@ func (m *MockQuicSession) OpenStream() (Stream, error) { // OpenStream indicates an expected call of OpenStream func (mr *MockQuicSessionMockRecorder) OpenStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockQuicSession)(nil).OpenStream)) } // OpenStreamSync mocks base method func (m *MockQuicSession) OpenStreamSync() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenStreamSync") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -158,11 +177,13 @@ func (m *MockQuicSession) OpenStreamSync() (Stream, error) { // OpenStreamSync indicates an expected call of OpenStreamSync func (mr *MockQuicSessionMockRecorder) OpenStreamSync() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockQuicSession)(nil).OpenStreamSync)) } // OpenUniStream mocks base method func (m *MockQuicSession) OpenUniStream() (SendStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenUniStream") ret0, _ := ret[0].(SendStream) ret1, _ := ret[1].(error) @@ -171,11 +192,13 @@ func (m *MockQuicSession) OpenUniStream() (SendStream, error) { // OpenUniStream indicates an expected call of OpenUniStream func (mr *MockQuicSessionMockRecorder) OpenUniStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockQuicSession)(nil).OpenUniStream)) } // OpenUniStreamSync mocks base method func (m *MockQuicSession) OpenUniStreamSync() (SendStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenUniStreamSync") ret0, _ := ret[0].(SendStream) ret1, _ := ret[1].(error) @@ -184,11 +207,13 @@ func (m *MockQuicSession) OpenUniStreamSync() (SendStream, error) { // OpenUniStreamSync indicates an expected call of OpenUniStreamSync func (mr *MockQuicSessionMockRecorder) OpenUniStreamSync() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockQuicSession)(nil).OpenUniStreamSync)) } // RemoteAddr mocks base method func (m *MockQuicSession) RemoteAddr() net.Addr { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoteAddr") ret0, _ := ret[0].(net.Addr) return ret0 @@ -196,11 +221,13 @@ func (m *MockQuicSession) RemoteAddr() net.Addr { // RemoteAddr indicates an expected call of RemoteAddr func (mr *MockQuicSessionMockRecorder) RemoteAddr() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockQuicSession)(nil).RemoteAddr)) } // closeForRecreating mocks base method func (m *MockQuicSession) closeForRecreating() protocol.PacketNumber { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "closeForRecreating") ret0, _ := ret[0].(protocol.PacketNumber) return ret0 @@ -208,31 +235,37 @@ func (m *MockQuicSession) closeForRecreating() protocol.PacketNumber { // closeForRecreating indicates an expected call of closeForRecreating func (mr *MockQuicSessionMockRecorder) closeForRecreating() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForRecreating", reflect.TypeOf((*MockQuicSession)(nil).closeForRecreating)) } // closeRemote mocks base method func (m *MockQuicSession) closeRemote(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "closeRemote", arg0) } // closeRemote indicates an expected call of closeRemote func (mr *MockQuicSessionMockRecorder) closeRemote(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeRemote", reflect.TypeOf((*MockQuicSession)(nil).closeRemote), arg0) } // destroy mocks base method func (m *MockQuicSession) destroy(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "destroy", arg0) } // destroy indicates an expected call of destroy func (mr *MockQuicSessionMockRecorder) destroy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "destroy", reflect.TypeOf((*MockQuicSession)(nil).destroy), arg0) } // getPerspective mocks base method func (m *MockQuicSession) getPerspective() protocol.Perspective { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "getPerspective") ret0, _ := ret[0].(protocol.Perspective) return ret0 @@ -240,21 +273,25 @@ func (m *MockQuicSession) getPerspective() protocol.Perspective { // getPerspective indicates an expected call of getPerspective func (mr *MockQuicSessionMockRecorder) getPerspective() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getPerspective", reflect.TypeOf((*MockQuicSession)(nil).getPerspective)) } // handlePacket mocks base method func (m *MockQuicSession) handlePacket(arg0 *receivedPacket) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handlePacket", arg0) } // handlePacket indicates an expected call of handlePacket func (mr *MockQuicSessionMockRecorder) handlePacket(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handlePacket", reflect.TypeOf((*MockQuicSession)(nil).handlePacket), arg0) } // run mocks base method func (m *MockQuicSession) run() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "run") ret0, _ := ret[0].(error) return ret0 @@ -262,5 +299,6 @@ func (m *MockQuicSession) run() error { // run indicates an expected call of run func (mr *MockQuicSessionMockRecorder) run() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "run", reflect.TypeOf((*MockQuicSession)(nil).run)) } diff --git a/mock_receive_stream_internal_test.go b/mock_receive_stream_internal_test.go index 4060d279..b40e3d9e 100644 --- a/mock_receive_stream_internal_test.go +++ b/mock_receive_stream_internal_test.go @@ -38,16 +38,19 @@ func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder { // CancelRead mocks base method func (m *MockReceiveStreamI) CancelRead(arg0 protocol.ApplicationErrorCode) { + m.ctrl.T.Helper() m.ctrl.Call(m, "CancelRead", arg0) } // CancelRead indicates an expected call of CancelRead func (mr *MockReceiveStreamIMockRecorder) CancelRead(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockReceiveStreamI)(nil).CancelRead), arg0) } // Read mocks base method func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Read", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) @@ -56,11 +59,13 @@ func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) { // Read indicates an expected call of Read func (mr *MockReceiveStreamIMockRecorder) Read(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockReceiveStreamI)(nil).Read), arg0) } // SetReadDeadline mocks base method func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetReadDeadline", arg0) ret0, _ := ret[0].(error) return ret0 @@ -68,11 +73,13 @@ func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error { // SetReadDeadline indicates an expected call of SetReadDeadline func (mr *MockReceiveStreamIMockRecorder) SetReadDeadline(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockReceiveStreamI)(nil).SetReadDeadline), arg0) } // StreamID mocks base method func (m *MockReceiveStreamI) StreamID() protocol.StreamID { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StreamID") ret0, _ := ret[0].(protocol.StreamID) return ret0 @@ -80,21 +87,25 @@ func (m *MockReceiveStreamI) StreamID() protocol.StreamID { // StreamID indicates an expected call of StreamID func (mr *MockReceiveStreamIMockRecorder) StreamID() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockReceiveStreamI)(nil).StreamID)) } // closeForShutdown mocks base method func (m *MockReceiveStreamI) closeForShutdown(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "closeForShutdown", arg0) } // closeForShutdown indicates an expected call of closeForShutdown func (mr *MockReceiveStreamIMockRecorder) closeForShutdown(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockReceiveStreamI)(nil).closeForShutdown), arg0) } // getWindowUpdate mocks base method func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "getWindowUpdate") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -102,11 +113,13 @@ func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount { // getWindowUpdate indicates an expected call of getWindowUpdate func (mr *MockReceiveStreamIMockRecorder) getWindowUpdate() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockReceiveStreamI)(nil).getWindowUpdate)) } // handleResetStreamFrame mocks base method func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -114,11 +127,13 @@ func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) // handleResetStreamFrame indicates an expected call of handleResetStreamFrame func (mr *MockReceiveStreamIMockRecorder) handleResetStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleResetStreamFrame), arg0) } // handleStreamFrame mocks base method func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "handleStreamFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -126,5 +141,6 @@ func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { // handleStreamFrame indicates an expected call of handleStreamFrame func (mr *MockReceiveStreamIMockRecorder) handleStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleStreamFrame), arg0) } diff --git a/mock_sealing_manager_test.go b/mock_sealing_manager_test.go index 32ebae20..c24d953e 100644 --- a/mock_sealing_manager_test.go +++ b/mock_sealing_manager_test.go @@ -37,6 +37,7 @@ func (m *MockSealingManager) EXPECT() *MockSealingManagerMockRecorder { // GetSealer mocks base method func (m *MockSealingManager) GetSealer() (protocol.EncryptionLevel, handshake.Sealer) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSealer") ret0, _ := ret[0].(protocol.EncryptionLevel) ret1, _ := ret[1].(handshake.Sealer) @@ -45,11 +46,13 @@ func (m *MockSealingManager) GetSealer() (protocol.EncryptionLevel, handshake.Se // GetSealer indicates an expected call of GetSealer func (mr *MockSealingManagerMockRecorder) GetSealer() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSealer", reflect.TypeOf((*MockSealingManager)(nil).GetSealer)) } // GetSealerWithEncryptionLevel mocks base method func (m *MockSealingManager) GetSealerWithEncryptionLevel(arg0 protocol.EncryptionLevel) (handshake.Sealer, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSealerWithEncryptionLevel", arg0) ret0, _ := ret[0].(handshake.Sealer) ret1, _ := ret[1].(error) @@ -58,5 +61,6 @@ func (m *MockSealingManager) GetSealerWithEncryptionLevel(arg0 protocol.Encrypti // GetSealerWithEncryptionLevel indicates an expected call of GetSealerWithEncryptionLevel func (mr *MockSealingManagerMockRecorder) GetSealerWithEncryptionLevel(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSealerWithEncryptionLevel", reflect.TypeOf((*MockSealingManager)(nil).GetSealerWithEncryptionLevel), arg0) } diff --git a/mock_send_stream_internal_test.go b/mock_send_stream_internal_test.go index a7edfdce..c1075af6 100644 --- a/mock_send_stream_internal_test.go +++ b/mock_send_stream_internal_test.go @@ -39,16 +39,19 @@ func (m *MockSendStreamI) EXPECT() *MockSendStreamIMockRecorder { // CancelWrite mocks base method func (m *MockSendStreamI) CancelWrite(arg0 protocol.ApplicationErrorCode) { + m.ctrl.T.Helper() m.ctrl.Call(m, "CancelWrite", arg0) } // CancelWrite indicates an expected call of CancelWrite func (mr *MockSendStreamIMockRecorder) CancelWrite(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockSendStreamI)(nil).CancelWrite), arg0) } // Close mocks base method func (m *MockSendStreamI) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -56,11 +59,13 @@ func (m *MockSendStreamI) Close() error { // Close indicates an expected call of Close func (mr *MockSendStreamIMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSendStreamI)(nil).Close)) } // Context mocks base method func (m *MockSendStreamI) Context() context.Context { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) return ret0 @@ -68,11 +73,13 @@ func (m *MockSendStreamI) Context() context.Context { // Context indicates an expected call of Context func (mr *MockSendStreamIMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSendStreamI)(nil).Context)) } // SetWriteDeadline mocks base method func (m *MockSendStreamI) SetWriteDeadline(arg0 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetWriteDeadline", arg0) ret0, _ := ret[0].(error) return ret0 @@ -80,11 +87,13 @@ func (m *MockSendStreamI) SetWriteDeadline(arg0 time.Time) error { // SetWriteDeadline indicates an expected call of SetWriteDeadline func (mr *MockSendStreamIMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockSendStreamI)(nil).SetWriteDeadline), arg0) } // StreamID mocks base method func (m *MockSendStreamI) StreamID() protocol.StreamID { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StreamID") ret0, _ := ret[0].(protocol.StreamID) return ret0 @@ -92,11 +101,13 @@ func (m *MockSendStreamI) StreamID() protocol.StreamID { // StreamID indicates an expected call of StreamID func (mr *MockSendStreamIMockRecorder) StreamID() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockSendStreamI)(nil).StreamID)) } // Write mocks base method func (m *MockSendStreamI) Write(arg0 []byte) (int, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) @@ -105,41 +116,49 @@ func (m *MockSendStreamI) Write(arg0 []byte) (int, error) { // Write indicates an expected call of Write func (mr *MockSendStreamIMockRecorder) Write(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockSendStreamI)(nil).Write), arg0) } // closeForShutdown mocks base method func (m *MockSendStreamI) closeForShutdown(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "closeForShutdown", arg0) } // closeForShutdown indicates an expected call of closeForShutdown func (mr *MockSendStreamIMockRecorder) closeForShutdown(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockSendStreamI)(nil).closeForShutdown), arg0) } // handleMaxStreamDataFrame mocks base method func (m *MockSendStreamI) handleMaxStreamDataFrame(arg0 *wire.MaxStreamDataFrame) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handleMaxStreamDataFrame", arg0) } // handleMaxStreamDataFrame indicates an expected call of handleMaxStreamDataFrame func (mr *MockSendStreamIMockRecorder) handleMaxStreamDataFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleMaxStreamDataFrame", reflect.TypeOf((*MockSendStreamI)(nil).handleMaxStreamDataFrame), arg0) } // handleStopSendingFrame mocks base method func (m *MockSendStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handleStopSendingFrame", arg0) } // handleStopSendingFrame indicates an expected call of handleStopSendingFrame func (mr *MockSendStreamIMockRecorder) handleStopSendingFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockSendStreamI)(nil).handleStopSendingFrame), arg0) } // hasData mocks base method func (m *MockSendStreamI) hasData() bool { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "hasData") ret0, _ := ret[0].(bool) return ret0 @@ -147,11 +166,13 @@ func (m *MockSendStreamI) hasData() bool { // hasData indicates an expected call of hasData func (mr *MockSendStreamIMockRecorder) hasData() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockSendStreamI)(nil).hasData)) } // popStreamFrame mocks base method func (m *MockSendStreamI) popStreamFrame(arg0 protocol.ByteCount) (*wire.StreamFrame, bool) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "popStreamFrame", arg0) ret0, _ := ret[0].(*wire.StreamFrame) ret1, _ := ret[1].(bool) @@ -160,5 +181,6 @@ func (m *MockSendStreamI) popStreamFrame(arg0 protocol.ByteCount) (*wire.StreamF // popStreamFrame indicates an expected call of popStreamFrame func (mr *MockSendStreamIMockRecorder) popStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockSendStreamI)(nil).popStreamFrame), arg0) } diff --git a/mock_session_runner_test.go b/mock_session_runner_test.go index aeba646e..d1efee9c 100644 --- a/mock_session_runner_test.go +++ b/mock_session_runner_test.go @@ -36,30 +36,36 @@ func (m *MockSessionRunner) EXPECT() *MockSessionRunnerMockRecorder { // onHandshakeComplete mocks base method func (m *MockSessionRunner) onHandshakeComplete(arg0 Session) { + m.ctrl.T.Helper() m.ctrl.Call(m, "onHandshakeComplete", arg0) } // onHandshakeComplete indicates an expected call of onHandshakeComplete func (mr *MockSessionRunnerMockRecorder) onHandshakeComplete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "onHandshakeComplete", reflect.TypeOf((*MockSessionRunner)(nil).onHandshakeComplete), arg0) } // removeConnectionID mocks base method func (m *MockSessionRunner) removeConnectionID(arg0 protocol.ConnectionID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "removeConnectionID", arg0) } // removeConnectionID indicates an expected call of removeConnectionID func (mr *MockSessionRunnerMockRecorder) removeConnectionID(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "removeConnectionID", reflect.TypeOf((*MockSessionRunner)(nil).removeConnectionID), arg0) } // retireConnectionID mocks base method func (m *MockSessionRunner) retireConnectionID(arg0 protocol.ConnectionID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "retireConnectionID", arg0) } // retireConnectionID indicates an expected call of retireConnectionID func (mr *MockSessionRunnerMockRecorder) retireConnectionID(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "retireConnectionID", reflect.TypeOf((*MockSessionRunner)(nil).retireConnectionID), arg0) } diff --git a/mock_stream_getter_test.go b/mock_stream_getter_test.go index 8dfa2d86..8b766a1b 100644 --- a/mock_stream_getter_test.go +++ b/mock_stream_getter_test.go @@ -36,6 +36,7 @@ func (m *MockStreamGetter) EXPECT() *MockStreamGetterMockRecorder { // GetOrOpenReceiveStream mocks base method func (m *MockStreamGetter) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0) ret0, _ := ret[0].(receiveStreamI) ret1, _ := ret[1].(error) @@ -44,11 +45,13 @@ func (m *MockStreamGetter) GetOrOpenReceiveStream(arg0 protocol.StreamID) (recei // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream func (mr *MockStreamGetterMockRecorder) GetOrOpenReceiveStream(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamGetter)(nil).GetOrOpenReceiveStream), arg0) } // GetOrOpenSendStream mocks base method func (m *MockStreamGetter) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0) ret0, _ := ret[0].(sendStreamI) ret1, _ := ret[1].(error) @@ -57,5 +60,6 @@ func (m *MockStreamGetter) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStre // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream func (mr *MockStreamGetterMockRecorder) GetOrOpenSendStream(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamGetter)(nil).GetOrOpenSendStream), arg0) } diff --git a/mock_stream_internal_test.go b/mock_stream_internal_test.go index 19b91165..d6d0c2b2 100644 --- a/mock_stream_internal_test.go +++ b/mock_stream_internal_test.go @@ -39,26 +39,31 @@ func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder { // CancelRead mocks base method func (m *MockStreamI) CancelRead(arg0 protocol.ApplicationErrorCode) { + m.ctrl.T.Helper() m.ctrl.Call(m, "CancelRead", arg0) } // CancelRead indicates an expected call of CancelRead func (mr *MockStreamIMockRecorder) CancelRead(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStreamI)(nil).CancelRead), arg0) } // CancelWrite mocks base method func (m *MockStreamI) CancelWrite(arg0 protocol.ApplicationErrorCode) { + m.ctrl.T.Helper() m.ctrl.Call(m, "CancelWrite", arg0) } // CancelWrite indicates an expected call of CancelWrite func (mr *MockStreamIMockRecorder) CancelWrite(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStreamI)(nil).CancelWrite), arg0) } // Close mocks base method func (m *MockStreamI) Close() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Close") ret0, _ := ret[0].(error) return ret0 @@ -66,11 +71,13 @@ func (m *MockStreamI) Close() error { // Close indicates an expected call of Close func (mr *MockStreamIMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamI)(nil).Close)) } // Context mocks base method func (m *MockStreamI) Context() context.Context { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Context") ret0, _ := ret[0].(context.Context) return ret0 @@ -78,11 +85,13 @@ func (m *MockStreamI) Context() context.Context { // Context indicates an expected call of Context func (mr *MockStreamIMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStreamI)(nil).Context)) } // Read mocks base method func (m *MockStreamI) Read(arg0 []byte) (int, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Read", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) @@ -91,11 +100,13 @@ func (m *MockStreamI) Read(arg0 []byte) (int, error) { // Read indicates an expected call of Read func (mr *MockStreamIMockRecorder) Read(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStreamI)(nil).Read), arg0) } // SetDeadline mocks base method func (m *MockStreamI) SetDeadline(arg0 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetDeadline", arg0) ret0, _ := ret[0].(error) return ret0 @@ -103,11 +114,13 @@ func (m *MockStreamI) SetDeadline(arg0 time.Time) error { // SetDeadline indicates an expected call of SetDeadline func (mr *MockStreamIMockRecorder) SetDeadline(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStreamI)(nil).SetDeadline), arg0) } // SetReadDeadline mocks base method func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetReadDeadline", arg0) ret0, _ := ret[0].(error) return ret0 @@ -115,11 +128,13 @@ func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error { // SetReadDeadline indicates an expected call of SetReadDeadline func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStreamI)(nil).SetReadDeadline), arg0) } // SetWriteDeadline mocks base method func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetWriteDeadline", arg0) ret0, _ := ret[0].(error) return ret0 @@ -127,11 +142,13 @@ func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error { // SetWriteDeadline indicates an expected call of SetWriteDeadline func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStreamI)(nil).SetWriteDeadline), arg0) } // StreamID mocks base method func (m *MockStreamI) StreamID() protocol.StreamID { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "StreamID") ret0, _ := ret[0].(protocol.StreamID) return ret0 @@ -139,11 +156,13 @@ func (m *MockStreamI) StreamID() protocol.StreamID { // StreamID indicates an expected call of StreamID func (mr *MockStreamIMockRecorder) StreamID() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStreamI)(nil).StreamID)) } // Write mocks base method func (m *MockStreamI) Write(arg0 []byte) (int, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Write", arg0) ret0, _ := ret[0].(int) ret1, _ := ret[1].(error) @@ -152,21 +171,25 @@ func (m *MockStreamI) Write(arg0 []byte) (int, error) { // Write indicates an expected call of Write func (mr *MockStreamIMockRecorder) Write(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStreamI)(nil).Write), arg0) } // closeForShutdown mocks base method func (m *MockStreamI) closeForShutdown(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "closeForShutdown", arg0) } // closeForShutdown indicates an expected call of closeForShutdown func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockStreamI)(nil).closeForShutdown), arg0) } // getWindowUpdate mocks base method func (m *MockStreamI) getWindowUpdate() protocol.ByteCount { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "getWindowUpdate") ret0, _ := ret[0].(protocol.ByteCount) return ret0 @@ -174,21 +197,25 @@ func (m *MockStreamI) getWindowUpdate() protocol.ByteCount { // getWindowUpdate indicates an expected call of getWindowUpdate func (mr *MockStreamIMockRecorder) getWindowUpdate() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockStreamI)(nil).getWindowUpdate)) } // handleMaxStreamDataFrame mocks base method func (m *MockStreamI) handleMaxStreamDataFrame(arg0 *wire.MaxStreamDataFrame) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handleMaxStreamDataFrame", arg0) } // handleMaxStreamDataFrame indicates an expected call of handleMaxStreamDataFrame func (mr *MockStreamIMockRecorder) handleMaxStreamDataFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleMaxStreamDataFrame", reflect.TypeOf((*MockStreamI)(nil).handleMaxStreamDataFrame), arg0) } // handleResetStreamFrame mocks base method func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -196,21 +223,25 @@ func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error // handleResetStreamFrame indicates an expected call of handleResetStreamFrame func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleResetStreamFrame), arg0) } // handleStopSendingFrame mocks base method func (m *MockStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handleStopSendingFrame", arg0) } // handleStopSendingFrame indicates an expected call of handleStopSendingFrame func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockStreamI)(nil).handleStopSendingFrame), arg0) } // handleStreamFrame mocks base method func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "handleStreamFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -218,11 +249,13 @@ func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { // handleStreamFrame indicates an expected call of handleStreamFrame func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleStreamFrame), arg0) } // hasData mocks base method func (m *MockStreamI) hasData() bool { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "hasData") ret0, _ := ret[0].(bool) return ret0 @@ -230,11 +263,13 @@ func (m *MockStreamI) hasData() bool { // hasData indicates an expected call of hasData func (mr *MockStreamIMockRecorder) hasData() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockStreamI)(nil).hasData)) } // popStreamFrame mocks base method func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount) (*wire.StreamFrame, bool) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "popStreamFrame", arg0) ret0, _ := ret[0].(*wire.StreamFrame) ret1, _ := ret[1].(bool) @@ -243,5 +278,6 @@ func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount) (*wire.StreamFrame // popStreamFrame indicates an expected call of popStreamFrame func (mr *MockStreamIMockRecorder) popStreamFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockStreamI)(nil).popStreamFrame), arg0) } diff --git a/mock_stream_manager_test.go b/mock_stream_manager_test.go index 9991d28f..153652b1 100644 --- a/mock_stream_manager_test.go +++ b/mock_stream_manager_test.go @@ -38,6 +38,7 @@ func (m *MockStreamManager) EXPECT() *MockStreamManagerMockRecorder { // AcceptStream mocks base method func (m *MockStreamManager) AcceptStream() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AcceptStream") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -46,11 +47,13 @@ func (m *MockStreamManager) AcceptStream() (Stream, error) { // AcceptStream indicates an expected call of AcceptStream func (mr *MockStreamManagerMockRecorder) AcceptStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptStream)) } // AcceptUniStream mocks base method func (m *MockStreamManager) AcceptUniStream() (ReceiveStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AcceptUniStream") ret0, _ := ret[0].(ReceiveStream) ret1, _ := ret[1].(error) @@ -59,21 +62,25 @@ func (m *MockStreamManager) AcceptUniStream() (ReceiveStream, error) { // AcceptUniStream indicates an expected call of AcceptUniStream func (mr *MockStreamManagerMockRecorder) AcceptUniStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptUniStream)) } // CloseWithError mocks base method func (m *MockStreamManager) CloseWithError(arg0 error) { + m.ctrl.T.Helper() m.ctrl.Call(m, "CloseWithError", arg0) } // CloseWithError indicates an expected call of CloseWithError func (mr *MockStreamManagerMockRecorder) CloseWithError(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockStreamManager)(nil).CloseWithError), arg0) } // DeleteStream mocks base method func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteStream", arg0) ret0, _ := ret[0].(error) return ret0 @@ -81,11 +88,13 @@ func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error { // DeleteStream indicates an expected call of DeleteStream func (mr *MockStreamManagerMockRecorder) DeleteStream(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStream", reflect.TypeOf((*MockStreamManager)(nil).DeleteStream), arg0) } // GetOrOpenReceiveStream mocks base method func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0) ret0, _ := ret[0].(receiveStreamI) ret1, _ := ret[1].(error) @@ -94,11 +103,13 @@ func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (rece // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream func (mr *MockStreamManagerMockRecorder) GetOrOpenReceiveStream(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenReceiveStream), arg0) } // GetOrOpenSendStream mocks base method func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0) ret0, _ := ret[0].(sendStreamI) ret1, _ := ret[1].(error) @@ -107,11 +118,13 @@ func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStr // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream func (mr *MockStreamManagerMockRecorder) GetOrOpenSendStream(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenSendStream), arg0) } // HandleMaxStreamsFrame mocks base method func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "HandleMaxStreamsFrame", arg0) ret0, _ := ret[0].(error) return ret0 @@ -119,11 +132,13 @@ func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) er // HandleMaxStreamsFrame indicates an expected call of HandleMaxStreamsFrame func (mr *MockStreamManagerMockRecorder) HandleMaxStreamsFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMaxStreamsFrame", reflect.TypeOf((*MockStreamManager)(nil).HandleMaxStreamsFrame), arg0) } // OpenStream mocks base method func (m *MockStreamManager) OpenStream() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenStream") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -132,11 +147,13 @@ func (m *MockStreamManager) OpenStream() (Stream, error) { // OpenStream indicates an expected call of OpenStream func (mr *MockStreamManagerMockRecorder) OpenStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockStreamManager)(nil).OpenStream)) } // OpenStreamSync mocks base method func (m *MockStreamManager) OpenStreamSync() (Stream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenStreamSync") ret0, _ := ret[0].(Stream) ret1, _ := ret[1].(error) @@ -145,11 +162,13 @@ func (m *MockStreamManager) OpenStreamSync() (Stream, error) { // OpenStreamSync indicates an expected call of OpenStreamSync func (mr *MockStreamManagerMockRecorder) OpenStreamSync() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenStreamSync)) } // OpenUniStream mocks base method func (m *MockStreamManager) OpenUniStream() (SendStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenUniStream") ret0, _ := ret[0].(SendStream) ret1, _ := ret[1].(error) @@ -158,11 +177,13 @@ func (m *MockStreamManager) OpenUniStream() (SendStream, error) { // OpenUniStream indicates an expected call of OpenUniStream func (mr *MockStreamManagerMockRecorder) OpenUniStream() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStream)) } // OpenUniStreamSync mocks base method func (m *MockStreamManager) OpenUniStreamSync() (SendStream, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenUniStreamSync") ret0, _ := ret[0].(SendStream) ret1, _ := ret[1].(error) @@ -171,15 +192,18 @@ func (m *MockStreamManager) OpenUniStreamSync() (SendStream, error) { // OpenUniStreamSync indicates an expected call of OpenUniStreamSync func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStreamSync)) } // UpdateLimits mocks base method func (m *MockStreamManager) UpdateLimits(arg0 *handshake.TransportParameters) { + m.ctrl.T.Helper() m.ctrl.Call(m, "UpdateLimits", arg0) } // UpdateLimits indicates an expected call of UpdateLimits func (mr *MockStreamManagerMockRecorder) UpdateLimits(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLimits", reflect.TypeOf((*MockStreamManager)(nil).UpdateLimits), arg0) } diff --git a/mock_stream_sender_test.go b/mock_stream_sender_test.go index d6f090a1..8b333121 100644 --- a/mock_stream_sender_test.go +++ b/mock_stream_sender_test.go @@ -37,30 +37,36 @@ func (m *MockStreamSender) EXPECT() *MockStreamSenderMockRecorder { // onHasStreamData mocks base method func (m *MockStreamSender) onHasStreamData(arg0 protocol.StreamID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "onHasStreamData", arg0) } // onHasStreamData indicates an expected call of onHasStreamData func (mr *MockStreamSenderMockRecorder) onHasStreamData(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "onHasStreamData", reflect.TypeOf((*MockStreamSender)(nil).onHasStreamData), arg0) } // onStreamCompleted mocks base method func (m *MockStreamSender) onStreamCompleted(arg0 protocol.StreamID) { + m.ctrl.T.Helper() m.ctrl.Call(m, "onStreamCompleted", arg0) } // onStreamCompleted indicates an expected call of onStreamCompleted func (mr *MockStreamSenderMockRecorder) onStreamCompleted(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "onStreamCompleted", reflect.TypeOf((*MockStreamSender)(nil).onStreamCompleted), arg0) } // queueControlFrame mocks base method func (m *MockStreamSender) queueControlFrame(arg0 wire.Frame) { + m.ctrl.T.Helper() m.ctrl.Call(m, "queueControlFrame", arg0) } // queueControlFrame indicates an expected call of queueControlFrame func (mr *MockStreamSenderMockRecorder) queueControlFrame(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "queueControlFrame", reflect.TypeOf((*MockStreamSender)(nil).queueControlFrame), arg0) } diff --git a/mock_unknown_packet_handler_test.go b/mock_unknown_packet_handler_test.go index 65f2978a..ca4771d6 100644 --- a/mock_unknown_packet_handler_test.go +++ b/mock_unknown_packet_handler_test.go @@ -35,6 +35,7 @@ func (m *MockUnknownPacketHandler) EXPECT() *MockUnknownPacketHandlerMockRecorde // closeWithError mocks base method func (m *MockUnknownPacketHandler) closeWithError(arg0 error) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "closeWithError", arg0) ret0, _ := ret[0].(error) return ret0 @@ -42,15 +43,18 @@ func (m *MockUnknownPacketHandler) closeWithError(arg0 error) error { // closeWithError indicates an expected call of closeWithError func (mr *MockUnknownPacketHandlerMockRecorder) closeWithError(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeWithError", reflect.TypeOf((*MockUnknownPacketHandler)(nil).closeWithError), arg0) } // handlePacket mocks base method func (m *MockUnknownPacketHandler) handlePacket(arg0 *receivedPacket) { + m.ctrl.T.Helper() m.ctrl.Call(m, "handlePacket", arg0) } // handlePacket indicates an expected call of handlePacket func (mr *MockUnknownPacketHandlerMockRecorder) handlePacket(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handlePacket", reflect.TypeOf((*MockUnknownPacketHandler)(nil).handlePacket), arg0) } diff --git a/mock_unpacker_test.go b/mock_unpacker_test.go index 7a36bebf..8fb1838e 100644 --- a/mock_unpacker_test.go +++ b/mock_unpacker_test.go @@ -36,6 +36,7 @@ func (m *MockUnpacker) EXPECT() *MockUnpackerMockRecorder { // Unpack mocks base method func (m *MockUnpacker) Unpack(arg0 *wire.Header, arg1 []byte) (*unpackedPacket, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Unpack", arg0, arg1) ret0, _ := ret[0].(*unpackedPacket) ret1, _ := ret[1].(error) @@ -44,5 +45,6 @@ func (m *MockUnpacker) Unpack(arg0 *wire.Header, arg1 []byte) (*unpackedPacket, // Unpack indicates an expected call of Unpack func (mr *MockUnpackerMockRecorder) Unpack(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unpack", reflect.TypeOf((*MockUnpacker)(nil).Unpack), arg0, arg1) }