diff --git a/go.mod b/go.mod index bdb16756..840efa90 100644 --- a/go.mod +++ b/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 diff --git a/go.sum b/go.sum index 27ced0d5..1b1c57de 100644 --- a/go.sum +++ b/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= diff --git a/internal/ackhandler/mock_sent_packet_tracker_test.go b/internal/ackhandler/mock_sent_packet_tracker_test.go index 9c3e8b8c..2490c40b 100644 --- a/internal/ackhandler/mock_sent_packet_tracker_test.go +++ b/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) diff --git a/internal/handshake/mock_handshake_runner_test.go b/internal/handshake/mock_handshake_runner_test.go index cc5cf734..574cabe3 100644 --- a/internal/handshake/mock_handshake_runner_test.go +++ b/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) diff --git a/internal/mocks/ackhandler/received_packet_handler.go b/internal/mocks/ackhandler/received_packet_handler.go index d0c0f330..ee33c8aa 100644 --- a/internal/mocks/ackhandler/received_packet_handler.go +++ b/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) diff --git a/internal/mocks/ackhandler/sent_packet_handler.go b/internal/mocks/ackhandler/sent_packet_handler.go index 491cbfbc..df1ef044 100644 --- a/internal/mocks/ackhandler/sent_packet_handler.go +++ b/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)) diff --git a/internal/mocks/congestion.go b/internal/mocks/congestion.go index 1325f8c4..d9267db5 100644 --- a/internal/mocks/congestion.go +++ b/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) diff --git a/internal/mocks/connection_flow_controller.go b/internal/mocks/connection_flow_controller.go index 14892c1b..2fb5b0d8 100644 --- a/internal/mocks/connection_flow_controller.go +++ b/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) diff --git a/internal/mocks/crypto_setup.go b/internal/mocks/crypto_setup.go index ba1d2965..0d56332a 100644 --- a/internal/mocks/crypto_setup.go +++ b/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) diff --git a/internal/mocks/logging/connection_tracer.go b/internal/mocks/logging/connection_tracer.go index ae9eca7f..64d774ca 100644 --- a/internal/mocks/logging/connection_tracer.go +++ b/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) diff --git a/internal/mocks/logging/tracer.go b/internal/mocks/logging/tracer.go index 2a643e35..30f814f7 100644 --- a/internal/mocks/logging/tracer.go +++ b/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) diff --git a/internal/mocks/long_header_opener.go b/internal/mocks/long_header_opener.go index c5610adf..c60b75d1 100644 --- a/internal/mocks/long_header_opener.go +++ b/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) diff --git a/internal/mocks/quic/early_listener.go b/internal/mocks/quic/early_listener.go index 673acae5..395a1b19 100644 --- a/internal/mocks/quic/early_listener.go +++ b/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)) diff --git a/internal/mocks/quic/early_session.go b/internal/mocks/quic/early_session.go index 0c81bead..3d5e5519 100644 --- a/internal/mocks/quic/early_session.go +++ b/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) diff --git a/internal/mocks/quic/stream.go b/internal/mocks/quic/stream.go index 90c19aed..a8d899a7 100644 --- a/internal/mocks/quic/stream.go +++ b/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) diff --git a/internal/mocks/short_header_opener.go b/internal/mocks/short_header_opener.go index fe81572e..5cddaf4c 100644 --- a/internal/mocks/short_header_opener.go +++ b/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) diff --git a/internal/mocks/short_header_sealer.go b/internal/mocks/short_header_sealer.go index 81825543..af66aaf1 100644 --- a/internal/mocks/short_header_sealer.go +++ b/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) diff --git a/internal/mocks/stream_flow_controller.go b/internal/mocks/stream_flow_controller.go index 819dbc09..69371d4f 100644 --- a/internal/mocks/stream_flow_controller.go +++ b/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) diff --git a/internal/mocks/tls/client_session_cache.go b/internal/mocks/tls/client_session_cache.go index 0e43c552..e3ae2c8e 100644 --- a/internal/mocks/tls/client_session_cache.go +++ b/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) diff --git a/logging/mock_connection_tracer_test.go b/logging/mock_connection_tracer_test.go index c290e0c7..4ec76d6b 100644 --- a/logging/mock_connection_tracer_test.go +++ b/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) diff --git a/logging/mock_tracer_test.go b/logging/mock_tracer_test.go index 22e39c0d..971c319c 100644 --- a/logging/mock_tracer_test.go +++ b/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) diff --git a/mock_ack_frame_source_test.go b/mock_ack_frame_source_test.go index 528719a0..c8439c09 100644 --- a/mock_ack_frame_source_test.go +++ b/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) diff --git a/mock_crypto_data_handler_test.go b/mock_crypto_data_handler_test.go index 5cfb10fd..c7c18ada 100644 --- a/mock_crypto_data_handler_test.go +++ b/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) diff --git a/mock_crypto_stream_test.go b/mock_crypto_stream_test.go index dfdea27b..be271112 100644 --- a/mock_crypto_stream_test.go +++ b/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) diff --git a/mock_frame_source_test.go b/mock_frame_source_test.go index 56407b83..4d13093f 100644 --- a/mock_frame_source_test.go +++ b/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)) diff --git a/mock_multiplexer_test.go b/mock_multiplexer_test.go index 90784d8f..7909b288 100644 --- a/mock_multiplexer_test.go +++ b/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) diff --git a/mock_packer_test.go b/mock_packer_test.go index d05be9c0..cf6fef50 100644 --- a/mock_packer_test.go +++ b/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) diff --git a/mock_packet_handler_manager_test.go b/mock_packet_handler_manager_test.go index c622b164..45e72f3d 100644 --- a/mock_packet_handler_manager_test.go +++ b/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) diff --git a/mock_packet_handler_test.go b/mock_packet_handler_test.go index 500045ed..143e7dd6 100644 --- a/mock_packet_handler_test.go +++ b/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)) diff --git a/mock_packetconn_test.go b/mock_packetconn_test.go index e3fe28a8..d6731e4a 100644 --- a/mock_packetconn_test.go +++ b/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) diff --git a/mock_quic_session_test.go b/mock_quic_session_test.go index d8b5ac0c..ae8ea245 100644 --- a/mock_quic_session_test.go +++ b/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)) diff --git a/mock_receive_stream_internal_test.go b/mock_receive_stream_internal_test.go index b40e3d9e..d9380aaf 100644 --- a/mock_receive_stream_internal_test.go +++ b/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) diff --git a/mock_sealing_manager_test.go b/mock_sealing_manager_test.go index 238fff32..2cdb5e89 100644 --- a/mock_sealing_manager_test.go +++ b/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)) diff --git a/mock_send_conn_test.go b/mock_send_conn_test.go index dac92b32..ac0d8637 100644 --- a/mock_send_conn_test.go +++ b/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) diff --git a/mock_send_stream_internal_test.go b/mock_send_stream_internal_test.go index b5707848..449e371e 100644 --- a/mock_send_stream_internal_test.go +++ b/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) diff --git a/mock_sender_test.go b/mock_sender_test.go index 60a216a3..43a47678 100644 --- a/mock_sender_test.go +++ b/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)) diff --git a/mock_session_runner_test.go b/mock_session_runner_test.go index 4460b214..7b3d5a3e 100644 --- a/mock_session_runner_test.go +++ b/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) diff --git a/mock_stream_getter_test.go b/mock_stream_getter_test.go index 8b766a1b..9fc7a136 100644 --- a/mock_stream_getter_test.go +++ b/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) diff --git a/mock_stream_internal_test.go b/mock_stream_internal_test.go index 206b9c9b..de01cefe 100644 --- a/mock_stream_internal_test.go +++ b/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) diff --git a/mock_stream_manager_test.go b/mock_stream_manager_test.go index cfe5b2be..96d9a7e4 100644 --- a/mock_stream_manager_test.go +++ b/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) diff --git a/mock_stream_sender_test.go b/mock_stream_sender_test.go index 8b333121..c0c0d021 100644 --- a/mock_stream_sender_test.go +++ b/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) diff --git a/mock_token_store_test.go b/mock_token_store_test.go index 4ef22546..e7385005 100644 --- a/mock_token_store_test.go +++ b/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) diff --git a/mock_unknown_packet_handler_test.go b/mock_unknown_packet_handler_test.go index a0adf556..0cc19b85 100644 --- a/mock_unknown_packet_handler_test.go +++ b/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) diff --git a/mock_unpacker_test.go b/mock_unpacker_test.go index 60b35021..2c9a41f3 100644 --- a/mock_unpacker_test.go +++ b/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)