run go generate ./...

2025-04-03 04:07:35 +03:00 · 2019-03-05 13:42:56 +09:00 · 2019-03-05 13:42:56 +09:00 · 5e34cb1d71
commit 5e34cb1d71
parent 42ea34048a
27 changed files with 332 additions and 0 deletions
--- 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)
 }
--- 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))
 }
--- 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)
 }
--- 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)
 }
--- 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))
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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))
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }
--- 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)
 }