update gomock to v1.5.0

go.mod

@@ -5,7 +5,7 @@ go 1.14
 require (
 	github.com/cheekybits/genny v1.0.0
 	github.com/francoispqt/gojay v1.2.13
-	github.com/golang/mock v1.4.4
+	github.com/golang/mock v1.5.0
 	github.com/marten-seemann/qpack v0.2.1
 	github.com/marten-seemann/qtls-go1-15 v0.1.1
 	github.com/marten-seemann/qtls-go1-16 v0.1.0

go.sum

@@ -37,6 +37,8 @@ github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc=
 github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/mock v1.5.0 h1:jlYHihg//f7RRwuPfptm04yp4s7O6Kw8EZiVYIGcH0g=
+github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -145,6 +147,7 @@ golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+
 golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d h1:1ZiEyfaQIg3Qh0EoqpwAakHVhecoE5wlSg5GjnafJGw=
 golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
@@ -153,6 +156,8 @@ golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL
 golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -164,6 +169,7 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
@@ -209,6 +215,10 @@ golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e h1:aZzprAO9/8oim3qStq3wc1Xuxx4QmAGriC4VU4ojemQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=

internal/ackhandler/mock_sent_packet_tracker_test.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockSentPacketTracker is a mock of SentPacketTracker interface
+// MockSentPacketTracker is a mock of SentPacketTracker interface.
 type MockSentPacketTracker struct {
 	ctrl     *gomock.Controller
 	recorder *MockSentPacketTrackerMockRecorder
 }
 
-// MockSentPacketTrackerMockRecorder is the mock recorder for MockSentPacketTracker
+// MockSentPacketTrackerMockRecorder is the mock recorder for MockSentPacketTracker.
 type MockSentPacketTrackerMockRecorder struct {
 	mock *MockSentPacketTracker
 }
 
-// NewMockSentPacketTracker creates a new mock instance
+// NewMockSentPacketTracker creates a new mock instance.
 func NewMockSentPacketTracker(ctrl *gomock.Controller) *MockSentPacketTracker {
 	mock := &MockSentPacketTracker{ctrl: ctrl}
 	mock.recorder = &MockSentPacketTrackerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSentPacketTracker) EXPECT() *MockSentPacketTrackerMockRecorder {
 	return m.recorder
 }
 
-// GetLowestPacketNotConfirmedAcked mocks base method
+// GetLowestPacketNotConfirmedAcked mocks base method.
 func (m *MockSentPacketTracker) GetLowestPacketNotConfirmedAcked() protocol.PacketNumber {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetLowestPacketNotConfirmedAcked")
@@ -42,19 +42,19 @@ func (m *MockSentPacketTracker) GetLowestPacketNotConfirmedAcked() protocol.Pack
 	return ret0
 }
 
-// GetLowestPacketNotConfirmedAcked indicates an expected call of GetLowestPacketNotConfirmedAcked
+// GetLowestPacketNotConfirmedAcked indicates an expected call of GetLowestPacketNotConfirmedAcked.
 func (mr *MockSentPacketTrackerMockRecorder) GetLowestPacketNotConfirmedAcked() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLowestPacketNotConfirmedAcked", reflect.TypeOf((*MockSentPacketTracker)(nil).GetLowestPacketNotConfirmedAcked))
 }
 
-// ReceivedPacket mocks base method
+// ReceivedPacket mocks base method.
 func (m *MockSentPacketTracker) ReceivedPacket(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedPacket", arg0)
 }
 
-// ReceivedPacket indicates an expected call of ReceivedPacket
+// ReceivedPacket indicates an expected call of ReceivedPacket.
 func (mr *MockSentPacketTrackerMockRecorder) ReceivedPacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockSentPacketTracker)(nil).ReceivedPacket), arg0)

internal/handshake/mock_handshake_runner_test.go

@@ -12,72 +12,72 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockHandshakeRunner is a mock of HandshakeRunner interface
+// MockHandshakeRunner is a mock of HandshakeRunner interface.
 type MockHandshakeRunner struct {
 	ctrl     *gomock.Controller
 	recorder *MockHandshakeRunnerMockRecorder
 }
 
-// MockHandshakeRunnerMockRecorder is the mock recorder for MockHandshakeRunner
+// MockHandshakeRunnerMockRecorder is the mock recorder for MockHandshakeRunner.
 type MockHandshakeRunnerMockRecorder struct {
 	mock *MockHandshakeRunner
 }
 
-// NewMockHandshakeRunner creates a new mock instance
+// NewMockHandshakeRunner creates a new mock instance.
 func NewMockHandshakeRunner(ctrl *gomock.Controller) *MockHandshakeRunner {
 	mock := &MockHandshakeRunner{ctrl: ctrl}
 	mock.recorder = &MockHandshakeRunnerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockHandshakeRunner) EXPECT() *MockHandshakeRunnerMockRecorder {
 	return m.recorder
 }
 
-// DropKeys mocks base method
+// DropKeys mocks base method.
 func (m *MockHandshakeRunner) DropKeys(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DropKeys", arg0)
 }
 
-// DropKeys indicates an expected call of DropKeys
+// DropKeys indicates an expected call of DropKeys.
 func (mr *MockHandshakeRunnerMockRecorder) DropKeys(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropKeys", reflect.TypeOf((*MockHandshakeRunner)(nil).DropKeys), arg0)
 }
 
-// OnError mocks base method
+// OnError mocks base method.
 func (m *MockHandshakeRunner) OnError(arg0 error) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "OnError", arg0)
 }
 
-// OnError indicates an expected call of OnError
+// OnError indicates an expected call of OnError.
 func (mr *MockHandshakeRunnerMockRecorder) OnError(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnError", reflect.TypeOf((*MockHandshakeRunner)(nil).OnError), arg0)
 }
 
-// OnHandshakeComplete mocks base method
+// OnHandshakeComplete mocks base method.
 func (m *MockHandshakeRunner) OnHandshakeComplete() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "OnHandshakeComplete")
 }
 
-// OnHandshakeComplete indicates an expected call of OnHandshakeComplete
+// OnHandshakeComplete indicates an expected call of OnHandshakeComplete.
 func (mr *MockHandshakeRunnerMockRecorder) OnHandshakeComplete() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnHandshakeComplete", reflect.TypeOf((*MockHandshakeRunner)(nil).OnHandshakeComplete))
 }
 
-// OnReceivedParams mocks base method
+// OnReceivedParams mocks base method.
 func (m *MockHandshakeRunner) OnReceivedParams(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "OnReceivedParams", arg0)
 }
 
-// OnReceivedParams indicates an expected call of OnReceivedParams
+// OnReceivedParams indicates an expected call of OnReceivedParams.
 func (mr *MockHandshakeRunnerMockRecorder) OnReceivedParams(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnReceivedParams", reflect.TypeOf((*MockHandshakeRunner)(nil).OnReceivedParams), arg0)

internal/mocks/ackhandler/received_packet_handler.go

@@ -13,42 +13,42 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockReceivedPacketHandler is a mock of ReceivedPacketHandler interface
+// MockReceivedPacketHandler is a mock of ReceivedPacketHandler interface.
 type MockReceivedPacketHandler struct {
 	ctrl     *gomock.Controller
 	recorder *MockReceivedPacketHandlerMockRecorder
 }
 
-// MockReceivedPacketHandlerMockRecorder is the mock recorder for MockReceivedPacketHandler
+// MockReceivedPacketHandlerMockRecorder is the mock recorder for MockReceivedPacketHandler.
 type MockReceivedPacketHandlerMockRecorder struct {
 	mock *MockReceivedPacketHandler
 }
 
-// NewMockReceivedPacketHandler creates a new mock instance
+// NewMockReceivedPacketHandler creates a new mock instance.
 func NewMockReceivedPacketHandler(ctrl *gomock.Controller) *MockReceivedPacketHandler {
 	mock := &MockReceivedPacketHandler{ctrl: ctrl}
 	mock.recorder = &MockReceivedPacketHandlerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockReceivedPacketHandler) EXPECT() *MockReceivedPacketHandlerMockRecorder {
 	return m.recorder
 }
 
-// DropPackets mocks base method
+// DropPackets mocks base method.
 func (m *MockReceivedPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DropPackets", arg0)
 }
 
-// DropPackets indicates an expected call of DropPackets
+// DropPackets indicates an expected call of DropPackets.
 func (mr *MockReceivedPacketHandlerMockRecorder) DropPackets(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropPackets", reflect.TypeOf((*MockReceivedPacketHandler)(nil).DropPackets), arg0)
 }
 
-// GetAckFrame mocks base method
+// GetAckFrame mocks base method.
 func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel, arg1 bool) *wire.AckFrame {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAckFrame", arg0, arg1)
@@ -56,13 +56,13 @@ func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel, a
 	return ret0
 }
 
-// GetAckFrame indicates an expected call of GetAckFrame
+// GetAckFrame indicates an expected call of GetAckFrame.
 func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0, arg1)
 }
 
-// GetAlarmTimeout mocks base method
+// GetAlarmTimeout mocks base method.
 func (m *MockReceivedPacketHandler) GetAlarmTimeout() time.Time {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAlarmTimeout")
@@ -70,13 +70,13 @@ func (m *MockReceivedPacketHandler) GetAlarmTimeout() time.Time {
 	return ret0
 }
 
-// GetAlarmTimeout indicates an expected call of GetAlarmTimeout
+// 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))
 }
 
-// IsPotentiallyDuplicate mocks base method
+// IsPotentiallyDuplicate mocks base method.
 func (m *MockReceivedPacketHandler) IsPotentiallyDuplicate(arg0 protocol.PacketNumber, arg1 protocol.EncryptionLevel) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsPotentiallyDuplicate", arg0, arg1)
@@ -84,13 +84,13 @@ func (m *MockReceivedPacketHandler) IsPotentiallyDuplicate(arg0 protocol.PacketN
 	return ret0
 }
 
-// IsPotentiallyDuplicate indicates an expected call of IsPotentiallyDuplicate
+// IsPotentiallyDuplicate indicates an expected call of IsPotentiallyDuplicate.
 func (mr *MockReceivedPacketHandlerMockRecorder) IsPotentiallyDuplicate(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPotentiallyDuplicate", reflect.TypeOf((*MockReceivedPacketHandler)(nil).IsPotentiallyDuplicate), arg0, arg1)
 }
 
-// ReceivedPacket mocks base method
+// ReceivedPacket mocks base method.
 func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, arg1 protocol.ECN, arg2 protocol.EncryptionLevel, arg3 time.Time, arg4 bool) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2, arg3, arg4)
@@ -98,7 +98,7 @@ func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, a
 	return ret0
 }
 
-// ReceivedPacket indicates an expected call of ReceivedPacket
+// ReceivedPacket indicates an expected call of ReceivedPacket.
 func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3, arg4 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, arg4)

internal/mocks/ackhandler/sent_packet_handler.go

@@ -14,42 +14,42 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockSentPacketHandler is a mock of SentPacketHandler interface
+// MockSentPacketHandler is a mock of SentPacketHandler interface.
 type MockSentPacketHandler struct {
 	ctrl     *gomock.Controller
 	recorder *MockSentPacketHandlerMockRecorder
 }
 
-// MockSentPacketHandlerMockRecorder is the mock recorder for MockSentPacketHandler
+// MockSentPacketHandlerMockRecorder is the mock recorder for MockSentPacketHandler.
 type MockSentPacketHandlerMockRecorder struct {
 	mock *MockSentPacketHandler
 }
 
-// NewMockSentPacketHandler creates a new mock instance
+// NewMockSentPacketHandler creates a new mock instance.
 func NewMockSentPacketHandler(ctrl *gomock.Controller) *MockSentPacketHandler {
 	mock := &MockSentPacketHandler{ctrl: ctrl}
 	mock.recorder = &MockSentPacketHandlerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSentPacketHandler) EXPECT() *MockSentPacketHandlerMockRecorder {
 	return m.recorder
 }
 
-// DropPackets mocks base method
+// DropPackets mocks base method.
 func (m *MockSentPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DropPackets", arg0)
 }
 
-// DropPackets indicates an expected call of DropPackets
+// DropPackets indicates an expected call of DropPackets.
 func (mr *MockSentPacketHandlerMockRecorder) DropPackets(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropPackets", reflect.TypeOf((*MockSentPacketHandler)(nil).DropPackets), arg0)
 }
 
-// GetLossDetectionTimeout mocks base method
+// GetLossDetectionTimeout mocks base method.
 func (m *MockSentPacketHandler) GetLossDetectionTimeout() time.Time {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetLossDetectionTimeout")
@@ -57,13 +57,13 @@ func (m *MockSentPacketHandler) GetLossDetectionTimeout() time.Time {
 	return ret0
 }
 
-// GetLossDetectionTimeout indicates an expected call of GetLossDetectionTimeout
+// GetLossDetectionTimeout indicates an expected call of GetLossDetectionTimeout.
 func (mr *MockSentPacketHandlerMockRecorder) GetLossDetectionTimeout() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLossDetectionTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).GetLossDetectionTimeout))
 }
 
-// HasPacingBudget mocks base method
+// HasPacingBudget mocks base method.
 func (m *MockSentPacketHandler) HasPacingBudget() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HasPacingBudget")
@@ -71,13 +71,13 @@ func (m *MockSentPacketHandler) HasPacingBudget() bool {
 	return ret0
 }
 
-// HasPacingBudget indicates an expected call of HasPacingBudget
+// HasPacingBudget indicates an expected call of HasPacingBudget.
 func (mr *MockSentPacketHandlerMockRecorder) HasPacingBudget() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPacingBudget", reflect.TypeOf((*MockSentPacketHandler)(nil).HasPacingBudget))
 }
 
-// OnLossDetectionTimeout mocks base method
+// OnLossDetectionTimeout mocks base method.
 func (m *MockSentPacketHandler) OnLossDetectionTimeout() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OnLossDetectionTimeout")
@@ -85,13 +85,13 @@ func (m *MockSentPacketHandler) OnLossDetectionTimeout() error {
 	return ret0
 }
 
-// OnLossDetectionTimeout indicates an expected call of OnLossDetectionTimeout
+// OnLossDetectionTimeout indicates an expected call of OnLossDetectionTimeout.
 func (mr *MockSentPacketHandlerMockRecorder) OnLossDetectionTimeout() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnLossDetectionTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).OnLossDetectionTimeout))
 }
 
-// PeekPacketNumber mocks base method
+// 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)
@@ -100,13 +100,13 @@ func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel)
 	return ret0, ret1
 }
 
-// PeekPacketNumber indicates an expected call of PeekPacketNumber
+// 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
+// PopPacketNumber mocks base method.
 func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) protocol.PacketNumber {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PopPacketNumber", arg0)
@@ -114,13 +114,13 @@ func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) p
 	return ret0
 }
 
-// PopPacketNumber indicates an expected call of PopPacketNumber
+// 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)
 }
 
-// QueueProbePacket mocks base method
+// QueueProbePacket mocks base method.
 func (m *MockSentPacketHandler) QueueProbePacket(arg0 protocol.EncryptionLevel) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "QueueProbePacket", arg0)
@@ -128,13 +128,13 @@ func (m *MockSentPacketHandler) QueueProbePacket(arg0 protocol.EncryptionLevel)
 	return ret0
 }
 
-// QueueProbePacket indicates an expected call of QueueProbePacket
+// QueueProbePacket indicates an expected call of QueueProbePacket.
 func (mr *MockSentPacketHandlerMockRecorder) QueueProbePacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueProbePacket", reflect.TypeOf((*MockSentPacketHandler)(nil).QueueProbePacket), arg0)
 }
 
-// ReceivedAck mocks base method
+// ReceivedAck mocks base method.
 func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.EncryptionLevel, arg2 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2)
@@ -142,25 +142,25 @@ func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.E
 	return ret0
 }
 
-// ReceivedAck indicates an expected call of ReceivedAck
+// ReceivedAck indicates an expected call of ReceivedAck.
 func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2)
 }
 
-// ReceivedBytes mocks base method
+// ReceivedBytes mocks base method.
 func (m *MockSentPacketHandler) ReceivedBytes(arg0 protocol.ByteCount) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedBytes", arg0)
 }
 
-// ReceivedBytes indicates an expected call of ReceivedBytes
+// ReceivedBytes indicates an expected call of ReceivedBytes.
 func (mr *MockSentPacketHandlerMockRecorder) ReceivedBytes(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedBytes", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedBytes), arg0)
 }
 
-// ResetForRetry mocks base method
+// ResetForRetry mocks base method.
 func (m *MockSentPacketHandler) ResetForRetry() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ResetForRetry")
@@ -168,13 +168,13 @@ func (m *MockSentPacketHandler) ResetForRetry() error {
 	return ret0
 }
 
-// ResetForRetry indicates an expected call of ResetForRetry
+// 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
+// SendMode mocks base method.
 func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMode")
@@ -182,37 +182,37 @@ func (m *MockSentPacketHandler) SendMode() ackhandler.SendMode {
 	return ret0
 }
 
-// SendMode indicates an expected call of 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
+// 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
+// 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)
 }
 
-// SetHandshakeConfirmed mocks base method
+// SetHandshakeConfirmed mocks base method.
 func (m *MockSentPacketHandler) SetHandshakeConfirmed() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetHandshakeConfirmed")
 }
 
-// SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed
+// SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed.
 func (mr *MockSentPacketHandlerMockRecorder) SetHandshakeConfirmed() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeConfirmed", reflect.TypeOf((*MockSentPacketHandler)(nil).SetHandshakeConfirmed))
 }
 
-// TimeUntilSend mocks base method
+// TimeUntilSend mocks base method.
 func (m *MockSentPacketHandler) TimeUntilSend() time.Time {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TimeUntilSend")
@@ -220,7 +220,7 @@ func (m *MockSentPacketHandler) TimeUntilSend() time.Time {
 	return ret0
 }
 
-// TimeUntilSend indicates an expected call of TimeUntilSend
+// 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))

internal/mocks/congestion.go

@@ -12,30 +12,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockSendAlgorithmWithDebugInfos is a mock of SendAlgorithmWithDebugInfos interface
+// MockSendAlgorithmWithDebugInfos is a mock of SendAlgorithmWithDebugInfos interface.
 type MockSendAlgorithmWithDebugInfos struct {
 	ctrl     *gomock.Controller
 	recorder *MockSendAlgorithmWithDebugInfosMockRecorder
 }
 
-// MockSendAlgorithmWithDebugInfosMockRecorder is the mock recorder for MockSendAlgorithmWithDebugInfos
+// MockSendAlgorithmWithDebugInfosMockRecorder is the mock recorder for MockSendAlgorithmWithDebugInfos.
 type MockSendAlgorithmWithDebugInfosMockRecorder struct {
 	mock *MockSendAlgorithmWithDebugInfos
 }
 
-// NewMockSendAlgorithmWithDebugInfos creates a new mock instance
+// NewMockSendAlgorithmWithDebugInfos creates a new mock instance.
 func NewMockSendAlgorithmWithDebugInfos(ctrl *gomock.Controller) *MockSendAlgorithmWithDebugInfos {
 	mock := &MockSendAlgorithmWithDebugInfos{ctrl: ctrl}
 	mock.recorder = &MockSendAlgorithmWithDebugInfosMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSendAlgorithmWithDebugInfos) EXPECT() *MockSendAlgorithmWithDebugInfosMockRecorder {
 	return m.recorder
 }
 
-// CanSend mocks base method
+// CanSend mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) CanSend(arg0 protocol.ByteCount) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CanSend", arg0)
@@ -43,13 +43,13 @@ func (m *MockSendAlgorithmWithDebugInfos) CanSend(arg0 protocol.ByteCount) bool
 	return ret0
 }
 
-// CanSend indicates an expected call of CanSend
+// CanSend indicates an expected call of CanSend.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) CanSend(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanSend", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).CanSend), arg0)
 }
 
-// GetCongestionWindow mocks base method
+// GetCongestionWindow mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) GetCongestionWindow() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCongestionWindow")
@@ -57,13 +57,13 @@ func (m *MockSendAlgorithmWithDebugInfos) GetCongestionWindow() protocol.ByteCou
 	return ret0
 }
 
-// GetCongestionWindow indicates an expected call of GetCongestionWindow
+// GetCongestionWindow indicates an expected call of GetCongestionWindow.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCongestionWindow", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).GetCongestionWindow))
 }
 
-// HasPacingBudget mocks base method
+// HasPacingBudget mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) HasPacingBudget() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HasPacingBudget")
@@ -71,13 +71,13 @@ func (m *MockSendAlgorithmWithDebugInfos) HasPacingBudget() bool {
 	return ret0
 }
 
-// HasPacingBudget indicates an expected call of HasPacingBudget
+// HasPacingBudget indicates an expected call of HasPacingBudget.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPacingBudget", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).HasPacingBudget))
 }
 
-// InRecovery mocks base method
+// InRecovery mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) InRecovery() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InRecovery")
@@ -85,13 +85,13 @@ func (m *MockSendAlgorithmWithDebugInfos) InRecovery() bool {
 	return ret0
 }
 
-// InRecovery indicates an expected call of InRecovery
+// InRecovery indicates an expected call of InRecovery.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InRecovery", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).InRecovery))
 }
 
-// InSlowStart mocks base method
+// InSlowStart mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) InSlowStart() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "InSlowStart")
@@ -99,73 +99,73 @@ func (m *MockSendAlgorithmWithDebugInfos) InSlowStart() bool {
 	return ret0
 }
 
-// InSlowStart indicates an expected call of InSlowStart
+// InSlowStart indicates an expected call of InSlowStart.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InSlowStart", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).InSlowStart))
 }
 
-// MaybeExitSlowStart mocks base method
+// MaybeExitSlowStart mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) MaybeExitSlowStart() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "MaybeExitSlowStart")
 }
 
-// MaybeExitSlowStart indicates an expected call of MaybeExitSlowStart
+// MaybeExitSlowStart indicates an expected call of MaybeExitSlowStart.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybeExitSlowStart", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).MaybeExitSlowStart))
 }
 
-// OnPacketAcked mocks base method
+// OnPacketAcked mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) 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
+// OnPacketAcked indicates an expected call of OnPacketAcked.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketAcked", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnPacketAcked), arg0, arg1, arg2, arg3)
 }
 
-// OnPacketLost mocks base method
+// OnPacketLost mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) 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
+// OnPacketLost indicates an expected call of OnPacketLost.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketLost(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketLost", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnPacketLost), arg0, arg1, arg2)
 }
 
-// OnPacketSent mocks base method
+// OnPacketSent mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) 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
+// OnPacketSent indicates an expected call of OnPacketSent.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketSent", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnPacketSent), arg0, arg1, arg2, arg3, arg4)
 }
 
-// OnRetransmissionTimeout mocks base method
+// OnRetransmissionTimeout mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) OnRetransmissionTimeout(arg0 bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "OnRetransmissionTimeout", arg0)
 }
 
-// OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout
+// OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetransmissionTimeout", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnRetransmissionTimeout), arg0)
 }
 
-// TimeUntilSend mocks base method
+// TimeUntilSend mocks base method.
 func (m *MockSendAlgorithmWithDebugInfos) TimeUntilSend(arg0 protocol.ByteCount) time.Time {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TimeUntilSend", arg0)
@@ -173,7 +173,7 @@ func (m *MockSendAlgorithmWithDebugInfos) TimeUntilSend(arg0 protocol.ByteCount)
 	return ret0
 }
 
-// TimeUntilSend indicates an expected call of TimeUntilSend
+// TimeUntilSend indicates an expected call of TimeUntilSend.
 func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeUntilSend", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).TimeUntilSend), arg0)

internal/mocks/connection_flow_controller.go

@@ -11,54 +11,54 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockConnectionFlowController is a mock of ConnectionFlowController interface
+// MockConnectionFlowController is a mock of ConnectionFlowController interface.
 type MockConnectionFlowController struct {
 	ctrl     *gomock.Controller
 	recorder *MockConnectionFlowControllerMockRecorder
 }
 
-// MockConnectionFlowControllerMockRecorder is the mock recorder for MockConnectionFlowController
+// MockConnectionFlowControllerMockRecorder is the mock recorder for MockConnectionFlowController.
 type MockConnectionFlowControllerMockRecorder struct {
 	mock *MockConnectionFlowController
 }
 
-// NewMockConnectionFlowController creates a new mock instance
+// NewMockConnectionFlowController creates a new mock instance.
 func NewMockConnectionFlowController(ctrl *gomock.Controller) *MockConnectionFlowController {
 	mock := &MockConnectionFlowController{ctrl: ctrl}
 	mock.recorder = &MockConnectionFlowControllerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockConnectionFlowController) EXPECT() *MockConnectionFlowControllerMockRecorder {
 	return m.recorder
 }
 
-// AddBytesRead mocks base method
+// 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
+// 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
+// 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
+// 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
+// GetWindowUpdate mocks base method.
 func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWindowUpdate")
@@ -66,13 +66,13 @@ func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount {
 	return ret0
 }
 
-// GetWindowUpdate indicates an expected call of GetWindowUpdate
+// 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
+// IsNewlyBlocked mocks base method.
 func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsNewlyBlocked")
@@ -81,13 +81,13 @@ func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCoun
 	return ret0, ret1
 }
 
-// IsNewlyBlocked indicates an expected call of IsNewlyBlocked
+// 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
+// SendWindowSize mocks base method.
 func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendWindowSize")
@@ -95,19 +95,19 @@ func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount {
 	return ret0
 }
 
-// SendWindowSize indicates an expected call of SendWindowSize
+// 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
+// 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
+// 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)

internal/mocks/crypto_setup.go

@@ -13,42 +13,42 @@ import (
 	qtls "github.com/lucas-clemente/quic-go/internal/qtls"
 )
 
-// MockCryptoSetup is a mock of CryptoSetup interface
+// MockCryptoSetup is a mock of CryptoSetup interface.
 type MockCryptoSetup struct {
 	ctrl     *gomock.Controller
 	recorder *MockCryptoSetupMockRecorder
 }
 
-// MockCryptoSetupMockRecorder is the mock recorder for MockCryptoSetup
+// MockCryptoSetupMockRecorder is the mock recorder for MockCryptoSetup.
 type MockCryptoSetupMockRecorder struct {
 	mock *MockCryptoSetup
 }
 
-// NewMockCryptoSetup creates a new mock instance
+// NewMockCryptoSetup creates a new mock instance.
 func NewMockCryptoSetup(ctrl *gomock.Controller) *MockCryptoSetup {
 	mock := &MockCryptoSetup{ctrl: ctrl}
 	mock.recorder = &MockCryptoSetupMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockCryptoSetup) EXPECT() *MockCryptoSetupMockRecorder {
 	return m.recorder
 }
 
-// ChangeConnectionID mocks base method
+// ChangeConnectionID mocks base method.
 func (m *MockCryptoSetup) ChangeConnectionID(arg0 protocol.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ChangeConnectionID", arg0)
 }
 
-// ChangeConnectionID indicates an expected call of ChangeConnectionID
+// 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
+// Close mocks base method.
 func (m *MockCryptoSetup) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -56,13 +56,13 @@ func (m *MockCryptoSetup) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// 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
+// ConnectionState mocks base method.
 func (m *MockCryptoSetup) ConnectionState() qtls.ConnectionState {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ConnectionState")
@@ -70,13 +70,13 @@ func (m *MockCryptoSetup) ConnectionState() qtls.ConnectionState {
 	return ret0
 }
 
-// ConnectionState indicates an expected call of 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))
 }
 
-// Get0RTTOpener mocks base method
+// Get0RTTOpener mocks base method.
 func (m *MockCryptoSetup) Get0RTTOpener() (handshake.LongHeaderOpener, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get0RTTOpener")
@@ -85,13 +85,13 @@ func (m *MockCryptoSetup) Get0RTTOpener() (handshake.LongHeaderOpener, error) {
 	return ret0, ret1
 }
 
-// Get0RTTOpener indicates an expected call of Get0RTTOpener
+// Get0RTTOpener indicates an expected call of Get0RTTOpener.
 func (mr *MockCryptoSetupMockRecorder) Get0RTTOpener() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTOpener", reflect.TypeOf((*MockCryptoSetup)(nil).Get0RTTOpener))
 }
 
-// Get0RTTSealer mocks base method
+// Get0RTTSealer mocks base method.
 func (m *MockCryptoSetup) Get0RTTSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get0RTTSealer")
@@ -100,13 +100,13 @@ func (m *MockCryptoSetup) Get0RTTSealer() (handshake.LongHeaderSealer, error) {
 	return ret0, ret1
 }
 
-// Get0RTTSealer indicates an expected call of Get0RTTSealer
+// Get0RTTSealer indicates an expected call of Get0RTTSealer.
 func (mr *MockCryptoSetupMockRecorder) Get0RTTSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTSealer", reflect.TypeOf((*MockCryptoSetup)(nil).Get0RTTSealer))
 }
 
-// Get1RTTOpener mocks base method
+// Get1RTTOpener mocks base method.
 func (m *MockCryptoSetup) Get1RTTOpener() (handshake.ShortHeaderOpener, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get1RTTOpener")
@@ -115,13 +115,13 @@ func (m *MockCryptoSetup) Get1RTTOpener() (handshake.ShortHeaderOpener, error) {
 	return ret0, ret1
 }
 
-// Get1RTTOpener indicates an expected call of Get1RTTOpener
+// Get1RTTOpener indicates an expected call of Get1RTTOpener.
 func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTOpener", reflect.TypeOf((*MockCryptoSetup)(nil).Get1RTTOpener))
 }
 
-// Get1RTTSealer mocks base method
+// Get1RTTSealer mocks base method.
 func (m *MockCryptoSetup) Get1RTTSealer() (handshake.ShortHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get1RTTSealer")
@@ -130,13 +130,13 @@ func (m *MockCryptoSetup) Get1RTTSealer() (handshake.ShortHeaderSealer, error) {
 	return ret0, ret1
 }
 
-// Get1RTTSealer indicates an expected call of Get1RTTSealer
+// Get1RTTSealer indicates an expected call of Get1RTTSealer.
 func (mr *MockCryptoSetupMockRecorder) Get1RTTSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTSealer", reflect.TypeOf((*MockCryptoSetup)(nil).Get1RTTSealer))
 }
 
-// GetHandshakeOpener mocks base method
+// GetHandshakeOpener mocks base method.
 func (m *MockCryptoSetup) GetHandshakeOpener() (handshake.LongHeaderOpener, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHandshakeOpener")
@@ -145,13 +145,13 @@ func (m *MockCryptoSetup) GetHandshakeOpener() (handshake.LongHeaderOpener, erro
 	return ret0, ret1
 }
 
-// GetHandshakeOpener indicates an expected call of GetHandshakeOpener
+// GetHandshakeOpener indicates an expected call of GetHandshakeOpener.
 func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeOpener", reflect.TypeOf((*MockCryptoSetup)(nil).GetHandshakeOpener))
 }
 
-// GetHandshakeSealer mocks base method
+// GetHandshakeSealer mocks base method.
 func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHandshakeSealer")
@@ -160,13 +160,13 @@ func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.LongHeaderSealer, erro
 	return ret0, ret1
 }
 
-// GetHandshakeSealer indicates an expected call of GetHandshakeSealer
+// GetHandshakeSealer indicates an expected call of GetHandshakeSealer.
 func (mr *MockCryptoSetupMockRecorder) GetHandshakeSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeSealer", reflect.TypeOf((*MockCryptoSetup)(nil).GetHandshakeSealer))
 }
 
-// GetInitialOpener mocks base method
+// GetInitialOpener mocks base method.
 func (m *MockCryptoSetup) GetInitialOpener() (handshake.LongHeaderOpener, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetInitialOpener")
@@ -175,13 +175,13 @@ func (m *MockCryptoSetup) GetInitialOpener() (handshake.LongHeaderOpener, error)
 	return ret0, ret1
 }
 
-// GetInitialOpener indicates an expected call of GetInitialOpener
+// GetInitialOpener indicates an expected call of GetInitialOpener.
 func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialOpener", reflect.TypeOf((*MockCryptoSetup)(nil).GetInitialOpener))
 }
 
-// GetInitialSealer mocks base method
+// GetInitialSealer mocks base method.
 func (m *MockCryptoSetup) GetInitialSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetInitialSealer")
@@ -190,13 +190,13 @@ func (m *MockCryptoSetup) GetInitialSealer() (handshake.LongHeaderSealer, error)
 	return ret0, ret1
 }
 
-// GetInitialSealer indicates an expected call of GetInitialSealer
+// GetInitialSealer indicates an expected call of GetInitialSealer.
 func (mr *MockCryptoSetupMockRecorder) GetInitialSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialSealer", reflect.TypeOf((*MockCryptoSetup)(nil).GetInitialSealer))
 }
 
-// GetSessionTicket mocks base method
+// GetSessionTicket mocks base method.
 func (m *MockCryptoSetup) GetSessionTicket() ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetSessionTicket")
@@ -205,13 +205,13 @@ func (m *MockCryptoSetup) GetSessionTicket() ([]byte, error) {
 	return ret0, ret1
 }
 
-// GetSessionTicket indicates an expected call of GetSessionTicket
+// GetSessionTicket indicates an expected call of GetSessionTicket.
 func (mr *MockCryptoSetupMockRecorder) GetSessionTicket() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTicket", reflect.TypeOf((*MockCryptoSetup)(nil).GetSessionTicket))
 }
 
-// HandleMessage mocks base method
+// 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)
@@ -219,37 +219,37 @@ func (m *MockCryptoSetup) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLev
 	return ret0
 }
 
-// HandleMessage indicates an expected call of HandleMessage
+// 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
+// RunHandshake mocks base method.
 func (m *MockCryptoSetup) RunHandshake() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RunHandshake")
 }
 
-// RunHandshake indicates an expected call of RunHandshake
+// 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))
 }
 
-// SetHandshakeConfirmed mocks base method
+// SetHandshakeConfirmed mocks base method.
 func (m *MockCryptoSetup) SetHandshakeConfirmed() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetHandshakeConfirmed")
 }
 
-// SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed
+// SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed.
 func (mr *MockCryptoSetupMockRecorder) SetHandshakeConfirmed() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeConfirmed", reflect.TypeOf((*MockCryptoSetup)(nil).SetHandshakeConfirmed))
 }
 
-// SetLargest1RTTAcked mocks base method
+// SetLargest1RTTAcked mocks base method.
 func (m *MockCryptoSetup) SetLargest1RTTAcked(arg0 protocol.PacketNumber) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetLargest1RTTAcked", arg0)
@@ -257,7 +257,7 @@ func (m *MockCryptoSetup) SetLargest1RTTAcked(arg0 protocol.PacketNumber) error
 	return ret0
 }
 
-// SetLargest1RTTAcked indicates an expected call of SetLargest1RTTAcked
+// SetLargest1RTTAcked indicates an expected call of SetLargest1RTTAcked.
 func (mr *MockCryptoSetupMockRecorder) SetLargest1RTTAcked(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLargest1RTTAcked", reflect.TypeOf((*MockCryptoSetup)(nil).SetLargest1RTTAcked), arg0)

internal/mocks/logging/connection_tracer.go

@@ -16,312 +16,312 @@ import (
 	logging "github.com/lucas-clemente/quic-go/logging"
 )
 
-// MockConnectionTracer is a mock of ConnectionTracer interface
+// MockConnectionTracer is a mock of ConnectionTracer interface.
 type MockConnectionTracer struct {
 	ctrl     *gomock.Controller
 	recorder *MockConnectionTracerMockRecorder
 }
 
-// MockConnectionTracerMockRecorder is the mock recorder for MockConnectionTracer
+// MockConnectionTracerMockRecorder is the mock recorder for MockConnectionTracer.
 type MockConnectionTracerMockRecorder struct {
 	mock *MockConnectionTracer
 }
 
-// NewMockConnectionTracer creates a new mock instance
+// NewMockConnectionTracer creates a new mock instance.
 func NewMockConnectionTracer(ctrl *gomock.Controller) *MockConnectionTracer {
 	mock := &MockConnectionTracer{ctrl: ctrl}
 	mock.recorder = &MockConnectionTracerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockConnectionTracer) EXPECT() *MockConnectionTracerMockRecorder {
 	return m.recorder
 }
 
-// BufferedPacket mocks base method
+// BufferedPacket mocks base method.
 func (m *MockConnectionTracer) BufferedPacket(arg0 protocol.PacketType) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "BufferedPacket", arg0)
 }
 
-// BufferedPacket indicates an expected call of BufferedPacket
+// BufferedPacket indicates an expected call of BufferedPacket.
 func (mr *MockConnectionTracerMockRecorder) BufferedPacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BufferedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).BufferedPacket), arg0)
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockConnectionTracer) Close() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Close")
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockConnectionTracerMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnectionTracer)(nil).Close))
 }
 
-// ClosedConnection mocks base method
+// ClosedConnection mocks base method.
 func (m *MockConnectionTracer) ClosedConnection(arg0 logging.CloseReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ClosedConnection", arg0)
 }
 
-// ClosedConnection indicates an expected call of ClosedConnection
+// ClosedConnection indicates an expected call of ClosedConnection.
 func (mr *MockConnectionTracerMockRecorder) ClosedConnection(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).ClosedConnection), arg0)
 }
 
-// Debug mocks base method
+// Debug mocks base method.
 func (m *MockConnectionTracer) Debug(arg0, arg1 string) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Debug", arg0, arg1)
 }
 
-// Debug indicates an expected call of Debug
+// Debug indicates an expected call of Debug.
 func (mr *MockConnectionTracerMockRecorder) Debug(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockConnectionTracer)(nil).Debug), arg0, arg1)
 }
 
-// DroppedEncryptionLevel mocks base method
+// DroppedEncryptionLevel mocks base method.
 func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedEncryptionLevel", arg0)
 }
 
-// DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel
+// DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel.
 func (mr *MockConnectionTracerMockRecorder) DroppedEncryptionLevel(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedEncryptionLevel", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedEncryptionLevel), arg0)
 }
 
-// DroppedKey mocks base method
+// DroppedKey mocks base method.
 func (m *MockConnectionTracer) DroppedKey(arg0 protocol.KeyPhase) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedKey", arg0)
 }
 
-// DroppedKey indicates an expected call of DroppedKey
+// DroppedKey indicates an expected call of DroppedKey.
 func (mr *MockConnectionTracerMockRecorder) DroppedKey(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedKey", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedKey), arg0)
 }
 
-// DroppedPacket mocks base method
+// DroppedPacket mocks base method.
 func (m *MockConnectionTracer) DroppedPacket(arg0 protocol.PacketType, arg1 protocol.ByteCount, arg2 logging.PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2)
 }
 
-// DroppedPacket indicates an expected call of DroppedPacket
+// DroppedPacket indicates an expected call of DroppedPacket.
 func (mr *MockConnectionTracerMockRecorder) DroppedPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedPacket), arg0, arg1, arg2)
 }
 
-// LossTimerCanceled mocks base method
+// LossTimerCanceled mocks base method.
 func (m *MockConnectionTracer) LossTimerCanceled() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LossTimerCanceled")
 }
 
-// LossTimerCanceled indicates an expected call of LossTimerCanceled
+// LossTimerCanceled indicates an expected call of LossTimerCanceled.
 func (mr *MockConnectionTracerMockRecorder) LossTimerCanceled() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerCanceled", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerCanceled))
 }
 
-// LossTimerExpired mocks base method
+// LossTimerExpired mocks base method.
 func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LossTimerExpired", arg0, arg1)
 }
 
-// LossTimerExpired indicates an expected call of LossTimerExpired
+// LossTimerExpired indicates an expected call of LossTimerExpired.
 func (mr *MockConnectionTracerMockRecorder) LossTimerExpired(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerExpired", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerExpired), arg0, arg1)
 }
 
-// LostPacket mocks base method
+// LostPacket mocks base method.
 func (m *MockConnectionTracer) LostPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber, arg2 logging.PacketLossReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LostPacket", arg0, arg1, arg2)
 }
 
-// LostPacket indicates an expected call of LostPacket
+// LostPacket indicates an expected call of LostPacket.
 func (mr *MockConnectionTracerMockRecorder) LostPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LostPacket", reflect.TypeOf((*MockConnectionTracer)(nil).LostPacket), arg0, arg1, arg2)
 }
 
-// ReceivedPacket mocks base method
+// ReceivedPacket mocks base method.
 func (m *MockConnectionTracer) ReceivedPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2)
 }
 
-// ReceivedPacket indicates an expected call of ReceivedPacket
+// ReceivedPacket indicates an expected call of ReceivedPacket.
 func (mr *MockConnectionTracerMockRecorder) ReceivedPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedPacket), arg0, arg1, arg2)
 }
 
-// ReceivedRetry mocks base method
+// ReceivedRetry mocks base method.
 func (m *MockConnectionTracer) ReceivedRetry(arg0 *wire.Header) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedRetry", arg0)
 }
 
-// ReceivedRetry indicates an expected call of ReceivedRetry
+// ReceivedRetry indicates an expected call of ReceivedRetry.
 func (mr *MockConnectionTracerMockRecorder) ReceivedRetry(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedRetry", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedRetry), arg0)
 }
 
-// ReceivedTransportParameters mocks base method
+// ReceivedTransportParameters mocks base method.
 func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedTransportParameters", arg0)
 }
 
-// ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters
+// ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) ReceivedTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedTransportParameters), arg0)
 }
 
-// ReceivedVersionNegotiationPacket mocks base method
+// ReceivedVersionNegotiationPacket mocks base method.
 func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(arg0 *wire.Header, arg1 []protocol.VersionNumber) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedVersionNegotiationPacket", arg0, arg1)
 }
 
-// ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket
+// ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket.
 func (mr *MockConnectionTracerMockRecorder) ReceivedVersionNegotiationPacket(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedVersionNegotiationPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedVersionNegotiationPacket), arg0, arg1)
 }
 
-// RestoredTransportParameters mocks base method
+// RestoredTransportParameters mocks base method.
 func (m *MockConnectionTracer) RestoredTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RestoredTransportParameters", arg0)
 }
 
-// RestoredTransportParameters indicates an expected call of RestoredTransportParameters
+// RestoredTransportParameters indicates an expected call of RestoredTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) RestoredTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoredTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).RestoredTransportParameters), arg0)
 }
 
-// SentPacket mocks base method
+// SentPacket mocks base method.
 func (m *MockConnectionTracer) SentPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 *wire.AckFrame, arg3 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
 }
 
-// SentPacket indicates an expected call of SentPacket
+// SentPacket indicates an expected call of SentPacket.
 func (mr *MockConnectionTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentPacket), arg0, arg1, arg2, arg3)
 }
 
-// SentTransportParameters mocks base method
+// SentTransportParameters mocks base method.
 func (m *MockConnectionTracer) SentTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentTransportParameters", arg0)
 }
 
-// SentTransportParameters indicates an expected call of SentTransportParameters
+// SentTransportParameters indicates an expected call of SentTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) SentTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).SentTransportParameters), arg0)
 }
 
-// SetLossTimer mocks base method
+// SetLossTimer mocks base method.
 func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 protocol.EncryptionLevel, arg2 time.Time) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetLossTimer", arg0, arg1, arg2)
 }
 
-// SetLossTimer indicates an expected call of SetLossTimer
+// SetLossTimer indicates an expected call of SetLossTimer.
 func (mr *MockConnectionTracerMockRecorder) SetLossTimer(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLossTimer", reflect.TypeOf((*MockConnectionTracer)(nil).SetLossTimer), arg0, arg1, arg2)
 }
 
-// StartedConnection mocks base method
+// StartedConnection mocks base method.
 func (m *MockConnectionTracer) StartedConnection(arg0, arg1 net.Addr, arg2 protocol.VersionNumber, arg3, arg4 protocol.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "StartedConnection", arg0, arg1, arg2, arg3, arg4)
 }
 
-// StartedConnection indicates an expected call of StartedConnection
+// StartedConnection indicates an expected call of StartedConnection.
 func (mr *MockConnectionTracerMockRecorder) StartedConnection(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).StartedConnection), arg0, arg1, arg2, arg3, arg4)
 }
 
-// UpdatedCongestionState mocks base method
+// UpdatedCongestionState mocks base method.
 func (m *MockConnectionTracer) UpdatedCongestionState(arg0 logging.CongestionState) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedCongestionState", arg0)
 }
 
-// UpdatedCongestionState indicates an expected call of UpdatedCongestionState
+// UpdatedCongestionState indicates an expected call of UpdatedCongestionState.
 func (mr *MockConnectionTracerMockRecorder) UpdatedCongestionState(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedCongestionState", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedCongestionState), arg0)
 }
 
-// UpdatedKey mocks base method
+// UpdatedKey mocks base method.
 func (m *MockConnectionTracer) UpdatedKey(arg0 protocol.KeyPhase, arg1 bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKey", arg0, arg1)
 }
 
-// UpdatedKey indicates an expected call of UpdatedKey
+// UpdatedKey indicates an expected call of UpdatedKey.
 func (mr *MockConnectionTracerMockRecorder) UpdatedKey(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKey", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKey), arg0, arg1)
 }
 
-// UpdatedKeyFromTLS mocks base method
+// UpdatedKeyFromTLS mocks base method.
 func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 protocol.EncryptionLevel, arg1 protocol.Perspective) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKeyFromTLS", arg0, arg1)
 }
 
-// UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS
+// UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS.
 func (mr *MockConnectionTracerMockRecorder) UpdatedKeyFromTLS(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKeyFromTLS", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKeyFromTLS), arg0, arg1)
 }
 
-// UpdatedMetrics mocks base method
+// UpdatedMetrics mocks base method.
 func (m *MockConnectionTracer) UpdatedMetrics(arg0 *utils.RTTStats, arg1, arg2 protocol.ByteCount, arg3 int) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedMetrics", arg0, arg1, arg2, arg3)
 }
 
-// UpdatedMetrics indicates an expected call of UpdatedMetrics
+// UpdatedMetrics indicates an expected call of UpdatedMetrics.
 func (mr *MockConnectionTracerMockRecorder) UpdatedMetrics(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedMetrics", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedMetrics), arg0, arg1, arg2, arg3)
 }
 
-// UpdatedPTOCount mocks base method
+// UpdatedPTOCount mocks base method.
 func (m *MockConnectionTracer) UpdatedPTOCount(arg0 uint32) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedPTOCount", arg0)
 }
 
-// UpdatedPTOCount indicates an expected call of UpdatedPTOCount
+// UpdatedPTOCount indicates an expected call of UpdatedPTOCount.
 func (mr *MockConnectionTracerMockRecorder) UpdatedPTOCount(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedPTOCount", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedPTOCount), arg0)

internal/mocks/logging/tracer.go

@@ -14,54 +14,54 @@ import (
 	logging "github.com/lucas-clemente/quic-go/logging"
 )
 
-// MockTracer is a mock of Tracer interface
+// MockTracer is a mock of Tracer interface.
 type MockTracer struct {
 	ctrl     *gomock.Controller
 	recorder *MockTracerMockRecorder
 }
 
-// MockTracerMockRecorder is the mock recorder for MockTracer
+// MockTracerMockRecorder is the mock recorder for MockTracer.
 type MockTracerMockRecorder struct {
 	mock *MockTracer
 }
 
-// NewMockTracer creates a new mock instance
+// NewMockTracer creates a new mock instance.
 func NewMockTracer(ctrl *gomock.Controller) *MockTracer {
 	mock := &MockTracer{ctrl: ctrl}
 	mock.recorder = &MockTracerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockTracer) EXPECT() *MockTracerMockRecorder {
 	return m.recorder
 }
 
-// DroppedPacket mocks base method
+// DroppedPacket mocks base method.
 func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 protocol.PacketType, arg2 protocol.ByteCount, arg3 logging.PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
 }
 
-// DroppedPacket indicates an expected call of DroppedPacket
+// DroppedPacket indicates an expected call of DroppedPacket.
 func (mr *MockTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockTracer)(nil).DroppedPacket), arg0, arg1, arg2, arg3)
 }
 
-// SentPacket mocks base method
+// SentPacket mocks base method.
 func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *wire.Header, arg2 protocol.ByteCount, arg3 []logging.Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
 }
 
-// SentPacket indicates an expected call of SentPacket
+// SentPacket indicates an expected call of SentPacket.
 func (mr *MockTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockTracer)(nil).SentPacket), arg0, arg1, arg2, arg3)
 }
 
-// TracerForConnection mocks base method
+// TracerForConnection mocks base method.
 func (m *MockTracer) TracerForConnection(arg0 protocol.Perspective, arg1 protocol.ConnectionID) logging.ConnectionTracer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TracerForConnection", arg0, arg1)
@@ -69,7 +69,7 @@ func (m *MockTracer) TracerForConnection(arg0 protocol.Perspective, arg1 protoco
 	return ret0
 }
 
-// TracerForConnection indicates an expected call of TracerForConnection
+// TracerForConnection indicates an expected call of TracerForConnection.
 func (mr *MockTracerMockRecorder) TracerForConnection(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TracerForConnection", reflect.TypeOf((*MockTracer)(nil).TracerForConnection), arg0, arg1)

internal/mocks/long_header_opener.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockLongHeaderOpener is a mock of LongHeaderOpener interface
+// MockLongHeaderOpener is a mock of LongHeaderOpener interface.
 type MockLongHeaderOpener struct {
 	ctrl     *gomock.Controller
 	recorder *MockLongHeaderOpenerMockRecorder
 }
 
-// MockLongHeaderOpenerMockRecorder is the mock recorder for MockLongHeaderOpener
+// MockLongHeaderOpenerMockRecorder is the mock recorder for MockLongHeaderOpener.
 type MockLongHeaderOpenerMockRecorder struct {
 	mock *MockLongHeaderOpener
 }
 
-// NewMockLongHeaderOpener creates a new mock instance
+// NewMockLongHeaderOpener creates a new mock instance.
 func NewMockLongHeaderOpener(ctrl *gomock.Controller) *MockLongHeaderOpener {
 	mock := &MockLongHeaderOpener{ctrl: ctrl}
 	mock.recorder = &MockLongHeaderOpenerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockLongHeaderOpener) EXPECT() *MockLongHeaderOpenerMockRecorder {
 	return m.recorder
 }
 
-// DecodePacketNumber mocks base method
+// DecodePacketNumber mocks base method.
 func (m *MockLongHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) protocol.PacketNumber {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DecodePacketNumber", arg0, arg1)
@@ -42,25 +42,25 @@ func (m *MockLongHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, ar
 	return ret0
 }
 
-// DecodePacketNumber indicates an expected call of DecodePacketNumber
+// DecodePacketNumber indicates an expected call of DecodePacketNumber.
 func (mr *MockLongHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePacketNumber", reflect.TypeOf((*MockLongHeaderOpener)(nil).DecodePacketNumber), arg0, arg1)
 }
 
-// DecryptHeader mocks base method
+// DecryptHeader mocks base method.
 func (m *MockLongHeaderOpener) 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
+// DecryptHeader indicates an expected call of DecryptHeader.
 func (mr *MockLongHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptHeader", reflect.TypeOf((*MockLongHeaderOpener)(nil).DecryptHeader), arg0, arg1, arg2)
 }
 
-// Open mocks base method
+// Open mocks base method.
 func (m *MockLongHeaderOpener) 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)
@@ -69,7 +69,7 @@ func (m *MockLongHeaderOpener) Open(arg0, arg1 []byte, arg2 protocol.PacketNumbe
 	return ret0, ret1
 }
 
-// Open indicates an expected call of Open
+// Open indicates an expected call of Open.
 func (mr *MockLongHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockLongHeaderOpener)(nil).Open), arg0, arg1, arg2, arg3)

internal/mocks/quic/early_listener.go

@@ -13,30 +13,30 @@ import (
 	quic "github.com/lucas-clemente/quic-go"
 )
 
-// MockEarlyListener is a mock of EarlyListener interface
+// MockEarlyListener is a mock of EarlyListener interface.
 type MockEarlyListener struct {
 	ctrl     *gomock.Controller
 	recorder *MockEarlyListenerMockRecorder
 }
 
-// MockEarlyListenerMockRecorder is the mock recorder for MockEarlyListener
+// MockEarlyListenerMockRecorder is the mock recorder for MockEarlyListener.
 type MockEarlyListenerMockRecorder struct {
 	mock *MockEarlyListener
 }
 
-// NewMockEarlyListener creates a new mock instance
+// NewMockEarlyListener creates a new mock instance.
 func NewMockEarlyListener(ctrl *gomock.Controller) *MockEarlyListener {
 	mock := &MockEarlyListener{ctrl: ctrl}
 	mock.recorder = &MockEarlyListenerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockEarlyListener) EXPECT() *MockEarlyListenerMockRecorder {
 	return m.recorder
 }
 
-// Accept mocks base method
+// Accept mocks base method.
 func (m *MockEarlyListener) Accept(arg0 context.Context) (quic.EarlySession, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Accept", arg0)
@@ -45,13 +45,13 @@ func (m *MockEarlyListener) Accept(arg0 context.Context) (quic.EarlySession, err
 	return ret0, ret1
 }
 
-// Accept indicates an expected call of Accept
+// Accept indicates an expected call of Accept.
 func (mr *MockEarlyListenerMockRecorder) Accept(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Accept", reflect.TypeOf((*MockEarlyListener)(nil).Accept), arg0)
 }
 
-// Addr mocks base method
+// Addr mocks base method.
 func (m *MockEarlyListener) Addr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Addr")
@@ -59,13 +59,13 @@ func (m *MockEarlyListener) Addr() net.Addr {
 	return ret0
 }
 
-// Addr indicates an expected call of Addr
+// Addr indicates an expected call of Addr.
 func (mr *MockEarlyListenerMockRecorder) Addr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addr", reflect.TypeOf((*MockEarlyListener)(nil).Addr))
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockEarlyListener) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -73,7 +73,7 @@ func (m *MockEarlyListener) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockEarlyListenerMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockEarlyListener)(nil).Close))

internal/mocks/quic/early_session.go

@@ -14,30 +14,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockEarlySession is a mock of EarlySession interface
+// MockEarlySession is a mock of EarlySession interface.
 type MockEarlySession struct {
 	ctrl     *gomock.Controller
 	recorder *MockEarlySessionMockRecorder
 }
 
-// MockEarlySessionMockRecorder is the mock recorder for MockEarlySession
+// MockEarlySessionMockRecorder is the mock recorder for MockEarlySession.
 type MockEarlySessionMockRecorder struct {
 	mock *MockEarlySession
 }
 
-// NewMockEarlySession creates a new mock instance
+// NewMockEarlySession creates a new mock instance.
 func NewMockEarlySession(ctrl *gomock.Controller) *MockEarlySession {
 	mock := &MockEarlySession{ctrl: ctrl}
 	mock.recorder = &MockEarlySessionMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockEarlySession) EXPECT() *MockEarlySessionMockRecorder {
 	return m.recorder
 }
 
-// AcceptStream mocks base method
+// AcceptStream mocks base method.
 func (m *MockEarlySession) AcceptStream(arg0 context.Context) (quic.Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptStream", arg0)
@@ -46,13 +46,13 @@ func (m *MockEarlySession) AcceptStream(arg0 context.Context) (quic.Stream, erro
 	return ret0, ret1
 }
 
-// AcceptStream indicates an expected call of AcceptStream
+// AcceptStream indicates an expected call of AcceptStream.
 func (mr *MockEarlySessionMockRecorder) AcceptStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockEarlySession)(nil).AcceptStream), arg0)
 }
 
-// AcceptUniStream mocks base method
+// AcceptUniStream mocks base method.
 func (m *MockEarlySession) AcceptUniStream(arg0 context.Context) (quic.ReceiveStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptUniStream", arg0)
@@ -61,13 +61,13 @@ func (m *MockEarlySession) AcceptUniStream(arg0 context.Context) (quic.ReceiveSt
 	return ret0, ret1
 }
 
-// AcceptUniStream indicates an expected call of AcceptUniStream
+// AcceptUniStream indicates an expected call of AcceptUniStream.
 func (mr *MockEarlySessionMockRecorder) AcceptUniStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockEarlySession)(nil).AcceptUniStream), arg0)
 }
 
-// CloseWithError mocks base method
+// CloseWithError mocks base method.
 func (m *MockEarlySession) CloseWithError(arg0 protocol.ApplicationErrorCode, arg1 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
@@ -75,13 +75,13 @@ func (m *MockEarlySession) CloseWithError(arg0 protocol.ApplicationErrorCode, ar
 	return ret0
 }
 
-// CloseWithError indicates an expected call of CloseWithError
+// CloseWithError indicates an expected call of CloseWithError.
 func (mr *MockEarlySessionMockRecorder) CloseWithError(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockEarlySession)(nil).CloseWithError), arg0, arg1)
 }
 
-// ConnectionState mocks base method
+// ConnectionState mocks base method.
 func (m *MockEarlySession) ConnectionState() quic.ConnectionState {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ConnectionState")
@@ -89,13 +89,13 @@ func (m *MockEarlySession) ConnectionState() quic.ConnectionState {
 	return ret0
 }
 
-// ConnectionState indicates an expected call of ConnectionState
+// ConnectionState indicates an expected call of ConnectionState.
 func (mr *MockEarlySessionMockRecorder) ConnectionState() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockEarlySession)(nil).ConnectionState))
 }
 
-// Context mocks base method
+// Context mocks base method.
 func (m *MockEarlySession) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
@@ -103,13 +103,13 @@ func (m *MockEarlySession) Context() context.Context {
 	return ret0
 }
 
-// Context indicates an expected call of Context
+// Context indicates an expected call of Context.
 func (mr *MockEarlySessionMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockEarlySession)(nil).Context))
 }
 
-// HandshakeComplete mocks base method
+// HandshakeComplete mocks base method.
 func (m *MockEarlySession) HandshakeComplete() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HandshakeComplete")
@@ -117,13 +117,13 @@ func (m *MockEarlySession) HandshakeComplete() context.Context {
 	return ret0
 }
 
-// HandshakeComplete indicates an expected call of HandshakeComplete
+// HandshakeComplete indicates an expected call of HandshakeComplete.
 func (mr *MockEarlySessionMockRecorder) HandshakeComplete() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandshakeComplete", reflect.TypeOf((*MockEarlySession)(nil).HandshakeComplete))
 }
 
-// LocalAddr mocks base method
+// LocalAddr mocks base method.
 func (m *MockEarlySession) LocalAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LocalAddr")
@@ -131,13 +131,13 @@ func (m *MockEarlySession) LocalAddr() net.Addr {
 	return ret0
 }
 
-// LocalAddr indicates an expected call of LocalAddr
+// LocalAddr indicates an expected call of LocalAddr.
 func (mr *MockEarlySessionMockRecorder) LocalAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockEarlySession)(nil).LocalAddr))
 }
 
-// OpenStream mocks base method
+// OpenStream mocks base method.
 func (m *MockEarlySession) OpenStream() (quic.Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStream")
@@ -146,13 +146,13 @@ func (m *MockEarlySession) OpenStream() (quic.Stream, error) {
 	return ret0, ret1
 }
 
-// OpenStream indicates an expected call of OpenStream
+// OpenStream indicates an expected call of OpenStream.
 func (mr *MockEarlySessionMockRecorder) OpenStream() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockEarlySession)(nil).OpenStream))
 }
 
-// OpenStreamSync mocks base method
+// OpenStreamSync mocks base method.
 func (m *MockEarlySession) OpenStreamSync(arg0 context.Context) (quic.Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStreamSync", arg0)
@@ -161,13 +161,13 @@ func (m *MockEarlySession) OpenStreamSync(arg0 context.Context) (quic.Stream, er
 	return ret0, ret1
 }
 
-// OpenStreamSync indicates an expected call of OpenStreamSync
+// OpenStreamSync indicates an expected call of OpenStreamSync.
 func (mr *MockEarlySessionMockRecorder) OpenStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockEarlySession)(nil).OpenStreamSync), arg0)
 }
 
-// OpenUniStream mocks base method
+// OpenUniStream mocks base method.
 func (m *MockEarlySession) OpenUniStream() (quic.SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStream")
@@ -176,13 +176,13 @@ func (m *MockEarlySession) OpenUniStream() (quic.SendStream, error) {
 	return ret0, ret1
 }
 
-// OpenUniStream indicates an expected call of OpenUniStream
+// OpenUniStream indicates an expected call of OpenUniStream.
 func (mr *MockEarlySessionMockRecorder) OpenUniStream() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockEarlySession)(nil).OpenUniStream))
 }
 
-// OpenUniStreamSync mocks base method
+// OpenUniStreamSync mocks base method.
 func (m *MockEarlySession) OpenUniStreamSync(arg0 context.Context) (quic.SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStreamSync", arg0)
@@ -191,13 +191,13 @@ func (m *MockEarlySession) OpenUniStreamSync(arg0 context.Context) (quic.SendStr
 	return ret0, ret1
 }
 
-// OpenUniStreamSync indicates an expected call of OpenUniStreamSync
+// OpenUniStreamSync indicates an expected call of OpenUniStreamSync.
 func (mr *MockEarlySessionMockRecorder) OpenUniStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockEarlySession)(nil).OpenUniStreamSync), arg0)
 }
 
-// ReceiveMessage mocks base method
+// ReceiveMessage mocks base method.
 func (m *MockEarlySession) ReceiveMessage() ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReceiveMessage")
@@ -206,13 +206,13 @@ func (m *MockEarlySession) ReceiveMessage() ([]byte, error) {
 	return ret0, ret1
 }
 
-// ReceiveMessage indicates an expected call of ReceiveMessage
+// ReceiveMessage indicates an expected call of ReceiveMessage.
 func (mr *MockEarlySessionMockRecorder) ReceiveMessage() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockEarlySession)(nil).ReceiveMessage))
 }
 
-// RemoteAddr mocks base method
+// RemoteAddr mocks base method.
 func (m *MockEarlySession) RemoteAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoteAddr")
@@ -220,13 +220,13 @@ func (m *MockEarlySession) RemoteAddr() net.Addr {
 	return ret0
 }
 
-// RemoteAddr indicates an expected call of RemoteAddr
+// RemoteAddr indicates an expected call of RemoteAddr.
 func (mr *MockEarlySessionMockRecorder) RemoteAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockEarlySession)(nil).RemoteAddr))
 }
 
-// SendMessage mocks base method
+// SendMessage mocks base method.
 func (m *MockEarlySession) SendMessage(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMessage", arg0)
@@ -234,7 +234,7 @@ func (m *MockEarlySession) SendMessage(arg0 []byte) error {
 	return ret0
 }
 
-// SendMessage indicates an expected call of SendMessage
+// SendMessage indicates an expected call of SendMessage.
 func (mr *MockEarlySessionMockRecorder) SendMessage(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockEarlySession)(nil).SendMessage), arg0)

internal/mocks/quic/stream.go

@@ -13,54 +13,54 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockStream is a mock of Stream interface
+// MockStream is a mock of Stream interface.
 type MockStream struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamMockRecorder
 }
 
-// MockStreamMockRecorder is the mock recorder for MockStream
+// MockStreamMockRecorder is the mock recorder for MockStream.
 type MockStreamMockRecorder struct {
 	mock *MockStream
 }
 
-// NewMockStream creates a new mock instance
+// NewMockStream creates a new mock instance.
 func NewMockStream(ctrl *gomock.Controller) *MockStream {
 	mock := &MockStream{ctrl: ctrl}
 	mock.recorder = &MockStreamMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStream) EXPECT() *MockStreamMockRecorder {
 	return m.recorder
 }
 
-// CancelRead mocks base method
+// CancelRead mocks base method.
 func (m *MockStream) CancelRead(arg0 protocol.ApplicationErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelRead", arg0)
 }
 
-// CancelRead indicates an expected call of CancelRead
+// CancelRead indicates an expected call of CancelRead.
 func (mr *MockStreamMockRecorder) CancelRead(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStream)(nil).CancelRead), arg0)
 }
 
-// CancelWrite mocks base method
+// CancelWrite mocks base method.
 func (m *MockStream) CancelWrite(arg0 protocol.ApplicationErrorCode) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CancelWrite", arg0)
 }
 
-// CancelWrite indicates an expected call of CancelWrite
+// CancelWrite indicates an expected call of CancelWrite.
 func (mr *MockStreamMockRecorder) CancelWrite(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStream)(nil).CancelWrite), arg0)
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockStream) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -68,13 +68,13 @@ func (m *MockStream) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockStreamMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStream)(nil).Close))
 }
 
-// Context mocks base method
+// Context mocks base method.
 func (m *MockStream) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
@@ -82,13 +82,13 @@ func (m *MockStream) Context() context.Context {
 	return ret0
 }
 
-// Context indicates an expected call of Context
+// Context indicates an expected call of Context.
 func (mr *MockStreamMockRecorder) Context() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStream)(nil).Context))
 }
 
-// Read mocks base method
+// Read mocks base method.
 func (m *MockStream) Read(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Read", arg0)
@@ -97,13 +97,13 @@ func (m *MockStream) Read(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Read indicates an expected call of Read
+// Read indicates an expected call of Read.
 func (mr *MockStreamMockRecorder) Read(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStream)(nil).Read), arg0)
 }
 
-// SetDeadline mocks base method
+// SetDeadline mocks base method.
 func (m *MockStream) SetDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetDeadline", arg0)
@@ -111,13 +111,13 @@ func (m *MockStream) SetDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetDeadline indicates an expected call of SetDeadline
+// SetDeadline indicates an expected call of SetDeadline.
 func (mr *MockStreamMockRecorder) SetDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStream)(nil).SetDeadline), arg0)
 }
 
-// SetReadDeadline mocks base method
+// SetReadDeadline mocks base method.
 func (m *MockStream) SetReadDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
@@ -125,13 +125,13 @@ func (m *MockStream) SetReadDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetReadDeadline indicates an expected call of SetReadDeadline
+// SetReadDeadline indicates an expected call of SetReadDeadline.
 func (mr *MockStreamMockRecorder) SetReadDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStream)(nil).SetReadDeadline), arg0)
 }
 
-// SetWriteDeadline mocks base method
+// SetWriteDeadline mocks base method.
 func (m *MockStream) SetWriteDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
@@ -139,13 +139,13 @@ func (m *MockStream) SetWriteDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetWriteDeadline indicates an expected call of SetWriteDeadline
+// SetWriteDeadline indicates an expected call of SetWriteDeadline.
 func (mr *MockStreamMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStream)(nil).SetWriteDeadline), arg0)
 }
 
-// StreamID mocks base method
+// StreamID mocks base method.
 func (m *MockStream) StreamID() protocol.StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
@@ -153,13 +153,13 @@ func (m *MockStream) StreamID() protocol.StreamID {
 	return ret0
 }
 
-// StreamID indicates an expected call of StreamID
+// StreamID indicates an expected call of StreamID.
 func (mr *MockStreamMockRecorder) StreamID() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStream)(nil).StreamID))
 }
 
-// Write mocks base method
+// Write mocks base method.
 func (m *MockStream) Write(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Write", arg0)
@@ -168,7 +168,7 @@ func (m *MockStream) Write(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Write indicates an expected call of Write
+// Write indicates an expected call of Write.
 func (mr *MockStreamMockRecorder) Write(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStream)(nil).Write), arg0)

internal/mocks/short_header_opener.go

@@ -12,30 +12,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockShortHeaderOpener is a mock of ShortHeaderOpener interface
+// MockShortHeaderOpener is a mock of ShortHeaderOpener interface.
 type MockShortHeaderOpener struct {
 	ctrl     *gomock.Controller
 	recorder *MockShortHeaderOpenerMockRecorder
 }
 
-// MockShortHeaderOpenerMockRecorder is the mock recorder for MockShortHeaderOpener
+// MockShortHeaderOpenerMockRecorder is the mock recorder for MockShortHeaderOpener.
 type MockShortHeaderOpenerMockRecorder struct {
 	mock *MockShortHeaderOpener
 }
 
-// NewMockShortHeaderOpener creates a new mock instance
+// NewMockShortHeaderOpener creates a new mock instance.
 func NewMockShortHeaderOpener(ctrl *gomock.Controller) *MockShortHeaderOpener {
 	mock := &MockShortHeaderOpener{ctrl: ctrl}
 	mock.recorder = &MockShortHeaderOpenerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockShortHeaderOpener) EXPECT() *MockShortHeaderOpenerMockRecorder {
 	return m.recorder
 }
 
-// DecodePacketNumber mocks base method
+// DecodePacketNumber mocks base method.
 func (m *MockShortHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) protocol.PacketNumber {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DecodePacketNumber", arg0, arg1)
@@ -43,25 +43,25 @@ func (m *MockShortHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, a
 	return ret0
 }
 
-// DecodePacketNumber indicates an expected call of DecodePacketNumber
+// DecodePacketNumber indicates an expected call of DecodePacketNumber.
 func (mr *MockShortHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePacketNumber", reflect.TypeOf((*MockShortHeaderOpener)(nil).DecodePacketNumber), arg0, arg1)
 }
 
-// DecryptHeader mocks base method
+// DecryptHeader mocks base method.
 func (m *MockShortHeaderOpener) 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
+// DecryptHeader indicates an expected call of DecryptHeader.
 func (mr *MockShortHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptHeader", reflect.TypeOf((*MockShortHeaderOpener)(nil).DecryptHeader), arg0, arg1, arg2)
 }
 
-// Open mocks base method
+// Open mocks base method.
 func (m *MockShortHeaderOpener) Open(arg0, arg1 []byte, arg2 time.Time, arg3 protocol.PacketNumber, arg4 protocol.KeyPhaseBit, arg5 []byte) ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Open", arg0, arg1, arg2, arg3, arg4, arg5)
@@ -70,7 +70,7 @@ func (m *MockShortHeaderOpener) Open(arg0, arg1 []byte, arg2 time.Time, arg3 pro
 	return ret0, ret1
 }
 
-// Open indicates an expected call of Open
+// Open indicates an expected call of Open.
 func (mr *MockShortHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockShortHeaderOpener)(nil).Open), arg0, arg1, arg2, arg3, arg4, arg5)

internal/mocks/short_header_sealer.go

@@ -11,42 +11,42 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockShortHeaderSealer is a mock of ShortHeaderSealer interface
+// MockShortHeaderSealer is a mock of ShortHeaderSealer interface.
 type MockShortHeaderSealer struct {
 	ctrl     *gomock.Controller
 	recorder *MockShortHeaderSealerMockRecorder
 }
 
-// MockShortHeaderSealerMockRecorder is the mock recorder for MockShortHeaderSealer
+// MockShortHeaderSealerMockRecorder is the mock recorder for MockShortHeaderSealer.
 type MockShortHeaderSealerMockRecorder struct {
 	mock *MockShortHeaderSealer
 }
 
-// NewMockShortHeaderSealer creates a new mock instance
+// NewMockShortHeaderSealer creates a new mock instance.
 func NewMockShortHeaderSealer(ctrl *gomock.Controller) *MockShortHeaderSealer {
 	mock := &MockShortHeaderSealer{ctrl: ctrl}
 	mock.recorder = &MockShortHeaderSealerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockShortHeaderSealer) EXPECT() *MockShortHeaderSealerMockRecorder {
 	return m.recorder
 }
 
-// EncryptHeader mocks base method
+// EncryptHeader mocks base method.
 func (m *MockShortHeaderSealer) 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
+// EncryptHeader indicates an expected call of EncryptHeader.
 func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptHeader", reflect.TypeOf((*MockShortHeaderSealer)(nil).EncryptHeader), arg0, arg1, arg2)
 }
 
-// KeyPhase mocks base method
+// KeyPhase mocks base method.
 func (m *MockShortHeaderSealer) KeyPhase() protocol.KeyPhaseBit {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "KeyPhase")
@@ -54,13 +54,13 @@ func (m *MockShortHeaderSealer) KeyPhase() protocol.KeyPhaseBit {
 	return ret0
 }
 
-// KeyPhase indicates an expected call of KeyPhase
+// KeyPhase indicates an expected call of KeyPhase.
 func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyPhase", reflect.TypeOf((*MockShortHeaderSealer)(nil).KeyPhase))
 }
 
-// Overhead mocks base method
+// Overhead mocks base method.
 func (m *MockShortHeaderSealer) Overhead() int {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Overhead")
@@ -68,13 +68,13 @@ func (m *MockShortHeaderSealer) Overhead() int {
 	return ret0
 }
 
-// Overhead indicates an expected call of Overhead
+// Overhead indicates an expected call of Overhead.
 func (mr *MockShortHeaderSealerMockRecorder) Overhead() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Overhead", reflect.TypeOf((*MockShortHeaderSealer)(nil).Overhead))
 }
 
-// Seal mocks base method
+// Seal mocks base method.
 func (m *MockShortHeaderSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumber, arg3 []byte) []byte {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Seal", arg0, arg1, arg2, arg3)
@@ -82,7 +82,7 @@ func (m *MockShortHeaderSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumb
 	return ret0
 }
 
-// Seal indicates an expected call of Seal
+// Seal indicates an expected call of Seal.
 func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockShortHeaderSealer)(nil).Seal), arg0, arg1, arg2, arg3)

internal/mocks/stream_flow_controller.go

@@ -11,66 +11,66 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockStreamFlowController is a mock of StreamFlowController interface
+// MockStreamFlowController is a mock of StreamFlowController interface.
 type MockStreamFlowController struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamFlowControllerMockRecorder
 }
 
-// MockStreamFlowControllerMockRecorder is the mock recorder for MockStreamFlowController
+// MockStreamFlowControllerMockRecorder is the mock recorder for MockStreamFlowController.
 type MockStreamFlowControllerMockRecorder struct {
 	mock *MockStreamFlowController
 }
 
-// NewMockStreamFlowController creates a new mock instance
+// NewMockStreamFlowController creates a new mock instance.
 func NewMockStreamFlowController(ctrl *gomock.Controller) *MockStreamFlowController {
 	mock := &MockStreamFlowController{ctrl: ctrl}
 	mock.recorder = &MockStreamFlowControllerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStreamFlowController) EXPECT() *MockStreamFlowControllerMockRecorder {
 	return m.recorder
 }
 
-// Abandon mocks base method
+// Abandon mocks base method.
 func (m *MockStreamFlowController) Abandon() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Abandon")
 }
 
-// Abandon indicates an expected call of 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
+// 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
+// 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
+// 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
+// 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
+// GetWindowUpdate mocks base method.
 func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetWindowUpdate")
@@ -78,13 +78,13 @@ func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount {
 	return ret0
 }
 
-// GetWindowUpdate indicates an expected call of GetWindowUpdate
+// 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
+// IsNewlyBlocked mocks base method.
 func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "IsNewlyBlocked")
@@ -93,13 +93,13 @@ func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) {
 	return ret0, ret1
 }
 
-// IsNewlyBlocked indicates an expected call of IsNewlyBlocked
+// 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
+// SendWindowSize mocks base method.
 func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendWindowSize")
@@ -107,13 +107,13 @@ func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount {
 	return ret0
 }
 
-// SendWindowSize indicates an expected call of SendWindowSize
+// 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
+// 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)
@@ -121,19 +121,19 @@ func (m *MockStreamFlowController) UpdateHighestReceived(arg0 protocol.ByteCount
 	return ret0
 }
 
-// UpdateHighestReceived indicates an expected call of UpdateHighestReceived
+// 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
+// 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
+// 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)

internal/mocks/tls/client_session_cache.go

@@ -11,30 +11,30 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockClientSessionCache is a mock of ClientSessionCache interface
+// MockClientSessionCache is a mock of ClientSessionCache interface.
 type MockClientSessionCache struct {
 	ctrl     *gomock.Controller
 	recorder *MockClientSessionCacheMockRecorder
 }
 
-// MockClientSessionCacheMockRecorder is the mock recorder for MockClientSessionCache
+// MockClientSessionCacheMockRecorder is the mock recorder for MockClientSessionCache.
 type MockClientSessionCacheMockRecorder struct {
 	mock *MockClientSessionCache
 }
 
-// NewMockClientSessionCache creates a new mock instance
+// NewMockClientSessionCache creates a new mock instance.
 func NewMockClientSessionCache(ctrl *gomock.Controller) *MockClientSessionCache {
 	mock := &MockClientSessionCache{ctrl: ctrl}
 	mock.recorder = &MockClientSessionCacheMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockClientSessionCache) EXPECT() *MockClientSessionCacheMockRecorder {
 	return m.recorder
 }
 
-// Get mocks base method
+// Get mocks base method.
 func (m *MockClientSessionCache) Get(arg0 string) (*tls.ClientSessionState, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get", arg0)
@@ -43,19 +43,19 @@ func (m *MockClientSessionCache) Get(arg0 string) (*tls.ClientSessionState, bool
 	return ret0, ret1
 }
 
-// Get indicates an expected call of Get
+// Get indicates an expected call of Get.
 func (mr *MockClientSessionCacheMockRecorder) Get(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClientSessionCache)(nil).Get), arg0)
 }
 
-// Put mocks base method
+// Put mocks base method.
 func (m *MockClientSessionCache) Put(arg0 string, arg1 *tls.ClientSessionState) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Put", arg0, arg1)
 }
 
-// Put indicates an expected call of Put
+// Put indicates an expected call of Put.
 func (mr *MockClientSessionCacheMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClientSessionCache)(nil).Put), arg0, arg1)

logging/mock_connection_tracer_test.go

@@ -15,312 +15,312 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockConnectionTracer is a mock of ConnectionTracer interface
+// MockConnectionTracer is a mock of ConnectionTracer interface.
 type MockConnectionTracer struct {
 	ctrl     *gomock.Controller
 	recorder *MockConnectionTracerMockRecorder
 }
 
-// MockConnectionTracerMockRecorder is the mock recorder for MockConnectionTracer
+// MockConnectionTracerMockRecorder is the mock recorder for MockConnectionTracer.
 type MockConnectionTracerMockRecorder struct {
 	mock *MockConnectionTracer
 }
 
-// NewMockConnectionTracer creates a new mock instance
+// NewMockConnectionTracer creates a new mock instance.
 func NewMockConnectionTracer(ctrl *gomock.Controller) *MockConnectionTracer {
 	mock := &MockConnectionTracer{ctrl: ctrl}
 	mock.recorder = &MockConnectionTracerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockConnectionTracer) EXPECT() *MockConnectionTracerMockRecorder {
 	return m.recorder
 }
 
-// BufferedPacket mocks base method
+// BufferedPacket mocks base method.
 func (m *MockConnectionTracer) BufferedPacket(arg0 protocol.PacketType) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "BufferedPacket", arg0)
 }
 
-// BufferedPacket indicates an expected call of BufferedPacket
+// BufferedPacket indicates an expected call of BufferedPacket.
 func (mr *MockConnectionTracerMockRecorder) BufferedPacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BufferedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).BufferedPacket), arg0)
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockConnectionTracer) Close() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Close")
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockConnectionTracerMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnectionTracer)(nil).Close))
 }
 
-// ClosedConnection mocks base method
+// ClosedConnection mocks base method.
 func (m *MockConnectionTracer) ClosedConnection(arg0 CloseReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ClosedConnection", arg0)
 }
 
-// ClosedConnection indicates an expected call of ClosedConnection
+// ClosedConnection indicates an expected call of ClosedConnection.
 func (mr *MockConnectionTracerMockRecorder) ClosedConnection(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).ClosedConnection), arg0)
 }
 
-// Debug mocks base method
+// Debug mocks base method.
 func (m *MockConnectionTracer) Debug(arg0, arg1 string) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Debug", arg0, arg1)
 }
 
-// Debug indicates an expected call of Debug
+// Debug indicates an expected call of Debug.
 func (mr *MockConnectionTracerMockRecorder) Debug(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockConnectionTracer)(nil).Debug), arg0, arg1)
 }
 
-// DroppedEncryptionLevel mocks base method
+// DroppedEncryptionLevel mocks base method.
 func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedEncryptionLevel", arg0)
 }
 
-// DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel
+// DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel.
 func (mr *MockConnectionTracerMockRecorder) DroppedEncryptionLevel(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedEncryptionLevel", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedEncryptionLevel), arg0)
 }
 
-// DroppedKey mocks base method
+// DroppedKey mocks base method.
 func (m *MockConnectionTracer) DroppedKey(arg0 protocol.KeyPhase) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedKey", arg0)
 }
 
-// DroppedKey indicates an expected call of DroppedKey
+// DroppedKey indicates an expected call of DroppedKey.
 func (mr *MockConnectionTracerMockRecorder) DroppedKey(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedKey", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedKey), arg0)
 }
 
-// DroppedPacket mocks base method
+// DroppedPacket mocks base method.
 func (m *MockConnectionTracer) DroppedPacket(arg0 protocol.PacketType, arg1 protocol.ByteCount, arg2 PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2)
 }
 
-// DroppedPacket indicates an expected call of DroppedPacket
+// DroppedPacket indicates an expected call of DroppedPacket.
 func (mr *MockConnectionTracerMockRecorder) DroppedPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedPacket), arg0, arg1, arg2)
 }
 
-// LossTimerCanceled mocks base method
+// LossTimerCanceled mocks base method.
 func (m *MockConnectionTracer) LossTimerCanceled() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LossTimerCanceled")
 }
 
-// LossTimerCanceled indicates an expected call of LossTimerCanceled
+// LossTimerCanceled indicates an expected call of LossTimerCanceled.
 func (mr *MockConnectionTracerMockRecorder) LossTimerCanceled() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerCanceled", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerCanceled))
 }
 
-// LossTimerExpired mocks base method
+// LossTimerExpired mocks base method.
 func (m *MockConnectionTracer) LossTimerExpired(arg0 TimerType, arg1 protocol.EncryptionLevel) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LossTimerExpired", arg0, arg1)
 }
 
-// LossTimerExpired indicates an expected call of LossTimerExpired
+// LossTimerExpired indicates an expected call of LossTimerExpired.
 func (mr *MockConnectionTracerMockRecorder) LossTimerExpired(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerExpired", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerExpired), arg0, arg1)
 }
 
-// LostPacket mocks base method
+// LostPacket mocks base method.
 func (m *MockConnectionTracer) LostPacket(arg0 protocol.EncryptionLevel, arg1 protocol.PacketNumber, arg2 PacketLossReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "LostPacket", arg0, arg1, arg2)
 }
 
-// LostPacket indicates an expected call of LostPacket
+// LostPacket indicates an expected call of LostPacket.
 func (mr *MockConnectionTracerMockRecorder) LostPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LostPacket", reflect.TypeOf((*MockConnectionTracer)(nil).LostPacket), arg0, arg1, arg2)
 }
 
-// ReceivedPacket mocks base method
+// ReceivedPacket mocks base method.
 func (m *MockConnectionTracer) ReceivedPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 []Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedPacket", arg0, arg1, arg2)
 }
 
-// ReceivedPacket indicates an expected call of ReceivedPacket
+// ReceivedPacket indicates an expected call of ReceivedPacket.
 func (mr *MockConnectionTracerMockRecorder) ReceivedPacket(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedPacket), arg0, arg1, arg2)
 }
 
-// ReceivedRetry mocks base method
+// ReceivedRetry mocks base method.
 func (m *MockConnectionTracer) ReceivedRetry(arg0 *wire.Header) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedRetry", arg0)
 }
 
-// ReceivedRetry indicates an expected call of ReceivedRetry
+// ReceivedRetry indicates an expected call of ReceivedRetry.
 func (mr *MockConnectionTracerMockRecorder) ReceivedRetry(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedRetry", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedRetry), arg0)
 }
 
-// ReceivedTransportParameters mocks base method
+// ReceivedTransportParameters mocks base method.
 func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedTransportParameters", arg0)
 }
 
-// ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters
+// ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) ReceivedTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedTransportParameters), arg0)
 }
 
-// ReceivedVersionNegotiationPacket mocks base method
+// ReceivedVersionNegotiationPacket mocks base method.
 func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(arg0 *wire.Header, arg1 []protocol.VersionNumber) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReceivedVersionNegotiationPacket", arg0, arg1)
 }
 
-// ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket
+// ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket.
 func (mr *MockConnectionTracerMockRecorder) ReceivedVersionNegotiationPacket(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedVersionNegotiationPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedVersionNegotiationPacket), arg0, arg1)
 }
 
-// RestoredTransportParameters mocks base method
+// RestoredTransportParameters mocks base method.
 func (m *MockConnectionTracer) RestoredTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RestoredTransportParameters", arg0)
 }
 
-// RestoredTransportParameters indicates an expected call of RestoredTransportParameters
+// RestoredTransportParameters indicates an expected call of RestoredTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) RestoredTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoredTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).RestoredTransportParameters), arg0)
 }
 
-// SentPacket mocks base method
+// SentPacket mocks base method.
 func (m *MockConnectionTracer) SentPacket(arg0 *wire.ExtendedHeader, arg1 protocol.ByteCount, arg2 *wire.AckFrame, arg3 []Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
 }
 
-// SentPacket indicates an expected call of SentPacket
+// SentPacket indicates an expected call of SentPacket.
 func (mr *MockConnectionTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentPacket), arg0, arg1, arg2, arg3)
 }
 
-// SentTransportParameters mocks base method
+// SentTransportParameters mocks base method.
 func (m *MockConnectionTracer) SentTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentTransportParameters", arg0)
 }
 
-// SentTransportParameters indicates an expected call of SentTransportParameters
+// SentTransportParameters indicates an expected call of SentTransportParameters.
 func (mr *MockConnectionTracerMockRecorder) SentTransportParameters(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).SentTransportParameters), arg0)
 }
 
-// SetLossTimer mocks base method
+// SetLossTimer mocks base method.
 func (m *MockConnectionTracer) SetLossTimer(arg0 TimerType, arg1 protocol.EncryptionLevel, arg2 time.Time) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SetLossTimer", arg0, arg1, arg2)
 }
 
-// SetLossTimer indicates an expected call of SetLossTimer
+// SetLossTimer indicates an expected call of SetLossTimer.
 func (mr *MockConnectionTracerMockRecorder) SetLossTimer(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLossTimer", reflect.TypeOf((*MockConnectionTracer)(nil).SetLossTimer), arg0, arg1, arg2)
 }
 
-// StartedConnection mocks base method
+// StartedConnection mocks base method.
 func (m *MockConnectionTracer) StartedConnection(arg0, arg1 net.Addr, arg2 protocol.VersionNumber, arg3, arg4 protocol.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "StartedConnection", arg0, arg1, arg2, arg3, arg4)
 }
 
-// StartedConnection indicates an expected call of StartedConnection
+// StartedConnection indicates an expected call of StartedConnection.
 func (mr *MockConnectionTracerMockRecorder) StartedConnection(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).StartedConnection), arg0, arg1, arg2, arg3, arg4)
 }
 
-// UpdatedCongestionState mocks base method
+// UpdatedCongestionState mocks base method.
 func (m *MockConnectionTracer) UpdatedCongestionState(arg0 CongestionState) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedCongestionState", arg0)
 }
 
-// UpdatedCongestionState indicates an expected call of UpdatedCongestionState
+// UpdatedCongestionState indicates an expected call of UpdatedCongestionState.
 func (mr *MockConnectionTracerMockRecorder) UpdatedCongestionState(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedCongestionState", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedCongestionState), arg0)
 }
 
-// UpdatedKey mocks base method
+// UpdatedKey mocks base method.
 func (m *MockConnectionTracer) UpdatedKey(arg0 protocol.KeyPhase, arg1 bool) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKey", arg0, arg1)
 }
 
-// UpdatedKey indicates an expected call of UpdatedKey
+// UpdatedKey indicates an expected call of UpdatedKey.
 func (mr *MockConnectionTracerMockRecorder) UpdatedKey(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKey", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKey), arg0, arg1)
 }
 
-// UpdatedKeyFromTLS mocks base method
+// UpdatedKeyFromTLS mocks base method.
 func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 protocol.EncryptionLevel, arg1 protocol.Perspective) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedKeyFromTLS", arg0, arg1)
 }
 
-// UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS
+// UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS.
 func (mr *MockConnectionTracerMockRecorder) UpdatedKeyFromTLS(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKeyFromTLS", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKeyFromTLS), arg0, arg1)
 }
 
-// UpdatedMetrics mocks base method
+// UpdatedMetrics mocks base method.
 func (m *MockConnectionTracer) UpdatedMetrics(arg0 *utils.RTTStats, arg1, arg2 protocol.ByteCount, arg3 int) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedMetrics", arg0, arg1, arg2, arg3)
 }
 
-// UpdatedMetrics indicates an expected call of UpdatedMetrics
+// UpdatedMetrics indicates an expected call of UpdatedMetrics.
 func (mr *MockConnectionTracerMockRecorder) UpdatedMetrics(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedMetrics", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedMetrics), arg0, arg1, arg2, arg3)
 }
 
-// UpdatedPTOCount mocks base method
+// UpdatedPTOCount mocks base method.
 func (m *MockConnectionTracer) UpdatedPTOCount(arg0 uint32) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdatedPTOCount", arg0)
 }
 
-// UpdatedPTOCount indicates an expected call of UpdatedPTOCount
+// UpdatedPTOCount indicates an expected call of UpdatedPTOCount.
 func (mr *MockConnectionTracerMockRecorder) UpdatedPTOCount(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedPTOCount", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedPTOCount), arg0)

logging/mock_tracer_test.go

@@ -13,54 +13,54 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockTracer is a mock of Tracer interface
+// MockTracer is a mock of Tracer interface.
 type MockTracer struct {
 	ctrl     *gomock.Controller
 	recorder *MockTracerMockRecorder
 }
 
-// MockTracerMockRecorder is the mock recorder for MockTracer
+// MockTracerMockRecorder is the mock recorder for MockTracer.
 type MockTracerMockRecorder struct {
 	mock *MockTracer
 }
 
-// NewMockTracer creates a new mock instance
+// NewMockTracer creates a new mock instance.
 func NewMockTracer(ctrl *gomock.Controller) *MockTracer {
 	mock := &MockTracer{ctrl: ctrl}
 	mock.recorder = &MockTracerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockTracer) EXPECT() *MockTracerMockRecorder {
 	return m.recorder
 }
 
-// DroppedPacket mocks base method
+// DroppedPacket mocks base method.
 func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 protocol.PacketType, arg2 protocol.ByteCount, arg3 PacketDropReason) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "DroppedPacket", arg0, arg1, arg2, arg3)
 }
 
-// DroppedPacket indicates an expected call of DroppedPacket
+// DroppedPacket indicates an expected call of DroppedPacket.
 func (mr *MockTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockTracer)(nil).DroppedPacket), arg0, arg1, arg2, arg3)
 }
 
-// SentPacket mocks base method
+// SentPacket mocks base method.
 func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *wire.Header, arg2 protocol.ByteCount, arg3 []Frame) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "SentPacket", arg0, arg1, arg2, arg3)
 }
 
-// SentPacket indicates an expected call of SentPacket
+// SentPacket indicates an expected call of SentPacket.
 func (mr *MockTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockTracer)(nil).SentPacket), arg0, arg1, arg2, arg3)
 }
 
-// TracerForConnection mocks base method
+// TracerForConnection mocks base method.
 func (m *MockTracer) TracerForConnection(arg0 protocol.Perspective, arg1 protocol.ConnectionID) ConnectionTracer {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "TracerForConnection", arg0, arg1)
@@ -68,7 +68,7 @@ func (m *MockTracer) TracerForConnection(arg0 protocol.Perspective, arg1 protoco
 	return ret0
 }
 
-// TracerForConnection indicates an expected call of TracerForConnection
+// TracerForConnection indicates an expected call of TracerForConnection.
 func (mr *MockTracerMockRecorder) TracerForConnection(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TracerForConnection", reflect.TypeOf((*MockTracer)(nil).TracerForConnection), arg0, arg1)

mock_ack_frame_source_test.go

@@ -12,30 +12,30 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockAckFrameSource is a mock of AckFrameSource interface
+// MockAckFrameSource is a mock of AckFrameSource interface.
 type MockAckFrameSource struct {
 	ctrl     *gomock.Controller
 	recorder *MockAckFrameSourceMockRecorder
 }
 
-// MockAckFrameSourceMockRecorder is the mock recorder for MockAckFrameSource
+// MockAckFrameSourceMockRecorder is the mock recorder for MockAckFrameSource.
 type MockAckFrameSourceMockRecorder struct {
 	mock *MockAckFrameSource
 }
 
-// NewMockAckFrameSource creates a new mock instance
+// NewMockAckFrameSource creates a new mock instance.
 func NewMockAckFrameSource(ctrl *gomock.Controller) *MockAckFrameSource {
 	mock := &MockAckFrameSource{ctrl: ctrl}
 	mock.recorder = &MockAckFrameSourceMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockAckFrameSource) EXPECT() *MockAckFrameSourceMockRecorder {
 	return m.recorder
 }
 
-// GetAckFrame mocks base method
+// GetAckFrame mocks base method.
 func (m *MockAckFrameSource) GetAckFrame(arg0 protocol.EncryptionLevel, arg1 bool) *wire.AckFrame {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetAckFrame", arg0, arg1)
@@ -43,7 +43,7 @@ func (m *MockAckFrameSource) GetAckFrame(arg0 protocol.EncryptionLevel, arg1 boo
 	return ret0
 }
 
-// GetAckFrame indicates an expected call of GetAckFrame
+// GetAckFrame indicates an expected call of GetAckFrame.
 func (mr *MockAckFrameSourceMockRecorder) GetAckFrame(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockAckFrameSource)(nil).GetAckFrame), arg0, arg1)

mock_crypto_data_handler_test.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockCryptoDataHandler is a mock of CryptoDataHandler interface
+// MockCryptoDataHandler is a mock of CryptoDataHandler interface.
 type MockCryptoDataHandler struct {
 	ctrl     *gomock.Controller
 	recorder *MockCryptoDataHandlerMockRecorder
 }
 
-// MockCryptoDataHandlerMockRecorder is the mock recorder for MockCryptoDataHandler
+// MockCryptoDataHandlerMockRecorder is the mock recorder for MockCryptoDataHandler.
 type MockCryptoDataHandlerMockRecorder struct {
 	mock *MockCryptoDataHandler
 }
 
-// NewMockCryptoDataHandler creates a new mock instance
+// NewMockCryptoDataHandler creates a new mock instance.
 func NewMockCryptoDataHandler(ctrl *gomock.Controller) *MockCryptoDataHandler {
 	mock := &MockCryptoDataHandler{ctrl: ctrl}
 	mock.recorder = &MockCryptoDataHandlerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockCryptoDataHandler) EXPECT() *MockCryptoDataHandlerMockRecorder {
 	return m.recorder
 }
 
-// HandleMessage mocks base method
+// 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)
@@ -42,7 +42,7 @@ func (m *MockCryptoDataHandler) HandleMessage(arg0 []byte, arg1 protocol.Encrypt
 	return ret0
 }
 
-// HandleMessage indicates an expected call of HandleMessage
+// 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)

mock_crypto_stream_test.go

@@ -12,30 +12,30 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockCryptoStream is a mock of CryptoStream interface
+// MockCryptoStream is a mock of CryptoStream interface.
 type MockCryptoStream struct {
 	ctrl     *gomock.Controller
 	recorder *MockCryptoStreamMockRecorder
 }
 
-// MockCryptoStreamMockRecorder is the mock recorder for MockCryptoStream
+// MockCryptoStreamMockRecorder is the mock recorder for MockCryptoStream.
 type MockCryptoStreamMockRecorder struct {
 	mock *MockCryptoStream
 }
 
-// NewMockCryptoStream creates a new mock instance
+// NewMockCryptoStream creates a new mock instance.
 func NewMockCryptoStream(ctrl *gomock.Controller) *MockCryptoStream {
 	mock := &MockCryptoStream{ctrl: ctrl}
 	mock.recorder = &MockCryptoStreamMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockCryptoStream) EXPECT() *MockCryptoStreamMockRecorder {
 	return m.recorder
 }
 
-// Finish mocks base method
+// Finish mocks base method.
 func (m *MockCryptoStream) Finish() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Finish")
@@ -43,13 +43,13 @@ func (m *MockCryptoStream) Finish() error {
 	return ret0
 }
 
-// Finish indicates an expected call of Finish
+// 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
+// GetCryptoData mocks base method.
 func (m *MockCryptoStream) GetCryptoData() []byte {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetCryptoData")
@@ -57,13 +57,13 @@ func (m *MockCryptoStream) GetCryptoData() []byte {
 	return ret0
 }
 
-// GetCryptoData indicates an expected call of GetCryptoData
+// 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
+// HandleCryptoFrame mocks base method.
 func (m *MockCryptoStream) HandleCryptoFrame(arg0 *wire.CryptoFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HandleCryptoFrame", arg0)
@@ -71,13 +71,13 @@ func (m *MockCryptoStream) HandleCryptoFrame(arg0 *wire.CryptoFrame) error {
 	return ret0
 }
 
-// HandleCryptoFrame indicates an expected call of HandleCryptoFrame
+// 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
+// HasData mocks base method.
 func (m *MockCryptoStream) HasData() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HasData")
@@ -85,13 +85,13 @@ func (m *MockCryptoStream) HasData() bool {
 	return ret0
 }
 
-// HasData indicates an expected call of HasData
+// 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
+// PopCryptoFrame mocks base method.
 func (m *MockCryptoStream) PopCryptoFrame(arg0 protocol.ByteCount) *wire.CryptoFrame {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PopCryptoFrame", arg0)
@@ -99,13 +99,13 @@ func (m *MockCryptoStream) PopCryptoFrame(arg0 protocol.ByteCount) *wire.CryptoF
 	return ret0
 }
 
-// PopCryptoFrame indicates an expected call of PopCryptoFrame
+// 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
+// Write mocks base method.
 func (m *MockCryptoStream) Write(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Write", arg0)
@@ -114,7 +114,7 @@ func (m *MockCryptoStream) Write(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Write indicates an expected call of Write
+// 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)

mock_frame_source_test.go

@@ -12,30 +12,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockFrameSource is a mock of FrameSource interface
+// MockFrameSource is a mock of FrameSource interface.
 type MockFrameSource struct {
 	ctrl     *gomock.Controller
 	recorder *MockFrameSourceMockRecorder
 }
 
-// MockFrameSourceMockRecorder is the mock recorder for MockFrameSource
+// MockFrameSourceMockRecorder is the mock recorder for MockFrameSource.
 type MockFrameSourceMockRecorder struct {
 	mock *MockFrameSource
 }
 
-// NewMockFrameSource creates a new mock instance
+// NewMockFrameSource creates a new mock instance.
 func NewMockFrameSource(ctrl *gomock.Controller) *MockFrameSource {
 	mock := &MockFrameSource{ctrl: ctrl}
 	mock.recorder = &MockFrameSourceMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockFrameSource) EXPECT() *MockFrameSourceMockRecorder {
 	return m.recorder
 }
 
-// AppendControlFrames mocks base method
+// AppendControlFrames mocks base method.
 func (m *MockFrameSource) AppendControlFrames(arg0 []ackhandler.Frame, arg1 protocol.ByteCount) ([]ackhandler.Frame, protocol.ByteCount) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AppendControlFrames", arg0, arg1)
@@ -44,13 +44,13 @@ func (m *MockFrameSource) AppendControlFrames(arg0 []ackhandler.Frame, arg1 prot
 	return ret0, ret1
 }
 
-// AppendControlFrames indicates an expected call of AppendControlFrames
+// 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
+// AppendStreamFrames mocks base method.
 func (m *MockFrameSource) AppendStreamFrames(arg0 []ackhandler.Frame, arg1 protocol.ByteCount) ([]ackhandler.Frame, protocol.ByteCount) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AppendStreamFrames", arg0, arg1)
@@ -59,13 +59,13 @@ func (m *MockFrameSource) AppendStreamFrames(arg0 []ackhandler.Frame, arg1 proto
 	return ret0, ret1
 }
 
-// AppendStreamFrames indicates an expected call of AppendStreamFrames
+// 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)
 }
 
-// HasData mocks base method
+// HasData mocks base method.
 func (m *MockFrameSource) HasData() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HasData")
@@ -73,7 +73,7 @@ func (m *MockFrameSource) HasData() bool {
 	return ret0
 }
 
-// HasData indicates an expected call of HasData
+// HasData indicates an expected call of HasData.
 func (mr *MockFrameSourceMockRecorder) HasData() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasData", reflect.TypeOf((*MockFrameSource)(nil).HasData))

mock_multiplexer_test.go

@@ -12,30 +12,30 @@ import (
 	logging "github.com/lucas-clemente/quic-go/logging"
 )
 
-// MockMultiplexer is a mock of Multiplexer interface
+// MockMultiplexer is a mock of Multiplexer interface.
 type MockMultiplexer struct {
 	ctrl     *gomock.Controller
 	recorder *MockMultiplexerMockRecorder
 }
 
-// MockMultiplexerMockRecorder is the mock recorder for MockMultiplexer
+// MockMultiplexerMockRecorder is the mock recorder for MockMultiplexer.
 type MockMultiplexerMockRecorder struct {
 	mock *MockMultiplexer
 }
 
-// NewMockMultiplexer creates a new mock instance
+// NewMockMultiplexer creates a new mock instance.
 func NewMockMultiplexer(ctrl *gomock.Controller) *MockMultiplexer {
 	mock := &MockMultiplexer{ctrl: ctrl}
 	mock.recorder = &MockMultiplexerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockMultiplexer) EXPECT() *MockMultiplexerMockRecorder {
 	return m.recorder
 }
 
-// AddConn mocks base method
+// AddConn mocks base method.
 func (m *MockMultiplexer) AddConn(arg0 net.PacketConn, arg1 int, arg2 []byte, arg3 logging.Tracer) (packetHandlerManager, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddConn", arg0, arg1, arg2, arg3)
@@ -44,13 +44,13 @@ func (m *MockMultiplexer) AddConn(arg0 net.PacketConn, arg1 int, arg2 []byte, ar
 	return ret0, ret1
 }
 
-// AddConn indicates an expected call of AddConn
+// AddConn indicates an expected call of AddConn.
 func (mr *MockMultiplexerMockRecorder) AddConn(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddConn", reflect.TypeOf((*MockMultiplexer)(nil).AddConn), arg0, arg1, arg2, arg3)
 }
 
-// RemoveConn mocks base method
+// RemoveConn mocks base method.
 func (m *MockMultiplexer) RemoveConn(arg0 indexableConn) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoveConn", arg0)
@@ -58,7 +58,7 @@ func (m *MockMultiplexer) RemoveConn(arg0 indexableConn) error {
 	return ret0
 }
 
-// RemoveConn indicates an expected call of RemoveConn
+// 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)

mock_packer_test.go

@@ -13,42 +13,42 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockPacker is a mock of Packer interface
+// MockPacker is a mock of Packer interface.
 type MockPacker struct {
 	ctrl     *gomock.Controller
 	recorder *MockPackerMockRecorder
 }
 
-// MockPackerMockRecorder is the mock recorder for MockPacker
+// MockPackerMockRecorder is the mock recorder for MockPacker.
 type MockPackerMockRecorder struct {
 	mock *MockPacker
 }
 
-// NewMockPacker creates a new mock instance
+// NewMockPacker creates a new mock instance.
 func NewMockPacker(ctrl *gomock.Controller) *MockPacker {
 	mock := &MockPacker{ctrl: ctrl}
 	mock.recorder = &MockPackerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPacker) EXPECT() *MockPackerMockRecorder {
 	return m.recorder
 }
 
-// HandleTransportParameters mocks base method
+// HandleTransportParameters mocks base method.
 func (m *MockPacker) HandleTransportParameters(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "HandleTransportParameters", arg0)
 }
 
-// HandleTransportParameters indicates an expected call of HandleTransportParameters
+// 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
+// MaybePackAckPacket mocks base method.
 func (m *MockPacker) MaybePackAckPacket(arg0 bool) (*packedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MaybePackAckPacket", arg0)
@@ -57,13 +57,13 @@ func (m *MockPacker) MaybePackAckPacket(arg0 bool) (*packedPacket, error) {
 	return ret0, ret1
 }
 
-// MaybePackAckPacket indicates an expected call of MaybePackAckPacket
+// MaybePackAckPacket indicates an expected call of MaybePackAckPacket.
 func (mr *MockPackerMockRecorder) MaybePackAckPacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackAckPacket", reflect.TypeOf((*MockPacker)(nil).MaybePackAckPacket), arg0)
 }
 
-// MaybePackProbePacket mocks base method
+// MaybePackProbePacket mocks base method.
 func (m *MockPacker) MaybePackProbePacket(arg0 protocol.EncryptionLevel) (*packedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "MaybePackProbePacket", arg0)
@@ -72,13 +72,13 @@ func (m *MockPacker) MaybePackProbePacket(arg0 protocol.EncryptionLevel) (*packe
 	return ret0, ret1
 }
 
-// MaybePackProbePacket indicates an expected call of MaybePackProbePacket
+// MaybePackProbePacket indicates an expected call of MaybePackProbePacket.
 func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackProbePacket", reflect.TypeOf((*MockPacker)(nil).MaybePackProbePacket), arg0)
 }
 
-// PackCoalescedPacket mocks base method
+// PackCoalescedPacket mocks base method.
 func (m *MockPacker) PackCoalescedPacket() (*coalescedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PackCoalescedPacket")
@@ -87,13 +87,13 @@ func (m *MockPacker) PackCoalescedPacket() (*coalescedPacket, error) {
 	return ret0, ret1
 }
 
-// PackCoalescedPacket indicates an expected call of PackCoalescedPacket
+// PackCoalescedPacket indicates an expected call of PackCoalescedPacket.
 func (mr *MockPackerMockRecorder) PackCoalescedPacket() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket))
 }
 
-// PackConnectionClose mocks base method
+// PackConnectionClose mocks base method.
 func (m *MockPacker) PackConnectionClose(arg0 *qerr.QuicError) (*coalescedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PackConnectionClose", arg0)
@@ -102,13 +102,13 @@ func (m *MockPacker) PackConnectionClose(arg0 *qerr.QuicError) (*coalescedPacket
 	return ret0, ret1
 }
 
-// PackConnectionClose indicates an expected call of PackConnectionClose
+// 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
+// PackPacket mocks base method.
 func (m *MockPacker) PackPacket() (*packedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "PackPacket")
@@ -117,19 +117,19 @@ func (m *MockPacker) PackPacket() (*packedPacket, error) {
 	return ret0, ret1
 }
 
-// PackPacket indicates an expected call of PackPacket
+// 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))
 }
 
-// SetToken mocks base method
+// 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
+// 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)

mock_packet_handler_manager_test.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockPacketHandlerManager is a mock of PacketHandlerManager interface
+// MockPacketHandlerManager is a mock of PacketHandlerManager interface.
 type MockPacketHandlerManager struct {
 	ctrl     *gomock.Controller
 	recorder *MockPacketHandlerManagerMockRecorder
 }
 
-// MockPacketHandlerManagerMockRecorder is the mock recorder for MockPacketHandlerManager
+// MockPacketHandlerManagerMockRecorder is the mock recorder for MockPacketHandlerManager.
 type MockPacketHandlerManagerMockRecorder struct {
 	mock *MockPacketHandlerManager
 }
 
-// NewMockPacketHandlerManager creates a new mock instance
+// NewMockPacketHandlerManager creates a new mock instance.
 func NewMockPacketHandlerManager(ctrl *gomock.Controller) *MockPacketHandlerManager {
 	mock := &MockPacketHandlerManager{ctrl: ctrl}
 	mock.recorder = &MockPacketHandlerManagerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPacketHandlerManager) EXPECT() *MockPacketHandlerManagerMockRecorder {
 	return m.recorder
 }
 
-// Add mocks base method
+// Add mocks base method.
 func (m *MockPacketHandlerManager) Add(arg0 protocol.ConnectionID, arg1 packetHandler) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Add", arg0, arg1)
@@ -42,25 +42,25 @@ func (m *MockPacketHandlerManager) Add(arg0 protocol.ConnectionID, arg1 packetHa
 	return ret0
 }
 
-// Add indicates an expected call of Add
+// 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)
 }
 
-// AddResetToken mocks base method
+// AddResetToken mocks base method.
 func (m *MockPacketHandlerManager) AddResetToken(arg0 protocol.StatelessResetToken, arg1 packetHandler) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddResetToken", arg0, arg1)
 }
 
-// AddResetToken indicates an expected call of AddResetToken
+// AddResetToken indicates an expected call of AddResetToken.
 func (mr *MockPacketHandlerManagerMockRecorder) AddResetToken(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).AddResetToken), arg0, arg1)
 }
 
-// AddWithConnID mocks base method
+// AddWithConnID mocks base method.
 func (m *MockPacketHandlerManager) AddWithConnID(arg0, arg1 protocol.ConnectionID, arg2 func() packetHandler) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AddWithConnID", arg0, arg1, arg2)
@@ -68,25 +68,25 @@ func (m *MockPacketHandlerManager) AddWithConnID(arg0, arg1 protocol.ConnectionI
 	return ret0
 }
 
-// AddWithConnID indicates an expected call of AddWithConnID
+// AddWithConnID indicates an expected call of AddWithConnID.
 func (mr *MockPacketHandlerManagerMockRecorder) AddWithConnID(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWithConnID", reflect.TypeOf((*MockPacketHandlerManager)(nil).AddWithConnID), arg0, arg1, arg2)
 }
 
-// CloseServer mocks base method
+// CloseServer mocks base method.
 func (m *MockPacketHandlerManager) CloseServer() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "CloseServer")
 }
 
-// CloseServer indicates an expected call of 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))
 }
 
-// Destroy mocks base method
+// Destroy mocks base method.
 func (m *MockPacketHandlerManager) Destroy() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Destroy")
@@ -94,13 +94,13 @@ func (m *MockPacketHandlerManager) Destroy() error {
 	return ret0
 }
 
-// Destroy indicates an expected call of Destroy
+// Destroy indicates an expected call of Destroy.
 func (mr *MockPacketHandlerManagerMockRecorder) Destroy() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Destroy", reflect.TypeOf((*MockPacketHandlerManager)(nil).Destroy))
 }
 
-// GetStatelessResetToken mocks base method
+// GetStatelessResetToken mocks base method.
 func (m *MockPacketHandlerManager) GetStatelessResetToken(arg0 protocol.ConnectionID) protocol.StatelessResetToken {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetStatelessResetToken", arg0)
@@ -108,67 +108,67 @@ func (m *MockPacketHandlerManager) GetStatelessResetToken(arg0 protocol.Connecti
 	return ret0
 }
 
-// GetStatelessResetToken indicates an expected call of GetStatelessResetToken
+// GetStatelessResetToken indicates an expected call of GetStatelessResetToken.
 func (mr *MockPacketHandlerManagerMockRecorder) GetStatelessResetToken(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).GetStatelessResetToken), arg0)
 }
 
-// Remove mocks base method
+// 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
+// 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)
 }
 
-// RemoveResetToken mocks base method
+// RemoveResetToken mocks base method.
 func (m *MockPacketHandlerManager) RemoveResetToken(arg0 protocol.StatelessResetToken) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RemoveResetToken", arg0)
 }
 
-// RemoveResetToken indicates an expected call of RemoveResetToken
+// RemoveResetToken indicates an expected call of RemoveResetToken.
 func (mr *MockPacketHandlerManagerMockRecorder) RemoveResetToken(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).RemoveResetToken), arg0)
 }
 
-// ReplaceWithClosed mocks base method
+// ReplaceWithClosed mocks base method.
 func (m *MockPacketHandlerManager) ReplaceWithClosed(arg0 protocol.ConnectionID, arg1 packetHandler) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReplaceWithClosed", arg0, arg1)
 }
 
-// ReplaceWithClosed indicates an expected call of ReplaceWithClosed
+// ReplaceWithClosed indicates an expected call of ReplaceWithClosed.
 func (mr *MockPacketHandlerManagerMockRecorder) ReplaceWithClosed(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceWithClosed", reflect.TypeOf((*MockPacketHandlerManager)(nil).ReplaceWithClosed), arg0, arg1)
 }
 
-// Retire mocks base method
+// 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
+// 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
+// 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
+// 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)

mock_packet_handler_test.go

@@ -11,42 +11,42 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockPacketHandler is a mock of PacketHandler interface
+// MockPacketHandler is a mock of PacketHandler interface.
 type MockPacketHandler struct {
 	ctrl     *gomock.Controller
 	recorder *MockPacketHandlerMockRecorder
 }
 
-// MockPacketHandlerMockRecorder is the mock recorder for MockPacketHandler
+// MockPacketHandlerMockRecorder is the mock recorder for MockPacketHandler.
 type MockPacketHandlerMockRecorder struct {
 	mock *MockPacketHandler
 }
 
-// NewMockPacketHandler creates a new mock instance
+// NewMockPacketHandler creates a new mock instance.
 func NewMockPacketHandler(ctrl *gomock.Controller) *MockPacketHandler {
 	mock := &MockPacketHandler{ctrl: ctrl}
 	mock.recorder = &MockPacketHandlerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPacketHandler) EXPECT() *MockPacketHandlerMockRecorder {
 	return m.recorder
 }
 
-// destroy mocks base method
+// 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
+// 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
+// getPerspective mocks base method.
 func (m *MockPacketHandler) getPerspective() protocol.Perspective {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "getPerspective")
@@ -54,31 +54,31 @@ func (m *MockPacketHandler) getPerspective() protocol.Perspective {
 	return ret0
 }
 
-// getPerspective indicates an expected call of getPerspective
+// 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
+// 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
+// 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)
 }
 
-// shutdown mocks base method
+// shutdown mocks base method.
 func (m *MockPacketHandler) shutdown() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "shutdown")
 }
 
-// shutdown indicates an expected call of shutdown
+// shutdown indicates an expected call of shutdown.
 func (mr *MockPacketHandlerMockRecorder) shutdown() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "shutdown", reflect.TypeOf((*MockPacketHandler)(nil).shutdown))

mock_packetconn_test.go

@@ -12,30 +12,30 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockPacketConn is a mock of PacketConn interface
+// MockPacketConn is a mock of PacketConn interface.
 type MockPacketConn struct {
 	ctrl     *gomock.Controller
 	recorder *MockPacketConnMockRecorder
 }
 
-// MockPacketConnMockRecorder is the mock recorder for MockPacketConn
+// MockPacketConnMockRecorder is the mock recorder for MockPacketConn.
 type MockPacketConnMockRecorder struct {
 	mock *MockPacketConn
 }
 
-// NewMockPacketConn creates a new mock instance
+// NewMockPacketConn creates a new mock instance.
 func NewMockPacketConn(ctrl *gomock.Controller) *MockPacketConn {
 	mock := &MockPacketConn{ctrl: ctrl}
 	mock.recorder = &MockPacketConnMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockPacketConn) EXPECT() *MockPacketConnMockRecorder {
 	return m.recorder
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockPacketConn) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -43,13 +43,13 @@ func (m *MockPacketConn) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockPacketConnMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPacketConn)(nil).Close))
 }
 
-// LocalAddr mocks base method
+// LocalAddr mocks base method.
 func (m *MockPacketConn) LocalAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LocalAddr")
@@ -57,13 +57,13 @@ func (m *MockPacketConn) LocalAddr() net.Addr {
 	return ret0
 }
 
-// LocalAddr indicates an expected call of LocalAddr
+// LocalAddr indicates an expected call of LocalAddr.
 func (mr *MockPacketConnMockRecorder) LocalAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockPacketConn)(nil).LocalAddr))
 }
 
-// ReadFrom mocks base method
+// ReadFrom mocks base method.
 func (m *MockPacketConn) ReadFrom(arg0 []byte) (int, net.Addr, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReadFrom", arg0)
@@ -73,13 +73,13 @@ func (m *MockPacketConn) ReadFrom(arg0 []byte) (int, net.Addr, error) {
 	return ret0, ret1, ret2
 }
 
-// ReadFrom indicates an expected call of ReadFrom
+// ReadFrom indicates an expected call of ReadFrom.
 func (mr *MockPacketConnMockRecorder) ReadFrom(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFrom", reflect.TypeOf((*MockPacketConn)(nil).ReadFrom), arg0)
 }
 
-// SetDeadline mocks base method
+// SetDeadline mocks base method.
 func (m *MockPacketConn) SetDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetDeadline", arg0)
@@ -87,13 +87,13 @@ func (m *MockPacketConn) SetDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetDeadline indicates an expected call of SetDeadline
+// SetDeadline indicates an expected call of SetDeadline.
 func (mr *MockPacketConnMockRecorder) SetDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetDeadline), arg0)
 }
 
-// SetReadDeadline mocks base method
+// SetReadDeadline mocks base method.
 func (m *MockPacketConn) SetReadDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
@@ -101,13 +101,13 @@ func (m *MockPacketConn) SetReadDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetReadDeadline indicates an expected call of SetReadDeadline
+// SetReadDeadline indicates an expected call of SetReadDeadline.
 func (mr *MockPacketConnMockRecorder) SetReadDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetReadDeadline), arg0)
 }
 
-// SetWriteDeadline mocks base method
+// SetWriteDeadline mocks base method.
 func (m *MockPacketConn) SetWriteDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
@@ -115,13 +115,13 @@ func (m *MockPacketConn) SetWriteDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetWriteDeadline indicates an expected call of SetWriteDeadline
+// SetWriteDeadline indicates an expected call of SetWriteDeadline.
 func (mr *MockPacketConnMockRecorder) SetWriteDeadline(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetWriteDeadline), arg0)
 }
 
-// WriteTo mocks base method
+// WriteTo mocks base method.
 func (m *MockPacketConn) WriteTo(arg0 []byte, arg1 net.Addr) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WriteTo", arg0, arg1)
@@ -130,7 +130,7 @@ func (m *MockPacketConn) WriteTo(arg0 []byte, arg1 net.Addr) (int, error) {
 	return ret0, ret1
 }
 
-// WriteTo indicates an expected call of WriteTo
+// WriteTo indicates an expected call of WriteTo.
 func (mr *MockPacketConnMockRecorder) WriteTo(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTo", reflect.TypeOf((*MockPacketConn)(nil).WriteTo), arg0, arg1)

mock_quic_session_test.go

@@ -13,30 +13,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockQuicSession is a mock of QuicSession interface
+// MockQuicSession is a mock of QuicSession interface.
 type MockQuicSession struct {
 	ctrl     *gomock.Controller
 	recorder *MockQuicSessionMockRecorder
 }
 
-// MockQuicSessionMockRecorder is the mock recorder for MockQuicSession
+// MockQuicSessionMockRecorder is the mock recorder for MockQuicSession.
 type MockQuicSessionMockRecorder struct {
 	mock *MockQuicSession
 }
 
-// NewMockQuicSession creates a new mock instance
+// NewMockQuicSession creates a new mock instance.
 func NewMockQuicSession(ctrl *gomock.Controller) *MockQuicSession {
 	mock := &MockQuicSession{ctrl: ctrl}
 	mock.recorder = &MockQuicSessionMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockQuicSession) EXPECT() *MockQuicSessionMockRecorder {
 	return m.recorder
 }
 
-// AcceptStream mocks base method
+// AcceptStream mocks base method.
 func (m *MockQuicSession) AcceptStream(arg0 context.Context) (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptStream", arg0)
@@ -45,13 +45,13 @@ func (m *MockQuicSession) AcceptStream(arg0 context.Context) (Stream, error) {
 	return ret0, ret1
 }
 
-// AcceptStream indicates an expected call of AcceptStream
+// AcceptStream indicates an expected call of AcceptStream.
 func (mr *MockQuicSessionMockRecorder) AcceptStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockQuicSession)(nil).AcceptStream), arg0)
 }
 
-// AcceptUniStream mocks base method
+// AcceptUniStream mocks base method.
 func (m *MockQuicSession) AcceptUniStream(arg0 context.Context) (ReceiveStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptUniStream", arg0)
@@ -60,13 +60,13 @@ func (m *MockQuicSession) AcceptUniStream(arg0 context.Context) (ReceiveStream,
 	return ret0, ret1
 }
 
-// AcceptUniStream indicates an expected call of AcceptUniStream
+// AcceptUniStream indicates an expected call of AcceptUniStream.
 func (mr *MockQuicSessionMockRecorder) AcceptUniStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockQuicSession)(nil).AcceptUniStream), arg0)
 }
 
-// CloseWithError mocks base method
+// CloseWithError mocks base method.
 func (m *MockQuicSession) CloseWithError(arg0 protocol.ApplicationErrorCode, arg1 string) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "CloseWithError", arg0, arg1)
@@ -74,13 +74,13 @@ func (m *MockQuicSession) CloseWithError(arg0 protocol.ApplicationErrorCode, arg
 	return ret0
 }
 
-// CloseWithError indicates an expected call of CloseWithError
+// 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
+// ConnectionState mocks base method.
 func (m *MockQuicSession) ConnectionState() ConnectionState {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ConnectionState")
@@ -88,13 +88,13 @@ func (m *MockQuicSession) ConnectionState() ConnectionState {
 	return ret0
 }
 
-// ConnectionState indicates an expected call of 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
+// Context mocks base method.
 func (m *MockQuicSession) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
@@ -102,13 +102,13 @@ func (m *MockQuicSession) Context() context.Context {
 	return ret0
 }
 
-// Context indicates an expected call of 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
+// GetVersion mocks base method.
 func (m *MockQuicSession) GetVersion() protocol.VersionNumber {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetVersion")
@@ -116,13 +116,13 @@ func (m *MockQuicSession) GetVersion() protocol.VersionNumber {
 	return ret0
 }
 
-// GetVersion indicates an expected call of GetVersion
+// 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))
 }
 
-// HandshakeComplete mocks base method
+// HandshakeComplete mocks base method.
 func (m *MockQuicSession) HandshakeComplete() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HandshakeComplete")
@@ -130,13 +130,13 @@ func (m *MockQuicSession) HandshakeComplete() context.Context {
 	return ret0
 }
 
-// HandshakeComplete indicates an expected call of HandshakeComplete
+// HandshakeComplete indicates an expected call of HandshakeComplete.
 func (mr *MockQuicSessionMockRecorder) HandshakeComplete() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandshakeComplete", reflect.TypeOf((*MockQuicSession)(nil).HandshakeComplete))
 }
 
-// LocalAddr mocks base method
+// LocalAddr mocks base method.
 func (m *MockQuicSession) LocalAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LocalAddr")
@@ -144,13 +144,13 @@ func (m *MockQuicSession) LocalAddr() net.Addr {
 	return ret0
 }
 
-// LocalAddr indicates an expected call of LocalAddr
+// 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
+// OpenStream mocks base method.
 func (m *MockQuicSession) OpenStream() (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStream")
@@ -159,13 +159,13 @@ func (m *MockQuicSession) OpenStream() (Stream, error) {
 	return ret0, ret1
 }
 
-// OpenStream indicates an expected call of OpenStream
+// 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
+// OpenStreamSync mocks base method.
 func (m *MockQuicSession) OpenStreamSync(arg0 context.Context) (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStreamSync", arg0)
@@ -174,13 +174,13 @@ func (m *MockQuicSession) OpenStreamSync(arg0 context.Context) (Stream, error) {
 	return ret0, ret1
 }
 
-// OpenStreamSync indicates an expected call of OpenStreamSync
+// OpenStreamSync indicates an expected call of OpenStreamSync.
 func (mr *MockQuicSessionMockRecorder) OpenStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockQuicSession)(nil).OpenStreamSync), arg0)
 }
 
-// OpenUniStream mocks base method
+// OpenUniStream mocks base method.
 func (m *MockQuicSession) OpenUniStream() (SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStream")
@@ -189,13 +189,13 @@ func (m *MockQuicSession) OpenUniStream() (SendStream, error) {
 	return ret0, ret1
 }
 
-// OpenUniStream indicates an expected call of OpenUniStream
+// 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
+// OpenUniStreamSync mocks base method.
 func (m *MockQuicSession) OpenUniStreamSync(arg0 context.Context) (SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStreamSync", arg0)
@@ -204,13 +204,13 @@ func (m *MockQuicSession) OpenUniStreamSync(arg0 context.Context) (SendStream, e
 	return ret0, ret1
 }
 
-// OpenUniStreamSync indicates an expected call of OpenUniStreamSync
+// OpenUniStreamSync indicates an expected call of OpenUniStreamSync.
 func (mr *MockQuicSessionMockRecorder) OpenUniStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockQuicSession)(nil).OpenUniStreamSync), arg0)
 }
 
-// ReceiveMessage mocks base method
+// ReceiveMessage mocks base method.
 func (m *MockQuicSession) ReceiveMessage() ([]byte, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ReceiveMessage")
@@ -219,13 +219,13 @@ func (m *MockQuicSession) ReceiveMessage() ([]byte, error) {
 	return ret0, ret1
 }
 
-// ReceiveMessage indicates an expected call of ReceiveMessage
+// ReceiveMessage indicates an expected call of ReceiveMessage.
 func (mr *MockQuicSessionMockRecorder) ReceiveMessage() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveMessage", reflect.TypeOf((*MockQuicSession)(nil).ReceiveMessage))
 }
 
-// RemoteAddr mocks base method
+// RemoteAddr mocks base method.
 func (m *MockQuicSession) RemoteAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoteAddr")
@@ -233,13 +233,13 @@ func (m *MockQuicSession) RemoteAddr() net.Addr {
 	return ret0
 }
 
-// RemoteAddr indicates an expected call of RemoteAddr
+// 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))
 }
 
-// SendMessage mocks base method
+// SendMessage mocks base method.
 func (m *MockQuicSession) SendMessage(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SendMessage", arg0)
@@ -247,25 +247,25 @@ func (m *MockQuicSession) SendMessage(arg0 []byte) error {
 	return ret0
 }
 
-// SendMessage indicates an expected call of SendMessage
+// SendMessage indicates an expected call of SendMessage.
 func (mr *MockQuicSessionMockRecorder) SendMessage(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockQuicSession)(nil).SendMessage), arg0)
 }
 
-// destroy mocks base method
+// 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
+// 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)
 }
 
-// earlySessionReady mocks base method
+// earlySessionReady mocks base method.
 func (m *MockQuicSession) earlySessionReady() <-chan struct{} {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "earlySessionReady")
@@ -273,13 +273,13 @@ func (m *MockQuicSession) earlySessionReady() <-chan struct{} {
 	return ret0
 }
 
-// earlySessionReady indicates an expected call of earlySessionReady
+// earlySessionReady indicates an expected call of earlySessionReady.
 func (mr *MockQuicSessionMockRecorder) earlySessionReady() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "earlySessionReady", reflect.TypeOf((*MockQuicSession)(nil).earlySessionReady))
 }
 
-// getPerspective mocks base method
+// getPerspective mocks base method.
 func (m *MockQuicSession) getPerspective() protocol.Perspective {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "getPerspective")
@@ -287,25 +287,25 @@ func (m *MockQuicSession) getPerspective() protocol.Perspective {
 	return ret0
 }
 
-// getPerspective indicates an expected call of getPerspective
+// 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
+// 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
+// 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
+// run mocks base method.
 func (m *MockQuicSession) run() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "run")
@@ -313,19 +313,19 @@ func (m *MockQuicSession) run() error {
 	return ret0
 }
 
-// run indicates an expected call of run
+// 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))
 }
 
-// shutdown mocks base method
+// shutdown mocks base method.
 func (m *MockQuicSession) shutdown() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "shutdown")
 }
 
-// shutdown indicates an expected call of shutdown
+// shutdown indicates an expected call of shutdown.
 func (mr *MockQuicSessionMockRecorder) shutdown() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "shutdown", reflect.TypeOf((*MockQuicSession)(nil).shutdown))

mock_receive_stream_internal_test.go

@@ -13,42 +13,42 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockReceiveStreamI is a mock of ReceiveStreamI interface
+// MockReceiveStreamI is a mock of ReceiveStreamI interface.
 type MockReceiveStreamI struct {
 	ctrl     *gomock.Controller
 	recorder *MockReceiveStreamIMockRecorder
 }
 
-// MockReceiveStreamIMockRecorder is the mock recorder for MockReceiveStreamI
+// MockReceiveStreamIMockRecorder is the mock recorder for MockReceiveStreamI.
 type MockReceiveStreamIMockRecorder struct {
 	mock *MockReceiveStreamI
 }
 
-// NewMockReceiveStreamI creates a new mock instance
+// NewMockReceiveStreamI creates a new mock instance.
 func NewMockReceiveStreamI(ctrl *gomock.Controller) *MockReceiveStreamI {
 	mock := &MockReceiveStreamI{ctrl: ctrl}
 	mock.recorder = &MockReceiveStreamIMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder {
 	return m.recorder
 }
 
-// CancelRead mocks base method
+// 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
+// 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
+// Read mocks base method.
 func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Read", arg0)
@@ -57,13 +57,13 @@ func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Read indicates an expected call of Read
+// 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
+// SetReadDeadline mocks base method.
 func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
@@ -71,13 +71,13 @@ func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetReadDeadline indicates an expected call of SetReadDeadline
+// 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
+// StreamID mocks base method.
 func (m *MockReceiveStreamI) StreamID() protocol.StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
@@ -85,25 +85,25 @@ func (m *MockReceiveStreamI) StreamID() protocol.StreamID {
 	return ret0
 }
 
-// StreamID indicates an expected call of 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
+// 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
+// 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
+// getWindowUpdate mocks base method.
 func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "getWindowUpdate")
@@ -111,13 +111,13 @@ func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount {
 	return ret0
 }
 
-// getWindowUpdate indicates an expected call of getWindowUpdate
+// 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
+// handleResetStreamFrame mocks base method.
 func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0)
@@ -125,13 +125,13 @@ func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame)
 	return ret0
 }
 
-// handleResetStreamFrame indicates an expected call of handleResetStreamFrame
+// 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
+// handleStreamFrame mocks base method.
 func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "handleStreamFrame", arg0)
@@ -139,7 +139,7 @@ func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
 	return ret0
 }
 
-// handleStreamFrame indicates an expected call of handleStreamFrame
+// 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)

mock_sealing_manager_test.go

@@ -11,30 +11,30 @@ import (
 	handshake "github.com/lucas-clemente/quic-go/internal/handshake"
 )
 
-// MockSealingManager is a mock of SealingManager interface
+// MockSealingManager is a mock of SealingManager interface.
 type MockSealingManager struct {
 	ctrl     *gomock.Controller
 	recorder *MockSealingManagerMockRecorder
 }
 
-// MockSealingManagerMockRecorder is the mock recorder for MockSealingManager
+// MockSealingManagerMockRecorder is the mock recorder for MockSealingManager.
 type MockSealingManagerMockRecorder struct {
 	mock *MockSealingManager
 }
 
-// NewMockSealingManager creates a new mock instance
+// NewMockSealingManager creates a new mock instance.
 func NewMockSealingManager(ctrl *gomock.Controller) *MockSealingManager {
 	mock := &MockSealingManager{ctrl: ctrl}
 	mock.recorder = &MockSealingManagerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSealingManager) EXPECT() *MockSealingManagerMockRecorder {
 	return m.recorder
 }
 
-// Get0RTTSealer mocks base method
+// Get0RTTSealer mocks base method.
 func (m *MockSealingManager) Get0RTTSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get0RTTSealer")
@@ -43,13 +43,13 @@ func (m *MockSealingManager) Get0RTTSealer() (handshake.LongHeaderSealer, error)
 	return ret0, ret1
 }
 
-// Get0RTTSealer indicates an expected call of Get0RTTSealer
+// Get0RTTSealer indicates an expected call of Get0RTTSealer.
 func (mr *MockSealingManagerMockRecorder) Get0RTTSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTSealer", reflect.TypeOf((*MockSealingManager)(nil).Get0RTTSealer))
 }
 
-// Get1RTTSealer mocks base method
+// Get1RTTSealer mocks base method.
 func (m *MockSealingManager) Get1RTTSealer() (handshake.ShortHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Get1RTTSealer")
@@ -58,13 +58,13 @@ func (m *MockSealingManager) Get1RTTSealer() (handshake.ShortHeaderSealer, error
 	return ret0, ret1
 }
 
-// Get1RTTSealer indicates an expected call of Get1RTTSealer
+// Get1RTTSealer indicates an expected call of Get1RTTSealer.
 func (mr *MockSealingManagerMockRecorder) Get1RTTSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTSealer", reflect.TypeOf((*MockSealingManager)(nil).Get1RTTSealer))
 }
 
-// GetHandshakeSealer mocks base method
+// GetHandshakeSealer mocks base method.
 func (m *MockSealingManager) GetHandshakeSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetHandshakeSealer")
@@ -73,13 +73,13 @@ func (m *MockSealingManager) GetHandshakeSealer() (handshake.LongHeaderSealer, e
 	return ret0, ret1
 }
 
-// GetHandshakeSealer indicates an expected call of GetHandshakeSealer
+// GetHandshakeSealer indicates an expected call of GetHandshakeSealer.
 func (mr *MockSealingManagerMockRecorder) GetHandshakeSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeSealer", reflect.TypeOf((*MockSealingManager)(nil).GetHandshakeSealer))
 }
 
-// GetInitialSealer mocks base method
+// GetInitialSealer mocks base method.
 func (m *MockSealingManager) GetInitialSealer() (handshake.LongHeaderSealer, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetInitialSealer")
@@ -88,7 +88,7 @@ func (m *MockSealingManager) GetInitialSealer() (handshake.LongHeaderSealer, err
 	return ret0, ret1
 }
 
-// GetInitialSealer indicates an expected call of GetInitialSealer
+// GetInitialSealer indicates an expected call of GetInitialSealer.
 func (mr *MockSealingManagerMockRecorder) GetInitialSealer() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialSealer", reflect.TypeOf((*MockSealingManager)(nil).GetInitialSealer))

mock_send_conn_test.go

@@ -11,30 +11,30 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockSendConn is a mock of SendConn interface
+// MockSendConn is a mock of SendConn interface.
 type MockSendConn struct {
 	ctrl     *gomock.Controller
 	recorder *MockSendConnMockRecorder
 }
 
-// MockSendConnMockRecorder is the mock recorder for MockSendConn
+// MockSendConnMockRecorder is the mock recorder for MockSendConn.
 type MockSendConnMockRecorder struct {
 	mock *MockSendConn
 }
 
-// NewMockSendConn creates a new mock instance
+// NewMockSendConn creates a new mock instance.
 func NewMockSendConn(ctrl *gomock.Controller) *MockSendConn {
 	mock := &MockSendConn{ctrl: ctrl}
 	mock.recorder = &MockSendConnMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSendConn) EXPECT() *MockSendConnMockRecorder {
 	return m.recorder
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockSendConn) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -42,13 +42,13 @@ func (m *MockSendConn) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockSendConnMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSendConn)(nil).Close))
 }
 
-// LocalAddr mocks base method
+// LocalAddr mocks base method.
 func (m *MockSendConn) LocalAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "LocalAddr")
@@ -56,13 +56,13 @@ func (m *MockSendConn) LocalAddr() net.Addr {
 	return ret0
 }
 
-// LocalAddr indicates an expected call of LocalAddr
+// LocalAddr indicates an expected call of LocalAddr.
 func (mr *MockSendConnMockRecorder) LocalAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockSendConn)(nil).LocalAddr))
 }
 
-// RemoteAddr mocks base method
+// RemoteAddr mocks base method.
 func (m *MockSendConn) RemoteAddr() net.Addr {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "RemoteAddr")
@@ -70,13 +70,13 @@ func (m *MockSendConn) RemoteAddr() net.Addr {
 	return ret0
 }
 
-// RemoteAddr indicates an expected call of RemoteAddr
+// RemoteAddr indicates an expected call of RemoteAddr.
 func (mr *MockSendConnMockRecorder) RemoteAddr() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockSendConn)(nil).RemoteAddr))
 }
 
-// Write mocks base method
+// Write mocks base method.
 func (m *MockSendConn) Write(arg0 []byte) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Write", arg0)
@@ -84,7 +84,7 @@ func (m *MockSendConn) Write(arg0 []byte) error {
 	return ret0
 }
 
-// Write indicates an expected call of Write
+// Write indicates an expected call of Write.
 func (mr *MockSendConnMockRecorder) Write(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockSendConn)(nil).Write), arg0)

mock_send_stream_internal_test.go

@@ -15,42 +15,42 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockSendStreamI is a mock of SendStreamI interface
+// MockSendStreamI is a mock of SendStreamI interface.
 type MockSendStreamI struct {
 	ctrl     *gomock.Controller
 	recorder *MockSendStreamIMockRecorder
 }
 
-// MockSendStreamIMockRecorder is the mock recorder for MockSendStreamI
+// MockSendStreamIMockRecorder is the mock recorder for MockSendStreamI.
 type MockSendStreamIMockRecorder struct {
 	mock *MockSendStreamI
 }
 
-// NewMockSendStreamI creates a new mock instance
+// NewMockSendStreamI creates a new mock instance.
 func NewMockSendStreamI(ctrl *gomock.Controller) *MockSendStreamI {
 	mock := &MockSendStreamI{ctrl: ctrl}
 	mock.recorder = &MockSendStreamIMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSendStreamI) EXPECT() *MockSendStreamIMockRecorder {
 	return m.recorder
 }
 
-// CancelWrite mocks base method
+// 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
+// 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
+// Close mocks base method.
 func (m *MockSendStreamI) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -58,13 +58,13 @@ func (m *MockSendStreamI) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// 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
+// Context mocks base method.
 func (m *MockSendStreamI) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
@@ -72,13 +72,13 @@ func (m *MockSendStreamI) Context() context.Context {
 	return ret0
 }
 
-// Context indicates an expected call of 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
+// SetWriteDeadline mocks base method.
 func (m *MockSendStreamI) SetWriteDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
@@ -86,13 +86,13 @@ func (m *MockSendStreamI) SetWriteDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetWriteDeadline indicates an expected call of SetWriteDeadline
+// 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
+// StreamID mocks base method.
 func (m *MockSendStreamI) StreamID() protocol.StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
@@ -100,13 +100,13 @@ func (m *MockSendStreamI) StreamID() protocol.StreamID {
 	return ret0
 }
 
-// StreamID indicates an expected call of 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
+// Write mocks base method.
 func (m *MockSendStreamI) Write(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Write", arg0)
@@ -115,49 +115,49 @@ func (m *MockSendStreamI) Write(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Write indicates an expected call of Write
+// 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
+// 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
+// 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
+// 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
+// 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
+// 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
+// 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
+// hasData mocks base method.
 func (m *MockSendStreamI) hasData() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "hasData")
@@ -165,13 +165,13 @@ func (m *MockSendStreamI) hasData() bool {
 	return ret0
 }
 
-// hasData indicates an expected call of hasData
+// 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
+// popStreamFrame mocks base method.
 func (m *MockSendStreamI) popStreamFrame(arg0 protocol.ByteCount) (*ackhandler.Frame, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "popStreamFrame", arg0)
@@ -180,7 +180,7 @@ func (m *MockSendStreamI) popStreamFrame(arg0 protocol.ByteCount) (*ackhandler.F
 	return ret0, ret1
 }
 
-// popStreamFrame indicates an expected call of popStreamFrame
+// 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)

mock_sender_test.go

@@ -10,30 +10,30 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockSender is a mock of Sender interface
+// MockSender is a mock of Sender interface.
 type MockSender struct {
 	ctrl     *gomock.Controller
 	recorder *MockSenderMockRecorder
 }
 
-// MockSenderMockRecorder is the mock recorder for MockSender
+// MockSenderMockRecorder is the mock recorder for MockSender.
 type MockSenderMockRecorder struct {
 	mock *MockSender
 }
 
-// NewMockSender creates a new mock instance
+// NewMockSender creates a new mock instance.
 func NewMockSender(ctrl *gomock.Controller) *MockSender {
 	mock := &MockSender{ctrl: ctrl}
 	mock.recorder = &MockSenderMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSender) EXPECT() *MockSenderMockRecorder {
 	return m.recorder
 }
 
-// Available mocks base method
+// Available mocks base method.
 func (m *MockSender) Available() <-chan struct{} {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Available")
@@ -41,25 +41,25 @@ func (m *MockSender) Available() <-chan struct{} {
 	return ret0
 }
 
-// Available indicates an expected call of Available
+// Available indicates an expected call of Available.
 func (mr *MockSenderMockRecorder) Available() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Available", reflect.TypeOf((*MockSender)(nil).Available))
 }
 
-// Close mocks base method
+// Close mocks base method.
 func (m *MockSender) Close() {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Close")
 }
 
-// Close indicates an expected call of Close
+// Close indicates an expected call of Close.
 func (mr *MockSenderMockRecorder) Close() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSender)(nil).Close))
 }
 
-// Run mocks base method
+// Run mocks base method.
 func (m *MockSender) Run() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Run")
@@ -67,25 +67,25 @@ func (m *MockSender) Run() error {
 	return ret0
 }
 
-// Run indicates an expected call of Run
+// Run indicates an expected call of Run.
 func (mr *MockSenderMockRecorder) Run() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSender)(nil).Run))
 }
 
-// Send mocks base method
+// Send mocks base method.
 func (m *MockSender) Send(arg0 *packetBuffer) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Send", arg0)
 }
 
-// Send indicates an expected call of Send
+// Send indicates an expected call of Send.
 func (mr *MockSenderMockRecorder) Send(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSender)(nil).Send), arg0)
 }
 
-// WouldBlock mocks base method
+// WouldBlock mocks base method.
 func (m *MockSender) WouldBlock() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "WouldBlock")
@@ -93,7 +93,7 @@ func (m *MockSender) WouldBlock() bool {
 	return ret0
 }
 
-// WouldBlock indicates an expected call of WouldBlock
+// WouldBlock indicates an expected call of WouldBlock.
 func (mr *MockSenderMockRecorder) WouldBlock() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WouldBlock", reflect.TypeOf((*MockSender)(nil).WouldBlock))

mock_session_runner_test.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockSessionRunner is a mock of SessionRunner interface
+// MockSessionRunner is a mock of SessionRunner interface.
 type MockSessionRunner struct {
 	ctrl     *gomock.Controller
 	recorder *MockSessionRunnerMockRecorder
 }
 
-// MockSessionRunnerMockRecorder is the mock recorder for MockSessionRunner
+// MockSessionRunnerMockRecorder is the mock recorder for MockSessionRunner.
 type MockSessionRunnerMockRecorder struct {
 	mock *MockSessionRunner
 }
 
-// NewMockSessionRunner creates a new mock instance
+// NewMockSessionRunner creates a new mock instance.
 func NewMockSessionRunner(ctrl *gomock.Controller) *MockSessionRunner {
 	mock := &MockSessionRunner{ctrl: ctrl}
 	mock.recorder = &MockSessionRunnerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockSessionRunner) EXPECT() *MockSessionRunnerMockRecorder {
 	return m.recorder
 }
 
-// Add mocks base method
+// Add mocks base method.
 func (m *MockSessionRunner) Add(arg0 protocol.ConnectionID, arg1 packetHandler) bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Add", arg0, arg1)
@@ -42,25 +42,25 @@ func (m *MockSessionRunner) Add(arg0 protocol.ConnectionID, arg1 packetHandler)
 	return ret0
 }
 
-// Add indicates an expected call of Add
+// Add indicates an expected call of Add.
 func (mr *MockSessionRunnerMockRecorder) Add(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockSessionRunner)(nil).Add), arg0, arg1)
 }
 
-// AddResetToken mocks base method
+// AddResetToken mocks base method.
 func (m *MockSessionRunner) AddResetToken(arg0 protocol.StatelessResetToken, arg1 packetHandler) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "AddResetToken", arg0, arg1)
 }
 
-// AddResetToken indicates an expected call of AddResetToken
+// AddResetToken indicates an expected call of AddResetToken.
 func (mr *MockSessionRunnerMockRecorder) AddResetToken(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResetToken", reflect.TypeOf((*MockSessionRunner)(nil).AddResetToken), arg0, arg1)
 }
 
-// GetStatelessResetToken mocks base method
+// GetStatelessResetToken mocks base method.
 func (m *MockSessionRunner) GetStatelessResetToken(arg0 protocol.ConnectionID) protocol.StatelessResetToken {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetStatelessResetToken", arg0)
@@ -68,55 +68,55 @@ func (m *MockSessionRunner) GetStatelessResetToken(arg0 protocol.ConnectionID) p
 	return ret0
 }
 
-// GetStatelessResetToken indicates an expected call of GetStatelessResetToken
+// GetStatelessResetToken indicates an expected call of GetStatelessResetToken.
 func (mr *MockSessionRunnerMockRecorder) GetStatelessResetToken(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessResetToken", reflect.TypeOf((*MockSessionRunner)(nil).GetStatelessResetToken), arg0)
 }
 
-// Remove mocks base method
+// Remove mocks base method.
 func (m *MockSessionRunner) Remove(arg0 protocol.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Remove", arg0)
 }
 
-// Remove indicates an expected call of Remove
+// Remove indicates an expected call of Remove.
 func (mr *MockSessionRunnerMockRecorder) Remove(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockSessionRunner)(nil).Remove), arg0)
 }
 
-// RemoveResetToken mocks base method
+// RemoveResetToken mocks base method.
 func (m *MockSessionRunner) RemoveResetToken(arg0 protocol.StatelessResetToken) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "RemoveResetToken", arg0)
 }
 
-// RemoveResetToken indicates an expected call of RemoveResetToken
+// RemoveResetToken indicates an expected call of RemoveResetToken.
 func (mr *MockSessionRunnerMockRecorder) RemoveResetToken(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResetToken", reflect.TypeOf((*MockSessionRunner)(nil).RemoveResetToken), arg0)
 }
 
-// ReplaceWithClosed mocks base method
+// ReplaceWithClosed mocks base method.
 func (m *MockSessionRunner) ReplaceWithClosed(arg0 protocol.ConnectionID, arg1 packetHandler) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "ReplaceWithClosed", arg0, arg1)
 }
 
-// ReplaceWithClosed indicates an expected call of ReplaceWithClosed
+// ReplaceWithClosed indicates an expected call of ReplaceWithClosed.
 func (mr *MockSessionRunnerMockRecorder) ReplaceWithClosed(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceWithClosed", reflect.TypeOf((*MockSessionRunner)(nil).ReplaceWithClosed), arg0, arg1)
 }
 
-// Retire mocks base method
+// Retire mocks base method.
 func (m *MockSessionRunner) Retire(arg0 protocol.ConnectionID) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Retire", arg0)
 }
 
-// Retire indicates an expected call of Retire
+// Retire indicates an expected call of Retire.
 func (mr *MockSessionRunnerMockRecorder) Retire(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retire", reflect.TypeOf((*MockSessionRunner)(nil).Retire), arg0)

mock_stream_getter_test.go

@@ -11,30 +11,30 @@ import (
 	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
 )
 
-// MockStreamGetter is a mock of StreamGetter interface
+// MockStreamGetter is a mock of StreamGetter interface.
 type MockStreamGetter struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamGetterMockRecorder
 }
 
-// MockStreamGetterMockRecorder is the mock recorder for MockStreamGetter
+// MockStreamGetterMockRecorder is the mock recorder for MockStreamGetter.
 type MockStreamGetterMockRecorder struct {
 	mock *MockStreamGetter
 }
 
-// NewMockStreamGetter creates a new mock instance
+// NewMockStreamGetter creates a new mock instance.
 func NewMockStreamGetter(ctrl *gomock.Controller) *MockStreamGetter {
 	mock := &MockStreamGetter{ctrl: ctrl}
 	mock.recorder = &MockStreamGetterMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStreamGetter) EXPECT() *MockStreamGetterMockRecorder {
 	return m.recorder
 }
 
-// GetOrOpenReceiveStream mocks base method
+// GetOrOpenReceiveStream mocks base method.
 func (m *MockStreamGetter) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0)
@@ -43,13 +43,13 @@ func (m *MockStreamGetter) GetOrOpenReceiveStream(arg0 protocol.StreamID) (recei
 	return ret0, ret1
 }
 
-// GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream
+// 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
+// GetOrOpenSendStream mocks base method.
 func (m *MockStreamGetter) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0)
@@ -58,7 +58,7 @@ func (m *MockStreamGetter) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStre
 	return ret0, ret1
 }
 
-// GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream
+// 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)

mock_stream_internal_test.go

@@ -15,54 +15,54 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockStreamI is a mock of StreamI interface
+// MockStreamI is a mock of StreamI interface.
 type MockStreamI struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamIMockRecorder
 }
 
-// MockStreamIMockRecorder is the mock recorder for MockStreamI
+// MockStreamIMockRecorder is the mock recorder for MockStreamI.
 type MockStreamIMockRecorder struct {
 	mock *MockStreamI
 }
 
-// NewMockStreamI creates a new mock instance
+// NewMockStreamI creates a new mock instance.
 func NewMockStreamI(ctrl *gomock.Controller) *MockStreamI {
 	mock := &MockStreamI{ctrl: ctrl}
 	mock.recorder = &MockStreamIMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
 	return m.recorder
 }
 
-// CancelRead mocks base method
+// 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
+// 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
+// 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
+// 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
+// Close mocks base method.
 func (m *MockStreamI) Close() error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Close")
@@ -70,13 +70,13 @@ func (m *MockStreamI) Close() error {
 	return ret0
 }
 
-// Close indicates an expected call of Close
+// 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
+// Context mocks base method.
 func (m *MockStreamI) Context() context.Context {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Context")
@@ -84,13 +84,13 @@ func (m *MockStreamI) Context() context.Context {
 	return ret0
 }
 
-// Context indicates an expected call of 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
+// Read mocks base method.
 func (m *MockStreamI) Read(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Read", arg0)
@@ -99,13 +99,13 @@ func (m *MockStreamI) Read(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Read indicates an expected call of Read
+// 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
+// SetDeadline mocks base method.
 func (m *MockStreamI) SetDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetDeadline", arg0)
@@ -113,13 +113,13 @@ func (m *MockStreamI) SetDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetDeadline indicates an expected call of SetDeadline
+// 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
+// SetReadDeadline mocks base method.
 func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
@@ -127,13 +127,13 @@ func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetReadDeadline indicates an expected call of SetReadDeadline
+// 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
+// SetWriteDeadline mocks base method.
 func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
@@ -141,13 +141,13 @@ func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error {
 	return ret0
 }
 
-// SetWriteDeadline indicates an expected call of SetWriteDeadline
+// 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
+// StreamID mocks base method.
 func (m *MockStreamI) StreamID() protocol.StreamID {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "StreamID")
@@ -155,13 +155,13 @@ func (m *MockStreamI) StreamID() protocol.StreamID {
 	return ret0
 }
 
-// StreamID indicates an expected call of 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
+// Write mocks base method.
 func (m *MockStreamI) Write(arg0 []byte) (int, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Write", arg0)
@@ -170,25 +170,25 @@ func (m *MockStreamI) Write(arg0 []byte) (int, error) {
 	return ret0, ret1
 }
 
-// Write indicates an expected call of Write
+// 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
+// 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
+// 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
+// getWindowUpdate mocks base method.
 func (m *MockStreamI) getWindowUpdate() protocol.ByteCount {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "getWindowUpdate")
@@ -196,25 +196,25 @@ func (m *MockStreamI) getWindowUpdate() protocol.ByteCount {
 	return ret0
 }
 
-// getWindowUpdate indicates an expected call of getWindowUpdate
+// 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
+// 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
+// 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
+// handleResetStreamFrame mocks base method.
 func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0)
@@ -222,25 +222,25 @@ func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error
 	return ret0
 }
 
-// handleResetStreamFrame indicates an expected call of handleResetStreamFrame
+// 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
+// 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
+// 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
+// handleStreamFrame mocks base method.
 func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "handleStreamFrame", arg0)
@@ -248,13 +248,13 @@ func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
 	return ret0
 }
 
-// handleStreamFrame indicates an expected call of handleStreamFrame
+// 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
+// hasData mocks base method.
 func (m *MockStreamI) hasData() bool {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "hasData")
@@ -262,13 +262,13 @@ func (m *MockStreamI) hasData() bool {
 	return ret0
 }
 
-// hasData indicates an expected call of hasData
+// 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
+// popStreamFrame mocks base method.
 func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount) (*ackhandler.Frame, bool) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "popStreamFrame", arg0)
@@ -277,7 +277,7 @@ func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount) (*ackhandler.Frame
 	return ret0, ret1
 }
 
-// popStreamFrame indicates an expected call of popStreamFrame
+// 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)

mock_stream_manager_test.go

@@ -13,30 +13,30 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockStreamManager is a mock of StreamManager interface
+// MockStreamManager is a mock of StreamManager interface.
 type MockStreamManager struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamManagerMockRecorder
 }
 
-// MockStreamManagerMockRecorder is the mock recorder for MockStreamManager
+// MockStreamManagerMockRecorder is the mock recorder for MockStreamManager.
 type MockStreamManagerMockRecorder struct {
 	mock *MockStreamManager
 }
 
-// NewMockStreamManager creates a new mock instance
+// NewMockStreamManager creates a new mock instance.
 func NewMockStreamManager(ctrl *gomock.Controller) *MockStreamManager {
 	mock := &MockStreamManager{ctrl: ctrl}
 	mock.recorder = &MockStreamManagerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStreamManager) EXPECT() *MockStreamManagerMockRecorder {
 	return m.recorder
 }
 
-// AcceptStream mocks base method
+// AcceptStream mocks base method.
 func (m *MockStreamManager) AcceptStream(arg0 context.Context) (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptStream", arg0)
@@ -45,13 +45,13 @@ func (m *MockStreamManager) AcceptStream(arg0 context.Context) (Stream, error) {
 	return ret0, ret1
 }
 
-// AcceptStream indicates an expected call of AcceptStream
+// AcceptStream indicates an expected call of AcceptStream.
 func (mr *MockStreamManagerMockRecorder) AcceptStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptStream), arg0)
 }
 
-// AcceptUniStream mocks base method
+// AcceptUniStream mocks base method.
 func (m *MockStreamManager) AcceptUniStream(arg0 context.Context) (ReceiveStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "AcceptUniStream", arg0)
@@ -60,25 +60,25 @@ func (m *MockStreamManager) AcceptUniStream(arg0 context.Context) (ReceiveStream
 	return ret0, ret1
 }
 
-// AcceptUniStream indicates an expected call of AcceptUniStream
+// AcceptUniStream indicates an expected call of AcceptUniStream.
 func (mr *MockStreamManagerMockRecorder) AcceptUniStream(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptUniStream), arg0)
 }
 
-// CloseWithError mocks base method
+// 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
+// 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
+// DeleteStream mocks base method.
 func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "DeleteStream", arg0)
@@ -86,13 +86,13 @@ func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error {
 	return ret0
 }
 
-// DeleteStream indicates an expected call of DeleteStream
+// 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
+// GetOrOpenReceiveStream mocks base method.
 func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0)
@@ -101,13 +101,13 @@ func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (rece
 	return ret0, ret1
 }
 
-// GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream
+// 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
+// GetOrOpenSendStream mocks base method.
 func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0)
@@ -116,13 +116,13 @@ func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStr
 	return ret0, ret1
 }
 
-// GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream
+// 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
+// HandleMaxStreamsFrame mocks base method.
 func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) error {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "HandleMaxStreamsFrame", arg0)
@@ -130,13 +130,13 @@ func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) er
 	return ret0
 }
 
-// HandleMaxStreamsFrame indicates an expected call of HandleMaxStreamsFrame
+// 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
+// OpenStream mocks base method.
 func (m *MockStreamManager) OpenStream() (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStream")
@@ -145,13 +145,13 @@ func (m *MockStreamManager) OpenStream() (Stream, error) {
 	return ret0, ret1
 }
 
-// OpenStream indicates an expected call of OpenStream
+// 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
+// OpenStreamSync mocks base method.
 func (m *MockStreamManager) OpenStreamSync(arg0 context.Context) (Stream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenStreamSync", arg0)
@@ -160,13 +160,13 @@ func (m *MockStreamManager) OpenStreamSync(arg0 context.Context) (Stream, error)
 	return ret0, ret1
 }
 
-// OpenStreamSync indicates an expected call of OpenStreamSync
+// OpenStreamSync indicates an expected call of OpenStreamSync.
 func (mr *MockStreamManagerMockRecorder) OpenStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenStreamSync), arg0)
 }
 
-// OpenUniStream mocks base method
+// OpenUniStream mocks base method.
 func (m *MockStreamManager) OpenUniStream() (SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStream")
@@ -175,13 +175,13 @@ func (m *MockStreamManager) OpenUniStream() (SendStream, error) {
 	return ret0, ret1
 }
 
-// OpenUniStream indicates an expected call of OpenUniStream
+// 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
+// OpenUniStreamSync mocks base method.
 func (m *MockStreamManager) OpenUniStreamSync(arg0 context.Context) (SendStream, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "OpenUniStreamSync", arg0)
@@ -190,19 +190,19 @@ func (m *MockStreamManager) OpenUniStreamSync(arg0 context.Context) (SendStream,
 	return ret0, ret1
 }
 
-// OpenUniStreamSync indicates an expected call of OpenUniStreamSync
+// OpenUniStreamSync indicates an expected call of OpenUniStreamSync.
 func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStreamSync), arg0)
 }
 
-// UpdateLimits mocks base method
+// UpdateLimits mocks base method.
 func (m *MockStreamManager) UpdateLimits(arg0 *wire.TransportParameters) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "UpdateLimits", arg0)
 }
 
-// UpdateLimits indicates an expected call of UpdateLimits
+// 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)

mock_stream_sender_test.go

@@ -12,60 +12,60 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockStreamSender is a mock of StreamSender interface
+// MockStreamSender is a mock of StreamSender interface.
 type MockStreamSender struct {
 	ctrl     *gomock.Controller
 	recorder *MockStreamSenderMockRecorder
 }
 
-// MockStreamSenderMockRecorder is the mock recorder for MockStreamSender
+// MockStreamSenderMockRecorder is the mock recorder for MockStreamSender.
 type MockStreamSenderMockRecorder struct {
 	mock *MockStreamSender
 }
 
-// NewMockStreamSender creates a new mock instance
+// NewMockStreamSender creates a new mock instance.
 func NewMockStreamSender(ctrl *gomock.Controller) *MockStreamSender {
 	mock := &MockStreamSender{ctrl: ctrl}
 	mock.recorder = &MockStreamSenderMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockStreamSender) EXPECT() *MockStreamSenderMockRecorder {
 	return m.recorder
 }
 
-// onHasStreamData mocks base method
+// 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
+// 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
+// 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
+// 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
+// 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
+// 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)

mock_token_store_test.go

@@ -10,30 +10,30 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockTokenStore is a mock of TokenStore interface
+// MockTokenStore is a mock of TokenStore interface.
 type MockTokenStore struct {
 	ctrl     *gomock.Controller
 	recorder *MockTokenStoreMockRecorder
 }
 
-// MockTokenStoreMockRecorder is the mock recorder for MockTokenStore
+// MockTokenStoreMockRecorder is the mock recorder for MockTokenStore.
 type MockTokenStoreMockRecorder struct {
 	mock *MockTokenStore
 }
 
-// NewMockTokenStore creates a new mock instance
+// NewMockTokenStore creates a new mock instance.
 func NewMockTokenStore(ctrl *gomock.Controller) *MockTokenStore {
 	mock := &MockTokenStore{ctrl: ctrl}
 	mock.recorder = &MockTokenStoreMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockTokenStore) EXPECT() *MockTokenStoreMockRecorder {
 	return m.recorder
 }
 
-// Pop mocks base method
+// Pop mocks base method.
 func (m *MockTokenStore) Pop(arg0 string) *ClientToken {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Pop", arg0)
@@ -41,19 +41,19 @@ func (m *MockTokenStore) Pop(arg0 string) *ClientToken {
 	return ret0
 }
 
-// Pop indicates an expected call of Pop
+// Pop indicates an expected call of Pop.
 func (mr *MockTokenStoreMockRecorder) Pop(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pop", reflect.TypeOf((*MockTokenStore)(nil).Pop), arg0)
 }
 
-// Put mocks base method
+// Put mocks base method.
 func (m *MockTokenStore) Put(arg0 string, arg1 *ClientToken) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "Put", arg0, arg1)
 }
 
-// Put indicates an expected call of Put
+// Put indicates an expected call of Put.
 func (mr *MockTokenStoreMockRecorder) Put(arg0, arg1 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockTokenStore)(nil).Put), arg0, arg1)

mock_unknown_packet_handler_test.go

@@ -10,48 +10,48 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockUnknownPacketHandler is a mock of UnknownPacketHandler interface
+// MockUnknownPacketHandler is a mock of UnknownPacketHandler interface.
 type MockUnknownPacketHandler struct {
 	ctrl     *gomock.Controller
 	recorder *MockUnknownPacketHandlerMockRecorder
 }
 
-// MockUnknownPacketHandlerMockRecorder is the mock recorder for MockUnknownPacketHandler
+// MockUnknownPacketHandlerMockRecorder is the mock recorder for MockUnknownPacketHandler.
 type MockUnknownPacketHandlerMockRecorder struct {
 	mock *MockUnknownPacketHandler
 }
 
-// NewMockUnknownPacketHandler creates a new mock instance
+// NewMockUnknownPacketHandler creates a new mock instance.
 func NewMockUnknownPacketHandler(ctrl *gomock.Controller) *MockUnknownPacketHandler {
 	mock := &MockUnknownPacketHandler{ctrl: ctrl}
 	mock.recorder = &MockUnknownPacketHandlerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockUnknownPacketHandler) EXPECT() *MockUnknownPacketHandlerMockRecorder {
 	return m.recorder
 }
 
-// handlePacket mocks base method
+// 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
+// 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)
 }
 
-// setCloseError mocks base method
+// setCloseError mocks base method.
 func (m *MockUnknownPacketHandler) setCloseError(arg0 error) {
 	m.ctrl.T.Helper()
 	m.ctrl.Call(m, "setCloseError", arg0)
 }
 
-// setCloseError indicates an expected call of setCloseError
+// setCloseError indicates an expected call of setCloseError.
 func (mr *MockUnknownPacketHandlerMockRecorder) setCloseError(arg0 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setCloseError", reflect.TypeOf((*MockUnknownPacketHandler)(nil).setCloseError), arg0)

mock_unpacker_test.go

@@ -12,30 +12,30 @@ import (
 	wire "github.com/lucas-clemente/quic-go/internal/wire"
 )
 
-// MockUnpacker is a mock of Unpacker interface
+// MockUnpacker is a mock of Unpacker interface.
 type MockUnpacker struct {
 	ctrl     *gomock.Controller
 	recorder *MockUnpackerMockRecorder
 }
 
-// MockUnpackerMockRecorder is the mock recorder for MockUnpacker
+// MockUnpackerMockRecorder is the mock recorder for MockUnpacker.
 type MockUnpackerMockRecorder struct {
 	mock *MockUnpacker
 }
 
-// NewMockUnpacker creates a new mock instance
+// NewMockUnpacker creates a new mock instance.
 func NewMockUnpacker(ctrl *gomock.Controller) *MockUnpacker {
 	mock := &MockUnpacker{ctrl: ctrl}
 	mock.recorder = &MockUnpackerMockRecorder{mock}
 	return mock
 }
 
-// EXPECT returns an object that allows the caller to indicate expected use
+// EXPECT returns an object that allows the caller to indicate expected use.
 func (m *MockUnpacker) EXPECT() *MockUnpackerMockRecorder {
 	return m.recorder
 }
 
-// Unpack mocks base method
+// Unpack mocks base method.
 func (m *MockUnpacker) Unpack(arg0 *wire.Header, arg1 time.Time, arg2 []byte) (*unpackedPacket, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "Unpack", arg0, arg1, arg2)
@@ -44,7 +44,7 @@ func (m *MockUnpacker) Unpack(arg0 *wire.Header, arg1 time.Time, arg2 []byte) (*
 	return ret0, ret1
 }
 
-// Unpack indicates an expected call of Unpack
+// Unpack indicates an expected call of Unpack.
 func (mr *MockUnpackerMockRecorder) Unpack(arg0, arg1, arg2 interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unpack", reflect.TypeOf((*MockUnpacker)(nil).Unpack), arg0, arg1, arg2)