diff --git a/connection_test.go b/connection_test.go index 74e79618..fe318d22 100644 --- a/connection_test.go +++ b/connection_test.go @@ -84,7 +84,7 @@ var _ = Describe("Connection", func() { }) } - expectAppendPacket := func(packer *MockPacker, p shortHeaderPacket, b []byte) *PackerAppendPacketCall { + expectAppendPacket := func(packer *MockPacker, p shortHeaderPacket, b []byte) *MockPackerAppendPacketCall { return packer.EXPECT().AppendPacket(gomock.Any(), gomock.Any(), Version1).DoAndReturn(func(buf *packetBuffer, _ protocol.ByteCount, _ protocol.Version) (shortHeaderPacket, error) { buf.Data = append(buf.Data, b...) return p, nil diff --git a/go.mod b/go.mod index 76087a2f..53b198e1 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/onsi/ginkgo/v2 v2.9.5 github.com/onsi/gomega v1.27.6 github.com/quic-go/qpack v0.4.0 - go.uber.org/mock v0.3.0 + go.uber.org/mock v0.4.0 golang.org/x/crypto v0.4.0 golang.org/x/exp v0.0.0-20221205204356-47842c84f3db golang.org/x/net v0.10.0 diff --git a/go.sum b/go.sum index 47e4bbee..1d051514 100644 --- a/go.sum +++ b/go.sum @@ -123,8 +123,8 @@ github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cb github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU= github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM= go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA= -go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo= -go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw= golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= diff --git a/http3/mock_quic_early_listener_test.go b/http3/mock_quic_early_listener_test.go index a63086ed..bcbfa289 100644 --- a/http3/mock_quic_early_listener_test.go +++ b/http3/mock_quic_early_listener_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -package http3 -destination mock_quic_early_listener_test.go github.com/quic-go/quic-go/http3 QUICEarlyListener // + // Package http3 is a generated GoMock package. package http3 @@ -50,31 +51,31 @@ func (m *MockQUICEarlyListener) Accept(arg0 context.Context) (quic.EarlyConnecti } // Accept indicates an expected call of Accept. -func (mr *MockQUICEarlyListenerMockRecorder) Accept(arg0 any) *QUICEarlyListenerAcceptCall { +func (mr *MockQUICEarlyListenerMockRecorder) Accept(arg0 any) *MockQUICEarlyListenerAcceptCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Accept", reflect.TypeOf((*MockQUICEarlyListener)(nil).Accept), arg0) - return &QUICEarlyListenerAcceptCall{Call: call} + return &MockQUICEarlyListenerAcceptCall{Call: call} } -// QUICEarlyListenerAcceptCall wrap *gomock.Call -type QUICEarlyListenerAcceptCall struct { +// MockQUICEarlyListenerAcceptCall wrap *gomock.Call +type MockQUICEarlyListenerAcceptCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICEarlyListenerAcceptCall) Return(arg0 quic.EarlyConnection, arg1 error) *QUICEarlyListenerAcceptCall { +func (c *MockQUICEarlyListenerAcceptCall) Return(arg0 quic.EarlyConnection, arg1 error) *MockQUICEarlyListenerAcceptCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICEarlyListenerAcceptCall) Do(f func(context.Context) (quic.EarlyConnection, error)) *QUICEarlyListenerAcceptCall { +func (c *MockQUICEarlyListenerAcceptCall) Do(f func(context.Context) (quic.EarlyConnection, error)) *MockQUICEarlyListenerAcceptCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICEarlyListenerAcceptCall) DoAndReturn(f func(context.Context) (quic.EarlyConnection, error)) *QUICEarlyListenerAcceptCall { +func (c *MockQUICEarlyListenerAcceptCall) DoAndReturn(f func(context.Context) (quic.EarlyConnection, error)) *MockQUICEarlyListenerAcceptCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -88,31 +89,31 @@ func (m *MockQUICEarlyListener) Addr() net.Addr { } // Addr indicates an expected call of Addr. -func (mr *MockQUICEarlyListenerMockRecorder) Addr() *QUICEarlyListenerAddrCall { +func (mr *MockQUICEarlyListenerMockRecorder) Addr() *MockQUICEarlyListenerAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Addr", reflect.TypeOf((*MockQUICEarlyListener)(nil).Addr)) - return &QUICEarlyListenerAddrCall{Call: call} + return &MockQUICEarlyListenerAddrCall{Call: call} } -// QUICEarlyListenerAddrCall wrap *gomock.Call -type QUICEarlyListenerAddrCall struct { +// MockQUICEarlyListenerAddrCall wrap *gomock.Call +type MockQUICEarlyListenerAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICEarlyListenerAddrCall) Return(arg0 net.Addr) *QUICEarlyListenerAddrCall { +func (c *MockQUICEarlyListenerAddrCall) Return(arg0 net.Addr) *MockQUICEarlyListenerAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICEarlyListenerAddrCall) Do(f func() net.Addr) *QUICEarlyListenerAddrCall { +func (c *MockQUICEarlyListenerAddrCall) Do(f func() net.Addr) *MockQUICEarlyListenerAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICEarlyListenerAddrCall) DoAndReturn(f func() net.Addr) *QUICEarlyListenerAddrCall { +func (c *MockQUICEarlyListenerAddrCall) DoAndReturn(f func() net.Addr) *MockQUICEarlyListenerAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockQUICEarlyListener) Close() error { } // Close indicates an expected call of Close. -func (mr *MockQUICEarlyListenerMockRecorder) Close() *QUICEarlyListenerCloseCall { +func (mr *MockQUICEarlyListenerMockRecorder) Close() *MockQUICEarlyListenerCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockQUICEarlyListener)(nil).Close)) - return &QUICEarlyListenerCloseCall{Call: call} + return &MockQUICEarlyListenerCloseCall{Call: call} } -// QUICEarlyListenerCloseCall wrap *gomock.Call -type QUICEarlyListenerCloseCall struct { +// MockQUICEarlyListenerCloseCall wrap *gomock.Call +type MockQUICEarlyListenerCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICEarlyListenerCloseCall) Return(arg0 error) *QUICEarlyListenerCloseCall { +func (c *MockQUICEarlyListenerCloseCall) Return(arg0 error) *MockQUICEarlyListenerCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICEarlyListenerCloseCall) Do(f func() error) *QUICEarlyListenerCloseCall { +func (c *MockQUICEarlyListenerCloseCall) Do(f func() error) *MockQUICEarlyListenerCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICEarlyListenerCloseCall) DoAndReturn(f func() error) *QUICEarlyListenerCloseCall { +func (c *MockQUICEarlyListenerCloseCall) DoAndReturn(f func() error) *MockQUICEarlyListenerCloseCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/http3/mock_roundtripcloser_test.go b/http3/mock_roundtripcloser_test.go index e0e06f99..adc0c687 100644 --- a/http3/mock_roundtripcloser_test.go +++ b/http3/mock_roundtripcloser_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package http3 -destination mock_roundtripcloser_test.go github.com/quic-go/quic-go/http3 RoundTripCloser // + // Package http3 is a generated GoMock package. package http3 @@ -47,31 +48,31 @@ func (m *MockRoundTripCloser) Close() error { } // Close indicates an expected call of Close. -func (mr *MockRoundTripCloserMockRecorder) Close() *RoundTripCloserCloseCall { +func (mr *MockRoundTripCloserMockRecorder) Close() *MockRoundTripCloserCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRoundTripCloser)(nil).Close)) - return &RoundTripCloserCloseCall{Call: call} + return &MockRoundTripCloserCloseCall{Call: call} } -// RoundTripCloserCloseCall wrap *gomock.Call -type RoundTripCloserCloseCall struct { +// MockRoundTripCloserCloseCall wrap *gomock.Call +type MockRoundTripCloserCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RoundTripCloserCloseCall) Return(arg0 error) *RoundTripCloserCloseCall { +func (c *MockRoundTripCloserCloseCall) Return(arg0 error) *MockRoundTripCloserCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RoundTripCloserCloseCall) Do(f func() error) *RoundTripCloserCloseCall { +func (c *MockRoundTripCloserCloseCall) Do(f func() error) *MockRoundTripCloserCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RoundTripCloserCloseCall) DoAndReturn(f func() error) *RoundTripCloserCloseCall { +func (c *MockRoundTripCloserCloseCall) DoAndReturn(f func() error) *MockRoundTripCloserCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -85,31 +86,31 @@ func (m *MockRoundTripCloser) HandshakeComplete() bool { } // HandshakeComplete indicates an expected call of HandshakeComplete. -func (mr *MockRoundTripCloserMockRecorder) HandshakeComplete() *RoundTripCloserHandshakeCompleteCall { +func (mr *MockRoundTripCloserMockRecorder) HandshakeComplete() *MockRoundTripCloserHandshakeCompleteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandshakeComplete", reflect.TypeOf((*MockRoundTripCloser)(nil).HandshakeComplete)) - return &RoundTripCloserHandshakeCompleteCall{Call: call} + return &MockRoundTripCloserHandshakeCompleteCall{Call: call} } -// RoundTripCloserHandshakeCompleteCall wrap *gomock.Call -type RoundTripCloserHandshakeCompleteCall struct { +// MockRoundTripCloserHandshakeCompleteCall wrap *gomock.Call +type MockRoundTripCloserHandshakeCompleteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RoundTripCloserHandshakeCompleteCall) Return(arg0 bool) *RoundTripCloserHandshakeCompleteCall { +func (c *MockRoundTripCloserHandshakeCompleteCall) Return(arg0 bool) *MockRoundTripCloserHandshakeCompleteCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RoundTripCloserHandshakeCompleteCall) Do(f func() bool) *RoundTripCloserHandshakeCompleteCall { +func (c *MockRoundTripCloserHandshakeCompleteCall) Do(f func() bool) *MockRoundTripCloserHandshakeCompleteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RoundTripCloserHandshakeCompleteCall) DoAndReturn(f func() bool) *RoundTripCloserHandshakeCompleteCall { +func (c *MockRoundTripCloserHandshakeCompleteCall) DoAndReturn(f func() bool) *MockRoundTripCloserHandshakeCompleteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockRoundTripCloser) RoundTripOpt(arg0 *http.Request, arg1 RoundTripOpt } // RoundTripOpt indicates an expected call of RoundTripOpt. -func (mr *MockRoundTripCloserMockRecorder) RoundTripOpt(arg0, arg1 any) *RoundTripCloserRoundTripOptCall { +func (mr *MockRoundTripCloserMockRecorder) RoundTripOpt(arg0, arg1 any) *MockRoundTripCloserRoundTripOptCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RoundTripOpt", reflect.TypeOf((*MockRoundTripCloser)(nil).RoundTripOpt), arg0, arg1) - return &RoundTripCloserRoundTripOptCall{Call: call} + return &MockRoundTripCloserRoundTripOptCall{Call: call} } -// RoundTripCloserRoundTripOptCall wrap *gomock.Call -type RoundTripCloserRoundTripOptCall struct { +// MockRoundTripCloserRoundTripOptCall wrap *gomock.Call +type MockRoundTripCloserRoundTripOptCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RoundTripCloserRoundTripOptCall) Return(arg0 *http.Response, arg1 error) *RoundTripCloserRoundTripOptCall { +func (c *MockRoundTripCloserRoundTripOptCall) Return(arg0 *http.Response, arg1 error) *MockRoundTripCloserRoundTripOptCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *RoundTripCloserRoundTripOptCall) Do(f func(*http.Request, RoundTripOpt) (*http.Response, error)) *RoundTripCloserRoundTripOptCall { +func (c *MockRoundTripCloserRoundTripOptCall) Do(f func(*http.Request, RoundTripOpt) (*http.Response, error)) *MockRoundTripCloserRoundTripOptCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RoundTripCloserRoundTripOptCall) DoAndReturn(f func(*http.Request, RoundTripOpt) (*http.Response, error)) *RoundTripCloserRoundTripOptCall { +func (c *MockRoundTripCloserRoundTripOptCall) DoAndReturn(f func(*http.Request, RoundTripOpt) (*http.Response, error)) *MockRoundTripCloserRoundTripOptCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/integrationtests/gomodvendor/go.mod b/integrationtests/gomodvendor/go.mod index a9ac6c32..106f783e 100644 --- a/integrationtests/gomodvendor/go.mod +++ b/integrationtests/gomodvendor/go.mod @@ -10,7 +10,7 @@ require ( github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 // indirect github.com/onsi/ginkgo/v2 v2.9.5 // indirect github.com/quic-go/qpack v0.4.0 // indirect - go.uber.org/mock v0.3.0 // indirect + go.uber.org/mock v0.4.0 // indirect golang.org/x/crypto v0.4.0 // indirect golang.org/x/exp v0.0.0-20221205204356-47842c84f3db // indirect golang.org/x/mod v0.11.0 // indirect diff --git a/integrationtests/gomodvendor/go.sum b/integrationtests/gomodvendor/go.sum index b03fcbd1..46feb463 100644 --- a/integrationtests/gomodvendor/go.sum +++ b/integrationtests/gomodvendor/go.sum @@ -26,8 +26,8 @@ github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo= -go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/crypto v0.4.0 h1:UVQgzMY87xqpKNgb+kDsll2Igd33HszWHFLmpaRMq/8= golang.org/x/crypto v0.4.0/go.mod h1:3quD/ATkf6oY+rnes5c3ExXTbLc8mueNue5/DoinL80= golang.org/x/exp v0.0.0-20221205204356-47842c84f3db h1:D/cFflL63o2KSLJIwjlcIt8PR064j/xsmdEJL/YvY/o= diff --git a/internal/ackhandler/mock_ecn_handler_test.go b/internal/ackhandler/mock_ecn_handler_test.go index 194ab891..42cd0ff1 100644 --- a/internal/ackhandler/mock_ecn_handler_test.go +++ b/internal/ackhandler/mock_ecn_handler_test.go @@ -5,6 +5,7 @@ // // mockgen -build_flags=-tags=gomock -package ackhandler -destination mock_ecn_handler_test.go github.com/quic-go/quic-go/internal/ackhandler ECNHandler // + // Package ackhandler is a generated GoMock package. package ackhandler diff --git a/internal/ackhandler/mock_sent_packet_tracker_test.go b/internal/ackhandler/mock_sent_packet_tracker_test.go index 3e41b255..8c658137 100644 --- a/internal/ackhandler/mock_sent_packet_tracker_test.go +++ b/internal/ackhandler/mock_sent_packet_tracker_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package ackhandler -destination mock_sent_packet_tracker_test.go github.com/quic-go/quic-go/internal/ackhandler SentPacketTracker // + // Package ackhandler is a generated GoMock package. package ackhandler @@ -47,31 +48,31 @@ func (m *MockSentPacketTracker) GetLowestPacketNotConfirmedAcked() protocol.Pack } // GetLowestPacketNotConfirmedAcked indicates an expected call of GetLowestPacketNotConfirmedAcked. -func (mr *MockSentPacketTrackerMockRecorder) GetLowestPacketNotConfirmedAcked() *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall { +func (mr *MockSentPacketTrackerMockRecorder) GetLowestPacketNotConfirmedAcked() *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLowestPacketNotConfirmedAcked", reflect.TypeOf((*MockSentPacketTracker)(nil).GetLowestPacketNotConfirmedAcked)) - return &SentPacketTrackerGetLowestPacketNotConfirmedAckedCall{Call: call} + return &MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall{Call: call} } -// SentPacketTrackerGetLowestPacketNotConfirmedAckedCall wrap *gomock.Call -type SentPacketTrackerGetLowestPacketNotConfirmedAckedCall struct { +// MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall wrap *gomock.Call +type MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall) Return(arg0 protocol.PacketNumber) *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall { +func (c *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall) Return(arg0 protocol.PacketNumber) *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall) Do(f func() protocol.PacketNumber) *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall { +func (c *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall) Do(f func() protocol.PacketNumber) *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall) DoAndReturn(f func() protocol.PacketNumber) *SentPacketTrackerGetLowestPacketNotConfirmedAckedCall { +func (c *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall) DoAndReturn(f func() protocol.PacketNumber) *MockSentPacketTrackerGetLowestPacketNotConfirmedAckedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockSentPacketTracker) ReceivedPacket(arg0 protocol.EncryptionLevel) { } // ReceivedPacket indicates an expected call of ReceivedPacket. -func (mr *MockSentPacketTrackerMockRecorder) ReceivedPacket(arg0 any) *SentPacketTrackerReceivedPacketCall { +func (mr *MockSentPacketTrackerMockRecorder) ReceivedPacket(arg0 any) *MockSentPacketTrackerReceivedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockSentPacketTracker)(nil).ReceivedPacket), arg0) - return &SentPacketTrackerReceivedPacketCall{Call: call} + return &MockSentPacketTrackerReceivedPacketCall{Call: call} } -// SentPacketTrackerReceivedPacketCall wrap *gomock.Call -type SentPacketTrackerReceivedPacketCall struct { +// MockSentPacketTrackerReceivedPacketCall wrap *gomock.Call +type MockSentPacketTrackerReceivedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketTrackerReceivedPacketCall) Return() *SentPacketTrackerReceivedPacketCall { +func (c *MockSentPacketTrackerReceivedPacketCall) Return() *MockSentPacketTrackerReceivedPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketTrackerReceivedPacketCall) Do(f func(protocol.EncryptionLevel)) *SentPacketTrackerReceivedPacketCall { +func (c *MockSentPacketTrackerReceivedPacketCall) Do(f func(protocol.EncryptionLevel)) *MockSentPacketTrackerReceivedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketTrackerReceivedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel)) *SentPacketTrackerReceivedPacketCall { +func (c *MockSentPacketTrackerReceivedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockSentPacketTrackerReceivedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/ackhandler/received_packet_handler.go b/internal/mocks/ackhandler/received_packet_handler.go index c94cd889..c9c0fd57 100644 --- a/internal/mocks/ackhandler/received_packet_handler.go +++ b/internal/mocks/ackhandler/received_packet_handler.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mockackhandler -destination ackhandler/received_packet_handler.go github.com/quic-go/quic-go/internal/ackhandler ReceivedPacketHandler // + // Package mockackhandler is a generated GoMock package. package mockackhandler @@ -47,31 +48,31 @@ func (m *MockReceivedPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) { } // DropPackets indicates an expected call of DropPackets. -func (mr *MockReceivedPacketHandlerMockRecorder) DropPackets(arg0 any) *ReceivedPacketHandlerDropPacketsCall { +func (mr *MockReceivedPacketHandlerMockRecorder) DropPackets(arg0 any) *MockReceivedPacketHandlerDropPacketsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropPackets", reflect.TypeOf((*MockReceivedPacketHandler)(nil).DropPackets), arg0) - return &ReceivedPacketHandlerDropPacketsCall{Call: call} + return &MockReceivedPacketHandlerDropPacketsCall{Call: call} } -// ReceivedPacketHandlerDropPacketsCall wrap *gomock.Call -type ReceivedPacketHandlerDropPacketsCall struct { +// MockReceivedPacketHandlerDropPacketsCall wrap *gomock.Call +type MockReceivedPacketHandlerDropPacketsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceivedPacketHandlerDropPacketsCall) Return() *ReceivedPacketHandlerDropPacketsCall { +func (c *MockReceivedPacketHandlerDropPacketsCall) Return() *MockReceivedPacketHandlerDropPacketsCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ReceivedPacketHandlerDropPacketsCall) Do(f func(protocol.EncryptionLevel)) *ReceivedPacketHandlerDropPacketsCall { +func (c *MockReceivedPacketHandlerDropPacketsCall) Do(f func(protocol.EncryptionLevel)) *MockReceivedPacketHandlerDropPacketsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceivedPacketHandlerDropPacketsCall) DoAndReturn(f func(protocol.EncryptionLevel)) *ReceivedPacketHandlerDropPacketsCall { +func (c *MockReceivedPacketHandlerDropPacketsCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockReceivedPacketHandlerDropPacketsCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -85,31 +86,31 @@ func (m *MockReceivedPacketHandler) GetAckFrame(arg0 protocol.EncryptionLevel, a } // GetAckFrame indicates an expected call of GetAckFrame. -func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0, arg1 any) *ReceivedPacketHandlerGetAckFrameCall { +func (mr *MockReceivedPacketHandlerMockRecorder) GetAckFrame(arg0, arg1 any) *MockReceivedPacketHandlerGetAckFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAckFrame), arg0, arg1) - return &ReceivedPacketHandlerGetAckFrameCall{Call: call} + return &MockReceivedPacketHandlerGetAckFrameCall{Call: call} } -// ReceivedPacketHandlerGetAckFrameCall wrap *gomock.Call -type ReceivedPacketHandlerGetAckFrameCall struct { +// MockReceivedPacketHandlerGetAckFrameCall wrap *gomock.Call +type MockReceivedPacketHandlerGetAckFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceivedPacketHandlerGetAckFrameCall) Return(arg0 *wire.AckFrame) *ReceivedPacketHandlerGetAckFrameCall { +func (c *MockReceivedPacketHandlerGetAckFrameCall) Return(arg0 *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceivedPacketHandlerGetAckFrameCall) Do(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *ReceivedPacketHandlerGetAckFrameCall { +func (c *MockReceivedPacketHandlerGetAckFrameCall) Do(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceivedPacketHandlerGetAckFrameCall) DoAndReturn(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *ReceivedPacketHandlerGetAckFrameCall { +func (c *MockReceivedPacketHandlerGetAckFrameCall) DoAndReturn(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *MockReceivedPacketHandlerGetAckFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -123,31 +124,31 @@ func (m *MockReceivedPacketHandler) GetAlarmTimeout() time.Time { } // GetAlarmTimeout indicates an expected call of GetAlarmTimeout. -func (mr *MockReceivedPacketHandlerMockRecorder) GetAlarmTimeout() *ReceivedPacketHandlerGetAlarmTimeoutCall { +func (mr *MockReceivedPacketHandlerMockRecorder) GetAlarmTimeout() *MockReceivedPacketHandlerGetAlarmTimeoutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmTimeout", reflect.TypeOf((*MockReceivedPacketHandler)(nil).GetAlarmTimeout)) - return &ReceivedPacketHandlerGetAlarmTimeoutCall{Call: call} + return &MockReceivedPacketHandlerGetAlarmTimeoutCall{Call: call} } -// ReceivedPacketHandlerGetAlarmTimeoutCall wrap *gomock.Call -type ReceivedPacketHandlerGetAlarmTimeoutCall struct { +// MockReceivedPacketHandlerGetAlarmTimeoutCall wrap *gomock.Call +type MockReceivedPacketHandlerGetAlarmTimeoutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceivedPacketHandlerGetAlarmTimeoutCall) Return(arg0 time.Time) *ReceivedPacketHandlerGetAlarmTimeoutCall { +func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) Return(arg0 time.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceivedPacketHandlerGetAlarmTimeoutCall) Do(f func() time.Time) *ReceivedPacketHandlerGetAlarmTimeoutCall { +func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) Do(f func() time.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceivedPacketHandlerGetAlarmTimeoutCall) DoAndReturn(f func() time.Time) *ReceivedPacketHandlerGetAlarmTimeoutCall { +func (c *MockReceivedPacketHandlerGetAlarmTimeoutCall) DoAndReturn(f func() time.Time) *MockReceivedPacketHandlerGetAlarmTimeoutCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -161,31 +162,31 @@ func (m *MockReceivedPacketHandler) IsPotentiallyDuplicate(arg0 protocol.PacketN } // IsPotentiallyDuplicate indicates an expected call of IsPotentiallyDuplicate. -func (mr *MockReceivedPacketHandlerMockRecorder) IsPotentiallyDuplicate(arg0, arg1 any) *ReceivedPacketHandlerIsPotentiallyDuplicateCall { +func (mr *MockReceivedPacketHandlerMockRecorder) IsPotentiallyDuplicate(arg0, arg1 any) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPotentiallyDuplicate", reflect.TypeOf((*MockReceivedPacketHandler)(nil).IsPotentiallyDuplicate), arg0, arg1) - return &ReceivedPacketHandlerIsPotentiallyDuplicateCall{Call: call} + return &MockReceivedPacketHandlerIsPotentiallyDuplicateCall{Call: call} } -// ReceivedPacketHandlerIsPotentiallyDuplicateCall wrap *gomock.Call -type ReceivedPacketHandlerIsPotentiallyDuplicateCall struct { +// MockReceivedPacketHandlerIsPotentiallyDuplicateCall wrap *gomock.Call +type MockReceivedPacketHandlerIsPotentiallyDuplicateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceivedPacketHandlerIsPotentiallyDuplicateCall) Return(arg0 bool) *ReceivedPacketHandlerIsPotentiallyDuplicateCall { +func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) Return(arg0 bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceivedPacketHandlerIsPotentiallyDuplicateCall) Do(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *ReceivedPacketHandlerIsPotentiallyDuplicateCall { +func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) Do(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceivedPacketHandlerIsPotentiallyDuplicateCall) DoAndReturn(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *ReceivedPacketHandlerIsPotentiallyDuplicateCall { +func (c *MockReceivedPacketHandlerIsPotentiallyDuplicateCall) DoAndReturn(f func(protocol.PacketNumber, protocol.EncryptionLevel) bool) *MockReceivedPacketHandlerIsPotentiallyDuplicateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -199,31 +200,31 @@ func (m *MockReceivedPacketHandler) ReceivedPacket(arg0 protocol.PacketNumber, a } // ReceivedPacket indicates an expected call of ReceivedPacket. -func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3, arg4 any) *ReceivedPacketHandlerReceivedPacketCall { +func (mr *MockReceivedPacketHandlerMockRecorder) ReceivedPacket(arg0, arg1, arg2, arg3, arg4 any) *MockReceivedPacketHandlerReceivedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedPacket", reflect.TypeOf((*MockReceivedPacketHandler)(nil).ReceivedPacket), arg0, arg1, arg2, arg3, arg4) - return &ReceivedPacketHandlerReceivedPacketCall{Call: call} + return &MockReceivedPacketHandlerReceivedPacketCall{Call: call} } -// ReceivedPacketHandlerReceivedPacketCall wrap *gomock.Call -type ReceivedPacketHandlerReceivedPacketCall struct { +// MockReceivedPacketHandlerReceivedPacketCall wrap *gomock.Call +type MockReceivedPacketHandlerReceivedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceivedPacketHandlerReceivedPacketCall) Return(arg0 error) *ReceivedPacketHandlerReceivedPacketCall { +func (c *MockReceivedPacketHandlerReceivedPacketCall) Return(arg0 error) *MockReceivedPacketHandlerReceivedPacketCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceivedPacketHandlerReceivedPacketCall) Do(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, time.Time, bool) error) *ReceivedPacketHandlerReceivedPacketCall { +func (c *MockReceivedPacketHandlerReceivedPacketCall) Do(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, time.Time, bool) error) *MockReceivedPacketHandlerReceivedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceivedPacketHandlerReceivedPacketCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, time.Time, bool) error) *ReceivedPacketHandlerReceivedPacketCall { +func (c *MockReceivedPacketHandlerReceivedPacketCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ECN, protocol.EncryptionLevel, time.Time, bool) error) *MockReceivedPacketHandlerReceivedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/ackhandler/sent_packet_handler.go b/internal/mocks/ackhandler/sent_packet_handler.go index 343b4b6e..9efeb9be 100644 --- a/internal/mocks/ackhandler/sent_packet_handler.go +++ b/internal/mocks/ackhandler/sent_packet_handler.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mockackhandler -destination ackhandler/sent_packet_handler.go github.com/quic-go/quic-go/internal/ackhandler SentPacketHandler // + // Package mockackhandler is a generated GoMock package. package mockackhandler @@ -48,31 +49,31 @@ func (m *MockSentPacketHandler) DropPackets(arg0 protocol.EncryptionLevel) { } // DropPackets indicates an expected call of DropPackets. -func (mr *MockSentPacketHandlerMockRecorder) DropPackets(arg0 any) *SentPacketHandlerDropPacketsCall { +func (mr *MockSentPacketHandlerMockRecorder) DropPackets(arg0 any) *MockSentPacketHandlerDropPacketsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropPackets", reflect.TypeOf((*MockSentPacketHandler)(nil).DropPackets), arg0) - return &SentPacketHandlerDropPacketsCall{Call: call} + return &MockSentPacketHandlerDropPacketsCall{Call: call} } -// SentPacketHandlerDropPacketsCall wrap *gomock.Call -type SentPacketHandlerDropPacketsCall struct { +// MockSentPacketHandlerDropPacketsCall wrap *gomock.Call +type MockSentPacketHandlerDropPacketsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerDropPacketsCall) Return() *SentPacketHandlerDropPacketsCall { +func (c *MockSentPacketHandlerDropPacketsCall) Return() *MockSentPacketHandlerDropPacketsCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerDropPacketsCall) Do(f func(protocol.EncryptionLevel)) *SentPacketHandlerDropPacketsCall { +func (c *MockSentPacketHandlerDropPacketsCall) Do(f func(protocol.EncryptionLevel)) *MockSentPacketHandlerDropPacketsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerDropPacketsCall) DoAndReturn(f func(protocol.EncryptionLevel)) *SentPacketHandlerDropPacketsCall { +func (c *MockSentPacketHandlerDropPacketsCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockSentPacketHandlerDropPacketsCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockSentPacketHandler) ECNMode(arg0 bool) protocol.ECN { } // ECNMode indicates an expected call of ECNMode. -func (mr *MockSentPacketHandlerMockRecorder) ECNMode(arg0 any) *SentPacketHandlerECNModeCall { +func (mr *MockSentPacketHandlerMockRecorder) ECNMode(arg0 any) *MockSentPacketHandlerECNModeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ECNMode", reflect.TypeOf((*MockSentPacketHandler)(nil).ECNMode), arg0) - return &SentPacketHandlerECNModeCall{Call: call} + return &MockSentPacketHandlerECNModeCall{Call: call} } -// SentPacketHandlerECNModeCall wrap *gomock.Call -type SentPacketHandlerECNModeCall struct { +// MockSentPacketHandlerECNModeCall wrap *gomock.Call +type MockSentPacketHandlerECNModeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerECNModeCall) Return(arg0 protocol.ECN) *SentPacketHandlerECNModeCall { +func (c *MockSentPacketHandlerECNModeCall) Return(arg0 protocol.ECN) *MockSentPacketHandlerECNModeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerECNModeCall) Do(f func(bool) protocol.ECN) *SentPacketHandlerECNModeCall { +func (c *MockSentPacketHandlerECNModeCall) Do(f func(bool) protocol.ECN) *MockSentPacketHandlerECNModeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerECNModeCall) DoAndReturn(f func(bool) protocol.ECN) *SentPacketHandlerECNModeCall { +func (c *MockSentPacketHandlerECNModeCall) DoAndReturn(f func(bool) protocol.ECN) *MockSentPacketHandlerECNModeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockSentPacketHandler) GetLossDetectionTimeout() time.Time { } // GetLossDetectionTimeout indicates an expected call of GetLossDetectionTimeout. -func (mr *MockSentPacketHandlerMockRecorder) GetLossDetectionTimeout() *SentPacketHandlerGetLossDetectionTimeoutCall { +func (mr *MockSentPacketHandlerMockRecorder) GetLossDetectionTimeout() *MockSentPacketHandlerGetLossDetectionTimeoutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLossDetectionTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).GetLossDetectionTimeout)) - return &SentPacketHandlerGetLossDetectionTimeoutCall{Call: call} + return &MockSentPacketHandlerGetLossDetectionTimeoutCall{Call: call} } -// SentPacketHandlerGetLossDetectionTimeoutCall wrap *gomock.Call -type SentPacketHandlerGetLossDetectionTimeoutCall struct { +// MockSentPacketHandlerGetLossDetectionTimeoutCall wrap *gomock.Call +type MockSentPacketHandlerGetLossDetectionTimeoutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerGetLossDetectionTimeoutCall) Return(arg0 time.Time) *SentPacketHandlerGetLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerGetLossDetectionTimeoutCall) Return(arg0 time.Time) *MockSentPacketHandlerGetLossDetectionTimeoutCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerGetLossDetectionTimeoutCall) Do(f func() time.Time) *SentPacketHandlerGetLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerGetLossDetectionTimeoutCall) Do(f func() time.Time) *MockSentPacketHandlerGetLossDetectionTimeoutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerGetLossDetectionTimeoutCall) DoAndReturn(f func() time.Time) *SentPacketHandlerGetLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerGetLossDetectionTimeoutCall) DoAndReturn(f func() time.Time) *MockSentPacketHandlerGetLossDetectionTimeoutCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockSentPacketHandler) OnLossDetectionTimeout() error { } // OnLossDetectionTimeout indicates an expected call of OnLossDetectionTimeout. -func (mr *MockSentPacketHandlerMockRecorder) OnLossDetectionTimeout() *SentPacketHandlerOnLossDetectionTimeoutCall { +func (mr *MockSentPacketHandlerMockRecorder) OnLossDetectionTimeout() *MockSentPacketHandlerOnLossDetectionTimeoutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnLossDetectionTimeout", reflect.TypeOf((*MockSentPacketHandler)(nil).OnLossDetectionTimeout)) - return &SentPacketHandlerOnLossDetectionTimeoutCall{Call: call} + return &MockSentPacketHandlerOnLossDetectionTimeoutCall{Call: call} } -// SentPacketHandlerOnLossDetectionTimeoutCall wrap *gomock.Call -type SentPacketHandlerOnLossDetectionTimeoutCall struct { +// MockSentPacketHandlerOnLossDetectionTimeoutCall wrap *gomock.Call +type MockSentPacketHandlerOnLossDetectionTimeoutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerOnLossDetectionTimeoutCall) Return(arg0 error) *SentPacketHandlerOnLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerOnLossDetectionTimeoutCall) Return(arg0 error) *MockSentPacketHandlerOnLossDetectionTimeoutCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerOnLossDetectionTimeoutCall) Do(f func() error) *SentPacketHandlerOnLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerOnLossDetectionTimeoutCall) Do(f func() error) *MockSentPacketHandlerOnLossDetectionTimeoutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerOnLossDetectionTimeoutCall) DoAndReturn(f func() error) *SentPacketHandlerOnLossDetectionTimeoutCall { +func (c *MockSentPacketHandlerOnLossDetectionTimeoutCall) DoAndReturn(f func() error) *MockSentPacketHandlerOnLossDetectionTimeoutCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -201,31 +202,31 @@ func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) } // PeekPacketNumber indicates an expected call of PeekPacketNumber. -func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber(arg0 any) *SentPacketHandlerPeekPacketNumberCall { +func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber(arg0 any) *MockSentPacketHandlerPeekPacketNumberCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeekPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PeekPacketNumber), arg0) - return &SentPacketHandlerPeekPacketNumberCall{Call: call} + return &MockSentPacketHandlerPeekPacketNumberCall{Call: call} } -// SentPacketHandlerPeekPacketNumberCall wrap *gomock.Call -type SentPacketHandlerPeekPacketNumberCall struct { +// MockSentPacketHandlerPeekPacketNumberCall wrap *gomock.Call +type MockSentPacketHandlerPeekPacketNumberCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerPeekPacketNumberCall) Return(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) *SentPacketHandlerPeekPacketNumberCall { +func (c *MockSentPacketHandlerPeekPacketNumberCall) Return(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen) *MockSentPacketHandlerPeekPacketNumberCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerPeekPacketNumberCall) Do(f func(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)) *SentPacketHandlerPeekPacketNumberCall { +func (c *MockSentPacketHandlerPeekPacketNumberCall) Do(f func(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)) *MockSentPacketHandlerPeekPacketNumberCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerPeekPacketNumberCall) DoAndReturn(f func(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)) *SentPacketHandlerPeekPacketNumberCall { +func (c *MockSentPacketHandlerPeekPacketNumberCall) DoAndReturn(f func(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)) *MockSentPacketHandlerPeekPacketNumberCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -239,31 +240,31 @@ func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) p } // PopPacketNumber indicates an expected call of PopPacketNumber. -func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber(arg0 any) *SentPacketHandlerPopPacketNumberCall { +func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber(arg0 any) *MockSentPacketHandlerPopPacketNumberCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PopPacketNumber), arg0) - return &SentPacketHandlerPopPacketNumberCall{Call: call} + return &MockSentPacketHandlerPopPacketNumberCall{Call: call} } -// SentPacketHandlerPopPacketNumberCall wrap *gomock.Call -type SentPacketHandlerPopPacketNumberCall struct { +// MockSentPacketHandlerPopPacketNumberCall wrap *gomock.Call +type MockSentPacketHandlerPopPacketNumberCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerPopPacketNumberCall) Return(arg0 protocol.PacketNumber) *SentPacketHandlerPopPacketNumberCall { +func (c *MockSentPacketHandlerPopPacketNumberCall) Return(arg0 protocol.PacketNumber) *MockSentPacketHandlerPopPacketNumberCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerPopPacketNumberCall) Do(f func(protocol.EncryptionLevel) protocol.PacketNumber) *SentPacketHandlerPopPacketNumberCall { +func (c *MockSentPacketHandlerPopPacketNumberCall) Do(f func(protocol.EncryptionLevel) protocol.PacketNumber) *MockSentPacketHandlerPopPacketNumberCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerPopPacketNumberCall) DoAndReturn(f func(protocol.EncryptionLevel) protocol.PacketNumber) *SentPacketHandlerPopPacketNumberCall { +func (c *MockSentPacketHandlerPopPacketNumberCall) DoAndReturn(f func(protocol.EncryptionLevel) protocol.PacketNumber) *MockSentPacketHandlerPopPacketNumberCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -277,31 +278,31 @@ func (m *MockSentPacketHandler) QueueProbePacket(arg0 protocol.EncryptionLevel) } // QueueProbePacket indicates an expected call of QueueProbePacket. -func (mr *MockSentPacketHandlerMockRecorder) QueueProbePacket(arg0 any) *SentPacketHandlerQueueProbePacketCall { +func (mr *MockSentPacketHandlerMockRecorder) QueueProbePacket(arg0 any) *MockSentPacketHandlerQueueProbePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueProbePacket", reflect.TypeOf((*MockSentPacketHandler)(nil).QueueProbePacket), arg0) - return &SentPacketHandlerQueueProbePacketCall{Call: call} + return &MockSentPacketHandlerQueueProbePacketCall{Call: call} } -// SentPacketHandlerQueueProbePacketCall wrap *gomock.Call -type SentPacketHandlerQueueProbePacketCall struct { +// MockSentPacketHandlerQueueProbePacketCall wrap *gomock.Call +type MockSentPacketHandlerQueueProbePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerQueueProbePacketCall) Return(arg0 bool) *SentPacketHandlerQueueProbePacketCall { +func (c *MockSentPacketHandlerQueueProbePacketCall) Return(arg0 bool) *MockSentPacketHandlerQueueProbePacketCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerQueueProbePacketCall) Do(f func(protocol.EncryptionLevel) bool) *SentPacketHandlerQueueProbePacketCall { +func (c *MockSentPacketHandlerQueueProbePacketCall) Do(f func(protocol.EncryptionLevel) bool) *MockSentPacketHandlerQueueProbePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerQueueProbePacketCall) DoAndReturn(f func(protocol.EncryptionLevel) bool) *SentPacketHandlerQueueProbePacketCall { +func (c *MockSentPacketHandlerQueueProbePacketCall) DoAndReturn(f func(protocol.EncryptionLevel) bool) *MockSentPacketHandlerQueueProbePacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -316,31 +317,31 @@ func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.E } // ReceivedAck indicates an expected call of ReceivedAck. -func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2 any) *SentPacketHandlerReceivedAckCall { +func (mr *MockSentPacketHandlerMockRecorder) ReceivedAck(arg0, arg1, arg2 any) *MockSentPacketHandlerReceivedAckCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedAck", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedAck), arg0, arg1, arg2) - return &SentPacketHandlerReceivedAckCall{Call: call} + return &MockSentPacketHandlerReceivedAckCall{Call: call} } -// SentPacketHandlerReceivedAckCall wrap *gomock.Call -type SentPacketHandlerReceivedAckCall struct { +// MockSentPacketHandlerReceivedAckCall wrap *gomock.Call +type MockSentPacketHandlerReceivedAckCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerReceivedAckCall) Return(arg0 bool, arg1 error) *SentPacketHandlerReceivedAckCall { +func (c *MockSentPacketHandlerReceivedAckCall) Return(arg0 bool, arg1 error) *MockSentPacketHandlerReceivedAckCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerReceivedAckCall) Do(f func(*wire.AckFrame, protocol.EncryptionLevel, time.Time) (bool, error)) *SentPacketHandlerReceivedAckCall { +func (c *MockSentPacketHandlerReceivedAckCall) Do(f func(*wire.AckFrame, protocol.EncryptionLevel, time.Time) (bool, error)) *MockSentPacketHandlerReceivedAckCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerReceivedAckCall) DoAndReturn(f func(*wire.AckFrame, protocol.EncryptionLevel, time.Time) (bool, error)) *SentPacketHandlerReceivedAckCall { +func (c *MockSentPacketHandlerReceivedAckCall) DoAndReturn(f func(*wire.AckFrame, protocol.EncryptionLevel, time.Time) (bool, error)) *MockSentPacketHandlerReceivedAckCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -352,31 +353,31 @@ func (m *MockSentPacketHandler) ReceivedBytes(arg0 protocol.ByteCount) { } // ReceivedBytes indicates an expected call of ReceivedBytes. -func (mr *MockSentPacketHandlerMockRecorder) ReceivedBytes(arg0 any) *SentPacketHandlerReceivedBytesCall { +func (mr *MockSentPacketHandlerMockRecorder) ReceivedBytes(arg0 any) *MockSentPacketHandlerReceivedBytesCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedBytes", reflect.TypeOf((*MockSentPacketHandler)(nil).ReceivedBytes), arg0) - return &SentPacketHandlerReceivedBytesCall{Call: call} + return &MockSentPacketHandlerReceivedBytesCall{Call: call} } -// SentPacketHandlerReceivedBytesCall wrap *gomock.Call -type SentPacketHandlerReceivedBytesCall struct { +// MockSentPacketHandlerReceivedBytesCall wrap *gomock.Call +type MockSentPacketHandlerReceivedBytesCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerReceivedBytesCall) Return() *SentPacketHandlerReceivedBytesCall { +func (c *MockSentPacketHandlerReceivedBytesCall) Return() *MockSentPacketHandlerReceivedBytesCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerReceivedBytesCall) Do(f func(protocol.ByteCount)) *SentPacketHandlerReceivedBytesCall { +func (c *MockSentPacketHandlerReceivedBytesCall) Do(f func(protocol.ByteCount)) *MockSentPacketHandlerReceivedBytesCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerReceivedBytesCall) DoAndReturn(f func(protocol.ByteCount)) *SentPacketHandlerReceivedBytesCall { +func (c *MockSentPacketHandlerReceivedBytesCall) DoAndReturn(f func(protocol.ByteCount)) *MockSentPacketHandlerReceivedBytesCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -390,31 +391,31 @@ func (m *MockSentPacketHandler) ResetForRetry(arg0 time.Time) error { } // ResetForRetry indicates an expected call of ResetForRetry. -func (mr *MockSentPacketHandlerMockRecorder) ResetForRetry(arg0 any) *SentPacketHandlerResetForRetryCall { +func (mr *MockSentPacketHandlerMockRecorder) ResetForRetry(arg0 any) *MockSentPacketHandlerResetForRetryCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetForRetry", reflect.TypeOf((*MockSentPacketHandler)(nil).ResetForRetry), arg0) - return &SentPacketHandlerResetForRetryCall{Call: call} + return &MockSentPacketHandlerResetForRetryCall{Call: call} } -// SentPacketHandlerResetForRetryCall wrap *gomock.Call -type SentPacketHandlerResetForRetryCall struct { +// MockSentPacketHandlerResetForRetryCall wrap *gomock.Call +type MockSentPacketHandlerResetForRetryCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerResetForRetryCall) Return(arg0 error) *SentPacketHandlerResetForRetryCall { +func (c *MockSentPacketHandlerResetForRetryCall) Return(arg0 error) *MockSentPacketHandlerResetForRetryCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerResetForRetryCall) Do(f func(time.Time) error) *SentPacketHandlerResetForRetryCall { +func (c *MockSentPacketHandlerResetForRetryCall) Do(f func(time.Time) error) *MockSentPacketHandlerResetForRetryCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerResetForRetryCall) DoAndReturn(f func(time.Time) error) *SentPacketHandlerResetForRetryCall { +func (c *MockSentPacketHandlerResetForRetryCall) DoAndReturn(f func(time.Time) error) *MockSentPacketHandlerResetForRetryCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -428,31 +429,31 @@ func (m *MockSentPacketHandler) SendMode(arg0 time.Time) ackhandler.SendMode { } // SendMode indicates an expected call of SendMode. -func (mr *MockSentPacketHandlerMockRecorder) SendMode(arg0 any) *SentPacketHandlerSendModeCall { +func (mr *MockSentPacketHandlerMockRecorder) SendMode(arg0 any) *MockSentPacketHandlerSendModeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMode", reflect.TypeOf((*MockSentPacketHandler)(nil).SendMode), arg0) - return &SentPacketHandlerSendModeCall{Call: call} + return &MockSentPacketHandlerSendModeCall{Call: call} } -// SentPacketHandlerSendModeCall wrap *gomock.Call -type SentPacketHandlerSendModeCall struct { +// MockSentPacketHandlerSendModeCall wrap *gomock.Call +type MockSentPacketHandlerSendModeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerSendModeCall) Return(arg0 ackhandler.SendMode) *SentPacketHandlerSendModeCall { +func (c *MockSentPacketHandlerSendModeCall) Return(arg0 ackhandler.SendMode) *MockSentPacketHandlerSendModeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerSendModeCall) Do(f func(time.Time) ackhandler.SendMode) *SentPacketHandlerSendModeCall { +func (c *MockSentPacketHandlerSendModeCall) Do(f func(time.Time) ackhandler.SendMode) *MockSentPacketHandlerSendModeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerSendModeCall) DoAndReturn(f func(time.Time) ackhandler.SendMode) *SentPacketHandlerSendModeCall { +func (c *MockSentPacketHandlerSendModeCall) DoAndReturn(f func(time.Time) ackhandler.SendMode) *MockSentPacketHandlerSendModeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -464,31 +465,31 @@ func (m *MockSentPacketHandler) SentPacket(arg0 time.Time, arg1, arg2 protocol.P } // SentPacket indicates an expected call of SentPacket. -func (mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 any) *SentPacketHandlerSentPacketCall { +func (mr *MockSentPacketHandlerMockRecorder) SentPacket(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 any) *MockSentPacketHandlerSentPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockSentPacketHandler)(nil).SentPacket), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) - return &SentPacketHandlerSentPacketCall{Call: call} + return &MockSentPacketHandlerSentPacketCall{Call: call} } -// SentPacketHandlerSentPacketCall wrap *gomock.Call -type SentPacketHandlerSentPacketCall struct { +// MockSentPacketHandlerSentPacketCall wrap *gomock.Call +type MockSentPacketHandlerSentPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerSentPacketCall) Return() *SentPacketHandlerSentPacketCall { +func (c *MockSentPacketHandlerSentPacketCall) Return() *MockSentPacketHandlerSentPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerSentPacketCall) Do(f func(time.Time, protocol.PacketNumber, protocol.PacketNumber, []ackhandler.StreamFrame, []ackhandler.Frame, protocol.EncryptionLevel, protocol.ECN, protocol.ByteCount, bool)) *SentPacketHandlerSentPacketCall { +func (c *MockSentPacketHandlerSentPacketCall) Do(f func(time.Time, protocol.PacketNumber, protocol.PacketNumber, []ackhandler.StreamFrame, []ackhandler.Frame, protocol.EncryptionLevel, protocol.ECN, protocol.ByteCount, bool)) *MockSentPacketHandlerSentPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerSentPacketCall) DoAndReturn(f func(time.Time, protocol.PacketNumber, protocol.PacketNumber, []ackhandler.StreamFrame, []ackhandler.Frame, protocol.EncryptionLevel, protocol.ECN, protocol.ByteCount, bool)) *SentPacketHandlerSentPacketCall { +func (c *MockSentPacketHandlerSentPacketCall) DoAndReturn(f func(time.Time, protocol.PacketNumber, protocol.PacketNumber, []ackhandler.StreamFrame, []ackhandler.Frame, protocol.EncryptionLevel, protocol.ECN, protocol.ByteCount, bool)) *MockSentPacketHandlerSentPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -500,31 +501,31 @@ func (m *MockSentPacketHandler) SetHandshakeConfirmed() { } // SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed. -func (mr *MockSentPacketHandlerMockRecorder) SetHandshakeConfirmed() *SentPacketHandlerSetHandshakeConfirmedCall { +func (mr *MockSentPacketHandlerMockRecorder) SetHandshakeConfirmed() *MockSentPacketHandlerSetHandshakeConfirmedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeConfirmed", reflect.TypeOf((*MockSentPacketHandler)(nil).SetHandshakeConfirmed)) - return &SentPacketHandlerSetHandshakeConfirmedCall{Call: call} + return &MockSentPacketHandlerSetHandshakeConfirmedCall{Call: call} } -// SentPacketHandlerSetHandshakeConfirmedCall wrap *gomock.Call -type SentPacketHandlerSetHandshakeConfirmedCall struct { +// MockSentPacketHandlerSetHandshakeConfirmedCall wrap *gomock.Call +type MockSentPacketHandlerSetHandshakeConfirmedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerSetHandshakeConfirmedCall) Return() *SentPacketHandlerSetHandshakeConfirmedCall { +func (c *MockSentPacketHandlerSetHandshakeConfirmedCall) Return() *MockSentPacketHandlerSetHandshakeConfirmedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerSetHandshakeConfirmedCall) Do(f func()) *SentPacketHandlerSetHandshakeConfirmedCall { +func (c *MockSentPacketHandlerSetHandshakeConfirmedCall) Do(f func()) *MockSentPacketHandlerSetHandshakeConfirmedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerSetHandshakeConfirmedCall) DoAndReturn(f func()) *SentPacketHandlerSetHandshakeConfirmedCall { +func (c *MockSentPacketHandlerSetHandshakeConfirmedCall) DoAndReturn(f func()) *MockSentPacketHandlerSetHandshakeConfirmedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -536,31 +537,31 @@ func (m *MockSentPacketHandler) SetMaxDatagramSize(arg0 protocol.ByteCount) { } // SetMaxDatagramSize indicates an expected call of SetMaxDatagramSize. -func (mr *MockSentPacketHandlerMockRecorder) SetMaxDatagramSize(arg0 any) *SentPacketHandlerSetMaxDatagramSizeCall { +func (mr *MockSentPacketHandlerMockRecorder) SetMaxDatagramSize(arg0 any) *MockSentPacketHandlerSetMaxDatagramSizeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxDatagramSize", reflect.TypeOf((*MockSentPacketHandler)(nil).SetMaxDatagramSize), arg0) - return &SentPacketHandlerSetMaxDatagramSizeCall{Call: call} + return &MockSentPacketHandlerSetMaxDatagramSizeCall{Call: call} } -// SentPacketHandlerSetMaxDatagramSizeCall wrap *gomock.Call -type SentPacketHandlerSetMaxDatagramSizeCall struct { +// MockSentPacketHandlerSetMaxDatagramSizeCall wrap *gomock.Call +type MockSentPacketHandlerSetMaxDatagramSizeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerSetMaxDatagramSizeCall) Return() *SentPacketHandlerSetMaxDatagramSizeCall { +func (c *MockSentPacketHandlerSetMaxDatagramSizeCall) Return() *MockSentPacketHandlerSetMaxDatagramSizeCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerSetMaxDatagramSizeCall) Do(f func(protocol.ByteCount)) *SentPacketHandlerSetMaxDatagramSizeCall { +func (c *MockSentPacketHandlerSetMaxDatagramSizeCall) Do(f func(protocol.ByteCount)) *MockSentPacketHandlerSetMaxDatagramSizeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerSetMaxDatagramSizeCall) DoAndReturn(f func(protocol.ByteCount)) *SentPacketHandlerSetMaxDatagramSizeCall { +func (c *MockSentPacketHandlerSetMaxDatagramSizeCall) DoAndReturn(f func(protocol.ByteCount)) *MockSentPacketHandlerSetMaxDatagramSizeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -574,31 +575,31 @@ func (m *MockSentPacketHandler) TimeUntilSend() time.Time { } // TimeUntilSend indicates an expected call of TimeUntilSend. -func (mr *MockSentPacketHandlerMockRecorder) TimeUntilSend() *SentPacketHandlerTimeUntilSendCall { +func (mr *MockSentPacketHandlerMockRecorder) TimeUntilSend() *MockSentPacketHandlerTimeUntilSendCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeUntilSend", reflect.TypeOf((*MockSentPacketHandler)(nil).TimeUntilSend)) - return &SentPacketHandlerTimeUntilSendCall{Call: call} + return &MockSentPacketHandlerTimeUntilSendCall{Call: call} } -// SentPacketHandlerTimeUntilSendCall wrap *gomock.Call -type SentPacketHandlerTimeUntilSendCall struct { +// MockSentPacketHandlerTimeUntilSendCall wrap *gomock.Call +type MockSentPacketHandlerTimeUntilSendCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SentPacketHandlerTimeUntilSendCall) Return(arg0 time.Time) *SentPacketHandlerTimeUntilSendCall { +func (c *MockSentPacketHandlerTimeUntilSendCall) Return(arg0 time.Time) *MockSentPacketHandlerTimeUntilSendCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SentPacketHandlerTimeUntilSendCall) Do(f func() time.Time) *SentPacketHandlerTimeUntilSendCall { +func (c *MockSentPacketHandlerTimeUntilSendCall) Do(f func() time.Time) *MockSentPacketHandlerTimeUntilSendCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SentPacketHandlerTimeUntilSendCall) DoAndReturn(f func() time.Time) *SentPacketHandlerTimeUntilSendCall { +func (c *MockSentPacketHandlerTimeUntilSendCall) DoAndReturn(f func() time.Time) *MockSentPacketHandlerTimeUntilSendCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/congestion.go b/internal/mocks/congestion.go index 14638b75..50654c0e 100644 --- a/internal/mocks/congestion.go +++ b/internal/mocks/congestion.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination congestion.go github.com/quic-go/quic-go/internal/congestion SendAlgorithmWithDebugInfos // + // Package mocks is a generated GoMock package. package mocks @@ -48,31 +49,31 @@ func (m *MockSendAlgorithmWithDebugInfos) CanSend(arg0 protocol.ByteCount) bool } // CanSend indicates an expected call of CanSend. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) CanSend(arg0 any) *SendAlgorithmWithDebugInfosCanSendCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) CanSend(arg0 any) *MockSendAlgorithmWithDebugInfosCanSendCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanSend", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).CanSend), arg0) - return &SendAlgorithmWithDebugInfosCanSendCall{Call: call} + return &MockSendAlgorithmWithDebugInfosCanSendCall{Call: call} } -// SendAlgorithmWithDebugInfosCanSendCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosCanSendCall struct { +// MockSendAlgorithmWithDebugInfosCanSendCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosCanSendCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosCanSendCall) Return(arg0 bool) *SendAlgorithmWithDebugInfosCanSendCall { +func (c *MockSendAlgorithmWithDebugInfosCanSendCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosCanSendCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosCanSendCall) Do(f func(protocol.ByteCount) bool) *SendAlgorithmWithDebugInfosCanSendCall { +func (c *MockSendAlgorithmWithDebugInfosCanSendCall) Do(f func(protocol.ByteCount) bool) *MockSendAlgorithmWithDebugInfosCanSendCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosCanSendCall) DoAndReturn(f func(protocol.ByteCount) bool) *SendAlgorithmWithDebugInfosCanSendCall { +func (c *MockSendAlgorithmWithDebugInfosCanSendCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockSendAlgorithmWithDebugInfosCanSendCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockSendAlgorithmWithDebugInfos) GetCongestionWindow() protocol.ByteCou } // GetCongestionWindow indicates an expected call of GetCongestionWindow. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow() *SendAlgorithmWithDebugInfosGetCongestionWindowCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) GetCongestionWindow() *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCongestionWindow", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).GetCongestionWindow)) - return &SendAlgorithmWithDebugInfosGetCongestionWindowCall{Call: call} + return &MockSendAlgorithmWithDebugInfosGetCongestionWindowCall{Call: call} } -// SendAlgorithmWithDebugInfosGetCongestionWindowCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosGetCongestionWindowCall struct { +// MockSendAlgorithmWithDebugInfosGetCongestionWindowCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosGetCongestionWindowCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosGetCongestionWindowCall) Return(arg0 protocol.ByteCount) *SendAlgorithmWithDebugInfosGetCongestionWindowCall { +func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Return(arg0 protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosGetCongestionWindowCall) Do(f func() protocol.ByteCount) *SendAlgorithmWithDebugInfosGetCongestionWindowCall { +func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) Do(f func() protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosGetCongestionWindowCall) DoAndReturn(f func() protocol.ByteCount) *SendAlgorithmWithDebugInfosGetCongestionWindowCall { +func (c *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall) DoAndReturn(f func() protocol.ByteCount) *MockSendAlgorithmWithDebugInfosGetCongestionWindowCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockSendAlgorithmWithDebugInfos) HasPacingBudget(arg0 time.Time) bool { } // HasPacingBudget indicates an expected call of HasPacingBudget. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget(arg0 any) *SendAlgorithmWithDebugInfosHasPacingBudgetCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) HasPacingBudget(arg0 any) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasPacingBudget", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).HasPacingBudget), arg0) - return &SendAlgorithmWithDebugInfosHasPacingBudgetCall{Call: call} + return &MockSendAlgorithmWithDebugInfosHasPacingBudgetCall{Call: call} } -// SendAlgorithmWithDebugInfosHasPacingBudgetCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosHasPacingBudgetCall struct { +// MockSendAlgorithmWithDebugInfosHasPacingBudgetCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosHasPacingBudgetCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosHasPacingBudgetCall) Return(arg0 bool) *SendAlgorithmWithDebugInfosHasPacingBudgetCall { +func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosHasPacingBudgetCall) Do(f func(time.Time) bool) *SendAlgorithmWithDebugInfosHasPacingBudgetCall { +func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) Do(f func(time.Time) bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosHasPacingBudgetCall) DoAndReturn(f func(time.Time) bool) *SendAlgorithmWithDebugInfosHasPacingBudgetCall { +func (c *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall) DoAndReturn(f func(time.Time) bool) *MockSendAlgorithmWithDebugInfosHasPacingBudgetCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockSendAlgorithmWithDebugInfos) InRecovery() bool { } // InRecovery indicates an expected call of InRecovery. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery() *SendAlgorithmWithDebugInfosInRecoveryCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InRecovery() *MockSendAlgorithmWithDebugInfosInRecoveryCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InRecovery", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).InRecovery)) - return &SendAlgorithmWithDebugInfosInRecoveryCall{Call: call} + return &MockSendAlgorithmWithDebugInfosInRecoveryCall{Call: call} } -// SendAlgorithmWithDebugInfosInRecoveryCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosInRecoveryCall struct { +// MockSendAlgorithmWithDebugInfosInRecoveryCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosInRecoveryCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosInRecoveryCall) Return(arg0 bool) *SendAlgorithmWithDebugInfosInRecoveryCall { +func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosInRecoveryCall) Do(f func() bool) *SendAlgorithmWithDebugInfosInRecoveryCall { +func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) Do(f func() bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosInRecoveryCall) DoAndReturn(f func() bool) *SendAlgorithmWithDebugInfosInRecoveryCall { +func (c *MockSendAlgorithmWithDebugInfosInRecoveryCall) DoAndReturn(f func() bool) *MockSendAlgorithmWithDebugInfosInRecoveryCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -200,31 +201,31 @@ func (m *MockSendAlgorithmWithDebugInfos) InSlowStart() bool { } // InSlowStart indicates an expected call of InSlowStart. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart() *SendAlgorithmWithDebugInfosInSlowStartCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) InSlowStart() *MockSendAlgorithmWithDebugInfosInSlowStartCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InSlowStart", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).InSlowStart)) - return &SendAlgorithmWithDebugInfosInSlowStartCall{Call: call} + return &MockSendAlgorithmWithDebugInfosInSlowStartCall{Call: call} } -// SendAlgorithmWithDebugInfosInSlowStartCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosInSlowStartCall struct { +// MockSendAlgorithmWithDebugInfosInSlowStartCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosInSlowStartCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosInSlowStartCall) Return(arg0 bool) *SendAlgorithmWithDebugInfosInSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) Return(arg0 bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosInSlowStartCall) Do(f func() bool) *SendAlgorithmWithDebugInfosInSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) Do(f func() bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosInSlowStartCall) DoAndReturn(f func() bool) *SendAlgorithmWithDebugInfosInSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosInSlowStartCall) DoAndReturn(f func() bool) *MockSendAlgorithmWithDebugInfosInSlowStartCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -236,31 +237,31 @@ func (m *MockSendAlgorithmWithDebugInfos) MaybeExitSlowStart() { } // MaybeExitSlowStart indicates an expected call of MaybeExitSlowStart. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart() *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) MaybeExitSlowStart() *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybeExitSlowStart", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).MaybeExitSlowStart)) - return &SendAlgorithmWithDebugInfosMaybeExitSlowStartCall{Call: call} + return &MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall{Call: call} } -// SendAlgorithmWithDebugInfosMaybeExitSlowStartCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosMaybeExitSlowStartCall struct { +// MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Return() *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Return() *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Do(f func()) *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) Do(f func()) *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall) DoAndReturn(f func()) *SendAlgorithmWithDebugInfosMaybeExitSlowStartCall { +func (c *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall) DoAndReturn(f func()) *MockSendAlgorithmWithDebugInfosMaybeExitSlowStartCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -272,31 +273,31 @@ func (m *MockSendAlgorithmWithDebugInfos) OnCongestionEvent(arg0 protocol.Packet } // OnCongestionEvent indicates an expected call of OnCongestionEvent. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnCongestionEvent(arg0, arg1, arg2 any) *SendAlgorithmWithDebugInfosOnCongestionEventCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnCongestionEvent(arg0, arg1, arg2 any) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnCongestionEvent", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnCongestionEvent), arg0, arg1, arg2) - return &SendAlgorithmWithDebugInfosOnCongestionEventCall{Call: call} + return &MockSendAlgorithmWithDebugInfosOnCongestionEventCall{Call: call} } -// SendAlgorithmWithDebugInfosOnCongestionEventCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosOnCongestionEventCall struct { +// MockSendAlgorithmWithDebugInfosOnCongestionEventCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosOnCongestionEventCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosOnCongestionEventCall) Return() *SendAlgorithmWithDebugInfosOnCongestionEventCall { +func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Return() *MockSendAlgorithmWithDebugInfosOnCongestionEventCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosOnCongestionEventCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *SendAlgorithmWithDebugInfosOnCongestionEventCall { +func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosOnCongestionEventCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *SendAlgorithmWithDebugInfosOnCongestionEventCall { +func (c *MockSendAlgorithmWithDebugInfosOnCongestionEventCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosOnCongestionEventCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -308,31 +309,31 @@ func (m *MockSendAlgorithmWithDebugInfos) OnPacketAcked(arg0 protocol.PacketNumb } // OnPacketAcked indicates an expected call of OnPacketAcked. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 any) *SendAlgorithmWithDebugInfosOnPacketAckedCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketAcked(arg0, arg1, arg2, arg3 any) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketAcked", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnPacketAcked), arg0, arg1, arg2, arg3) - return &SendAlgorithmWithDebugInfosOnPacketAckedCall{Call: call} + return &MockSendAlgorithmWithDebugInfosOnPacketAckedCall{Call: call} } -// SendAlgorithmWithDebugInfosOnPacketAckedCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosOnPacketAckedCall struct { +// MockSendAlgorithmWithDebugInfosOnPacketAckedCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosOnPacketAckedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosOnPacketAckedCall) Return() *SendAlgorithmWithDebugInfosOnPacketAckedCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketAckedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosOnPacketAckedCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *SendAlgorithmWithDebugInfosOnPacketAckedCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) Do(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosOnPacketAckedCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *SendAlgorithmWithDebugInfosOnPacketAckedCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketAckedCall) DoAndReturn(f func(protocol.PacketNumber, protocol.ByteCount, protocol.ByteCount, time.Time)) *MockSendAlgorithmWithDebugInfosOnPacketAckedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -344,31 +345,31 @@ func (m *MockSendAlgorithmWithDebugInfos) OnPacketSent(arg0 time.Time, arg1 prot } // OnPacketSent indicates an expected call of OnPacketSent. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 any) *SendAlgorithmWithDebugInfosOnPacketSentCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnPacketSent(arg0, arg1, arg2, arg3, arg4 any) *MockSendAlgorithmWithDebugInfosOnPacketSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnPacketSent", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnPacketSent), arg0, arg1, arg2, arg3, arg4) - return &SendAlgorithmWithDebugInfosOnPacketSentCall{Call: call} + return &MockSendAlgorithmWithDebugInfosOnPacketSentCall{Call: call} } -// SendAlgorithmWithDebugInfosOnPacketSentCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosOnPacketSentCall struct { +// MockSendAlgorithmWithDebugInfosOnPacketSentCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosOnPacketSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosOnPacketSentCall) Return() *SendAlgorithmWithDebugInfosOnPacketSentCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Return() *MockSendAlgorithmWithDebugInfosOnPacketSentCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosOnPacketSentCall) Do(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *SendAlgorithmWithDebugInfosOnPacketSentCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) Do(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *MockSendAlgorithmWithDebugInfosOnPacketSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosOnPacketSentCall) DoAndReturn(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *SendAlgorithmWithDebugInfosOnPacketSentCall { +func (c *MockSendAlgorithmWithDebugInfosOnPacketSentCall) DoAndReturn(f func(time.Time, protocol.ByteCount, protocol.PacketNumber, protocol.ByteCount, bool)) *MockSendAlgorithmWithDebugInfosOnPacketSentCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -380,31 +381,31 @@ func (m *MockSendAlgorithmWithDebugInfos) OnRetransmissionTimeout(arg0 bool) { } // OnRetransmissionTimeout indicates an expected call of OnRetransmissionTimeout. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout(arg0 any) *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) OnRetransmissionTimeout(arg0 any) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetransmissionTimeout", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).OnRetransmissionTimeout), arg0) - return &SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall{Call: call} + return &MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall{Call: call} } -// SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall struct { +// MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Return() *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { +func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Return() *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Do(f func(bool)) *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { +func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) Do(f func(bool)) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) DoAndReturn(f func(bool)) *SendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { +func (c *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall) DoAndReturn(f func(bool)) *MockSendAlgorithmWithDebugInfosOnRetransmissionTimeoutCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -416,31 +417,31 @@ func (m *MockSendAlgorithmWithDebugInfos) SetMaxDatagramSize(arg0 protocol.ByteC } // SetMaxDatagramSize indicates an expected call of SetMaxDatagramSize. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) SetMaxDatagramSize(arg0 any) *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) SetMaxDatagramSize(arg0 any) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxDatagramSize", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).SetMaxDatagramSize), arg0) - return &SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall{Call: call} + return &MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall{Call: call} } -// SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall struct { +// MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Return() *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { +func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Return() *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Do(f func(protocol.ByteCount)) *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { +func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) Do(f func(protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) DoAndReturn(f func(protocol.ByteCount)) *SendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { +func (c *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall) DoAndReturn(f func(protocol.ByteCount)) *MockSendAlgorithmWithDebugInfosSetMaxDatagramSizeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -454,31 +455,31 @@ func (m *MockSendAlgorithmWithDebugInfos) TimeUntilSend(arg0 protocol.ByteCount) } // TimeUntilSend indicates an expected call of TimeUntilSend. -func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend(arg0 any) *SendAlgorithmWithDebugInfosTimeUntilSendCall { +func (mr *MockSendAlgorithmWithDebugInfosMockRecorder) TimeUntilSend(arg0 any) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeUntilSend", reflect.TypeOf((*MockSendAlgorithmWithDebugInfos)(nil).TimeUntilSend), arg0) - return &SendAlgorithmWithDebugInfosTimeUntilSendCall{Call: call} + return &MockSendAlgorithmWithDebugInfosTimeUntilSendCall{Call: call} } -// SendAlgorithmWithDebugInfosTimeUntilSendCall wrap *gomock.Call -type SendAlgorithmWithDebugInfosTimeUntilSendCall struct { +// MockSendAlgorithmWithDebugInfosTimeUntilSendCall wrap *gomock.Call +type MockSendAlgorithmWithDebugInfosTimeUntilSendCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendAlgorithmWithDebugInfosTimeUntilSendCall) Return(arg0 time.Time) *SendAlgorithmWithDebugInfosTimeUntilSendCall { +func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Return(arg0 time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendAlgorithmWithDebugInfosTimeUntilSendCall) Do(f func(protocol.ByteCount) time.Time) *SendAlgorithmWithDebugInfosTimeUntilSendCall { +func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) Do(f func(protocol.ByteCount) time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendAlgorithmWithDebugInfosTimeUntilSendCall) DoAndReturn(f func(protocol.ByteCount) time.Time) *SendAlgorithmWithDebugInfosTimeUntilSendCall { +func (c *MockSendAlgorithmWithDebugInfosTimeUntilSendCall) DoAndReturn(f func(protocol.ByteCount) time.Time) *MockSendAlgorithmWithDebugInfosTimeUntilSendCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/connection_flow_controller.go b/internal/mocks/connection_flow_controller.go index 5f6cb2aa..cfb7b6be 100644 --- a/internal/mocks/connection_flow_controller.go +++ b/internal/mocks/connection_flow_controller.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination connection_flow_controller.go github.com/quic-go/quic-go/internal/flowcontrol ConnectionFlowController // + // Package mocks is a generated GoMock package. package mocks @@ -45,31 +46,31 @@ func (m *MockConnectionFlowController) AddBytesRead(arg0 protocol.ByteCount) { } // AddBytesRead indicates an expected call of AddBytesRead. -func (mr *MockConnectionFlowControllerMockRecorder) AddBytesRead(arg0 any) *ConnectionFlowControllerAddBytesReadCall { +func (mr *MockConnectionFlowControllerMockRecorder) AddBytesRead(arg0 any) *MockConnectionFlowControllerAddBytesReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesRead", reflect.TypeOf((*MockConnectionFlowController)(nil).AddBytesRead), arg0) - return &ConnectionFlowControllerAddBytesReadCall{Call: call} + return &MockConnectionFlowControllerAddBytesReadCall{Call: call} } -// ConnectionFlowControllerAddBytesReadCall wrap *gomock.Call -type ConnectionFlowControllerAddBytesReadCall struct { +// MockConnectionFlowControllerAddBytesReadCall wrap *gomock.Call +type MockConnectionFlowControllerAddBytesReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerAddBytesReadCall) Return() *ConnectionFlowControllerAddBytesReadCall { +func (c *MockConnectionFlowControllerAddBytesReadCall) Return() *MockConnectionFlowControllerAddBytesReadCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *ConnectionFlowControllerAddBytesReadCall { +func (c *MockConnectionFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *ConnectionFlowControllerAddBytesReadCall { +func (c *MockConnectionFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -81,31 +82,31 @@ func (m *MockConnectionFlowController) AddBytesSent(arg0 protocol.ByteCount) { } // AddBytesSent indicates an expected call of AddBytesSent. -func (mr *MockConnectionFlowControllerMockRecorder) AddBytesSent(arg0 any) *ConnectionFlowControllerAddBytesSentCall { +func (mr *MockConnectionFlowControllerMockRecorder) AddBytesSent(arg0 any) *MockConnectionFlowControllerAddBytesSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesSent", reflect.TypeOf((*MockConnectionFlowController)(nil).AddBytesSent), arg0) - return &ConnectionFlowControllerAddBytesSentCall{Call: call} + return &MockConnectionFlowControllerAddBytesSentCall{Call: call} } -// ConnectionFlowControllerAddBytesSentCall wrap *gomock.Call -type ConnectionFlowControllerAddBytesSentCall struct { +// MockConnectionFlowControllerAddBytesSentCall wrap *gomock.Call +type MockConnectionFlowControllerAddBytesSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerAddBytesSentCall) Return() *ConnectionFlowControllerAddBytesSentCall { +func (c *MockConnectionFlowControllerAddBytesSentCall) Return() *MockConnectionFlowControllerAddBytesSentCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *ConnectionFlowControllerAddBytesSentCall { +func (c *MockConnectionFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *ConnectionFlowControllerAddBytesSentCall { +func (c *MockConnectionFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *MockConnectionFlowControllerAddBytesSentCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -119,31 +120,31 @@ func (m *MockConnectionFlowController) GetWindowUpdate() protocol.ByteCount { } // GetWindowUpdate indicates an expected call of GetWindowUpdate. -func (mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *ConnectionFlowControllerGetWindowUpdateCall { +func (mr *MockConnectionFlowControllerMockRecorder) GetWindowUpdate() *MockConnectionFlowControllerGetWindowUpdateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWindowUpdate", reflect.TypeOf((*MockConnectionFlowController)(nil).GetWindowUpdate)) - return &ConnectionFlowControllerGetWindowUpdateCall{Call: call} + return &MockConnectionFlowControllerGetWindowUpdateCall{Call: call} } -// ConnectionFlowControllerGetWindowUpdateCall wrap *gomock.Call -type ConnectionFlowControllerGetWindowUpdateCall struct { +// MockConnectionFlowControllerGetWindowUpdateCall wrap *gomock.Call +type MockConnectionFlowControllerGetWindowUpdateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *ConnectionFlowControllerGetWindowUpdateCall { +func (c *MockConnectionFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *ConnectionFlowControllerGetWindowUpdateCall { +func (c *MockConnectionFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *ConnectionFlowControllerGetWindowUpdateCall { +func (c *MockConnectionFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockConnectionFlowControllerGetWindowUpdateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -158,31 +159,31 @@ func (m *MockConnectionFlowController) IsNewlyBlocked() (bool, protocol.ByteCoun } // IsNewlyBlocked indicates an expected call of IsNewlyBlocked. -func (mr *MockConnectionFlowControllerMockRecorder) IsNewlyBlocked() *ConnectionFlowControllerIsNewlyBlockedCall { +func (mr *MockConnectionFlowControllerMockRecorder) IsNewlyBlocked() *MockConnectionFlowControllerIsNewlyBlockedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNewlyBlocked", reflect.TypeOf((*MockConnectionFlowController)(nil).IsNewlyBlocked)) - return &ConnectionFlowControllerIsNewlyBlockedCall{Call: call} + return &MockConnectionFlowControllerIsNewlyBlockedCall{Call: call} } -// ConnectionFlowControllerIsNewlyBlockedCall wrap *gomock.Call -type ConnectionFlowControllerIsNewlyBlockedCall struct { +// MockConnectionFlowControllerIsNewlyBlockedCall wrap *gomock.Call +type MockConnectionFlowControllerIsNewlyBlockedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *ConnectionFlowControllerIsNewlyBlockedCall { +func (c *MockConnectionFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *MockConnectionFlowControllerIsNewlyBlockedCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *ConnectionFlowControllerIsNewlyBlockedCall { +func (c *MockConnectionFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *MockConnectionFlowControllerIsNewlyBlockedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *ConnectionFlowControllerIsNewlyBlockedCall { +func (c *MockConnectionFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *MockConnectionFlowControllerIsNewlyBlockedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -196,31 +197,31 @@ func (m *MockConnectionFlowController) Reset() error { } // Reset indicates an expected call of Reset. -func (mr *MockConnectionFlowControllerMockRecorder) Reset() *ConnectionFlowControllerResetCall { +func (mr *MockConnectionFlowControllerMockRecorder) Reset() *MockConnectionFlowControllerResetCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockConnectionFlowController)(nil).Reset)) - return &ConnectionFlowControllerResetCall{Call: call} + return &MockConnectionFlowControllerResetCall{Call: call} } -// ConnectionFlowControllerResetCall wrap *gomock.Call -type ConnectionFlowControllerResetCall struct { +// MockConnectionFlowControllerResetCall wrap *gomock.Call +type MockConnectionFlowControllerResetCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerResetCall) Return(arg0 error) *ConnectionFlowControllerResetCall { +func (c *MockConnectionFlowControllerResetCall) Return(arg0 error) *MockConnectionFlowControllerResetCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerResetCall) Do(f func() error) *ConnectionFlowControllerResetCall { +func (c *MockConnectionFlowControllerResetCall) Do(f func() error) *MockConnectionFlowControllerResetCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerResetCall) DoAndReturn(f func() error) *ConnectionFlowControllerResetCall { +func (c *MockConnectionFlowControllerResetCall) DoAndReturn(f func() error) *MockConnectionFlowControllerResetCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -234,31 +235,31 @@ func (m *MockConnectionFlowController) SendWindowSize() protocol.ByteCount { } // SendWindowSize indicates an expected call of SendWindowSize. -func (mr *MockConnectionFlowControllerMockRecorder) SendWindowSize() *ConnectionFlowControllerSendWindowSizeCall { +func (mr *MockConnectionFlowControllerMockRecorder) SendWindowSize() *MockConnectionFlowControllerSendWindowSizeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWindowSize", reflect.TypeOf((*MockConnectionFlowController)(nil).SendWindowSize)) - return &ConnectionFlowControllerSendWindowSizeCall{Call: call} + return &MockConnectionFlowControllerSendWindowSizeCall{Call: call} } -// ConnectionFlowControllerSendWindowSizeCall wrap *gomock.Call -type ConnectionFlowControllerSendWindowSizeCall struct { +// MockConnectionFlowControllerSendWindowSizeCall wrap *gomock.Call +type MockConnectionFlowControllerSendWindowSizeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *ConnectionFlowControllerSendWindowSizeCall { +func (c *MockConnectionFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *ConnectionFlowControllerSendWindowSizeCall { +func (c *MockConnectionFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *ConnectionFlowControllerSendWindowSizeCall { +func (c *MockConnectionFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *MockConnectionFlowControllerSendWindowSizeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -272,31 +273,31 @@ func (m *MockConnectionFlowController) UpdateSendWindow(arg0 protocol.ByteCount) } // UpdateSendWindow indicates an expected call of UpdateSendWindow. -func (mr *MockConnectionFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *ConnectionFlowControllerUpdateSendWindowCall { +func (mr *MockConnectionFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *MockConnectionFlowControllerUpdateSendWindowCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSendWindow", reflect.TypeOf((*MockConnectionFlowController)(nil).UpdateSendWindow), arg0) - return &ConnectionFlowControllerUpdateSendWindowCall{Call: call} + return &MockConnectionFlowControllerUpdateSendWindowCall{Call: call} } -// ConnectionFlowControllerUpdateSendWindowCall wrap *gomock.Call -type ConnectionFlowControllerUpdateSendWindowCall struct { +// MockConnectionFlowControllerUpdateSendWindowCall wrap *gomock.Call +type MockConnectionFlowControllerUpdateSendWindowCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionFlowControllerUpdateSendWindowCall) Return(arg0 bool) *ConnectionFlowControllerUpdateSendWindowCall { +func (c *MockConnectionFlowControllerUpdateSendWindowCall) Return(arg0 bool) *MockConnectionFlowControllerUpdateSendWindowCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *ConnectionFlowControllerUpdateSendWindowCall { +func (c *MockConnectionFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *MockConnectionFlowControllerUpdateSendWindowCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *ConnectionFlowControllerUpdateSendWindowCall { +func (c *MockConnectionFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockConnectionFlowControllerUpdateSendWindowCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/crypto_setup.go b/internal/mocks/crypto_setup.go index 91f2586e..cb984f64 100644 --- a/internal/mocks/crypto_setup.go +++ b/internal/mocks/crypto_setup.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination crypto_setup_tmp.go github.com/quic-go/quic-go/internal/handshake CryptoSetup // + // Package mocks is a generated GoMock package. package mocks @@ -46,31 +47,31 @@ func (m *MockCryptoSetup) ChangeConnectionID(arg0 protocol.ConnectionID) { } // ChangeConnectionID indicates an expected call of ChangeConnectionID. -func (mr *MockCryptoSetupMockRecorder) ChangeConnectionID(arg0 any) *CryptoSetupChangeConnectionIDCall { +func (mr *MockCryptoSetupMockRecorder) ChangeConnectionID(arg0 any) *MockCryptoSetupChangeConnectionIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeConnectionID", reflect.TypeOf((*MockCryptoSetup)(nil).ChangeConnectionID), arg0) - return &CryptoSetupChangeConnectionIDCall{Call: call} + return &MockCryptoSetupChangeConnectionIDCall{Call: call} } -// CryptoSetupChangeConnectionIDCall wrap *gomock.Call -type CryptoSetupChangeConnectionIDCall struct { +// MockCryptoSetupChangeConnectionIDCall wrap *gomock.Call +type MockCryptoSetupChangeConnectionIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupChangeConnectionIDCall) Return() *CryptoSetupChangeConnectionIDCall { +func (c *MockCryptoSetupChangeConnectionIDCall) Return() *MockCryptoSetupChangeConnectionIDCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupChangeConnectionIDCall) Do(f func(protocol.ConnectionID)) *CryptoSetupChangeConnectionIDCall { +func (c *MockCryptoSetupChangeConnectionIDCall) Do(f func(protocol.ConnectionID)) *MockCryptoSetupChangeConnectionIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupChangeConnectionIDCall) DoAndReturn(f func(protocol.ConnectionID)) *CryptoSetupChangeConnectionIDCall { +func (c *MockCryptoSetupChangeConnectionIDCall) DoAndReturn(f func(protocol.ConnectionID)) *MockCryptoSetupChangeConnectionIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -84,31 +85,31 @@ func (m *MockCryptoSetup) Close() error { } // Close indicates an expected call of Close. -func (mr *MockCryptoSetupMockRecorder) Close() *CryptoSetupCloseCall { +func (mr *MockCryptoSetupMockRecorder) Close() *MockCryptoSetupCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockCryptoSetup)(nil).Close)) - return &CryptoSetupCloseCall{Call: call} + return &MockCryptoSetupCloseCall{Call: call} } -// CryptoSetupCloseCall wrap *gomock.Call -type CryptoSetupCloseCall struct { +// MockCryptoSetupCloseCall wrap *gomock.Call +type MockCryptoSetupCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupCloseCall) Return(arg0 error) *CryptoSetupCloseCall { +func (c *MockCryptoSetupCloseCall) Return(arg0 error) *MockCryptoSetupCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupCloseCall) Do(f func() error) *CryptoSetupCloseCall { +func (c *MockCryptoSetupCloseCall) Do(f func() error) *MockCryptoSetupCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupCloseCall) DoAndReturn(f func() error) *CryptoSetupCloseCall { +func (c *MockCryptoSetupCloseCall) DoAndReturn(f func() error) *MockCryptoSetupCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -122,31 +123,31 @@ func (m *MockCryptoSetup) ConnectionState() handshake.ConnectionState { } // ConnectionState indicates an expected call of ConnectionState. -func (mr *MockCryptoSetupMockRecorder) ConnectionState() *CryptoSetupConnectionStateCall { +func (mr *MockCryptoSetupMockRecorder) ConnectionState() *MockCryptoSetupConnectionStateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockCryptoSetup)(nil).ConnectionState)) - return &CryptoSetupConnectionStateCall{Call: call} + return &MockCryptoSetupConnectionStateCall{Call: call} } -// CryptoSetupConnectionStateCall wrap *gomock.Call -type CryptoSetupConnectionStateCall struct { +// MockCryptoSetupConnectionStateCall wrap *gomock.Call +type MockCryptoSetupConnectionStateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupConnectionStateCall) Return(arg0 handshake.ConnectionState) *CryptoSetupConnectionStateCall { +func (c *MockCryptoSetupConnectionStateCall) Return(arg0 handshake.ConnectionState) *MockCryptoSetupConnectionStateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupConnectionStateCall) Do(f func() handshake.ConnectionState) *CryptoSetupConnectionStateCall { +func (c *MockCryptoSetupConnectionStateCall) Do(f func() handshake.ConnectionState) *MockCryptoSetupConnectionStateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupConnectionStateCall) DoAndReturn(f func() handshake.ConnectionState) *CryptoSetupConnectionStateCall { +func (c *MockCryptoSetupConnectionStateCall) DoAndReturn(f func() handshake.ConnectionState) *MockCryptoSetupConnectionStateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -158,31 +159,31 @@ func (m *MockCryptoSetup) DiscardInitialKeys() { } // DiscardInitialKeys indicates an expected call of DiscardInitialKeys. -func (mr *MockCryptoSetupMockRecorder) DiscardInitialKeys() *CryptoSetupDiscardInitialKeysCall { +func (mr *MockCryptoSetupMockRecorder) DiscardInitialKeys() *MockCryptoSetupDiscardInitialKeysCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiscardInitialKeys", reflect.TypeOf((*MockCryptoSetup)(nil).DiscardInitialKeys)) - return &CryptoSetupDiscardInitialKeysCall{Call: call} + return &MockCryptoSetupDiscardInitialKeysCall{Call: call} } -// CryptoSetupDiscardInitialKeysCall wrap *gomock.Call -type CryptoSetupDiscardInitialKeysCall struct { +// MockCryptoSetupDiscardInitialKeysCall wrap *gomock.Call +type MockCryptoSetupDiscardInitialKeysCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupDiscardInitialKeysCall) Return() *CryptoSetupDiscardInitialKeysCall { +func (c *MockCryptoSetupDiscardInitialKeysCall) Return() *MockCryptoSetupDiscardInitialKeysCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupDiscardInitialKeysCall) Do(f func()) *CryptoSetupDiscardInitialKeysCall { +func (c *MockCryptoSetupDiscardInitialKeysCall) Do(f func()) *MockCryptoSetupDiscardInitialKeysCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupDiscardInitialKeysCall) DoAndReturn(f func()) *CryptoSetupDiscardInitialKeysCall { +func (c *MockCryptoSetupDiscardInitialKeysCall) DoAndReturn(f func()) *MockCryptoSetupDiscardInitialKeysCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -197,31 +198,31 @@ func (m *MockCryptoSetup) Get0RTTOpener() (handshake.LongHeaderOpener, error) { } // Get0RTTOpener indicates an expected call of Get0RTTOpener. -func (mr *MockCryptoSetupMockRecorder) Get0RTTOpener() *CryptoSetupGet0RTTOpenerCall { +func (mr *MockCryptoSetupMockRecorder) Get0RTTOpener() *MockCryptoSetupGet0RTTOpenerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTOpener", reflect.TypeOf((*MockCryptoSetup)(nil).Get0RTTOpener)) - return &CryptoSetupGet0RTTOpenerCall{Call: call} + return &MockCryptoSetupGet0RTTOpenerCall{Call: call} } -// CryptoSetupGet0RTTOpenerCall wrap *gomock.Call -type CryptoSetupGet0RTTOpenerCall struct { +// MockCryptoSetupGet0RTTOpenerCall wrap *gomock.Call +type MockCryptoSetupGet0RTTOpenerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGet0RTTOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *CryptoSetupGet0RTTOpenerCall { +func (c *MockCryptoSetupGet0RTTOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGet0RTTOpenerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGet0RTTOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGet0RTTOpenerCall { +func (c *MockCryptoSetupGet0RTTOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGet0RTTOpenerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGet0RTTOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGet0RTTOpenerCall { +func (c *MockCryptoSetupGet0RTTOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGet0RTTOpenerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -236,31 +237,31 @@ func (m *MockCryptoSetup) Get0RTTSealer() (handshake.LongHeaderSealer, error) { } // Get0RTTSealer indicates an expected call of Get0RTTSealer. -func (mr *MockCryptoSetupMockRecorder) Get0RTTSealer() *CryptoSetupGet0RTTSealerCall { +func (mr *MockCryptoSetupMockRecorder) Get0RTTSealer() *MockCryptoSetupGet0RTTSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTSealer", reflect.TypeOf((*MockCryptoSetup)(nil).Get0RTTSealer)) - return &CryptoSetupGet0RTTSealerCall{Call: call} + return &MockCryptoSetupGet0RTTSealerCall{Call: call} } -// CryptoSetupGet0RTTSealerCall wrap *gomock.Call -type CryptoSetupGet0RTTSealerCall struct { +// MockCryptoSetupGet0RTTSealerCall wrap *gomock.Call +type MockCryptoSetupGet0RTTSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGet0RTTSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *CryptoSetupGet0RTTSealerCall { +func (c *MockCryptoSetupGet0RTTSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGet0RTTSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGet0RTTSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGet0RTTSealerCall { +func (c *MockCryptoSetupGet0RTTSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGet0RTTSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGet0RTTSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGet0RTTSealerCall { +func (c *MockCryptoSetupGet0RTTSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGet0RTTSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -275,31 +276,31 @@ func (m *MockCryptoSetup) Get1RTTOpener() (handshake.ShortHeaderOpener, error) { } // Get1RTTOpener indicates an expected call of Get1RTTOpener. -func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *CryptoSetupGet1RTTOpenerCall { +func (mr *MockCryptoSetupMockRecorder) Get1RTTOpener() *MockCryptoSetupGet1RTTOpenerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTOpener", reflect.TypeOf((*MockCryptoSetup)(nil).Get1RTTOpener)) - return &CryptoSetupGet1RTTOpenerCall{Call: call} + return &MockCryptoSetupGet1RTTOpenerCall{Call: call} } -// CryptoSetupGet1RTTOpenerCall wrap *gomock.Call -type CryptoSetupGet1RTTOpenerCall struct { +// MockCryptoSetupGet1RTTOpenerCall wrap *gomock.Call +type MockCryptoSetupGet1RTTOpenerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGet1RTTOpenerCall) Return(arg0 handshake.ShortHeaderOpener, arg1 error) *CryptoSetupGet1RTTOpenerCall { +func (c *MockCryptoSetupGet1RTTOpenerCall) Return(arg0 handshake.ShortHeaderOpener, arg1 error) *MockCryptoSetupGet1RTTOpenerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGet1RTTOpenerCall) Do(f func() (handshake.ShortHeaderOpener, error)) *CryptoSetupGet1RTTOpenerCall { +func (c *MockCryptoSetupGet1RTTOpenerCall) Do(f func() (handshake.ShortHeaderOpener, error)) *MockCryptoSetupGet1RTTOpenerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGet1RTTOpenerCall) DoAndReturn(f func() (handshake.ShortHeaderOpener, error)) *CryptoSetupGet1RTTOpenerCall { +func (c *MockCryptoSetupGet1RTTOpenerCall) DoAndReturn(f func() (handshake.ShortHeaderOpener, error)) *MockCryptoSetupGet1RTTOpenerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -314,31 +315,31 @@ func (m *MockCryptoSetup) Get1RTTSealer() (handshake.ShortHeaderSealer, error) { } // Get1RTTSealer indicates an expected call of Get1RTTSealer. -func (mr *MockCryptoSetupMockRecorder) Get1RTTSealer() *CryptoSetupGet1RTTSealerCall { +func (mr *MockCryptoSetupMockRecorder) Get1RTTSealer() *MockCryptoSetupGet1RTTSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTSealer", reflect.TypeOf((*MockCryptoSetup)(nil).Get1RTTSealer)) - return &CryptoSetupGet1RTTSealerCall{Call: call} + return &MockCryptoSetupGet1RTTSealerCall{Call: call} } -// CryptoSetupGet1RTTSealerCall wrap *gomock.Call -type CryptoSetupGet1RTTSealerCall struct { +// MockCryptoSetupGet1RTTSealerCall wrap *gomock.Call +type MockCryptoSetupGet1RTTSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGet1RTTSealerCall) Return(arg0 handshake.ShortHeaderSealer, arg1 error) *CryptoSetupGet1RTTSealerCall { +func (c *MockCryptoSetupGet1RTTSealerCall) Return(arg0 handshake.ShortHeaderSealer, arg1 error) *MockCryptoSetupGet1RTTSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGet1RTTSealerCall) Do(f func() (handshake.ShortHeaderSealer, error)) *CryptoSetupGet1RTTSealerCall { +func (c *MockCryptoSetupGet1RTTSealerCall) Do(f func() (handshake.ShortHeaderSealer, error)) *MockCryptoSetupGet1RTTSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGet1RTTSealerCall) DoAndReturn(f func() (handshake.ShortHeaderSealer, error)) *CryptoSetupGet1RTTSealerCall { +func (c *MockCryptoSetupGet1RTTSealerCall) DoAndReturn(f func() (handshake.ShortHeaderSealer, error)) *MockCryptoSetupGet1RTTSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -353,31 +354,31 @@ func (m *MockCryptoSetup) GetHandshakeOpener() (handshake.LongHeaderOpener, erro } // GetHandshakeOpener indicates an expected call of GetHandshakeOpener. -func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *CryptoSetupGetHandshakeOpenerCall { +func (mr *MockCryptoSetupMockRecorder) GetHandshakeOpener() *MockCryptoSetupGetHandshakeOpenerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeOpener", reflect.TypeOf((*MockCryptoSetup)(nil).GetHandshakeOpener)) - return &CryptoSetupGetHandshakeOpenerCall{Call: call} + return &MockCryptoSetupGetHandshakeOpenerCall{Call: call} } -// CryptoSetupGetHandshakeOpenerCall wrap *gomock.Call -type CryptoSetupGetHandshakeOpenerCall struct { +// MockCryptoSetupGetHandshakeOpenerCall wrap *gomock.Call +type MockCryptoSetupGetHandshakeOpenerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGetHandshakeOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *CryptoSetupGetHandshakeOpenerCall { +func (c *MockCryptoSetupGetHandshakeOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGetHandshakeOpenerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGetHandshakeOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGetHandshakeOpenerCall { +func (c *MockCryptoSetupGetHandshakeOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetHandshakeOpenerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGetHandshakeOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGetHandshakeOpenerCall { +func (c *MockCryptoSetupGetHandshakeOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetHandshakeOpenerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -392,31 +393,31 @@ func (m *MockCryptoSetup) GetHandshakeSealer() (handshake.LongHeaderSealer, erro } // GetHandshakeSealer indicates an expected call of GetHandshakeSealer. -func (mr *MockCryptoSetupMockRecorder) GetHandshakeSealer() *CryptoSetupGetHandshakeSealerCall { +func (mr *MockCryptoSetupMockRecorder) GetHandshakeSealer() *MockCryptoSetupGetHandshakeSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeSealer", reflect.TypeOf((*MockCryptoSetup)(nil).GetHandshakeSealer)) - return &CryptoSetupGetHandshakeSealerCall{Call: call} + return &MockCryptoSetupGetHandshakeSealerCall{Call: call} } -// CryptoSetupGetHandshakeSealerCall wrap *gomock.Call -type CryptoSetupGetHandshakeSealerCall struct { +// MockCryptoSetupGetHandshakeSealerCall wrap *gomock.Call +type MockCryptoSetupGetHandshakeSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGetHandshakeSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *CryptoSetupGetHandshakeSealerCall { +func (c *MockCryptoSetupGetHandshakeSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGetHandshakeSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGetHandshakeSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGetHandshakeSealerCall { +func (c *MockCryptoSetupGetHandshakeSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetHandshakeSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGetHandshakeSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGetHandshakeSealerCall { +func (c *MockCryptoSetupGetHandshakeSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetHandshakeSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -431,31 +432,31 @@ func (m *MockCryptoSetup) GetInitialOpener() (handshake.LongHeaderOpener, error) } // GetInitialOpener indicates an expected call of GetInitialOpener. -func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *CryptoSetupGetInitialOpenerCall { +func (mr *MockCryptoSetupMockRecorder) GetInitialOpener() *MockCryptoSetupGetInitialOpenerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialOpener", reflect.TypeOf((*MockCryptoSetup)(nil).GetInitialOpener)) - return &CryptoSetupGetInitialOpenerCall{Call: call} + return &MockCryptoSetupGetInitialOpenerCall{Call: call} } -// CryptoSetupGetInitialOpenerCall wrap *gomock.Call -type CryptoSetupGetInitialOpenerCall struct { +// MockCryptoSetupGetInitialOpenerCall wrap *gomock.Call +type MockCryptoSetupGetInitialOpenerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGetInitialOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *CryptoSetupGetInitialOpenerCall { +func (c *MockCryptoSetupGetInitialOpenerCall) Return(arg0 handshake.LongHeaderOpener, arg1 error) *MockCryptoSetupGetInitialOpenerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGetInitialOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGetInitialOpenerCall { +func (c *MockCryptoSetupGetInitialOpenerCall) Do(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetInitialOpenerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGetInitialOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *CryptoSetupGetInitialOpenerCall { +func (c *MockCryptoSetupGetInitialOpenerCall) DoAndReturn(f func() (handshake.LongHeaderOpener, error)) *MockCryptoSetupGetInitialOpenerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -470,31 +471,31 @@ func (m *MockCryptoSetup) GetInitialSealer() (handshake.LongHeaderSealer, error) } // GetInitialSealer indicates an expected call of GetInitialSealer. -func (mr *MockCryptoSetupMockRecorder) GetInitialSealer() *CryptoSetupGetInitialSealerCall { +func (mr *MockCryptoSetupMockRecorder) GetInitialSealer() *MockCryptoSetupGetInitialSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialSealer", reflect.TypeOf((*MockCryptoSetup)(nil).GetInitialSealer)) - return &CryptoSetupGetInitialSealerCall{Call: call} + return &MockCryptoSetupGetInitialSealerCall{Call: call} } -// CryptoSetupGetInitialSealerCall wrap *gomock.Call -type CryptoSetupGetInitialSealerCall struct { +// MockCryptoSetupGetInitialSealerCall wrap *gomock.Call +type MockCryptoSetupGetInitialSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGetInitialSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *CryptoSetupGetInitialSealerCall { +func (c *MockCryptoSetupGetInitialSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockCryptoSetupGetInitialSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGetInitialSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGetInitialSealerCall { +func (c *MockCryptoSetupGetInitialSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetInitialSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGetInitialSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *CryptoSetupGetInitialSealerCall { +func (c *MockCryptoSetupGetInitialSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockCryptoSetupGetInitialSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -509,31 +510,31 @@ func (m *MockCryptoSetup) GetSessionTicket() ([]byte, error) { } // GetSessionTicket indicates an expected call of GetSessionTicket. -func (mr *MockCryptoSetupMockRecorder) GetSessionTicket() *CryptoSetupGetSessionTicketCall { +func (mr *MockCryptoSetupMockRecorder) GetSessionTicket() *MockCryptoSetupGetSessionTicketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSessionTicket", reflect.TypeOf((*MockCryptoSetup)(nil).GetSessionTicket)) - return &CryptoSetupGetSessionTicketCall{Call: call} + return &MockCryptoSetupGetSessionTicketCall{Call: call} } -// CryptoSetupGetSessionTicketCall wrap *gomock.Call -type CryptoSetupGetSessionTicketCall struct { +// MockCryptoSetupGetSessionTicketCall wrap *gomock.Call +type MockCryptoSetupGetSessionTicketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupGetSessionTicketCall) Return(arg0 []byte, arg1 error) *CryptoSetupGetSessionTicketCall { +func (c *MockCryptoSetupGetSessionTicketCall) Return(arg0 []byte, arg1 error) *MockCryptoSetupGetSessionTicketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupGetSessionTicketCall) Do(f func() ([]byte, error)) *CryptoSetupGetSessionTicketCall { +func (c *MockCryptoSetupGetSessionTicketCall) Do(f func() ([]byte, error)) *MockCryptoSetupGetSessionTicketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupGetSessionTicketCall) DoAndReturn(f func() ([]byte, error)) *CryptoSetupGetSessionTicketCall { +func (c *MockCryptoSetupGetSessionTicketCall) DoAndReturn(f func() ([]byte, error)) *MockCryptoSetupGetSessionTicketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -547,31 +548,31 @@ func (m *MockCryptoSetup) HandleMessage(arg0 []byte, arg1 protocol.EncryptionLev } // HandleMessage indicates an expected call of HandleMessage. -func (mr *MockCryptoSetupMockRecorder) HandleMessage(arg0, arg1 any) *CryptoSetupHandleMessageCall { +func (mr *MockCryptoSetupMockRecorder) HandleMessage(arg0, arg1 any) *MockCryptoSetupHandleMessageCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockCryptoSetup)(nil).HandleMessage), arg0, arg1) - return &CryptoSetupHandleMessageCall{Call: call} + return &MockCryptoSetupHandleMessageCall{Call: call} } -// CryptoSetupHandleMessageCall wrap *gomock.Call -type CryptoSetupHandleMessageCall struct { +// MockCryptoSetupHandleMessageCall wrap *gomock.Call +type MockCryptoSetupHandleMessageCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupHandleMessageCall) Return(arg0 error) *CryptoSetupHandleMessageCall { +func (c *MockCryptoSetupHandleMessageCall) Return(arg0 error) *MockCryptoSetupHandleMessageCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupHandleMessageCall) Do(f func([]byte, protocol.EncryptionLevel) error) *CryptoSetupHandleMessageCall { +func (c *MockCryptoSetupHandleMessageCall) Do(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoSetupHandleMessageCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupHandleMessageCall) DoAndReturn(f func([]byte, protocol.EncryptionLevel) error) *CryptoSetupHandleMessageCall { +func (c *MockCryptoSetupHandleMessageCall) DoAndReturn(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoSetupHandleMessageCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -585,31 +586,31 @@ func (m *MockCryptoSetup) NextEvent() handshake.Event { } // NextEvent indicates an expected call of NextEvent. -func (mr *MockCryptoSetupMockRecorder) NextEvent() *CryptoSetupNextEventCall { +func (mr *MockCryptoSetupMockRecorder) NextEvent() *MockCryptoSetupNextEventCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextEvent", reflect.TypeOf((*MockCryptoSetup)(nil).NextEvent)) - return &CryptoSetupNextEventCall{Call: call} + return &MockCryptoSetupNextEventCall{Call: call} } -// CryptoSetupNextEventCall wrap *gomock.Call -type CryptoSetupNextEventCall struct { +// MockCryptoSetupNextEventCall wrap *gomock.Call +type MockCryptoSetupNextEventCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupNextEventCall) Return(arg0 handshake.Event) *CryptoSetupNextEventCall { +func (c *MockCryptoSetupNextEventCall) Return(arg0 handshake.Event) *MockCryptoSetupNextEventCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupNextEventCall) Do(f func() handshake.Event) *CryptoSetupNextEventCall { +func (c *MockCryptoSetupNextEventCall) Do(f func() handshake.Event) *MockCryptoSetupNextEventCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupNextEventCall) DoAndReturn(f func() handshake.Event) *CryptoSetupNextEventCall { +func (c *MockCryptoSetupNextEventCall) DoAndReturn(f func() handshake.Event) *MockCryptoSetupNextEventCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -621,31 +622,31 @@ func (m *MockCryptoSetup) SetHandshakeConfirmed() { } // SetHandshakeConfirmed indicates an expected call of SetHandshakeConfirmed. -func (mr *MockCryptoSetupMockRecorder) SetHandshakeConfirmed() *CryptoSetupSetHandshakeConfirmedCall { +func (mr *MockCryptoSetupMockRecorder) SetHandshakeConfirmed() *MockCryptoSetupSetHandshakeConfirmedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeConfirmed", reflect.TypeOf((*MockCryptoSetup)(nil).SetHandshakeConfirmed)) - return &CryptoSetupSetHandshakeConfirmedCall{Call: call} + return &MockCryptoSetupSetHandshakeConfirmedCall{Call: call} } -// CryptoSetupSetHandshakeConfirmedCall wrap *gomock.Call -type CryptoSetupSetHandshakeConfirmedCall struct { +// MockCryptoSetupSetHandshakeConfirmedCall wrap *gomock.Call +type MockCryptoSetupSetHandshakeConfirmedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupSetHandshakeConfirmedCall) Return() *CryptoSetupSetHandshakeConfirmedCall { +func (c *MockCryptoSetupSetHandshakeConfirmedCall) Return() *MockCryptoSetupSetHandshakeConfirmedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupSetHandshakeConfirmedCall) Do(f func()) *CryptoSetupSetHandshakeConfirmedCall { +func (c *MockCryptoSetupSetHandshakeConfirmedCall) Do(f func()) *MockCryptoSetupSetHandshakeConfirmedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupSetHandshakeConfirmedCall) DoAndReturn(f func()) *CryptoSetupSetHandshakeConfirmedCall { +func (c *MockCryptoSetupSetHandshakeConfirmedCall) DoAndReturn(f func()) *MockCryptoSetupSetHandshakeConfirmedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -659,31 +660,31 @@ func (m *MockCryptoSetup) SetLargest1RTTAcked(arg0 protocol.PacketNumber) error } // SetLargest1RTTAcked indicates an expected call of SetLargest1RTTAcked. -func (mr *MockCryptoSetupMockRecorder) SetLargest1RTTAcked(arg0 any) *CryptoSetupSetLargest1RTTAckedCall { +func (mr *MockCryptoSetupMockRecorder) SetLargest1RTTAcked(arg0 any) *MockCryptoSetupSetLargest1RTTAckedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLargest1RTTAcked", reflect.TypeOf((*MockCryptoSetup)(nil).SetLargest1RTTAcked), arg0) - return &CryptoSetupSetLargest1RTTAckedCall{Call: call} + return &MockCryptoSetupSetLargest1RTTAckedCall{Call: call} } -// CryptoSetupSetLargest1RTTAckedCall wrap *gomock.Call -type CryptoSetupSetLargest1RTTAckedCall struct { +// MockCryptoSetupSetLargest1RTTAckedCall wrap *gomock.Call +type MockCryptoSetupSetLargest1RTTAckedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupSetLargest1RTTAckedCall) Return(arg0 error) *CryptoSetupSetLargest1RTTAckedCall { +func (c *MockCryptoSetupSetLargest1RTTAckedCall) Return(arg0 error) *MockCryptoSetupSetLargest1RTTAckedCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupSetLargest1RTTAckedCall) Do(f func(protocol.PacketNumber) error) *CryptoSetupSetLargest1RTTAckedCall { +func (c *MockCryptoSetupSetLargest1RTTAckedCall) Do(f func(protocol.PacketNumber) error) *MockCryptoSetupSetLargest1RTTAckedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupSetLargest1RTTAckedCall) DoAndReturn(f func(protocol.PacketNumber) error) *CryptoSetupSetLargest1RTTAckedCall { +func (c *MockCryptoSetupSetLargest1RTTAckedCall) DoAndReturn(f func(protocol.PacketNumber) error) *MockCryptoSetupSetLargest1RTTAckedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -697,31 +698,31 @@ func (m *MockCryptoSetup) StartHandshake() error { } // StartHandshake indicates an expected call of StartHandshake. -func (mr *MockCryptoSetupMockRecorder) StartHandshake() *CryptoSetupStartHandshakeCall { +func (mr *MockCryptoSetupMockRecorder) StartHandshake() *MockCryptoSetupStartHandshakeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartHandshake", reflect.TypeOf((*MockCryptoSetup)(nil).StartHandshake)) - return &CryptoSetupStartHandshakeCall{Call: call} + return &MockCryptoSetupStartHandshakeCall{Call: call} } -// CryptoSetupStartHandshakeCall wrap *gomock.Call -type CryptoSetupStartHandshakeCall struct { +// MockCryptoSetupStartHandshakeCall wrap *gomock.Call +type MockCryptoSetupStartHandshakeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoSetupStartHandshakeCall) Return(arg0 error) *CryptoSetupStartHandshakeCall { +func (c *MockCryptoSetupStartHandshakeCall) Return(arg0 error) *MockCryptoSetupStartHandshakeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoSetupStartHandshakeCall) Do(f func() error) *CryptoSetupStartHandshakeCall { +func (c *MockCryptoSetupStartHandshakeCall) Do(f func() error) *MockCryptoSetupStartHandshakeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoSetupStartHandshakeCall) DoAndReturn(f func() error) *CryptoSetupStartHandshakeCall { +func (c *MockCryptoSetupStartHandshakeCall) DoAndReturn(f func() error) *MockCryptoSetupStartHandshakeCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/logging/internal/connection_tracer.go b/internal/mocks/logging/internal/connection_tracer.go index cc5b8e17..e02fab6b 100644 --- a/internal/mocks/logging/internal/connection_tracer.go +++ b/internal/mocks/logging/internal/connection_tracer.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package internal -destination internal/connection_tracer.go github.com/quic-go/quic-go/internal/mocks/logging ConnectionTracer // + // Package internal is a generated GoMock package. package internal @@ -50,31 +51,31 @@ func (m *MockConnectionTracer) AcknowledgedPacket(arg0 protocol.EncryptionLevel, } // AcknowledgedPacket indicates an expected call of AcknowledgedPacket. -func (mr *MockConnectionTracerMockRecorder) AcknowledgedPacket(arg0, arg1 any) *ConnectionTracerAcknowledgedPacketCall { +func (mr *MockConnectionTracerMockRecorder) AcknowledgedPacket(arg0, arg1 any) *MockConnectionTracerAcknowledgedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcknowledgedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).AcknowledgedPacket), arg0, arg1) - return &ConnectionTracerAcknowledgedPacketCall{Call: call} + return &MockConnectionTracerAcknowledgedPacketCall{Call: call} } -// ConnectionTracerAcknowledgedPacketCall wrap *gomock.Call -type ConnectionTracerAcknowledgedPacketCall struct { +// MockConnectionTracerAcknowledgedPacketCall wrap *gomock.Call +type MockConnectionTracerAcknowledgedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerAcknowledgedPacketCall) Return() *ConnectionTracerAcknowledgedPacketCall { +func (c *MockConnectionTracerAcknowledgedPacketCall) Return() *MockConnectionTracerAcknowledgedPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerAcknowledgedPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *ConnectionTracerAcknowledgedPacketCall { +func (c *MockConnectionTracerAcknowledgedPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *ConnectionTracerAcknowledgedPacketCall { +func (c *MockConnectionTracerAcknowledgedPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber)) *MockConnectionTracerAcknowledgedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockConnectionTracer) BufferedPacket(arg0 logging.PacketType, arg1 prot } // BufferedPacket indicates an expected call of BufferedPacket. -func (mr *MockConnectionTracerMockRecorder) BufferedPacket(arg0, arg1 any) *ConnectionTracerBufferedPacketCall { +func (mr *MockConnectionTracerMockRecorder) BufferedPacket(arg0, arg1 any) *MockConnectionTracerBufferedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BufferedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).BufferedPacket), arg0, arg1) - return &ConnectionTracerBufferedPacketCall{Call: call} + return &MockConnectionTracerBufferedPacketCall{Call: call} } -// ConnectionTracerBufferedPacketCall wrap *gomock.Call -type ConnectionTracerBufferedPacketCall struct { +// MockConnectionTracerBufferedPacketCall wrap *gomock.Call +type MockConnectionTracerBufferedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerBufferedPacketCall) Return() *ConnectionTracerBufferedPacketCall { +func (c *MockConnectionTracerBufferedPacketCall) Return() *MockConnectionTracerBufferedPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, protocol.ByteCount)) *ConnectionTracerBufferedPacketCall { +func (c *MockConnectionTracerBufferedPacketCall) Do(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.ByteCount)) *ConnectionTracerBufferedPacketCall { +func (c *MockConnectionTracerBufferedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.ByteCount)) *MockConnectionTracerBufferedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -122,31 +123,31 @@ func (m *MockConnectionTracer) ChoseALPN(arg0 string) { } // ChoseALPN indicates an expected call of ChoseALPN. -func (mr *MockConnectionTracerMockRecorder) ChoseALPN(arg0 any) *ConnectionTracerChoseALPNCall { +func (mr *MockConnectionTracerMockRecorder) ChoseALPN(arg0 any) *MockConnectionTracerChoseALPNCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChoseALPN", reflect.TypeOf((*MockConnectionTracer)(nil).ChoseALPN), arg0) - return &ConnectionTracerChoseALPNCall{Call: call} + return &MockConnectionTracerChoseALPNCall{Call: call} } -// ConnectionTracerChoseALPNCall wrap *gomock.Call -type ConnectionTracerChoseALPNCall struct { +// MockConnectionTracerChoseALPNCall wrap *gomock.Call +type MockConnectionTracerChoseALPNCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerChoseALPNCall) Return() *ConnectionTracerChoseALPNCall { +func (c *MockConnectionTracerChoseALPNCall) Return() *MockConnectionTracerChoseALPNCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerChoseALPNCall) Do(f func(string)) *ConnectionTracerChoseALPNCall { +func (c *MockConnectionTracerChoseALPNCall) Do(f func(string)) *MockConnectionTracerChoseALPNCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerChoseALPNCall) DoAndReturn(f func(string)) *ConnectionTracerChoseALPNCall { +func (c *MockConnectionTracerChoseALPNCall) DoAndReturn(f func(string)) *MockConnectionTracerChoseALPNCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -158,31 +159,31 @@ func (m *MockConnectionTracer) Close() { } // Close indicates an expected call of Close. -func (mr *MockConnectionTracerMockRecorder) Close() *ConnectionTracerCloseCall { +func (mr *MockConnectionTracerMockRecorder) Close() *MockConnectionTracerCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConnectionTracer)(nil).Close)) - return &ConnectionTracerCloseCall{Call: call} + return &MockConnectionTracerCloseCall{Call: call} } -// ConnectionTracerCloseCall wrap *gomock.Call -type ConnectionTracerCloseCall struct { +// MockConnectionTracerCloseCall wrap *gomock.Call +type MockConnectionTracerCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerCloseCall) Return() *ConnectionTracerCloseCall { +func (c *MockConnectionTracerCloseCall) Return() *MockConnectionTracerCloseCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerCloseCall) Do(f func()) *ConnectionTracerCloseCall { +func (c *MockConnectionTracerCloseCall) Do(f func()) *MockConnectionTracerCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerCloseCall) DoAndReturn(f func()) *ConnectionTracerCloseCall { +func (c *MockConnectionTracerCloseCall) DoAndReturn(f func()) *MockConnectionTracerCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -194,31 +195,31 @@ func (m *MockConnectionTracer) ClosedConnection(arg0 error) { } // ClosedConnection indicates an expected call of ClosedConnection. -func (mr *MockConnectionTracerMockRecorder) ClosedConnection(arg0 any) *ConnectionTracerClosedConnectionCall { +func (mr *MockConnectionTracerMockRecorder) ClosedConnection(arg0 any) *MockConnectionTracerClosedConnectionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClosedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).ClosedConnection), arg0) - return &ConnectionTracerClosedConnectionCall{Call: call} + return &MockConnectionTracerClosedConnectionCall{Call: call} } -// ConnectionTracerClosedConnectionCall wrap *gomock.Call -type ConnectionTracerClosedConnectionCall struct { +// MockConnectionTracerClosedConnectionCall wrap *gomock.Call +type MockConnectionTracerClosedConnectionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerClosedConnectionCall) Return() *ConnectionTracerClosedConnectionCall { +func (c *MockConnectionTracerClosedConnectionCall) Return() *MockConnectionTracerClosedConnectionCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerClosedConnectionCall) Do(f func(error)) *ConnectionTracerClosedConnectionCall { +func (c *MockConnectionTracerClosedConnectionCall) Do(f func(error)) *MockConnectionTracerClosedConnectionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerClosedConnectionCall) DoAndReturn(f func(error)) *ConnectionTracerClosedConnectionCall { +func (c *MockConnectionTracerClosedConnectionCall) DoAndReturn(f func(error)) *MockConnectionTracerClosedConnectionCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -230,31 +231,31 @@ func (m *MockConnectionTracer) Debug(arg0, arg1 string) { } // Debug indicates an expected call of Debug. -func (mr *MockConnectionTracerMockRecorder) Debug(arg0, arg1 any) *ConnectionTracerDebugCall { +func (mr *MockConnectionTracerMockRecorder) Debug(arg0, arg1 any) *MockConnectionTracerDebugCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockConnectionTracer)(nil).Debug), arg0, arg1) - return &ConnectionTracerDebugCall{Call: call} + return &MockConnectionTracerDebugCall{Call: call} } -// ConnectionTracerDebugCall wrap *gomock.Call -type ConnectionTracerDebugCall struct { +// MockConnectionTracerDebugCall wrap *gomock.Call +type MockConnectionTracerDebugCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerDebugCall) Return() *ConnectionTracerDebugCall { +func (c *MockConnectionTracerDebugCall) Return() *MockConnectionTracerDebugCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerDebugCall) Do(f func(string, string)) *ConnectionTracerDebugCall { +func (c *MockConnectionTracerDebugCall) Do(f func(string, string)) *MockConnectionTracerDebugCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerDebugCall) DoAndReturn(f func(string, string)) *ConnectionTracerDebugCall { +func (c *MockConnectionTracerDebugCall) DoAndReturn(f func(string, string)) *MockConnectionTracerDebugCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -266,31 +267,31 @@ func (m *MockConnectionTracer) DroppedEncryptionLevel(arg0 protocol.EncryptionLe } // DroppedEncryptionLevel indicates an expected call of DroppedEncryptionLevel. -func (mr *MockConnectionTracerMockRecorder) DroppedEncryptionLevel(arg0 any) *ConnectionTracerDroppedEncryptionLevelCall { +func (mr *MockConnectionTracerMockRecorder) DroppedEncryptionLevel(arg0 any) *MockConnectionTracerDroppedEncryptionLevelCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedEncryptionLevel", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedEncryptionLevel), arg0) - return &ConnectionTracerDroppedEncryptionLevelCall{Call: call} + return &MockConnectionTracerDroppedEncryptionLevelCall{Call: call} } -// ConnectionTracerDroppedEncryptionLevelCall wrap *gomock.Call -type ConnectionTracerDroppedEncryptionLevelCall struct { +// MockConnectionTracerDroppedEncryptionLevelCall wrap *gomock.Call +type MockConnectionTracerDroppedEncryptionLevelCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerDroppedEncryptionLevelCall) Return() *ConnectionTracerDroppedEncryptionLevelCall { +func (c *MockConnectionTracerDroppedEncryptionLevelCall) Return() *MockConnectionTracerDroppedEncryptionLevelCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerDroppedEncryptionLevelCall) Do(f func(protocol.EncryptionLevel)) *ConnectionTracerDroppedEncryptionLevelCall { +func (c *MockConnectionTracerDroppedEncryptionLevelCall) Do(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(protocol.EncryptionLevel)) *ConnectionTracerDroppedEncryptionLevelCall { +func (c *MockConnectionTracerDroppedEncryptionLevelCall) DoAndReturn(f func(protocol.EncryptionLevel)) *MockConnectionTracerDroppedEncryptionLevelCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -302,31 +303,31 @@ func (m *MockConnectionTracer) DroppedKey(arg0 protocol.KeyPhase) { } // DroppedKey indicates an expected call of DroppedKey. -func (mr *MockConnectionTracerMockRecorder) DroppedKey(arg0 any) *ConnectionTracerDroppedKeyCall { +func (mr *MockConnectionTracerMockRecorder) DroppedKey(arg0 any) *MockConnectionTracerDroppedKeyCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedKey", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedKey), arg0) - return &ConnectionTracerDroppedKeyCall{Call: call} + return &MockConnectionTracerDroppedKeyCall{Call: call} } -// ConnectionTracerDroppedKeyCall wrap *gomock.Call -type ConnectionTracerDroppedKeyCall struct { +// MockConnectionTracerDroppedKeyCall wrap *gomock.Call +type MockConnectionTracerDroppedKeyCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerDroppedKeyCall) Return() *ConnectionTracerDroppedKeyCall { +func (c *MockConnectionTracerDroppedKeyCall) Return() *MockConnectionTracerDroppedKeyCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerDroppedKeyCall) Do(f func(protocol.KeyPhase)) *ConnectionTracerDroppedKeyCall { +func (c *MockConnectionTracerDroppedKeyCall) Do(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerDroppedKeyCall) DoAndReturn(f func(protocol.KeyPhase)) *ConnectionTracerDroppedKeyCall { +func (c *MockConnectionTracerDroppedKeyCall) DoAndReturn(f func(protocol.KeyPhase)) *MockConnectionTracerDroppedKeyCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -338,31 +339,31 @@ func (m *MockConnectionTracer) DroppedPacket(arg0 logging.PacketType, arg1 proto } // DroppedPacket indicates an expected call of DroppedPacket. -func (mr *MockConnectionTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 any) *ConnectionTracerDroppedPacketCall { +func (mr *MockConnectionTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerDroppedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockConnectionTracer)(nil).DroppedPacket), arg0, arg1, arg2, arg3) - return &ConnectionTracerDroppedPacketCall{Call: call} + return &MockConnectionTracerDroppedPacketCall{Call: call} } -// ConnectionTracerDroppedPacketCall wrap *gomock.Call -type ConnectionTracerDroppedPacketCall struct { +// MockConnectionTracerDroppedPacketCall wrap *gomock.Call +type MockConnectionTracerDroppedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerDroppedPacketCall) Return() *ConnectionTracerDroppedPacketCall { +func (c *MockConnectionTracerDroppedPacketCall) Return() *MockConnectionTracerDroppedPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *ConnectionTracerDroppedPacketCall { +func (c *MockConnectionTracerDroppedPacketCall) Do(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *ConnectionTracerDroppedPacketCall { +func (c *MockConnectionTracerDroppedPacketCall) DoAndReturn(f func(logging.PacketType, protocol.PacketNumber, protocol.ByteCount, logging.PacketDropReason)) *MockConnectionTracerDroppedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -374,31 +375,31 @@ func (m *MockConnectionTracer) ECNStateUpdated(arg0 logging.ECNState, arg1 loggi } // ECNStateUpdated indicates an expected call of ECNStateUpdated. -func (mr *MockConnectionTracerMockRecorder) ECNStateUpdated(arg0, arg1 any) *ConnectionTracerECNStateUpdatedCall { +func (mr *MockConnectionTracerMockRecorder) ECNStateUpdated(arg0, arg1 any) *MockConnectionTracerECNStateUpdatedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ECNStateUpdated", reflect.TypeOf((*MockConnectionTracer)(nil).ECNStateUpdated), arg0, arg1) - return &ConnectionTracerECNStateUpdatedCall{Call: call} + return &MockConnectionTracerECNStateUpdatedCall{Call: call} } -// ConnectionTracerECNStateUpdatedCall wrap *gomock.Call -type ConnectionTracerECNStateUpdatedCall struct { +// MockConnectionTracerECNStateUpdatedCall wrap *gomock.Call +type MockConnectionTracerECNStateUpdatedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerECNStateUpdatedCall) Return() *ConnectionTracerECNStateUpdatedCall { +func (c *MockConnectionTracerECNStateUpdatedCall) Return() *MockConnectionTracerECNStateUpdatedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerECNStateUpdatedCall) Do(f func(logging.ECNState, logging.ECNStateTrigger)) *ConnectionTracerECNStateUpdatedCall { +func (c *MockConnectionTracerECNStateUpdatedCall) Do(f func(logging.ECNState, logging.ECNStateTrigger)) *MockConnectionTracerECNStateUpdatedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerECNStateUpdatedCall) DoAndReturn(f func(logging.ECNState, logging.ECNStateTrigger)) *ConnectionTracerECNStateUpdatedCall { +func (c *MockConnectionTracerECNStateUpdatedCall) DoAndReturn(f func(logging.ECNState, logging.ECNStateTrigger)) *MockConnectionTracerECNStateUpdatedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -410,31 +411,31 @@ func (m *MockConnectionTracer) LossTimerCanceled() { } // LossTimerCanceled indicates an expected call of LossTimerCanceled. -func (mr *MockConnectionTracerMockRecorder) LossTimerCanceled() *ConnectionTracerLossTimerCanceledCall { +func (mr *MockConnectionTracerMockRecorder) LossTimerCanceled() *MockConnectionTracerLossTimerCanceledCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerCanceled", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerCanceled)) - return &ConnectionTracerLossTimerCanceledCall{Call: call} + return &MockConnectionTracerLossTimerCanceledCall{Call: call} } -// ConnectionTracerLossTimerCanceledCall wrap *gomock.Call -type ConnectionTracerLossTimerCanceledCall struct { +// MockConnectionTracerLossTimerCanceledCall wrap *gomock.Call +type MockConnectionTracerLossTimerCanceledCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerLossTimerCanceledCall) Return() *ConnectionTracerLossTimerCanceledCall { +func (c *MockConnectionTracerLossTimerCanceledCall) Return() *MockConnectionTracerLossTimerCanceledCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerLossTimerCanceledCall) Do(f func()) *ConnectionTracerLossTimerCanceledCall { +func (c *MockConnectionTracerLossTimerCanceledCall) Do(f func()) *MockConnectionTracerLossTimerCanceledCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerLossTimerCanceledCall) DoAndReturn(f func()) *ConnectionTracerLossTimerCanceledCall { +func (c *MockConnectionTracerLossTimerCanceledCall) DoAndReturn(f func()) *MockConnectionTracerLossTimerCanceledCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -446,31 +447,31 @@ func (m *MockConnectionTracer) LossTimerExpired(arg0 logging.TimerType, arg1 pro } // LossTimerExpired indicates an expected call of LossTimerExpired. -func (mr *MockConnectionTracerMockRecorder) LossTimerExpired(arg0, arg1 any) *ConnectionTracerLossTimerExpiredCall { +func (mr *MockConnectionTracerMockRecorder) LossTimerExpired(arg0, arg1 any) *MockConnectionTracerLossTimerExpiredCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LossTimerExpired", reflect.TypeOf((*MockConnectionTracer)(nil).LossTimerExpired), arg0, arg1) - return &ConnectionTracerLossTimerExpiredCall{Call: call} + return &MockConnectionTracerLossTimerExpiredCall{Call: call} } -// ConnectionTracerLossTimerExpiredCall wrap *gomock.Call -type ConnectionTracerLossTimerExpiredCall struct { +// MockConnectionTracerLossTimerExpiredCall wrap *gomock.Call +type MockConnectionTracerLossTimerExpiredCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerLossTimerExpiredCall) Return() *ConnectionTracerLossTimerExpiredCall { +func (c *MockConnectionTracerLossTimerExpiredCall) Return() *MockConnectionTracerLossTimerExpiredCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, protocol.EncryptionLevel)) *ConnectionTracerLossTimerExpiredCall { +func (c *MockConnectionTracerLossTimerExpiredCall) Do(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel)) *ConnectionTracerLossTimerExpiredCall { +func (c *MockConnectionTracerLossTimerExpiredCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel)) *MockConnectionTracerLossTimerExpiredCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -482,31 +483,31 @@ func (m *MockConnectionTracer) LostPacket(arg0 protocol.EncryptionLevel, arg1 pr } // LostPacket indicates an expected call of LostPacket. -func (mr *MockConnectionTracerMockRecorder) LostPacket(arg0, arg1, arg2 any) *ConnectionTracerLostPacketCall { +func (mr *MockConnectionTracerMockRecorder) LostPacket(arg0, arg1, arg2 any) *MockConnectionTracerLostPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LostPacket", reflect.TypeOf((*MockConnectionTracer)(nil).LostPacket), arg0, arg1, arg2) - return &ConnectionTracerLostPacketCall{Call: call} + return &MockConnectionTracerLostPacketCall{Call: call} } -// ConnectionTracerLostPacketCall wrap *gomock.Call -type ConnectionTracerLostPacketCall struct { +// MockConnectionTracerLostPacketCall wrap *gomock.Call +type MockConnectionTracerLostPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerLostPacketCall) Return() *ConnectionTracerLostPacketCall { +func (c *MockConnectionTracerLostPacketCall) Return() *MockConnectionTracerLostPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerLostPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *ConnectionTracerLostPacketCall { +func (c *MockConnectionTracerLostPacketCall) Do(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerLostPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *ConnectionTracerLostPacketCall { +func (c *MockConnectionTracerLostPacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.PacketNumber, logging.PacketLossReason)) *MockConnectionTracerLostPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -518,31 +519,31 @@ func (m *MockConnectionTracer) NegotiatedVersion(arg0 protocol.Version, arg1, ar } // NegotiatedVersion indicates an expected call of NegotiatedVersion. -func (mr *MockConnectionTracerMockRecorder) NegotiatedVersion(arg0, arg1, arg2 any) *ConnectionTracerNegotiatedVersionCall { +func (mr *MockConnectionTracerMockRecorder) NegotiatedVersion(arg0, arg1, arg2 any) *MockConnectionTracerNegotiatedVersionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NegotiatedVersion", reflect.TypeOf((*MockConnectionTracer)(nil).NegotiatedVersion), arg0, arg1, arg2) - return &ConnectionTracerNegotiatedVersionCall{Call: call} + return &MockConnectionTracerNegotiatedVersionCall{Call: call} } -// ConnectionTracerNegotiatedVersionCall wrap *gomock.Call -type ConnectionTracerNegotiatedVersionCall struct { +// MockConnectionTracerNegotiatedVersionCall wrap *gomock.Call +type MockConnectionTracerNegotiatedVersionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerNegotiatedVersionCall) Return() *ConnectionTracerNegotiatedVersionCall { +func (c *MockConnectionTracerNegotiatedVersionCall) Return() *MockConnectionTracerNegotiatedVersionCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerNegotiatedVersionCall) Do(f func(protocol.Version, []protocol.Version, []protocol.Version)) *ConnectionTracerNegotiatedVersionCall { +func (c *MockConnectionTracerNegotiatedVersionCall) Do(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(protocol.Version, []protocol.Version, []protocol.Version)) *ConnectionTracerNegotiatedVersionCall { +func (c *MockConnectionTracerNegotiatedVersionCall) DoAndReturn(f func(protocol.Version, []protocol.Version, []protocol.Version)) *MockConnectionTracerNegotiatedVersionCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -554,31 +555,31 @@ func (m *MockConnectionTracer) ReceivedLongHeaderPacket(arg0 *wire.ExtendedHeade } // ReceivedLongHeaderPacket indicates an expected call of ReceivedLongHeaderPacket. -func (mr *MockConnectionTracerMockRecorder) ReceivedLongHeaderPacket(arg0, arg1, arg2, arg3 any) *ConnectionTracerReceivedLongHeaderPacketCall { +func (mr *MockConnectionTracerMockRecorder) ReceivedLongHeaderPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerReceivedLongHeaderPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedLongHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedLongHeaderPacket), arg0, arg1, arg2, arg3) - return &ConnectionTracerReceivedLongHeaderPacketCall{Call: call} + return &MockConnectionTracerReceivedLongHeaderPacketCall{Call: call} } -// ConnectionTracerReceivedLongHeaderPacketCall wrap *gomock.Call -type ConnectionTracerReceivedLongHeaderPacketCall struct { +// MockConnectionTracerReceivedLongHeaderPacketCall wrap *gomock.Call +type MockConnectionTracerReceivedLongHeaderPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerReceivedLongHeaderPacketCall) Return() *ConnectionTracerReceivedLongHeaderPacketCall { +func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Return() *MockConnectionTracerReceivedLongHeaderPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *ConnectionTracerReceivedLongHeaderPacketCall { +func (c *MockConnectionTracerReceivedLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *ConnectionTracerReceivedLongHeaderPacketCall { +func (c *MockConnectionTracerReceivedLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedLongHeaderPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -590,31 +591,31 @@ func (m *MockConnectionTracer) ReceivedRetry(arg0 *wire.Header) { } // ReceivedRetry indicates an expected call of ReceivedRetry. -func (mr *MockConnectionTracerMockRecorder) ReceivedRetry(arg0 any) *ConnectionTracerReceivedRetryCall { +func (mr *MockConnectionTracerMockRecorder) ReceivedRetry(arg0 any) *MockConnectionTracerReceivedRetryCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedRetry", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedRetry), arg0) - return &ConnectionTracerReceivedRetryCall{Call: call} + return &MockConnectionTracerReceivedRetryCall{Call: call} } -// ConnectionTracerReceivedRetryCall wrap *gomock.Call -type ConnectionTracerReceivedRetryCall struct { +// MockConnectionTracerReceivedRetryCall wrap *gomock.Call +type MockConnectionTracerReceivedRetryCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerReceivedRetryCall) Return() *ConnectionTracerReceivedRetryCall { +func (c *MockConnectionTracerReceivedRetryCall) Return() *MockConnectionTracerReceivedRetryCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerReceivedRetryCall) Do(f func(*wire.Header)) *ConnectionTracerReceivedRetryCall { +func (c *MockConnectionTracerReceivedRetryCall) Do(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerReceivedRetryCall) DoAndReturn(f func(*wire.Header)) *ConnectionTracerReceivedRetryCall { +func (c *MockConnectionTracerReceivedRetryCall) DoAndReturn(f func(*wire.Header)) *MockConnectionTracerReceivedRetryCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -626,31 +627,31 @@ func (m *MockConnectionTracer) ReceivedShortHeaderPacket(arg0 *logging.ShortHead } // ReceivedShortHeaderPacket indicates an expected call of ReceivedShortHeaderPacket. -func (mr *MockConnectionTracerMockRecorder) ReceivedShortHeaderPacket(arg0, arg1, arg2, arg3 any) *ConnectionTracerReceivedShortHeaderPacketCall { +func (mr *MockConnectionTracerMockRecorder) ReceivedShortHeaderPacket(arg0, arg1, arg2, arg3 any) *MockConnectionTracerReceivedShortHeaderPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedShortHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedShortHeaderPacket), arg0, arg1, arg2, arg3) - return &ConnectionTracerReceivedShortHeaderPacketCall{Call: call} + return &MockConnectionTracerReceivedShortHeaderPacketCall{Call: call} } -// ConnectionTracerReceivedShortHeaderPacketCall wrap *gomock.Call -type ConnectionTracerReceivedShortHeaderPacketCall struct { +// MockConnectionTracerReceivedShortHeaderPacketCall wrap *gomock.Call +type MockConnectionTracerReceivedShortHeaderPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerReceivedShortHeaderPacketCall) Return() *ConnectionTracerReceivedShortHeaderPacketCall { +func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Return() *MockConnectionTracerReceivedShortHeaderPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *ConnectionTracerReceivedShortHeaderPacketCall { +func (c *MockConnectionTracerReceivedShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *ConnectionTracerReceivedShortHeaderPacketCall { +func (c *MockConnectionTracerReceivedShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, []logging.Frame)) *MockConnectionTracerReceivedShortHeaderPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -662,31 +663,31 @@ func (m *MockConnectionTracer) ReceivedTransportParameters(arg0 *wire.TransportP } // ReceivedTransportParameters indicates an expected call of ReceivedTransportParameters. -func (mr *MockConnectionTracerMockRecorder) ReceivedTransportParameters(arg0 any) *ConnectionTracerReceivedTransportParametersCall { +func (mr *MockConnectionTracerMockRecorder) ReceivedTransportParameters(arg0 any) *MockConnectionTracerReceivedTransportParametersCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedTransportParameters), arg0) - return &ConnectionTracerReceivedTransportParametersCall{Call: call} + return &MockConnectionTracerReceivedTransportParametersCall{Call: call} } -// ConnectionTracerReceivedTransportParametersCall wrap *gomock.Call -type ConnectionTracerReceivedTransportParametersCall struct { +// MockConnectionTracerReceivedTransportParametersCall wrap *gomock.Call +type MockConnectionTracerReceivedTransportParametersCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerReceivedTransportParametersCall) Return() *ConnectionTracerReceivedTransportParametersCall { +func (c *MockConnectionTracerReceivedTransportParametersCall) Return() *MockConnectionTracerReceivedTransportParametersCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerReceivedTransportParametersCall) Do(f func(*wire.TransportParameters)) *ConnectionTracerReceivedTransportParametersCall { +func (c *MockConnectionTracerReceivedTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *ConnectionTracerReceivedTransportParametersCall { +func (c *MockConnectionTracerReceivedTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerReceivedTransportParametersCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -698,31 +699,31 @@ func (m *MockConnectionTracer) ReceivedVersionNegotiationPacket(arg0, arg1 proto } // ReceivedVersionNegotiationPacket indicates an expected call of ReceivedVersionNegotiationPacket. -func (mr *MockConnectionTracerMockRecorder) ReceivedVersionNegotiationPacket(arg0, arg1, arg2 any) *ConnectionTracerReceivedVersionNegotiationPacketCall { +func (mr *MockConnectionTracerMockRecorder) ReceivedVersionNegotiationPacket(arg0, arg1, arg2 any) *MockConnectionTracerReceivedVersionNegotiationPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceivedVersionNegotiationPacket", reflect.TypeOf((*MockConnectionTracer)(nil).ReceivedVersionNegotiationPacket), arg0, arg1, arg2) - return &ConnectionTracerReceivedVersionNegotiationPacketCall{Call: call} + return &MockConnectionTracerReceivedVersionNegotiationPacketCall{Call: call} } -// ConnectionTracerReceivedVersionNegotiationPacketCall wrap *gomock.Call -type ConnectionTracerReceivedVersionNegotiationPacketCall struct { +// MockConnectionTracerReceivedVersionNegotiationPacketCall wrap *gomock.Call +type MockConnectionTracerReceivedVersionNegotiationPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerReceivedVersionNegotiationPacketCall) Return() *ConnectionTracerReceivedVersionNegotiationPacketCall { +func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Return() *MockConnectionTracerReceivedVersionNegotiationPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *ConnectionTracerReceivedVersionNegotiationPacketCall { +func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) Do(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *ConnectionTracerReceivedVersionNegotiationPacketCall { +func (c *MockConnectionTracerReceivedVersionNegotiationPacketCall) DoAndReturn(f func(protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockConnectionTracerReceivedVersionNegotiationPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -734,31 +735,31 @@ func (m *MockConnectionTracer) RestoredTransportParameters(arg0 *wire.TransportP } // RestoredTransportParameters indicates an expected call of RestoredTransportParameters. -func (mr *MockConnectionTracerMockRecorder) RestoredTransportParameters(arg0 any) *ConnectionTracerRestoredTransportParametersCall { +func (mr *MockConnectionTracerMockRecorder) RestoredTransportParameters(arg0 any) *MockConnectionTracerRestoredTransportParametersCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoredTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).RestoredTransportParameters), arg0) - return &ConnectionTracerRestoredTransportParametersCall{Call: call} + return &MockConnectionTracerRestoredTransportParametersCall{Call: call} } -// ConnectionTracerRestoredTransportParametersCall wrap *gomock.Call -type ConnectionTracerRestoredTransportParametersCall struct { +// MockConnectionTracerRestoredTransportParametersCall wrap *gomock.Call +type MockConnectionTracerRestoredTransportParametersCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerRestoredTransportParametersCall) Return() *ConnectionTracerRestoredTransportParametersCall { +func (c *MockConnectionTracerRestoredTransportParametersCall) Return() *MockConnectionTracerRestoredTransportParametersCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerRestoredTransportParametersCall) Do(f func(*wire.TransportParameters)) *ConnectionTracerRestoredTransportParametersCall { +func (c *MockConnectionTracerRestoredTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *ConnectionTracerRestoredTransportParametersCall { +func (c *MockConnectionTracerRestoredTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerRestoredTransportParametersCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -770,31 +771,31 @@ func (m *MockConnectionTracer) SentLongHeaderPacket(arg0 *wire.ExtendedHeader, a } // SentLongHeaderPacket indicates an expected call of SentLongHeaderPacket. -func (mr *MockConnectionTracerMockRecorder) SentLongHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *ConnectionTracerSentLongHeaderPacketCall { +func (mr *MockConnectionTracerMockRecorder) SentLongHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *MockConnectionTracerSentLongHeaderPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentLongHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentLongHeaderPacket), arg0, arg1, arg2, arg3, arg4) - return &ConnectionTracerSentLongHeaderPacketCall{Call: call} + return &MockConnectionTracerSentLongHeaderPacketCall{Call: call} } -// ConnectionTracerSentLongHeaderPacketCall wrap *gomock.Call -type ConnectionTracerSentLongHeaderPacketCall struct { +// MockConnectionTracerSentLongHeaderPacketCall wrap *gomock.Call +type MockConnectionTracerSentLongHeaderPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerSentLongHeaderPacketCall) Return() *ConnectionTracerSentLongHeaderPacketCall { +func (c *MockConnectionTracerSentLongHeaderPacketCall) Return() *MockConnectionTracerSentLongHeaderPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerSentLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *ConnectionTracerSentLongHeaderPacketCall { +func (c *MockConnectionTracerSentLongHeaderPacketCall) Do(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *ConnectionTracerSentLongHeaderPacketCall { +func (c *MockConnectionTracerSentLongHeaderPacketCall) DoAndReturn(f func(*wire.ExtendedHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentLongHeaderPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -806,31 +807,31 @@ func (m *MockConnectionTracer) SentShortHeaderPacket(arg0 *logging.ShortHeader, } // SentShortHeaderPacket indicates an expected call of SentShortHeaderPacket. -func (mr *MockConnectionTracerMockRecorder) SentShortHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *ConnectionTracerSentShortHeaderPacketCall { +func (mr *MockConnectionTracerMockRecorder) SentShortHeaderPacket(arg0, arg1, arg2, arg3, arg4 any) *MockConnectionTracerSentShortHeaderPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentShortHeaderPacket", reflect.TypeOf((*MockConnectionTracer)(nil).SentShortHeaderPacket), arg0, arg1, arg2, arg3, arg4) - return &ConnectionTracerSentShortHeaderPacketCall{Call: call} + return &MockConnectionTracerSentShortHeaderPacketCall{Call: call} } -// ConnectionTracerSentShortHeaderPacketCall wrap *gomock.Call -type ConnectionTracerSentShortHeaderPacketCall struct { +// MockConnectionTracerSentShortHeaderPacketCall wrap *gomock.Call +type MockConnectionTracerSentShortHeaderPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerSentShortHeaderPacketCall) Return() *ConnectionTracerSentShortHeaderPacketCall { +func (c *MockConnectionTracerSentShortHeaderPacketCall) Return() *MockConnectionTracerSentShortHeaderPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *ConnectionTracerSentShortHeaderPacketCall { +func (c *MockConnectionTracerSentShortHeaderPacketCall) Do(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *ConnectionTracerSentShortHeaderPacketCall { +func (c *MockConnectionTracerSentShortHeaderPacketCall) DoAndReturn(f func(*logging.ShortHeader, protocol.ByteCount, protocol.ECN, *wire.AckFrame, []logging.Frame)) *MockConnectionTracerSentShortHeaderPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -842,31 +843,31 @@ func (m *MockConnectionTracer) SentTransportParameters(arg0 *wire.TransportParam } // SentTransportParameters indicates an expected call of SentTransportParameters. -func (mr *MockConnectionTracerMockRecorder) SentTransportParameters(arg0 any) *ConnectionTracerSentTransportParametersCall { +func (mr *MockConnectionTracerMockRecorder) SentTransportParameters(arg0 any) *MockConnectionTracerSentTransportParametersCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentTransportParameters", reflect.TypeOf((*MockConnectionTracer)(nil).SentTransportParameters), arg0) - return &ConnectionTracerSentTransportParametersCall{Call: call} + return &MockConnectionTracerSentTransportParametersCall{Call: call} } -// ConnectionTracerSentTransportParametersCall wrap *gomock.Call -type ConnectionTracerSentTransportParametersCall struct { +// MockConnectionTracerSentTransportParametersCall wrap *gomock.Call +type MockConnectionTracerSentTransportParametersCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerSentTransportParametersCall) Return() *ConnectionTracerSentTransportParametersCall { +func (c *MockConnectionTracerSentTransportParametersCall) Return() *MockConnectionTracerSentTransportParametersCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerSentTransportParametersCall) Do(f func(*wire.TransportParameters)) *ConnectionTracerSentTransportParametersCall { +func (c *MockConnectionTracerSentTransportParametersCall) Do(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *ConnectionTracerSentTransportParametersCall { +func (c *MockConnectionTracerSentTransportParametersCall) DoAndReturn(f func(*wire.TransportParameters)) *MockConnectionTracerSentTransportParametersCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -878,31 +879,31 @@ func (m *MockConnectionTracer) SetLossTimer(arg0 logging.TimerType, arg1 protoco } // SetLossTimer indicates an expected call of SetLossTimer. -func (mr *MockConnectionTracerMockRecorder) SetLossTimer(arg0, arg1, arg2 any) *ConnectionTracerSetLossTimerCall { +func (mr *MockConnectionTracerMockRecorder) SetLossTimer(arg0, arg1, arg2 any) *MockConnectionTracerSetLossTimerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLossTimer", reflect.TypeOf((*MockConnectionTracer)(nil).SetLossTimer), arg0, arg1, arg2) - return &ConnectionTracerSetLossTimerCall{Call: call} + return &MockConnectionTracerSetLossTimerCall{Call: call} } -// ConnectionTracerSetLossTimerCall wrap *gomock.Call -type ConnectionTracerSetLossTimerCall struct { +// MockConnectionTracerSetLossTimerCall wrap *gomock.Call +type MockConnectionTracerSetLossTimerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerSetLossTimerCall) Return() *ConnectionTracerSetLossTimerCall { +func (c *MockConnectionTracerSetLossTimerCall) Return() *MockConnectionTracerSetLossTimerCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *ConnectionTracerSetLossTimerCall { +func (c *MockConnectionTracerSetLossTimerCall) Do(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *ConnectionTracerSetLossTimerCall { +func (c *MockConnectionTracerSetLossTimerCall) DoAndReturn(f func(logging.TimerType, protocol.EncryptionLevel, time.Time)) *MockConnectionTracerSetLossTimerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -914,31 +915,31 @@ func (m *MockConnectionTracer) StartedConnection(arg0, arg1 net.Addr, arg2, arg3 } // StartedConnection indicates an expected call of StartedConnection. -func (mr *MockConnectionTracerMockRecorder) StartedConnection(arg0, arg1, arg2, arg3 any) *ConnectionTracerStartedConnectionCall { +func (mr *MockConnectionTracerMockRecorder) StartedConnection(arg0, arg1, arg2, arg3 any) *MockConnectionTracerStartedConnectionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartedConnection", reflect.TypeOf((*MockConnectionTracer)(nil).StartedConnection), arg0, arg1, arg2, arg3) - return &ConnectionTracerStartedConnectionCall{Call: call} + return &MockConnectionTracerStartedConnectionCall{Call: call} } -// ConnectionTracerStartedConnectionCall wrap *gomock.Call -type ConnectionTracerStartedConnectionCall struct { +// MockConnectionTracerStartedConnectionCall wrap *gomock.Call +type MockConnectionTracerStartedConnectionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerStartedConnectionCall) Return() *ConnectionTracerStartedConnectionCall { +func (c *MockConnectionTracerStartedConnectionCall) Return() *MockConnectionTracerStartedConnectionCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *ConnectionTracerStartedConnectionCall { +func (c *MockConnectionTracerStartedConnectionCall) Do(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *ConnectionTracerStartedConnectionCall { +func (c *MockConnectionTracerStartedConnectionCall) DoAndReturn(f func(net.Addr, net.Addr, protocol.ConnectionID, protocol.ConnectionID)) *MockConnectionTracerStartedConnectionCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -950,31 +951,31 @@ func (m *MockConnectionTracer) UpdatedCongestionState(arg0 logging.CongestionSta } // UpdatedCongestionState indicates an expected call of UpdatedCongestionState. -func (mr *MockConnectionTracerMockRecorder) UpdatedCongestionState(arg0 any) *ConnectionTracerUpdatedCongestionStateCall { +func (mr *MockConnectionTracerMockRecorder) UpdatedCongestionState(arg0 any) *MockConnectionTracerUpdatedCongestionStateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedCongestionState", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedCongestionState), arg0) - return &ConnectionTracerUpdatedCongestionStateCall{Call: call} + return &MockConnectionTracerUpdatedCongestionStateCall{Call: call} } -// ConnectionTracerUpdatedCongestionStateCall wrap *gomock.Call -type ConnectionTracerUpdatedCongestionStateCall struct { +// MockConnectionTracerUpdatedCongestionStateCall wrap *gomock.Call +type MockConnectionTracerUpdatedCongestionStateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerUpdatedCongestionStateCall) Return() *ConnectionTracerUpdatedCongestionStateCall { +func (c *MockConnectionTracerUpdatedCongestionStateCall) Return() *MockConnectionTracerUpdatedCongestionStateCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerUpdatedCongestionStateCall) Do(f func(logging.CongestionState)) *ConnectionTracerUpdatedCongestionStateCall { +func (c *MockConnectionTracerUpdatedCongestionStateCall) Do(f func(logging.CongestionState)) *MockConnectionTracerUpdatedCongestionStateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerUpdatedCongestionStateCall) DoAndReturn(f func(logging.CongestionState)) *ConnectionTracerUpdatedCongestionStateCall { +func (c *MockConnectionTracerUpdatedCongestionStateCall) DoAndReturn(f func(logging.CongestionState)) *MockConnectionTracerUpdatedCongestionStateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -986,31 +987,31 @@ func (m *MockConnectionTracer) UpdatedKey(arg0 protocol.KeyPhase, arg1 bool) { } // UpdatedKey indicates an expected call of UpdatedKey. -func (mr *MockConnectionTracerMockRecorder) UpdatedKey(arg0, arg1 any) *ConnectionTracerUpdatedKeyCall { +func (mr *MockConnectionTracerMockRecorder) UpdatedKey(arg0, arg1 any) *MockConnectionTracerUpdatedKeyCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKey", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKey), arg0, arg1) - return &ConnectionTracerUpdatedKeyCall{Call: call} + return &MockConnectionTracerUpdatedKeyCall{Call: call} } -// ConnectionTracerUpdatedKeyCall wrap *gomock.Call -type ConnectionTracerUpdatedKeyCall struct { +// MockConnectionTracerUpdatedKeyCall wrap *gomock.Call +type MockConnectionTracerUpdatedKeyCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerUpdatedKeyCall) Return() *ConnectionTracerUpdatedKeyCall { +func (c *MockConnectionTracerUpdatedKeyCall) Return() *MockConnectionTracerUpdatedKeyCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerUpdatedKeyCall) Do(f func(protocol.KeyPhase, bool)) *ConnectionTracerUpdatedKeyCall { +func (c *MockConnectionTracerUpdatedKeyCall) Do(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerUpdatedKeyCall) DoAndReturn(f func(protocol.KeyPhase, bool)) *ConnectionTracerUpdatedKeyCall { +func (c *MockConnectionTracerUpdatedKeyCall) DoAndReturn(f func(protocol.KeyPhase, bool)) *MockConnectionTracerUpdatedKeyCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -1022,31 +1023,31 @@ func (m *MockConnectionTracer) UpdatedKeyFromTLS(arg0 protocol.EncryptionLevel, } // UpdatedKeyFromTLS indicates an expected call of UpdatedKeyFromTLS. -func (mr *MockConnectionTracerMockRecorder) UpdatedKeyFromTLS(arg0, arg1 any) *ConnectionTracerUpdatedKeyFromTLSCall { +func (mr *MockConnectionTracerMockRecorder) UpdatedKeyFromTLS(arg0, arg1 any) *MockConnectionTracerUpdatedKeyFromTLSCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedKeyFromTLS", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedKeyFromTLS), arg0, arg1) - return &ConnectionTracerUpdatedKeyFromTLSCall{Call: call} + return &MockConnectionTracerUpdatedKeyFromTLSCall{Call: call} } -// ConnectionTracerUpdatedKeyFromTLSCall wrap *gomock.Call -type ConnectionTracerUpdatedKeyFromTLSCall struct { +// MockConnectionTracerUpdatedKeyFromTLSCall wrap *gomock.Call +type MockConnectionTracerUpdatedKeyFromTLSCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerUpdatedKeyFromTLSCall) Return() *ConnectionTracerUpdatedKeyFromTLSCall { +func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Return() *MockConnectionTracerUpdatedKeyFromTLSCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerUpdatedKeyFromTLSCall) Do(f func(protocol.EncryptionLevel, protocol.Perspective)) *ConnectionTracerUpdatedKeyFromTLSCall { +func (c *MockConnectionTracerUpdatedKeyFromTLSCall) Do(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.Perspective)) *ConnectionTracerUpdatedKeyFromTLSCall { +func (c *MockConnectionTracerUpdatedKeyFromTLSCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.Perspective)) *MockConnectionTracerUpdatedKeyFromTLSCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -1058,31 +1059,31 @@ func (m *MockConnectionTracer) UpdatedMetrics(arg0 *utils.RTTStats, arg1, arg2 p } // UpdatedMetrics indicates an expected call of UpdatedMetrics. -func (mr *MockConnectionTracerMockRecorder) UpdatedMetrics(arg0, arg1, arg2, arg3 any) *ConnectionTracerUpdatedMetricsCall { +func (mr *MockConnectionTracerMockRecorder) UpdatedMetrics(arg0, arg1, arg2, arg3 any) *MockConnectionTracerUpdatedMetricsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedMetrics", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedMetrics), arg0, arg1, arg2, arg3) - return &ConnectionTracerUpdatedMetricsCall{Call: call} + return &MockConnectionTracerUpdatedMetricsCall{Call: call} } -// ConnectionTracerUpdatedMetricsCall wrap *gomock.Call -type ConnectionTracerUpdatedMetricsCall struct { +// MockConnectionTracerUpdatedMetricsCall wrap *gomock.Call +type MockConnectionTracerUpdatedMetricsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerUpdatedMetricsCall) Return() *ConnectionTracerUpdatedMetricsCall { +func (c *MockConnectionTracerUpdatedMetricsCall) Return() *MockConnectionTracerUpdatedMetricsCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerUpdatedMetricsCall) Do(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *ConnectionTracerUpdatedMetricsCall { +func (c *MockConnectionTracerUpdatedMetricsCall) Do(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *ConnectionTracerUpdatedMetricsCall { +func (c *MockConnectionTracerUpdatedMetricsCall) DoAndReturn(f func(*utils.RTTStats, protocol.ByteCount, protocol.ByteCount, int)) *MockConnectionTracerUpdatedMetricsCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -1094,31 +1095,31 @@ func (m *MockConnectionTracer) UpdatedPTOCount(arg0 uint32) { } // UpdatedPTOCount indicates an expected call of UpdatedPTOCount. -func (mr *MockConnectionTracerMockRecorder) UpdatedPTOCount(arg0 any) *ConnectionTracerUpdatedPTOCountCall { +func (mr *MockConnectionTracerMockRecorder) UpdatedPTOCount(arg0 any) *MockConnectionTracerUpdatedPTOCountCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedPTOCount", reflect.TypeOf((*MockConnectionTracer)(nil).UpdatedPTOCount), arg0) - return &ConnectionTracerUpdatedPTOCountCall{Call: call} + return &MockConnectionTracerUpdatedPTOCountCall{Call: call} } -// ConnectionTracerUpdatedPTOCountCall wrap *gomock.Call -type ConnectionTracerUpdatedPTOCountCall struct { +// MockConnectionTracerUpdatedPTOCountCall wrap *gomock.Call +type MockConnectionTracerUpdatedPTOCountCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnectionTracerUpdatedPTOCountCall) Return() *ConnectionTracerUpdatedPTOCountCall { +func (c *MockConnectionTracerUpdatedPTOCountCall) Return() *MockConnectionTracerUpdatedPTOCountCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnectionTracerUpdatedPTOCountCall) Do(f func(uint32)) *ConnectionTracerUpdatedPTOCountCall { +func (c *MockConnectionTracerUpdatedPTOCountCall) Do(f func(uint32)) *MockConnectionTracerUpdatedPTOCountCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnectionTracerUpdatedPTOCountCall) DoAndReturn(f func(uint32)) *ConnectionTracerUpdatedPTOCountCall { +func (c *MockConnectionTracerUpdatedPTOCountCall) DoAndReturn(f func(uint32)) *MockConnectionTracerUpdatedPTOCountCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/logging/internal/tracer.go b/internal/mocks/logging/internal/tracer.go index f8f3ae0e..2565203c 100644 --- a/internal/mocks/logging/internal/tracer.go +++ b/internal/mocks/logging/internal/tracer.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package internal -destination internal/tracer.go github.com/quic-go/quic-go/internal/mocks/logging Tracer // + // Package internal is a generated GoMock package. package internal @@ -48,31 +49,31 @@ func (m *MockTracer) Close() { } // Close indicates an expected call of Close. -func (mr *MockTracerMockRecorder) Close() *TracerCloseCall { +func (mr *MockTracerMockRecorder) Close() *MockTracerCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTracer)(nil).Close)) - return &TracerCloseCall{Call: call} + return &MockTracerCloseCall{Call: call} } -// TracerCloseCall wrap *gomock.Call -type TracerCloseCall struct { +// MockTracerCloseCall wrap *gomock.Call +type MockTracerCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TracerCloseCall) Return() *TracerCloseCall { +func (c *MockTracerCloseCall) Return() *MockTracerCloseCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TracerCloseCall) Do(f func()) *TracerCloseCall { +func (c *MockTracerCloseCall) Do(f func()) *MockTracerCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TracerCloseCall) DoAndReturn(f func()) *TracerCloseCall { +func (c *MockTracerCloseCall) DoAndReturn(f func()) *MockTracerCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -84,31 +85,31 @@ func (m *MockTracer) Debug(arg0, arg1 string) { } // Debug indicates an expected call of Debug. -func (mr *MockTracerMockRecorder) Debug(arg0, arg1 any) *TracerDebugCall { +func (mr *MockTracerMockRecorder) Debug(arg0, arg1 any) *MockTracerDebugCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debug", reflect.TypeOf((*MockTracer)(nil).Debug), arg0, arg1) - return &TracerDebugCall{Call: call} + return &MockTracerDebugCall{Call: call} } -// TracerDebugCall wrap *gomock.Call -type TracerDebugCall struct { +// MockTracerDebugCall wrap *gomock.Call +type MockTracerDebugCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TracerDebugCall) Return() *TracerDebugCall { +func (c *MockTracerDebugCall) Return() *MockTracerDebugCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TracerDebugCall) Do(f func(string, string)) *TracerDebugCall { +func (c *MockTracerDebugCall) Do(f func(string, string)) *MockTracerDebugCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TracerDebugCall) DoAndReturn(f func(string, string)) *TracerDebugCall { +func (c *MockTracerDebugCall) DoAndReturn(f func(string, string)) *MockTracerDebugCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -120,31 +121,31 @@ func (m *MockTracer) DroppedPacket(arg0 net.Addr, arg1 logging.PacketType, arg2 } // DroppedPacket indicates an expected call of DroppedPacket. -func (mr *MockTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 any) *TracerDroppedPacketCall { +func (mr *MockTracerMockRecorder) DroppedPacket(arg0, arg1, arg2, arg3 any) *MockTracerDroppedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DroppedPacket", reflect.TypeOf((*MockTracer)(nil).DroppedPacket), arg0, arg1, arg2, arg3) - return &TracerDroppedPacketCall{Call: call} + return &MockTracerDroppedPacketCall{Call: call} } -// TracerDroppedPacketCall wrap *gomock.Call -type TracerDroppedPacketCall struct { +// MockTracerDroppedPacketCall wrap *gomock.Call +type MockTracerDroppedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TracerDroppedPacketCall) Return() *TracerDroppedPacketCall { +func (c *MockTracerDroppedPacketCall) Return() *MockTracerDroppedPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *TracerDroppedPacketCall { +func (c *MockTracerDroppedPacketCall) Do(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *TracerDroppedPacketCall { +func (c *MockTracerDroppedPacketCall) DoAndReturn(f func(net.Addr, logging.PacketType, protocol.ByteCount, logging.PacketDropReason)) *MockTracerDroppedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -156,31 +157,31 @@ func (m *MockTracer) SentPacket(arg0 net.Addr, arg1 *wire.Header, arg2 protocol. } // SentPacket indicates an expected call of SentPacket. -func (mr *MockTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 any) *TracerSentPacketCall { +func (mr *MockTracerMockRecorder) SentPacket(arg0, arg1, arg2, arg3 any) *MockTracerSentPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentPacket", reflect.TypeOf((*MockTracer)(nil).SentPacket), arg0, arg1, arg2, arg3) - return &TracerSentPacketCall{Call: call} + return &MockTracerSentPacketCall{Call: call} } -// TracerSentPacketCall wrap *gomock.Call -type TracerSentPacketCall struct { +// MockTracerSentPacketCall wrap *gomock.Call +type MockTracerSentPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TracerSentPacketCall) Return() *TracerSentPacketCall { +func (c *MockTracerSentPacketCall) Return() *MockTracerSentPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TracerSentPacketCall) Do(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *TracerSentPacketCall { +func (c *MockTracerSentPacketCall) Do(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TracerSentPacketCall) DoAndReturn(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *TracerSentPacketCall { +func (c *MockTracerSentPacketCall) DoAndReturn(f func(net.Addr, *wire.Header, protocol.ByteCount, []logging.Frame)) *MockTracerSentPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -192,31 +193,31 @@ func (m *MockTracer) SentVersionNegotiationPacket(arg0 net.Addr, arg1, arg2 prot } // SentVersionNegotiationPacket indicates an expected call of SentVersionNegotiationPacket. -func (mr *MockTracerMockRecorder) SentVersionNegotiationPacket(arg0, arg1, arg2, arg3 any) *TracerSentVersionNegotiationPacketCall { +func (mr *MockTracerMockRecorder) SentVersionNegotiationPacket(arg0, arg1, arg2, arg3 any) *MockTracerSentVersionNegotiationPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SentVersionNegotiationPacket", reflect.TypeOf((*MockTracer)(nil).SentVersionNegotiationPacket), arg0, arg1, arg2, arg3) - return &TracerSentVersionNegotiationPacketCall{Call: call} + return &MockTracerSentVersionNegotiationPacketCall{Call: call} } -// TracerSentVersionNegotiationPacketCall wrap *gomock.Call -type TracerSentVersionNegotiationPacketCall struct { +// MockTracerSentVersionNegotiationPacketCall wrap *gomock.Call +type MockTracerSentVersionNegotiationPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TracerSentVersionNegotiationPacketCall) Return() *TracerSentVersionNegotiationPacketCall { +func (c *MockTracerSentVersionNegotiationPacketCall) Return() *MockTracerSentVersionNegotiationPacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *TracerSentVersionNegotiationPacketCall { +func (c *MockTracerSentVersionNegotiationPacketCall) Do(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *TracerSentVersionNegotiationPacketCall { +func (c *MockTracerSentVersionNegotiationPacketCall) DoAndReturn(f func(net.Addr, protocol.ArbitraryLenConnectionID, protocol.ArbitraryLenConnectionID, []protocol.Version)) *MockTracerSentVersionNegotiationPacketCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/long_header_opener.go b/internal/mocks/long_header_opener.go index b1c608a0..3473e586 100644 --- a/internal/mocks/long_header_opener.go +++ b/internal/mocks/long_header_opener.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination long_header_opener.go github.com/quic-go/quic-go/internal/handshake LongHeaderOpener // + // Package mocks is a generated GoMock package. package mocks @@ -47,31 +48,31 @@ func (m *MockLongHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, ar } // DecodePacketNumber indicates an expected call of DecodePacketNumber. -func (mr *MockLongHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *LongHeaderOpenerDecodePacketNumberCall { +func (mr *MockLongHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *MockLongHeaderOpenerDecodePacketNumberCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePacketNumber", reflect.TypeOf((*MockLongHeaderOpener)(nil).DecodePacketNumber), arg0, arg1) - return &LongHeaderOpenerDecodePacketNumberCall{Call: call} + return &MockLongHeaderOpenerDecodePacketNumberCall{Call: call} } -// LongHeaderOpenerDecodePacketNumberCall wrap *gomock.Call -type LongHeaderOpenerDecodePacketNumberCall struct { +// MockLongHeaderOpenerDecodePacketNumberCall wrap *gomock.Call +type MockLongHeaderOpenerDecodePacketNumberCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *LongHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *LongHeaderOpenerDecodePacketNumberCall { +func (c *MockLongHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *LongHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *LongHeaderOpenerDecodePacketNumberCall { +func (c *MockLongHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *LongHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *LongHeaderOpenerDecodePacketNumberCall { +func (c *MockLongHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockLongHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockLongHeaderOpener) DecryptHeader(arg0 []byte, arg1 *byte, arg2 []byt } // DecryptHeader indicates an expected call of DecryptHeader. -func (mr *MockLongHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *LongHeaderOpenerDecryptHeaderCall { +func (mr *MockLongHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *MockLongHeaderOpenerDecryptHeaderCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptHeader", reflect.TypeOf((*MockLongHeaderOpener)(nil).DecryptHeader), arg0, arg1, arg2) - return &LongHeaderOpenerDecryptHeaderCall{Call: call} + return &MockLongHeaderOpenerDecryptHeaderCall{Call: call} } -// LongHeaderOpenerDecryptHeaderCall wrap *gomock.Call -type LongHeaderOpenerDecryptHeaderCall struct { +// MockLongHeaderOpenerDecryptHeaderCall wrap *gomock.Call +type MockLongHeaderOpenerDecryptHeaderCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *LongHeaderOpenerDecryptHeaderCall) Return() *LongHeaderOpenerDecryptHeaderCall { +func (c *MockLongHeaderOpenerDecryptHeaderCall) Return() *MockLongHeaderOpenerDecryptHeaderCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *LongHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *LongHeaderOpenerDecryptHeaderCall { +func (c *MockLongHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockLongHeaderOpenerDecryptHeaderCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *LongHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *LongHeaderOpenerDecryptHeaderCall { +func (c *MockLongHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockLongHeaderOpenerDecryptHeaderCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -122,31 +123,31 @@ func (m *MockLongHeaderOpener) Open(arg0, arg1 []byte, arg2 protocol.PacketNumbe } // Open indicates an expected call of Open. -func (mr *MockLongHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 any) *LongHeaderOpenerOpenCall { +func (mr *MockLongHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3 any) *MockLongHeaderOpenerOpenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockLongHeaderOpener)(nil).Open), arg0, arg1, arg2, arg3) - return &LongHeaderOpenerOpenCall{Call: call} + return &MockLongHeaderOpenerOpenCall{Call: call} } -// LongHeaderOpenerOpenCall wrap *gomock.Call -type LongHeaderOpenerOpenCall struct { +// MockLongHeaderOpenerOpenCall wrap *gomock.Call +type MockLongHeaderOpenerOpenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *LongHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *LongHeaderOpenerOpenCall { +func (c *MockLongHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *MockLongHeaderOpenerOpenCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *LongHeaderOpenerOpenCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *LongHeaderOpenerOpenCall { +func (c *MockLongHeaderOpenerOpenCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *MockLongHeaderOpenerOpenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *LongHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *LongHeaderOpenerOpenCall { +func (c *MockLongHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) ([]byte, error)) *MockLongHeaderOpenerOpenCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/quic/early_conn.go b/internal/mocks/quic/early_conn.go index 2e726a82..f08f0481 100644 --- a/internal/mocks/quic/early_conn.go +++ b/internal/mocks/quic/early_conn.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mockquic -destination quic/early_conn_tmp.go github.com/quic-go/quic-go EarlyConnection // + // Package mockquic is a generated GoMock package. package mockquic @@ -51,31 +52,31 @@ func (m *MockEarlyConnection) AcceptStream(arg0 context.Context) (quic.Stream, e } // AcceptStream indicates an expected call of AcceptStream. -func (mr *MockEarlyConnectionMockRecorder) AcceptStream(arg0 any) *EarlyConnectionAcceptStreamCall { +func (mr *MockEarlyConnectionMockRecorder) AcceptStream(arg0 any) *MockEarlyConnectionAcceptStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockEarlyConnection)(nil).AcceptStream), arg0) - return &EarlyConnectionAcceptStreamCall{Call: call} + return &MockEarlyConnectionAcceptStreamCall{Call: call} } -// EarlyConnectionAcceptStreamCall wrap *gomock.Call -type EarlyConnectionAcceptStreamCall struct { +// MockEarlyConnectionAcceptStreamCall wrap *gomock.Call +type MockEarlyConnectionAcceptStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionAcceptStreamCall) Return(arg0 quic.Stream, arg1 error) *EarlyConnectionAcceptStreamCall { +func (c *MockEarlyConnectionAcceptStreamCall) Return(arg0 quic.Stream, arg1 error) *MockEarlyConnectionAcceptStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionAcceptStreamCall) Do(f func(context.Context) (quic.Stream, error)) *EarlyConnectionAcceptStreamCall { +func (c *MockEarlyConnectionAcceptStreamCall) Do(f func(context.Context) (quic.Stream, error)) *MockEarlyConnectionAcceptStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionAcceptStreamCall) DoAndReturn(f func(context.Context) (quic.Stream, error)) *EarlyConnectionAcceptStreamCall { +func (c *MockEarlyConnectionAcceptStreamCall) DoAndReturn(f func(context.Context) (quic.Stream, error)) *MockEarlyConnectionAcceptStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -90,31 +91,31 @@ func (m *MockEarlyConnection) AcceptUniStream(arg0 context.Context) (quic.Receiv } // AcceptUniStream indicates an expected call of AcceptUniStream. -func (mr *MockEarlyConnectionMockRecorder) AcceptUniStream(arg0 any) *EarlyConnectionAcceptUniStreamCall { +func (mr *MockEarlyConnectionMockRecorder) AcceptUniStream(arg0 any) *MockEarlyConnectionAcceptUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockEarlyConnection)(nil).AcceptUniStream), arg0) - return &EarlyConnectionAcceptUniStreamCall{Call: call} + return &MockEarlyConnectionAcceptUniStreamCall{Call: call} } -// EarlyConnectionAcceptUniStreamCall wrap *gomock.Call -type EarlyConnectionAcceptUniStreamCall struct { +// MockEarlyConnectionAcceptUniStreamCall wrap *gomock.Call +type MockEarlyConnectionAcceptUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionAcceptUniStreamCall) Return(arg0 quic.ReceiveStream, arg1 error) *EarlyConnectionAcceptUniStreamCall { +func (c *MockEarlyConnectionAcceptUniStreamCall) Return(arg0 quic.ReceiveStream, arg1 error) *MockEarlyConnectionAcceptUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionAcceptUniStreamCall) Do(f func(context.Context) (quic.ReceiveStream, error)) *EarlyConnectionAcceptUniStreamCall { +func (c *MockEarlyConnectionAcceptUniStreamCall) Do(f func(context.Context) (quic.ReceiveStream, error)) *MockEarlyConnectionAcceptUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionAcceptUniStreamCall) DoAndReturn(f func(context.Context) (quic.ReceiveStream, error)) *EarlyConnectionAcceptUniStreamCall { +func (c *MockEarlyConnectionAcceptUniStreamCall) DoAndReturn(f func(context.Context) (quic.ReceiveStream, error)) *MockEarlyConnectionAcceptUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -128,31 +129,31 @@ func (m *MockEarlyConnection) CloseWithError(arg0 qerr.ApplicationErrorCode, arg } // CloseWithError indicates an expected call of CloseWithError. -func (mr *MockEarlyConnectionMockRecorder) CloseWithError(arg0, arg1 any) *EarlyConnectionCloseWithErrorCall { +func (mr *MockEarlyConnectionMockRecorder) CloseWithError(arg0, arg1 any) *MockEarlyConnectionCloseWithErrorCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockEarlyConnection)(nil).CloseWithError), arg0, arg1) - return &EarlyConnectionCloseWithErrorCall{Call: call} + return &MockEarlyConnectionCloseWithErrorCall{Call: call} } -// EarlyConnectionCloseWithErrorCall wrap *gomock.Call -type EarlyConnectionCloseWithErrorCall struct { +// MockEarlyConnectionCloseWithErrorCall wrap *gomock.Call +type MockEarlyConnectionCloseWithErrorCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionCloseWithErrorCall) Return(arg0 error) *EarlyConnectionCloseWithErrorCall { +func (c *MockEarlyConnectionCloseWithErrorCall) Return(arg0 error) *MockEarlyConnectionCloseWithErrorCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *EarlyConnectionCloseWithErrorCall { +func (c *MockEarlyConnectionCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *EarlyConnectionCloseWithErrorCall { +func (c *MockEarlyConnectionCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockEarlyConnectionCloseWithErrorCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -166,31 +167,31 @@ func (m *MockEarlyConnection) ConnectionState() quic.ConnectionState { } // ConnectionState indicates an expected call of ConnectionState. -func (mr *MockEarlyConnectionMockRecorder) ConnectionState() *EarlyConnectionConnectionStateCall { +func (mr *MockEarlyConnectionMockRecorder) ConnectionState() *MockEarlyConnectionConnectionStateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockEarlyConnection)(nil).ConnectionState)) - return &EarlyConnectionConnectionStateCall{Call: call} + return &MockEarlyConnectionConnectionStateCall{Call: call} } -// EarlyConnectionConnectionStateCall wrap *gomock.Call -type EarlyConnectionConnectionStateCall struct { +// MockEarlyConnectionConnectionStateCall wrap *gomock.Call +type MockEarlyConnectionConnectionStateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionConnectionStateCall) Return(arg0 quic.ConnectionState) *EarlyConnectionConnectionStateCall { +func (c *MockEarlyConnectionConnectionStateCall) Return(arg0 quic.ConnectionState) *MockEarlyConnectionConnectionStateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionConnectionStateCall) Do(f func() quic.ConnectionState) *EarlyConnectionConnectionStateCall { +func (c *MockEarlyConnectionConnectionStateCall) Do(f func() quic.ConnectionState) *MockEarlyConnectionConnectionStateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionConnectionStateCall) DoAndReturn(f func() quic.ConnectionState) *EarlyConnectionConnectionStateCall { +func (c *MockEarlyConnectionConnectionStateCall) DoAndReturn(f func() quic.ConnectionState) *MockEarlyConnectionConnectionStateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -204,31 +205,31 @@ func (m *MockEarlyConnection) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockEarlyConnectionMockRecorder) Context() *EarlyConnectionContextCall { +func (mr *MockEarlyConnectionMockRecorder) Context() *MockEarlyConnectionContextCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockEarlyConnection)(nil).Context)) - return &EarlyConnectionContextCall{Call: call} + return &MockEarlyConnectionContextCall{Call: call} } -// EarlyConnectionContextCall wrap *gomock.Call -type EarlyConnectionContextCall struct { +// MockEarlyConnectionContextCall wrap *gomock.Call +type MockEarlyConnectionContextCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionContextCall) Return(arg0 context.Context) *EarlyConnectionContextCall { +func (c *MockEarlyConnectionContextCall) Return(arg0 context.Context) *MockEarlyConnectionContextCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionContextCall) Do(f func() context.Context) *EarlyConnectionContextCall { +func (c *MockEarlyConnectionContextCall) Do(f func() context.Context) *MockEarlyConnectionContextCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionContextCall) DoAndReturn(f func() context.Context) *EarlyConnectionContextCall { +func (c *MockEarlyConnectionContextCall) DoAndReturn(f func() context.Context) *MockEarlyConnectionContextCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -242,31 +243,31 @@ func (m *MockEarlyConnection) HandshakeComplete() <-chan struct{} { } // HandshakeComplete indicates an expected call of HandshakeComplete. -func (mr *MockEarlyConnectionMockRecorder) HandshakeComplete() *EarlyConnectionHandshakeCompleteCall { +func (mr *MockEarlyConnectionMockRecorder) HandshakeComplete() *MockEarlyConnectionHandshakeCompleteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandshakeComplete", reflect.TypeOf((*MockEarlyConnection)(nil).HandshakeComplete)) - return &EarlyConnectionHandshakeCompleteCall{Call: call} + return &MockEarlyConnectionHandshakeCompleteCall{Call: call} } -// EarlyConnectionHandshakeCompleteCall wrap *gomock.Call -type EarlyConnectionHandshakeCompleteCall struct { +// MockEarlyConnectionHandshakeCompleteCall wrap *gomock.Call +type MockEarlyConnectionHandshakeCompleteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionHandshakeCompleteCall) Return(arg0 <-chan struct{}) *EarlyConnectionHandshakeCompleteCall { +func (c *MockEarlyConnectionHandshakeCompleteCall) Return(arg0 <-chan struct{}) *MockEarlyConnectionHandshakeCompleteCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionHandshakeCompleteCall) Do(f func() <-chan struct{}) *EarlyConnectionHandshakeCompleteCall { +func (c *MockEarlyConnectionHandshakeCompleteCall) Do(f func() <-chan struct{}) *MockEarlyConnectionHandshakeCompleteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionHandshakeCompleteCall) DoAndReturn(f func() <-chan struct{}) *EarlyConnectionHandshakeCompleteCall { +func (c *MockEarlyConnectionHandshakeCompleteCall) DoAndReturn(f func() <-chan struct{}) *MockEarlyConnectionHandshakeCompleteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -280,31 +281,31 @@ func (m *MockEarlyConnection) LocalAddr() net.Addr { } // LocalAddr indicates an expected call of LocalAddr. -func (mr *MockEarlyConnectionMockRecorder) LocalAddr() *EarlyConnectionLocalAddrCall { +func (mr *MockEarlyConnectionMockRecorder) LocalAddr() *MockEarlyConnectionLocalAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockEarlyConnection)(nil).LocalAddr)) - return &EarlyConnectionLocalAddrCall{Call: call} + return &MockEarlyConnectionLocalAddrCall{Call: call} } -// EarlyConnectionLocalAddrCall wrap *gomock.Call -type EarlyConnectionLocalAddrCall struct { +// MockEarlyConnectionLocalAddrCall wrap *gomock.Call +type MockEarlyConnectionLocalAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionLocalAddrCall) Return(arg0 net.Addr) *EarlyConnectionLocalAddrCall { +func (c *MockEarlyConnectionLocalAddrCall) Return(arg0 net.Addr) *MockEarlyConnectionLocalAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionLocalAddrCall) Do(f func() net.Addr) *EarlyConnectionLocalAddrCall { +func (c *MockEarlyConnectionLocalAddrCall) Do(f func() net.Addr) *MockEarlyConnectionLocalAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionLocalAddrCall) DoAndReturn(f func() net.Addr) *EarlyConnectionLocalAddrCall { +func (c *MockEarlyConnectionLocalAddrCall) DoAndReturn(f func() net.Addr) *MockEarlyConnectionLocalAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -318,31 +319,31 @@ func (m *MockEarlyConnection) NextConnection() quic.Connection { } // NextConnection indicates an expected call of NextConnection. -func (mr *MockEarlyConnectionMockRecorder) NextConnection() *EarlyConnectionNextConnectionCall { +func (mr *MockEarlyConnectionMockRecorder) NextConnection() *MockEarlyConnectionNextConnectionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextConnection", reflect.TypeOf((*MockEarlyConnection)(nil).NextConnection)) - return &EarlyConnectionNextConnectionCall{Call: call} + return &MockEarlyConnectionNextConnectionCall{Call: call} } -// EarlyConnectionNextConnectionCall wrap *gomock.Call -type EarlyConnectionNextConnectionCall struct { +// MockEarlyConnectionNextConnectionCall wrap *gomock.Call +type MockEarlyConnectionNextConnectionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionNextConnectionCall) Return(arg0 quic.Connection) *EarlyConnectionNextConnectionCall { +func (c *MockEarlyConnectionNextConnectionCall) Return(arg0 quic.Connection) *MockEarlyConnectionNextConnectionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionNextConnectionCall) Do(f func() quic.Connection) *EarlyConnectionNextConnectionCall { +func (c *MockEarlyConnectionNextConnectionCall) Do(f func() quic.Connection) *MockEarlyConnectionNextConnectionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionNextConnectionCall) DoAndReturn(f func() quic.Connection) *EarlyConnectionNextConnectionCall { +func (c *MockEarlyConnectionNextConnectionCall) DoAndReturn(f func() quic.Connection) *MockEarlyConnectionNextConnectionCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -357,31 +358,31 @@ func (m *MockEarlyConnection) OpenStream() (quic.Stream, error) { } // OpenStream indicates an expected call of OpenStream. -func (mr *MockEarlyConnectionMockRecorder) OpenStream() *EarlyConnectionOpenStreamCall { +func (mr *MockEarlyConnectionMockRecorder) OpenStream() *MockEarlyConnectionOpenStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockEarlyConnection)(nil).OpenStream)) - return &EarlyConnectionOpenStreamCall{Call: call} + return &MockEarlyConnectionOpenStreamCall{Call: call} } -// EarlyConnectionOpenStreamCall wrap *gomock.Call -type EarlyConnectionOpenStreamCall struct { +// MockEarlyConnectionOpenStreamCall wrap *gomock.Call +type MockEarlyConnectionOpenStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionOpenStreamCall) Return(arg0 quic.Stream, arg1 error) *EarlyConnectionOpenStreamCall { +func (c *MockEarlyConnectionOpenStreamCall) Return(arg0 quic.Stream, arg1 error) *MockEarlyConnectionOpenStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionOpenStreamCall) Do(f func() (quic.Stream, error)) *EarlyConnectionOpenStreamCall { +func (c *MockEarlyConnectionOpenStreamCall) Do(f func() (quic.Stream, error)) *MockEarlyConnectionOpenStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionOpenStreamCall) DoAndReturn(f func() (quic.Stream, error)) *EarlyConnectionOpenStreamCall { +func (c *MockEarlyConnectionOpenStreamCall) DoAndReturn(f func() (quic.Stream, error)) *MockEarlyConnectionOpenStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -396,31 +397,31 @@ func (m *MockEarlyConnection) OpenStreamSync(arg0 context.Context) (quic.Stream, } // OpenStreamSync indicates an expected call of OpenStreamSync. -func (mr *MockEarlyConnectionMockRecorder) OpenStreamSync(arg0 any) *EarlyConnectionOpenStreamSyncCall { +func (mr *MockEarlyConnectionMockRecorder) OpenStreamSync(arg0 any) *MockEarlyConnectionOpenStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockEarlyConnection)(nil).OpenStreamSync), arg0) - return &EarlyConnectionOpenStreamSyncCall{Call: call} + return &MockEarlyConnectionOpenStreamSyncCall{Call: call} } -// EarlyConnectionOpenStreamSyncCall wrap *gomock.Call -type EarlyConnectionOpenStreamSyncCall struct { +// MockEarlyConnectionOpenStreamSyncCall wrap *gomock.Call +type MockEarlyConnectionOpenStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionOpenStreamSyncCall) Return(arg0 quic.Stream, arg1 error) *EarlyConnectionOpenStreamSyncCall { +func (c *MockEarlyConnectionOpenStreamSyncCall) Return(arg0 quic.Stream, arg1 error) *MockEarlyConnectionOpenStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionOpenStreamSyncCall) Do(f func(context.Context) (quic.Stream, error)) *EarlyConnectionOpenStreamSyncCall { +func (c *MockEarlyConnectionOpenStreamSyncCall) Do(f func(context.Context) (quic.Stream, error)) *MockEarlyConnectionOpenStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionOpenStreamSyncCall) DoAndReturn(f func(context.Context) (quic.Stream, error)) *EarlyConnectionOpenStreamSyncCall { +func (c *MockEarlyConnectionOpenStreamSyncCall) DoAndReturn(f func(context.Context) (quic.Stream, error)) *MockEarlyConnectionOpenStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -435,31 +436,31 @@ func (m *MockEarlyConnection) OpenUniStream() (quic.SendStream, error) { } // OpenUniStream indicates an expected call of OpenUniStream. -func (mr *MockEarlyConnectionMockRecorder) OpenUniStream() *EarlyConnectionOpenUniStreamCall { +func (mr *MockEarlyConnectionMockRecorder) OpenUniStream() *MockEarlyConnectionOpenUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockEarlyConnection)(nil).OpenUniStream)) - return &EarlyConnectionOpenUniStreamCall{Call: call} + return &MockEarlyConnectionOpenUniStreamCall{Call: call} } -// EarlyConnectionOpenUniStreamCall wrap *gomock.Call -type EarlyConnectionOpenUniStreamCall struct { +// MockEarlyConnectionOpenUniStreamCall wrap *gomock.Call +type MockEarlyConnectionOpenUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionOpenUniStreamCall) Return(arg0 quic.SendStream, arg1 error) *EarlyConnectionOpenUniStreamCall { +func (c *MockEarlyConnectionOpenUniStreamCall) Return(arg0 quic.SendStream, arg1 error) *MockEarlyConnectionOpenUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionOpenUniStreamCall) Do(f func() (quic.SendStream, error)) *EarlyConnectionOpenUniStreamCall { +func (c *MockEarlyConnectionOpenUniStreamCall) Do(f func() (quic.SendStream, error)) *MockEarlyConnectionOpenUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionOpenUniStreamCall) DoAndReturn(f func() (quic.SendStream, error)) *EarlyConnectionOpenUniStreamCall { +func (c *MockEarlyConnectionOpenUniStreamCall) DoAndReturn(f func() (quic.SendStream, error)) *MockEarlyConnectionOpenUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -474,31 +475,31 @@ func (m *MockEarlyConnection) OpenUniStreamSync(arg0 context.Context) (quic.Send } // OpenUniStreamSync indicates an expected call of OpenUniStreamSync. -func (mr *MockEarlyConnectionMockRecorder) OpenUniStreamSync(arg0 any) *EarlyConnectionOpenUniStreamSyncCall { +func (mr *MockEarlyConnectionMockRecorder) OpenUniStreamSync(arg0 any) *MockEarlyConnectionOpenUniStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockEarlyConnection)(nil).OpenUniStreamSync), arg0) - return &EarlyConnectionOpenUniStreamSyncCall{Call: call} + return &MockEarlyConnectionOpenUniStreamSyncCall{Call: call} } -// EarlyConnectionOpenUniStreamSyncCall wrap *gomock.Call -type EarlyConnectionOpenUniStreamSyncCall struct { +// MockEarlyConnectionOpenUniStreamSyncCall wrap *gomock.Call +type MockEarlyConnectionOpenUniStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionOpenUniStreamSyncCall) Return(arg0 quic.SendStream, arg1 error) *EarlyConnectionOpenUniStreamSyncCall { +func (c *MockEarlyConnectionOpenUniStreamSyncCall) Return(arg0 quic.SendStream, arg1 error) *MockEarlyConnectionOpenUniStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionOpenUniStreamSyncCall) Do(f func(context.Context) (quic.SendStream, error)) *EarlyConnectionOpenUniStreamSyncCall { +func (c *MockEarlyConnectionOpenUniStreamSyncCall) Do(f func(context.Context) (quic.SendStream, error)) *MockEarlyConnectionOpenUniStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (quic.SendStream, error)) *EarlyConnectionOpenUniStreamSyncCall { +func (c *MockEarlyConnectionOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (quic.SendStream, error)) *MockEarlyConnectionOpenUniStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -513,31 +514,31 @@ func (m *MockEarlyConnection) ReceiveDatagram(arg0 context.Context) ([]byte, err } // ReceiveDatagram indicates an expected call of ReceiveDatagram. -func (mr *MockEarlyConnectionMockRecorder) ReceiveDatagram(arg0 any) *EarlyConnectionReceiveDatagramCall { +func (mr *MockEarlyConnectionMockRecorder) ReceiveDatagram(arg0 any) *MockEarlyConnectionReceiveDatagramCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveDatagram", reflect.TypeOf((*MockEarlyConnection)(nil).ReceiveDatagram), arg0) - return &EarlyConnectionReceiveDatagramCall{Call: call} + return &MockEarlyConnectionReceiveDatagramCall{Call: call} } -// EarlyConnectionReceiveDatagramCall wrap *gomock.Call -type EarlyConnectionReceiveDatagramCall struct { +// MockEarlyConnectionReceiveDatagramCall wrap *gomock.Call +type MockEarlyConnectionReceiveDatagramCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionReceiveDatagramCall) Return(arg0 []byte, arg1 error) *EarlyConnectionReceiveDatagramCall { +func (c *MockEarlyConnectionReceiveDatagramCall) Return(arg0 []byte, arg1 error) *MockEarlyConnectionReceiveDatagramCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionReceiveDatagramCall) Do(f func(context.Context) ([]byte, error)) *EarlyConnectionReceiveDatagramCall { +func (c *MockEarlyConnectionReceiveDatagramCall) Do(f func(context.Context) ([]byte, error)) *MockEarlyConnectionReceiveDatagramCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionReceiveDatagramCall) DoAndReturn(f func(context.Context) ([]byte, error)) *EarlyConnectionReceiveDatagramCall { +func (c *MockEarlyConnectionReceiveDatagramCall) DoAndReturn(f func(context.Context) ([]byte, error)) *MockEarlyConnectionReceiveDatagramCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -551,31 +552,31 @@ func (m *MockEarlyConnection) RemoteAddr() net.Addr { } // RemoteAddr indicates an expected call of RemoteAddr. -func (mr *MockEarlyConnectionMockRecorder) RemoteAddr() *EarlyConnectionRemoteAddrCall { +func (mr *MockEarlyConnectionMockRecorder) RemoteAddr() *MockEarlyConnectionRemoteAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockEarlyConnection)(nil).RemoteAddr)) - return &EarlyConnectionRemoteAddrCall{Call: call} + return &MockEarlyConnectionRemoteAddrCall{Call: call} } -// EarlyConnectionRemoteAddrCall wrap *gomock.Call -type EarlyConnectionRemoteAddrCall struct { +// MockEarlyConnectionRemoteAddrCall wrap *gomock.Call +type MockEarlyConnectionRemoteAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionRemoteAddrCall) Return(arg0 net.Addr) *EarlyConnectionRemoteAddrCall { +func (c *MockEarlyConnectionRemoteAddrCall) Return(arg0 net.Addr) *MockEarlyConnectionRemoteAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionRemoteAddrCall) Do(f func() net.Addr) *EarlyConnectionRemoteAddrCall { +func (c *MockEarlyConnectionRemoteAddrCall) Do(f func() net.Addr) *MockEarlyConnectionRemoteAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionRemoteAddrCall) DoAndReturn(f func() net.Addr) *EarlyConnectionRemoteAddrCall { +func (c *MockEarlyConnectionRemoteAddrCall) DoAndReturn(f func() net.Addr) *MockEarlyConnectionRemoteAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -589,31 +590,31 @@ func (m *MockEarlyConnection) SendDatagram(arg0 []byte) error { } // SendDatagram indicates an expected call of SendDatagram. -func (mr *MockEarlyConnectionMockRecorder) SendDatagram(arg0 any) *EarlyConnectionSendDatagramCall { +func (mr *MockEarlyConnectionMockRecorder) SendDatagram(arg0 any) *MockEarlyConnectionSendDatagramCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDatagram", reflect.TypeOf((*MockEarlyConnection)(nil).SendDatagram), arg0) - return &EarlyConnectionSendDatagramCall{Call: call} + return &MockEarlyConnectionSendDatagramCall{Call: call} } -// EarlyConnectionSendDatagramCall wrap *gomock.Call -type EarlyConnectionSendDatagramCall struct { +// MockEarlyConnectionSendDatagramCall wrap *gomock.Call +type MockEarlyConnectionSendDatagramCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *EarlyConnectionSendDatagramCall) Return(arg0 error) *EarlyConnectionSendDatagramCall { +func (c *MockEarlyConnectionSendDatagramCall) Return(arg0 error) *MockEarlyConnectionSendDatagramCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *EarlyConnectionSendDatagramCall) Do(f func([]byte) error) *EarlyConnectionSendDatagramCall { +func (c *MockEarlyConnectionSendDatagramCall) Do(f func([]byte) error) *MockEarlyConnectionSendDatagramCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *EarlyConnectionSendDatagramCall) DoAndReturn(f func([]byte) error) *EarlyConnectionSendDatagramCall { +func (c *MockEarlyConnectionSendDatagramCall) DoAndReturn(f func([]byte) error) *MockEarlyConnectionSendDatagramCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/quic/stream.go b/internal/mocks/quic/stream.go index 2999b269..16b1f59d 100644 --- a/internal/mocks/quic/stream.go +++ b/internal/mocks/quic/stream.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mockquic -destination quic/stream.go github.com/quic-go/quic-go Stream // + // Package mockquic is a generated GoMock package. package mockquic @@ -48,31 +49,31 @@ func (m *MockStream) CancelRead(arg0 qerr.StreamErrorCode) { } // CancelRead indicates an expected call of CancelRead. -func (mr *MockStreamMockRecorder) CancelRead(arg0 any) *StreamCancelReadCall { +func (mr *MockStreamMockRecorder) CancelRead(arg0 any) *MockStreamCancelReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStream)(nil).CancelRead), arg0) - return &StreamCancelReadCall{Call: call} + return &MockStreamCancelReadCall{Call: call} } -// StreamCancelReadCall wrap *gomock.Call -type StreamCancelReadCall struct { +// MockStreamCancelReadCall wrap *gomock.Call +type MockStreamCancelReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamCancelReadCall) Return() *StreamCancelReadCall { +func (c *MockStreamCancelReadCall) Return() *MockStreamCancelReadCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamCancelReadCall) Do(f func(qerr.StreamErrorCode)) *StreamCancelReadCall { +func (c *MockStreamCancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamCancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *StreamCancelReadCall { +func (c *MockStreamCancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -84,31 +85,31 @@ func (m *MockStream) CancelWrite(arg0 qerr.StreamErrorCode) { } // CancelWrite indicates an expected call of CancelWrite. -func (mr *MockStreamMockRecorder) CancelWrite(arg0 any) *StreamCancelWriteCall { +func (mr *MockStreamMockRecorder) CancelWrite(arg0 any) *MockStreamCancelWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStream)(nil).CancelWrite), arg0) - return &StreamCancelWriteCall{Call: call} + return &MockStreamCancelWriteCall{Call: call} } -// StreamCancelWriteCall wrap *gomock.Call -type StreamCancelWriteCall struct { +// MockStreamCancelWriteCall wrap *gomock.Call +type MockStreamCancelWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamCancelWriteCall) Return() *StreamCancelWriteCall { +func (c *MockStreamCancelWriteCall) Return() *MockStreamCancelWriteCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamCancelWriteCall) Do(f func(qerr.StreamErrorCode)) *StreamCancelWriteCall { +func (c *MockStreamCancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamCancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *StreamCancelWriteCall { +func (c *MockStreamCancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamCancelWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -122,31 +123,31 @@ func (m *MockStream) Close() error { } // Close indicates an expected call of Close. -func (mr *MockStreamMockRecorder) Close() *StreamCloseCall { +func (mr *MockStreamMockRecorder) Close() *MockStreamCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStream)(nil).Close)) - return &StreamCloseCall{Call: call} + return &MockStreamCloseCall{Call: call} } -// StreamCloseCall wrap *gomock.Call -type StreamCloseCall struct { +// MockStreamCloseCall wrap *gomock.Call +type MockStreamCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamCloseCall) Return(arg0 error) *StreamCloseCall { +func (c *MockStreamCloseCall) Return(arg0 error) *MockStreamCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamCloseCall) Do(f func() error) *StreamCloseCall { +func (c *MockStreamCloseCall) Do(f func() error) *MockStreamCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamCloseCall) DoAndReturn(f func() error) *StreamCloseCall { +func (c *MockStreamCloseCall) DoAndReturn(f func() error) *MockStreamCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -160,31 +161,31 @@ func (m *MockStream) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockStreamMockRecorder) Context() *StreamContextCall { +func (mr *MockStreamMockRecorder) Context() *MockStreamContextCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStream)(nil).Context)) - return &StreamContextCall{Call: call} + return &MockStreamContextCall{Call: call} } -// StreamContextCall wrap *gomock.Call -type StreamContextCall struct { +// MockStreamContextCall wrap *gomock.Call +type MockStreamContextCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamContextCall) Return(arg0 context.Context) *StreamContextCall { +func (c *MockStreamContextCall) Return(arg0 context.Context) *MockStreamContextCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamContextCall) Do(f func() context.Context) *StreamContextCall { +func (c *MockStreamContextCall) Do(f func() context.Context) *MockStreamContextCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamContextCall) DoAndReturn(f func() context.Context) *StreamContextCall { +func (c *MockStreamContextCall) DoAndReturn(f func() context.Context) *MockStreamContextCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -199,31 +200,31 @@ func (m *MockStream) Read(arg0 []byte) (int, error) { } // Read indicates an expected call of Read. -func (mr *MockStreamMockRecorder) Read(arg0 any) *StreamReadCall { +func (mr *MockStreamMockRecorder) Read(arg0 any) *MockStreamReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStream)(nil).Read), arg0) - return &StreamReadCall{Call: call} + return &MockStreamReadCall{Call: call} } -// StreamReadCall wrap *gomock.Call -type StreamReadCall struct { +// MockStreamReadCall wrap *gomock.Call +type MockStreamReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamReadCall) Return(arg0 int, arg1 error) *StreamReadCall { +func (c *MockStreamReadCall) Return(arg0 int, arg1 error) *MockStreamReadCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamReadCall) Do(f func([]byte) (int, error)) *StreamReadCall { +func (c *MockStreamReadCall) Do(f func([]byte) (int, error)) *MockStreamReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamReadCall) DoAndReturn(f func([]byte) (int, error)) *StreamReadCall { +func (c *MockStreamReadCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -237,31 +238,31 @@ func (m *MockStream) SetDeadline(arg0 time.Time) error { } // SetDeadline indicates an expected call of SetDeadline. -func (mr *MockStreamMockRecorder) SetDeadline(arg0 any) *StreamSetDeadlineCall { +func (mr *MockStreamMockRecorder) SetDeadline(arg0 any) *MockStreamSetDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStream)(nil).SetDeadline), arg0) - return &StreamSetDeadlineCall{Call: call} + return &MockStreamSetDeadlineCall{Call: call} } -// StreamSetDeadlineCall wrap *gomock.Call -type StreamSetDeadlineCall struct { +// MockStreamSetDeadlineCall wrap *gomock.Call +type MockStreamSetDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSetDeadlineCall) Return(arg0 error) *StreamSetDeadlineCall { +func (c *MockStreamSetDeadlineCall) Return(arg0 error) *MockStreamSetDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamSetDeadlineCall) Do(f func(time.Time) error) *StreamSetDeadlineCall { +func (c *MockStreamSetDeadlineCall) Do(f func(time.Time) error) *MockStreamSetDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSetDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamSetDeadlineCall { +func (c *MockStreamSetDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamSetDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -275,31 +276,31 @@ func (m *MockStream) SetReadDeadline(arg0 time.Time) error { } // SetReadDeadline indicates an expected call of SetReadDeadline. -func (mr *MockStreamMockRecorder) SetReadDeadline(arg0 any) *StreamSetReadDeadlineCall { +func (mr *MockStreamMockRecorder) SetReadDeadline(arg0 any) *MockStreamSetReadDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStream)(nil).SetReadDeadline), arg0) - return &StreamSetReadDeadlineCall{Call: call} + return &MockStreamSetReadDeadlineCall{Call: call} } -// StreamSetReadDeadlineCall wrap *gomock.Call -type StreamSetReadDeadlineCall struct { +// MockStreamSetReadDeadlineCall wrap *gomock.Call +type MockStreamSetReadDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSetReadDeadlineCall) Return(arg0 error) *StreamSetReadDeadlineCall { +func (c *MockStreamSetReadDeadlineCall) Return(arg0 error) *MockStreamSetReadDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamSetReadDeadlineCall) Do(f func(time.Time) error) *StreamSetReadDeadlineCall { +func (c *MockStreamSetReadDeadlineCall) Do(f func(time.Time) error) *MockStreamSetReadDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamSetReadDeadlineCall { +func (c *MockStreamSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamSetReadDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -313,31 +314,31 @@ func (m *MockStream) SetWriteDeadline(arg0 time.Time) error { } // SetWriteDeadline indicates an expected call of SetWriteDeadline. -func (mr *MockStreamMockRecorder) SetWriteDeadline(arg0 any) *StreamSetWriteDeadlineCall { +func (mr *MockStreamMockRecorder) SetWriteDeadline(arg0 any) *MockStreamSetWriteDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStream)(nil).SetWriteDeadline), arg0) - return &StreamSetWriteDeadlineCall{Call: call} + return &MockStreamSetWriteDeadlineCall{Call: call} } -// StreamSetWriteDeadlineCall wrap *gomock.Call -type StreamSetWriteDeadlineCall struct { +// MockStreamSetWriteDeadlineCall wrap *gomock.Call +type MockStreamSetWriteDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSetWriteDeadlineCall) Return(arg0 error) *StreamSetWriteDeadlineCall { +func (c *MockStreamSetWriteDeadlineCall) Return(arg0 error) *MockStreamSetWriteDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamSetWriteDeadlineCall) Do(f func(time.Time) error) *StreamSetWriteDeadlineCall { +func (c *MockStreamSetWriteDeadlineCall) Do(f func(time.Time) error) *MockStreamSetWriteDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamSetWriteDeadlineCall { +func (c *MockStreamSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamSetWriteDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -351,31 +352,31 @@ func (m *MockStream) StreamID() protocol.StreamID { } // StreamID indicates an expected call of StreamID. -func (mr *MockStreamMockRecorder) StreamID() *StreamStreamIDCall { +func (mr *MockStreamMockRecorder) StreamID() *MockStreamStreamIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStream)(nil).StreamID)) - return &StreamStreamIDCall{Call: call} + return &MockStreamStreamIDCall{Call: call} } -// StreamStreamIDCall wrap *gomock.Call -type StreamStreamIDCall struct { +// MockStreamStreamIDCall wrap *gomock.Call +type MockStreamStreamIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamStreamIDCall) Return(arg0 protocol.StreamID) *StreamStreamIDCall { +func (c *MockStreamStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamStreamIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamStreamIDCall) Do(f func() protocol.StreamID) *StreamStreamIDCall { +func (c *MockStreamStreamIDCall) Do(f func() protocol.StreamID) *MockStreamStreamIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamStreamIDCall) DoAndReturn(f func() protocol.StreamID) *StreamStreamIDCall { +func (c *MockStreamStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamStreamIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -390,31 +391,31 @@ func (m *MockStream) Write(arg0 []byte) (int, error) { } // Write indicates an expected call of Write. -func (mr *MockStreamMockRecorder) Write(arg0 any) *StreamWriteCall { +func (mr *MockStreamMockRecorder) Write(arg0 any) *MockStreamWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStream)(nil).Write), arg0) - return &StreamWriteCall{Call: call} + return &MockStreamWriteCall{Call: call} } -// StreamWriteCall wrap *gomock.Call -type StreamWriteCall struct { +// MockStreamWriteCall wrap *gomock.Call +type MockStreamWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamWriteCall) Return(arg0 int, arg1 error) *StreamWriteCall { +func (c *MockStreamWriteCall) Return(arg0 int, arg1 error) *MockStreamWriteCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamWriteCall) Do(f func([]byte) (int, error)) *StreamWriteCall { +func (c *MockStreamWriteCall) Do(f func([]byte) (int, error)) *MockStreamWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamWriteCall) DoAndReturn(f func([]byte) (int, error)) *StreamWriteCall { +func (c *MockStreamWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamWriteCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/short_header_opener.go b/internal/mocks/short_header_opener.go index 859565a2..3fb68ad1 100644 --- a/internal/mocks/short_header_opener.go +++ b/internal/mocks/short_header_opener.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination short_header_opener.go github.com/quic-go/quic-go/internal/handshake ShortHeaderOpener // + // Package mocks is a generated GoMock package. package mocks @@ -48,31 +49,31 @@ func (m *MockShortHeaderOpener) DecodePacketNumber(arg0 protocol.PacketNumber, a } // DecodePacketNumber indicates an expected call of DecodePacketNumber. -func (mr *MockShortHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *ShortHeaderOpenerDecodePacketNumberCall { +func (mr *MockShortHeaderOpenerMockRecorder) DecodePacketNumber(arg0, arg1 any) *MockShortHeaderOpenerDecodePacketNumberCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodePacketNumber", reflect.TypeOf((*MockShortHeaderOpener)(nil).DecodePacketNumber), arg0, arg1) - return &ShortHeaderOpenerDecodePacketNumberCall{Call: call} + return &MockShortHeaderOpenerDecodePacketNumberCall{Call: call} } -// ShortHeaderOpenerDecodePacketNumberCall wrap *gomock.Call -type ShortHeaderOpenerDecodePacketNumberCall struct { +// MockShortHeaderOpenerDecodePacketNumberCall wrap *gomock.Call +type MockShortHeaderOpenerDecodePacketNumberCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *ShortHeaderOpenerDecodePacketNumberCall { +func (c *MockShortHeaderOpenerDecodePacketNumberCall) Return(arg0 protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *ShortHeaderOpenerDecodePacketNumberCall { +func (c *MockShortHeaderOpenerDecodePacketNumberCall) Do(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *ShortHeaderOpenerDecodePacketNumberCall { +func (c *MockShortHeaderOpenerDecodePacketNumberCall) DoAndReturn(f func(protocol.PacketNumber, protocol.PacketNumberLen) protocol.PacketNumber) *MockShortHeaderOpenerDecodePacketNumberCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -84,31 +85,31 @@ func (m *MockShortHeaderOpener) DecryptHeader(arg0 []byte, arg1 *byte, arg2 []by } // DecryptHeader indicates an expected call of DecryptHeader. -func (mr *MockShortHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *ShortHeaderOpenerDecryptHeaderCall { +func (mr *MockShortHeaderOpenerMockRecorder) DecryptHeader(arg0, arg1, arg2 any) *MockShortHeaderOpenerDecryptHeaderCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecryptHeader", reflect.TypeOf((*MockShortHeaderOpener)(nil).DecryptHeader), arg0, arg1, arg2) - return &ShortHeaderOpenerDecryptHeaderCall{Call: call} + return &MockShortHeaderOpenerDecryptHeaderCall{Call: call} } -// ShortHeaderOpenerDecryptHeaderCall wrap *gomock.Call -type ShortHeaderOpenerDecryptHeaderCall struct { +// MockShortHeaderOpenerDecryptHeaderCall wrap *gomock.Call +type MockShortHeaderOpenerDecryptHeaderCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderOpenerDecryptHeaderCall) Return() *ShortHeaderOpenerDecryptHeaderCall { +func (c *MockShortHeaderOpenerDecryptHeaderCall) Return() *MockShortHeaderOpenerDecryptHeaderCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *ShortHeaderOpenerDecryptHeaderCall { +func (c *MockShortHeaderOpenerDecryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockShortHeaderOpenerDecryptHeaderCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *ShortHeaderOpenerDecryptHeaderCall { +func (c *MockShortHeaderOpenerDecryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockShortHeaderOpenerDecryptHeaderCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -123,31 +124,31 @@ func (m *MockShortHeaderOpener) Open(arg0, arg1 []byte, arg2 time.Time, arg3 pro } // Open indicates an expected call of Open. -func (mr *MockShortHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4, arg5 any) *ShortHeaderOpenerOpenCall { +func (mr *MockShortHeaderOpenerMockRecorder) Open(arg0, arg1, arg2, arg3, arg4, arg5 any) *MockShortHeaderOpenerOpenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Open", reflect.TypeOf((*MockShortHeaderOpener)(nil).Open), arg0, arg1, arg2, arg3, arg4, arg5) - return &ShortHeaderOpenerOpenCall{Call: call} + return &MockShortHeaderOpenerOpenCall{Call: call} } -// ShortHeaderOpenerOpenCall wrap *gomock.Call -type ShortHeaderOpenerOpenCall struct { +// MockShortHeaderOpenerOpenCall wrap *gomock.Call +type MockShortHeaderOpenerOpenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *ShortHeaderOpenerOpenCall { +func (c *MockShortHeaderOpenerOpenCall) Return(arg0 []byte, arg1 error) *MockShortHeaderOpenerOpenCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderOpenerOpenCall) Do(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *ShortHeaderOpenerOpenCall { +func (c *MockShortHeaderOpenerOpenCall) Do(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *MockShortHeaderOpenerOpenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *ShortHeaderOpenerOpenCall { +func (c *MockShortHeaderOpenerOpenCall) DoAndReturn(f func([]byte, []byte, time.Time, protocol.PacketNumber, protocol.KeyPhaseBit, []byte) ([]byte, error)) *MockShortHeaderOpenerOpenCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/short_header_sealer.go b/internal/mocks/short_header_sealer.go index bd3333be..54d15abb 100644 --- a/internal/mocks/short_header_sealer.go +++ b/internal/mocks/short_header_sealer.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination short_header_sealer.go github.com/quic-go/quic-go/internal/handshake ShortHeaderSealer // + // Package mocks is a generated GoMock package. package mocks @@ -45,31 +46,31 @@ func (m *MockShortHeaderSealer) EncryptHeader(arg0 []byte, arg1 *byte, arg2 []by } // EncryptHeader indicates an expected call of EncryptHeader. -func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 any) *ShortHeaderSealerEncryptHeaderCall { +func (mr *MockShortHeaderSealerMockRecorder) EncryptHeader(arg0, arg1, arg2 any) *MockShortHeaderSealerEncryptHeaderCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncryptHeader", reflect.TypeOf((*MockShortHeaderSealer)(nil).EncryptHeader), arg0, arg1, arg2) - return &ShortHeaderSealerEncryptHeaderCall{Call: call} + return &MockShortHeaderSealerEncryptHeaderCall{Call: call} } -// ShortHeaderSealerEncryptHeaderCall wrap *gomock.Call -type ShortHeaderSealerEncryptHeaderCall struct { +// MockShortHeaderSealerEncryptHeaderCall wrap *gomock.Call +type MockShortHeaderSealerEncryptHeaderCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderSealerEncryptHeaderCall) Return() *ShortHeaderSealerEncryptHeaderCall { +func (c *MockShortHeaderSealerEncryptHeaderCall) Return() *MockShortHeaderSealerEncryptHeaderCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderSealerEncryptHeaderCall) Do(f func([]byte, *byte, []byte)) *ShortHeaderSealerEncryptHeaderCall { +func (c *MockShortHeaderSealerEncryptHeaderCall) Do(f func([]byte, *byte, []byte)) *MockShortHeaderSealerEncryptHeaderCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderSealerEncryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *ShortHeaderSealerEncryptHeaderCall { +func (c *MockShortHeaderSealerEncryptHeaderCall) DoAndReturn(f func([]byte, *byte, []byte)) *MockShortHeaderSealerEncryptHeaderCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockShortHeaderSealer) KeyPhase() protocol.KeyPhaseBit { } // KeyPhase indicates an expected call of KeyPhase. -func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *ShortHeaderSealerKeyPhaseCall { +func (mr *MockShortHeaderSealerMockRecorder) KeyPhase() *MockShortHeaderSealerKeyPhaseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyPhase", reflect.TypeOf((*MockShortHeaderSealer)(nil).KeyPhase)) - return &ShortHeaderSealerKeyPhaseCall{Call: call} + return &MockShortHeaderSealerKeyPhaseCall{Call: call} } -// ShortHeaderSealerKeyPhaseCall wrap *gomock.Call -type ShortHeaderSealerKeyPhaseCall struct { +// MockShortHeaderSealerKeyPhaseCall wrap *gomock.Call +type MockShortHeaderSealerKeyPhaseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderSealerKeyPhaseCall) Return(arg0 protocol.KeyPhaseBit) *ShortHeaderSealerKeyPhaseCall { +func (c *MockShortHeaderSealerKeyPhaseCall) Return(arg0 protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderSealerKeyPhaseCall) Do(f func() protocol.KeyPhaseBit) *ShortHeaderSealerKeyPhaseCall { +func (c *MockShortHeaderSealerKeyPhaseCall) Do(f func() protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderSealerKeyPhaseCall) DoAndReturn(f func() protocol.KeyPhaseBit) *ShortHeaderSealerKeyPhaseCall { +func (c *MockShortHeaderSealerKeyPhaseCall) DoAndReturn(f func() protocol.KeyPhaseBit) *MockShortHeaderSealerKeyPhaseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -121,31 +122,31 @@ func (m *MockShortHeaderSealer) Overhead() int { } // Overhead indicates an expected call of Overhead. -func (mr *MockShortHeaderSealerMockRecorder) Overhead() *ShortHeaderSealerOverheadCall { +func (mr *MockShortHeaderSealerMockRecorder) Overhead() *MockShortHeaderSealerOverheadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Overhead", reflect.TypeOf((*MockShortHeaderSealer)(nil).Overhead)) - return &ShortHeaderSealerOverheadCall{Call: call} + return &MockShortHeaderSealerOverheadCall{Call: call} } -// ShortHeaderSealerOverheadCall wrap *gomock.Call -type ShortHeaderSealerOverheadCall struct { +// MockShortHeaderSealerOverheadCall wrap *gomock.Call +type MockShortHeaderSealerOverheadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderSealerOverheadCall) Return(arg0 int) *ShortHeaderSealerOverheadCall { +func (c *MockShortHeaderSealerOverheadCall) Return(arg0 int) *MockShortHeaderSealerOverheadCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderSealerOverheadCall) Do(f func() int) *ShortHeaderSealerOverheadCall { +func (c *MockShortHeaderSealerOverheadCall) Do(f func() int) *MockShortHeaderSealerOverheadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderSealerOverheadCall) DoAndReturn(f func() int) *ShortHeaderSealerOverheadCall { +func (c *MockShortHeaderSealerOverheadCall) DoAndReturn(f func() int) *MockShortHeaderSealerOverheadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -159,31 +160,31 @@ func (m *MockShortHeaderSealer) Seal(arg0, arg1 []byte, arg2 protocol.PacketNumb } // Seal indicates an expected call of Seal. -func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 any) *ShortHeaderSealerSealCall { +func (mr *MockShortHeaderSealerMockRecorder) Seal(arg0, arg1, arg2, arg3 any) *MockShortHeaderSealerSealCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seal", reflect.TypeOf((*MockShortHeaderSealer)(nil).Seal), arg0, arg1, arg2, arg3) - return &ShortHeaderSealerSealCall{Call: call} + return &MockShortHeaderSealerSealCall{Call: call} } -// ShortHeaderSealerSealCall wrap *gomock.Call -type ShortHeaderSealerSealCall struct { +// MockShortHeaderSealerSealCall wrap *gomock.Call +type MockShortHeaderSealerSealCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ShortHeaderSealerSealCall) Return(arg0 []byte) *ShortHeaderSealerSealCall { +func (c *MockShortHeaderSealerSealCall) Return(arg0 []byte) *MockShortHeaderSealerSealCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ShortHeaderSealerSealCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *ShortHeaderSealerSealCall { +func (c *MockShortHeaderSealerSealCall) Do(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *MockShortHeaderSealerSealCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ShortHeaderSealerSealCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *ShortHeaderSealerSealCall { +func (c *MockShortHeaderSealerSealCall) DoAndReturn(f func([]byte, []byte, protocol.PacketNumber, []byte) []byte) *MockShortHeaderSealerSealCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/stream_flow_controller.go b/internal/mocks/stream_flow_controller.go index 2e244dfb..c1ba9468 100644 --- a/internal/mocks/stream_flow_controller.go +++ b/internal/mocks/stream_flow_controller.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocks -destination stream_flow_controller.go github.com/quic-go/quic-go/internal/flowcontrol StreamFlowController // + // Package mocks is a generated GoMock package. package mocks @@ -45,31 +46,31 @@ func (m *MockStreamFlowController) Abandon() { } // Abandon indicates an expected call of Abandon. -func (mr *MockStreamFlowControllerMockRecorder) Abandon() *StreamFlowControllerAbandonCall { +func (mr *MockStreamFlowControllerMockRecorder) Abandon() *MockStreamFlowControllerAbandonCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Abandon", reflect.TypeOf((*MockStreamFlowController)(nil).Abandon)) - return &StreamFlowControllerAbandonCall{Call: call} + return &MockStreamFlowControllerAbandonCall{Call: call} } -// StreamFlowControllerAbandonCall wrap *gomock.Call -type StreamFlowControllerAbandonCall struct { +// MockStreamFlowControllerAbandonCall wrap *gomock.Call +type MockStreamFlowControllerAbandonCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerAbandonCall) Return() *StreamFlowControllerAbandonCall { +func (c *MockStreamFlowControllerAbandonCall) Return() *MockStreamFlowControllerAbandonCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerAbandonCall) Do(f func()) *StreamFlowControllerAbandonCall { +func (c *MockStreamFlowControllerAbandonCall) Do(f func()) *MockStreamFlowControllerAbandonCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerAbandonCall) DoAndReturn(f func()) *StreamFlowControllerAbandonCall { +func (c *MockStreamFlowControllerAbandonCall) DoAndReturn(f func()) *MockStreamFlowControllerAbandonCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -81,31 +82,31 @@ func (m *MockStreamFlowController) AddBytesRead(arg0 protocol.ByteCount) { } // AddBytesRead indicates an expected call of AddBytesRead. -func (mr *MockStreamFlowControllerMockRecorder) AddBytesRead(arg0 any) *StreamFlowControllerAddBytesReadCall { +func (mr *MockStreamFlowControllerMockRecorder) AddBytesRead(arg0 any) *MockStreamFlowControllerAddBytesReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesRead", reflect.TypeOf((*MockStreamFlowController)(nil).AddBytesRead), arg0) - return &StreamFlowControllerAddBytesReadCall{Call: call} + return &MockStreamFlowControllerAddBytesReadCall{Call: call} } -// StreamFlowControllerAddBytesReadCall wrap *gomock.Call -type StreamFlowControllerAddBytesReadCall struct { +// MockStreamFlowControllerAddBytesReadCall wrap *gomock.Call +type MockStreamFlowControllerAddBytesReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerAddBytesReadCall) Return() *StreamFlowControllerAddBytesReadCall { +func (c *MockStreamFlowControllerAddBytesReadCall) Return() *MockStreamFlowControllerAddBytesReadCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *StreamFlowControllerAddBytesReadCall { +func (c *MockStreamFlowControllerAddBytesReadCall) Do(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *StreamFlowControllerAddBytesReadCall { +func (c *MockStreamFlowControllerAddBytesReadCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -117,31 +118,31 @@ func (m *MockStreamFlowController) AddBytesSent(arg0 protocol.ByteCount) { } // AddBytesSent indicates an expected call of AddBytesSent. -func (mr *MockStreamFlowControllerMockRecorder) AddBytesSent(arg0 any) *StreamFlowControllerAddBytesSentCall { +func (mr *MockStreamFlowControllerMockRecorder) AddBytesSent(arg0 any) *MockStreamFlowControllerAddBytesSentCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBytesSent", reflect.TypeOf((*MockStreamFlowController)(nil).AddBytesSent), arg0) - return &StreamFlowControllerAddBytesSentCall{Call: call} + return &MockStreamFlowControllerAddBytesSentCall{Call: call} } -// StreamFlowControllerAddBytesSentCall wrap *gomock.Call -type StreamFlowControllerAddBytesSentCall struct { +// MockStreamFlowControllerAddBytesSentCall wrap *gomock.Call +type MockStreamFlowControllerAddBytesSentCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerAddBytesSentCall) Return() *StreamFlowControllerAddBytesSentCall { +func (c *MockStreamFlowControllerAddBytesSentCall) Return() *MockStreamFlowControllerAddBytesSentCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *StreamFlowControllerAddBytesSentCall { +func (c *MockStreamFlowControllerAddBytesSentCall) Do(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesSentCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *StreamFlowControllerAddBytesSentCall { +func (c *MockStreamFlowControllerAddBytesSentCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamFlowControllerAddBytesSentCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -155,31 +156,31 @@ func (m *MockStreamFlowController) GetWindowUpdate() protocol.ByteCount { } // GetWindowUpdate indicates an expected call of GetWindowUpdate. -func (mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *StreamFlowControllerGetWindowUpdateCall { +func (mr *MockStreamFlowControllerMockRecorder) GetWindowUpdate() *MockStreamFlowControllerGetWindowUpdateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWindowUpdate", reflect.TypeOf((*MockStreamFlowController)(nil).GetWindowUpdate)) - return &StreamFlowControllerGetWindowUpdateCall{Call: call} + return &MockStreamFlowControllerGetWindowUpdateCall{Call: call} } -// StreamFlowControllerGetWindowUpdateCall wrap *gomock.Call -type StreamFlowControllerGetWindowUpdateCall struct { +// MockStreamFlowControllerGetWindowUpdateCall wrap *gomock.Call +type MockStreamFlowControllerGetWindowUpdateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *StreamFlowControllerGetWindowUpdateCall { +func (c *MockStreamFlowControllerGetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *StreamFlowControllerGetWindowUpdateCall { +func (c *MockStreamFlowControllerGetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *StreamFlowControllerGetWindowUpdateCall { +func (c *MockStreamFlowControllerGetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamFlowControllerGetWindowUpdateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -194,31 +195,31 @@ func (m *MockStreamFlowController) IsNewlyBlocked() (bool, protocol.ByteCount) { } // IsNewlyBlocked indicates an expected call of IsNewlyBlocked. -func (mr *MockStreamFlowControllerMockRecorder) IsNewlyBlocked() *StreamFlowControllerIsNewlyBlockedCall { +func (mr *MockStreamFlowControllerMockRecorder) IsNewlyBlocked() *MockStreamFlowControllerIsNewlyBlockedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsNewlyBlocked", reflect.TypeOf((*MockStreamFlowController)(nil).IsNewlyBlocked)) - return &StreamFlowControllerIsNewlyBlockedCall{Call: call} + return &MockStreamFlowControllerIsNewlyBlockedCall{Call: call} } -// StreamFlowControllerIsNewlyBlockedCall wrap *gomock.Call -type StreamFlowControllerIsNewlyBlockedCall struct { +// MockStreamFlowControllerIsNewlyBlockedCall wrap *gomock.Call +type MockStreamFlowControllerIsNewlyBlockedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *StreamFlowControllerIsNewlyBlockedCall { +func (c *MockStreamFlowControllerIsNewlyBlockedCall) Return(arg0 bool, arg1 protocol.ByteCount) *MockStreamFlowControllerIsNewlyBlockedCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *StreamFlowControllerIsNewlyBlockedCall { +func (c *MockStreamFlowControllerIsNewlyBlockedCall) Do(f func() (bool, protocol.ByteCount)) *MockStreamFlowControllerIsNewlyBlockedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *StreamFlowControllerIsNewlyBlockedCall { +func (c *MockStreamFlowControllerIsNewlyBlockedCall) DoAndReturn(f func() (bool, protocol.ByteCount)) *MockStreamFlowControllerIsNewlyBlockedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -232,31 +233,31 @@ func (m *MockStreamFlowController) SendWindowSize() protocol.ByteCount { } // SendWindowSize indicates an expected call of SendWindowSize. -func (mr *MockStreamFlowControllerMockRecorder) SendWindowSize() *StreamFlowControllerSendWindowSizeCall { +func (mr *MockStreamFlowControllerMockRecorder) SendWindowSize() *MockStreamFlowControllerSendWindowSizeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWindowSize", reflect.TypeOf((*MockStreamFlowController)(nil).SendWindowSize)) - return &StreamFlowControllerSendWindowSizeCall{Call: call} + return &MockStreamFlowControllerSendWindowSizeCall{Call: call} } -// StreamFlowControllerSendWindowSizeCall wrap *gomock.Call -type StreamFlowControllerSendWindowSizeCall struct { +// MockStreamFlowControllerSendWindowSizeCall wrap *gomock.Call +type MockStreamFlowControllerSendWindowSizeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *StreamFlowControllerSendWindowSizeCall { +func (c *MockStreamFlowControllerSendWindowSizeCall) Return(arg0 protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *StreamFlowControllerSendWindowSizeCall { +func (c *MockStreamFlowControllerSendWindowSizeCall) Do(f func() protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *StreamFlowControllerSendWindowSizeCall { +func (c *MockStreamFlowControllerSendWindowSizeCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamFlowControllerSendWindowSizeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -270,31 +271,31 @@ func (m *MockStreamFlowController) UpdateHighestReceived(arg0 protocol.ByteCount } // UpdateHighestReceived indicates an expected call of UpdateHighestReceived. -func (mr *MockStreamFlowControllerMockRecorder) UpdateHighestReceived(arg0, arg1 any) *StreamFlowControllerUpdateHighestReceivedCall { +func (mr *MockStreamFlowControllerMockRecorder) UpdateHighestReceived(arg0, arg1 any) *MockStreamFlowControllerUpdateHighestReceivedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHighestReceived", reflect.TypeOf((*MockStreamFlowController)(nil).UpdateHighestReceived), arg0, arg1) - return &StreamFlowControllerUpdateHighestReceivedCall{Call: call} + return &MockStreamFlowControllerUpdateHighestReceivedCall{Call: call} } -// StreamFlowControllerUpdateHighestReceivedCall wrap *gomock.Call -type StreamFlowControllerUpdateHighestReceivedCall struct { +// MockStreamFlowControllerUpdateHighestReceivedCall wrap *gomock.Call +type MockStreamFlowControllerUpdateHighestReceivedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerUpdateHighestReceivedCall) Return(arg0 error) *StreamFlowControllerUpdateHighestReceivedCall { +func (c *MockStreamFlowControllerUpdateHighestReceivedCall) Return(arg0 error) *MockStreamFlowControllerUpdateHighestReceivedCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerUpdateHighestReceivedCall) Do(f func(protocol.ByteCount, bool) error) *StreamFlowControllerUpdateHighestReceivedCall { +func (c *MockStreamFlowControllerUpdateHighestReceivedCall) Do(f func(protocol.ByteCount, bool) error) *MockStreamFlowControllerUpdateHighestReceivedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerUpdateHighestReceivedCall) DoAndReturn(f func(protocol.ByteCount, bool) error) *StreamFlowControllerUpdateHighestReceivedCall { +func (c *MockStreamFlowControllerUpdateHighestReceivedCall) DoAndReturn(f func(protocol.ByteCount, bool) error) *MockStreamFlowControllerUpdateHighestReceivedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -308,31 +309,31 @@ func (m *MockStreamFlowController) UpdateSendWindow(arg0 protocol.ByteCount) boo } // UpdateSendWindow indicates an expected call of UpdateSendWindow. -func (mr *MockStreamFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *StreamFlowControllerUpdateSendWindowCall { +func (mr *MockStreamFlowControllerMockRecorder) UpdateSendWindow(arg0 any) *MockStreamFlowControllerUpdateSendWindowCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSendWindow", reflect.TypeOf((*MockStreamFlowController)(nil).UpdateSendWindow), arg0) - return &StreamFlowControllerUpdateSendWindowCall{Call: call} + return &MockStreamFlowControllerUpdateSendWindowCall{Call: call} } -// StreamFlowControllerUpdateSendWindowCall wrap *gomock.Call -type StreamFlowControllerUpdateSendWindowCall struct { +// MockStreamFlowControllerUpdateSendWindowCall wrap *gomock.Call +type MockStreamFlowControllerUpdateSendWindowCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamFlowControllerUpdateSendWindowCall) Return(arg0 bool) *StreamFlowControllerUpdateSendWindowCall { +func (c *MockStreamFlowControllerUpdateSendWindowCall) Return(arg0 bool) *MockStreamFlowControllerUpdateSendWindowCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *StreamFlowControllerUpdateSendWindowCall { +func (c *MockStreamFlowControllerUpdateSendWindowCall) Do(f func(protocol.ByteCount) bool) *MockStreamFlowControllerUpdateSendWindowCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *StreamFlowControllerUpdateSendWindowCall { +func (c *MockStreamFlowControllerUpdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount) bool) *MockStreamFlowControllerUpdateSendWindowCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/internal/mocks/tls/client_session_cache.go b/internal/mocks/tls/client_session_cache.go index 1f57522f..5e2cf97f 100644 --- a/internal/mocks/tls/client_session_cache.go +++ b/internal/mocks/tls/client_session_cache.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package mocktls -destination tls/client_session_cache.go crypto/tls ClientSessionCache // + // Package mocktls is a generated GoMock package. package mocktls @@ -48,31 +49,31 @@ func (m *MockClientSessionCache) Get(arg0 string) (*tls.ClientSessionState, bool } // Get indicates an expected call of Get. -func (mr *MockClientSessionCacheMockRecorder) Get(arg0 any) *ClientSessionCacheGetCall { +func (mr *MockClientSessionCacheMockRecorder) Get(arg0 any) *MockClientSessionCacheGetCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockClientSessionCache)(nil).Get), arg0) - return &ClientSessionCacheGetCall{Call: call} + return &MockClientSessionCacheGetCall{Call: call} } -// ClientSessionCacheGetCall wrap *gomock.Call -type ClientSessionCacheGetCall struct { +// MockClientSessionCacheGetCall wrap *gomock.Call +type MockClientSessionCacheGetCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ClientSessionCacheGetCall) Return(arg0 *tls.ClientSessionState, arg1 bool) *ClientSessionCacheGetCall { +func (c *MockClientSessionCacheGetCall) Return(arg0 *tls.ClientSessionState, arg1 bool) *MockClientSessionCacheGetCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *ClientSessionCacheGetCall) Do(f func(string) (*tls.ClientSessionState, bool)) *ClientSessionCacheGetCall { +func (c *MockClientSessionCacheGetCall) Do(f func(string) (*tls.ClientSessionState, bool)) *MockClientSessionCacheGetCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ClientSessionCacheGetCall) DoAndReturn(f func(string) (*tls.ClientSessionState, bool)) *ClientSessionCacheGetCall { +func (c *MockClientSessionCacheGetCall) DoAndReturn(f func(string) (*tls.ClientSessionState, bool)) *MockClientSessionCacheGetCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -84,31 +85,31 @@ func (m *MockClientSessionCache) Put(arg0 string, arg1 *tls.ClientSessionState) } // Put indicates an expected call of Put. -func (mr *MockClientSessionCacheMockRecorder) Put(arg0, arg1 any) *ClientSessionCachePutCall { +func (mr *MockClientSessionCacheMockRecorder) Put(arg0, arg1 any) *MockClientSessionCachePutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockClientSessionCache)(nil).Put), arg0, arg1) - return &ClientSessionCachePutCall{Call: call} + return &MockClientSessionCachePutCall{Call: call} } -// ClientSessionCachePutCall wrap *gomock.Call -type ClientSessionCachePutCall struct { +// MockClientSessionCachePutCall wrap *gomock.Call +type MockClientSessionCachePutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ClientSessionCachePutCall) Return() *ClientSessionCachePutCall { +func (c *MockClientSessionCachePutCall) Return() *MockClientSessionCachePutCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ClientSessionCachePutCall) Do(f func(string, *tls.ClientSessionState)) *ClientSessionCachePutCall { +func (c *MockClientSessionCachePutCall) Do(f func(string, *tls.ClientSessionState)) *MockClientSessionCachePutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ClientSessionCachePutCall) DoAndReturn(f func(string, *tls.ClientSessionState)) *ClientSessionCachePutCall { +func (c *MockClientSessionCachePutCall) DoAndReturn(f func(string, *tls.ClientSessionState)) *MockClientSessionCachePutCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_ack_frame_source_test.go b/mock_ack_frame_source_test.go index b29660cc..5459c8c1 100644 --- a/mock_ack_frame_source_test.go +++ b/mock_ack_frame_source_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_ack_frame_source_test.go github.com/quic-go/quic-go AckFrameSource // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockAckFrameSource) GetAckFrame(arg0 protocol.EncryptionLevel, arg1 boo } // GetAckFrame indicates an expected call of GetAckFrame. -func (mr *MockAckFrameSourceMockRecorder) GetAckFrame(arg0, arg1 any) *AckFrameSourceGetAckFrameCall { +func (mr *MockAckFrameSourceMockRecorder) GetAckFrame(arg0, arg1 any) *MockAckFrameSourceGetAckFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAckFrame", reflect.TypeOf((*MockAckFrameSource)(nil).GetAckFrame), arg0, arg1) - return &AckFrameSourceGetAckFrameCall{Call: call} + return &MockAckFrameSourceGetAckFrameCall{Call: call} } -// AckFrameSourceGetAckFrameCall wrap *gomock.Call -type AckFrameSourceGetAckFrameCall struct { +// MockAckFrameSourceGetAckFrameCall wrap *gomock.Call +type MockAckFrameSourceGetAckFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *AckFrameSourceGetAckFrameCall) Return(arg0 *wire.AckFrame) *AckFrameSourceGetAckFrameCall { +func (c *MockAckFrameSourceGetAckFrameCall) Return(arg0 *wire.AckFrame) *MockAckFrameSourceGetAckFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *AckFrameSourceGetAckFrameCall) Do(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *AckFrameSourceGetAckFrameCall { +func (c *MockAckFrameSourceGetAckFrameCall) Do(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *MockAckFrameSourceGetAckFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *AckFrameSourceGetAckFrameCall) DoAndReturn(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *AckFrameSourceGetAckFrameCall { +func (c *MockAckFrameSourceGetAckFrameCall) DoAndReturn(f func(protocol.EncryptionLevel, bool) *wire.AckFrame) *MockAckFrameSourceGetAckFrameCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_batch_conn_test.go b/mock_batch_conn_test.go index 5337e40c..ea74b4e8 100644 --- a/mock_batch_conn_test.go +++ b/mock_batch_conn_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -package quic -self_package github.com/quic-go/quic-go -source sys_conn_oob.go -destination mock_batch_conn_test.go -mock_names batchConn=MockBatchConn // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockBatchConn) ReadBatch(ms []ipv4.Message, flags int) (int, error) { } // ReadBatch indicates an expected call of ReadBatch. -func (mr *MockBatchConnMockRecorder) ReadBatch(ms, flags any) *batchConnReadBatchCall { +func (mr *MockBatchConnMockRecorder) ReadBatch(ms, flags any) *MockBatchConnReadBatchCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadBatch", reflect.TypeOf((*MockBatchConn)(nil).ReadBatch), ms, flags) - return &batchConnReadBatchCall{Call: call} + return &MockBatchConnReadBatchCall{Call: call} } -// batchConnReadBatchCall wrap *gomock.Call -type batchConnReadBatchCall struct { +// MockBatchConnReadBatchCall wrap *gomock.Call +type MockBatchConnReadBatchCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *batchConnReadBatchCall) Return(arg0 int, arg1 error) *batchConnReadBatchCall { +func (c *MockBatchConnReadBatchCall) Return(arg0 int, arg1 error) *MockBatchConnReadBatchCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *batchConnReadBatchCall) Do(f func([]ipv4.Message, int) (int, error)) *batchConnReadBatchCall { +func (c *MockBatchConnReadBatchCall) Do(f func([]ipv4.Message, int) (int, error)) *MockBatchConnReadBatchCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *batchConnReadBatchCall) DoAndReturn(f func([]ipv4.Message, int) (int, error)) *batchConnReadBatchCall { +func (c *MockBatchConnReadBatchCall) DoAndReturn(f func([]ipv4.Message, int) (int, error)) *MockBatchConnReadBatchCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_conn_runner_test.go b/mock_conn_runner_test.go index cc119ddf..f9928165 100644 --- a/mock_conn_runner_test.go +++ b/mock_conn_runner_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_conn_runner_test.go github.com/quic-go/quic-go ConnRunner // + // Package quic is a generated GoMock package. package quic @@ -47,31 +48,31 @@ func (m *MockConnRunner) Add(arg0 protocol.ConnectionID, arg1 packetHandler) boo } // Add indicates an expected call of Add. -func (mr *MockConnRunnerMockRecorder) Add(arg0, arg1 any) *ConnRunnerAddCall { +func (mr *MockConnRunnerMockRecorder) Add(arg0, arg1 any) *MockConnRunnerAddCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockConnRunner)(nil).Add), arg0, arg1) - return &ConnRunnerAddCall{Call: call} + return &MockConnRunnerAddCall{Call: call} } -// ConnRunnerAddCall wrap *gomock.Call -type ConnRunnerAddCall struct { +// MockConnRunnerAddCall wrap *gomock.Call +type MockConnRunnerAddCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerAddCall) Return(arg0 bool) *ConnRunnerAddCall { +func (c *MockConnRunnerAddCall) Return(arg0 bool) *MockConnRunnerAddCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerAddCall) Do(f func(protocol.ConnectionID, packetHandler) bool) *ConnRunnerAddCall { +func (c *MockConnRunnerAddCall) Do(f func(protocol.ConnectionID, packetHandler) bool) *MockConnRunnerAddCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerAddCall) DoAndReturn(f func(protocol.ConnectionID, packetHandler) bool) *ConnRunnerAddCall { +func (c *MockConnRunnerAddCall) DoAndReturn(f func(protocol.ConnectionID, packetHandler) bool) *MockConnRunnerAddCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockConnRunner) AddResetToken(arg0 protocol.StatelessResetToken, arg1 p } // AddResetToken indicates an expected call of AddResetToken. -func (mr *MockConnRunnerMockRecorder) AddResetToken(arg0, arg1 any) *ConnRunnerAddResetTokenCall { +func (mr *MockConnRunnerMockRecorder) AddResetToken(arg0, arg1 any) *MockConnRunnerAddResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResetToken", reflect.TypeOf((*MockConnRunner)(nil).AddResetToken), arg0, arg1) - return &ConnRunnerAddResetTokenCall{Call: call} + return &MockConnRunnerAddResetTokenCall{Call: call} } -// ConnRunnerAddResetTokenCall wrap *gomock.Call -type ConnRunnerAddResetTokenCall struct { +// MockConnRunnerAddResetTokenCall wrap *gomock.Call +type MockConnRunnerAddResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerAddResetTokenCall) Return() *ConnRunnerAddResetTokenCall { +func (c *MockConnRunnerAddResetTokenCall) Return() *MockConnRunnerAddResetTokenCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerAddResetTokenCall) Do(f func(protocol.StatelessResetToken, packetHandler)) *ConnRunnerAddResetTokenCall { +func (c *MockConnRunnerAddResetTokenCall) Do(f func(protocol.StatelessResetToken, packetHandler)) *MockConnRunnerAddResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerAddResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken, packetHandler)) *ConnRunnerAddResetTokenCall { +func (c *MockConnRunnerAddResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken, packetHandler)) *MockConnRunnerAddResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -121,31 +122,31 @@ func (m *MockConnRunner) GetStatelessResetToken(arg0 protocol.ConnectionID) prot } // GetStatelessResetToken indicates an expected call of GetStatelessResetToken. -func (mr *MockConnRunnerMockRecorder) GetStatelessResetToken(arg0 any) *ConnRunnerGetStatelessResetTokenCall { +func (mr *MockConnRunnerMockRecorder) GetStatelessResetToken(arg0 any) *MockConnRunnerGetStatelessResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessResetToken", reflect.TypeOf((*MockConnRunner)(nil).GetStatelessResetToken), arg0) - return &ConnRunnerGetStatelessResetTokenCall{Call: call} + return &MockConnRunnerGetStatelessResetTokenCall{Call: call} } -// ConnRunnerGetStatelessResetTokenCall wrap *gomock.Call -type ConnRunnerGetStatelessResetTokenCall struct { +// MockConnRunnerGetStatelessResetTokenCall wrap *gomock.Call +type MockConnRunnerGetStatelessResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerGetStatelessResetTokenCall) Return(arg0 protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { +func (c *MockConnRunnerGetStatelessResetTokenCall) Return(arg0 protocol.StatelessResetToken) *MockConnRunnerGetStatelessResetTokenCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerGetStatelessResetTokenCall) Do(f func(protocol.ConnectionID) protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { +func (c *MockConnRunnerGetStatelessResetTokenCall) Do(f func(protocol.ConnectionID) protocol.StatelessResetToken) *MockConnRunnerGetStatelessResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerGetStatelessResetTokenCall) DoAndReturn(f func(protocol.ConnectionID) protocol.StatelessResetToken) *ConnRunnerGetStatelessResetTokenCall { +func (c *MockConnRunnerGetStatelessResetTokenCall) DoAndReturn(f func(protocol.ConnectionID) protocol.StatelessResetToken) *MockConnRunnerGetStatelessResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -157,31 +158,31 @@ func (m *MockConnRunner) Remove(arg0 protocol.ConnectionID) { } // Remove indicates an expected call of Remove. -func (mr *MockConnRunnerMockRecorder) Remove(arg0 any) *ConnRunnerRemoveCall { +func (mr *MockConnRunnerMockRecorder) Remove(arg0 any) *MockConnRunnerRemoveCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockConnRunner)(nil).Remove), arg0) - return &ConnRunnerRemoveCall{Call: call} + return &MockConnRunnerRemoveCall{Call: call} } -// ConnRunnerRemoveCall wrap *gomock.Call -type ConnRunnerRemoveCall struct { +// MockConnRunnerRemoveCall wrap *gomock.Call +type MockConnRunnerRemoveCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerRemoveCall) Return() *ConnRunnerRemoveCall { +func (c *MockConnRunnerRemoveCall) Return() *MockConnRunnerRemoveCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerRemoveCall) Do(f func(protocol.ConnectionID)) *ConnRunnerRemoveCall { +func (c *MockConnRunnerRemoveCall) Do(f func(protocol.ConnectionID)) *MockConnRunnerRemoveCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerRemoveCall) DoAndReturn(f func(protocol.ConnectionID)) *ConnRunnerRemoveCall { +func (c *MockConnRunnerRemoveCall) DoAndReturn(f func(protocol.ConnectionID)) *MockConnRunnerRemoveCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -193,31 +194,31 @@ func (m *MockConnRunner) RemoveResetToken(arg0 protocol.StatelessResetToken) { } // RemoveResetToken indicates an expected call of RemoveResetToken. -func (mr *MockConnRunnerMockRecorder) RemoveResetToken(arg0 any) *ConnRunnerRemoveResetTokenCall { +func (mr *MockConnRunnerMockRecorder) RemoveResetToken(arg0 any) *MockConnRunnerRemoveResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResetToken", reflect.TypeOf((*MockConnRunner)(nil).RemoveResetToken), arg0) - return &ConnRunnerRemoveResetTokenCall{Call: call} + return &MockConnRunnerRemoveResetTokenCall{Call: call} } -// ConnRunnerRemoveResetTokenCall wrap *gomock.Call -type ConnRunnerRemoveResetTokenCall struct { +// MockConnRunnerRemoveResetTokenCall wrap *gomock.Call +type MockConnRunnerRemoveResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerRemoveResetTokenCall) Return() *ConnRunnerRemoveResetTokenCall { +func (c *MockConnRunnerRemoveResetTokenCall) Return() *MockConnRunnerRemoveResetTokenCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerRemoveResetTokenCall) Do(f func(protocol.StatelessResetToken)) *ConnRunnerRemoveResetTokenCall { +func (c *MockConnRunnerRemoveResetTokenCall) Do(f func(protocol.StatelessResetToken)) *MockConnRunnerRemoveResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerRemoveResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken)) *ConnRunnerRemoveResetTokenCall { +func (c *MockConnRunnerRemoveResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken)) *MockConnRunnerRemoveResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -229,31 +230,31 @@ func (m *MockConnRunner) ReplaceWithClosed(arg0 []protocol.ConnectionID, arg1 [] } // ReplaceWithClosed indicates an expected call of ReplaceWithClosed. -func (mr *MockConnRunnerMockRecorder) ReplaceWithClosed(arg0, arg1 any) *ConnRunnerReplaceWithClosedCall { +func (mr *MockConnRunnerMockRecorder) ReplaceWithClosed(arg0, arg1 any) *MockConnRunnerReplaceWithClosedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceWithClosed", reflect.TypeOf((*MockConnRunner)(nil).ReplaceWithClosed), arg0, arg1) - return &ConnRunnerReplaceWithClosedCall{Call: call} + return &MockConnRunnerReplaceWithClosedCall{Call: call} } -// ConnRunnerReplaceWithClosedCall wrap *gomock.Call -type ConnRunnerReplaceWithClosedCall struct { +// MockConnRunnerReplaceWithClosedCall wrap *gomock.Call +type MockConnRunnerReplaceWithClosedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerReplaceWithClosedCall) Return() *ConnRunnerReplaceWithClosedCall { +func (c *MockConnRunnerReplaceWithClosedCall) Return() *MockConnRunnerReplaceWithClosedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerReplaceWithClosedCall) Do(f func([]protocol.ConnectionID, []byte)) *ConnRunnerReplaceWithClosedCall { +func (c *MockConnRunnerReplaceWithClosedCall) Do(f func([]protocol.ConnectionID, []byte)) *MockConnRunnerReplaceWithClosedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerReplaceWithClosedCall) DoAndReturn(f func([]protocol.ConnectionID, []byte)) *ConnRunnerReplaceWithClosedCall { +func (c *MockConnRunnerReplaceWithClosedCall) DoAndReturn(f func([]protocol.ConnectionID, []byte)) *MockConnRunnerReplaceWithClosedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -265,31 +266,31 @@ func (m *MockConnRunner) Retire(arg0 protocol.ConnectionID) { } // Retire indicates an expected call of Retire. -func (mr *MockConnRunnerMockRecorder) Retire(arg0 any) *ConnRunnerRetireCall { +func (mr *MockConnRunnerMockRecorder) Retire(arg0 any) *MockConnRunnerRetireCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retire", reflect.TypeOf((*MockConnRunner)(nil).Retire), arg0) - return &ConnRunnerRetireCall{Call: call} + return &MockConnRunnerRetireCall{Call: call} } -// ConnRunnerRetireCall wrap *gomock.Call -type ConnRunnerRetireCall struct { +// MockConnRunnerRetireCall wrap *gomock.Call +type MockConnRunnerRetireCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ConnRunnerRetireCall) Return() *ConnRunnerRetireCall { +func (c *MockConnRunnerRetireCall) Return() *MockConnRunnerRetireCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ConnRunnerRetireCall) Do(f func(protocol.ConnectionID)) *ConnRunnerRetireCall { +func (c *MockConnRunnerRetireCall) Do(f func(protocol.ConnectionID)) *MockConnRunnerRetireCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ConnRunnerRetireCall) DoAndReturn(f func(protocol.ConnectionID)) *ConnRunnerRetireCall { +func (c *MockConnRunnerRetireCall) DoAndReturn(f func(protocol.ConnectionID)) *MockConnRunnerRetireCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_crypto_data_handler_test.go b/mock_crypto_data_handler_test.go index f65526df..96fb3d8e 100644 --- a/mock_crypto_data_handler_test.go +++ b/mock_crypto_data_handler_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_crypto_data_handler_test.go github.com/quic-go/quic-go CryptoDataHandler // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockCryptoDataHandler) HandleMessage(arg0 []byte, arg1 protocol.Encrypt } // HandleMessage indicates an expected call of HandleMessage. -func (mr *MockCryptoDataHandlerMockRecorder) HandleMessage(arg0, arg1 any) *CryptoDataHandlerHandleMessageCall { +func (mr *MockCryptoDataHandlerMockRecorder) HandleMessage(arg0, arg1 any) *MockCryptoDataHandlerHandleMessageCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockCryptoDataHandler)(nil).HandleMessage), arg0, arg1) - return &CryptoDataHandlerHandleMessageCall{Call: call} + return &MockCryptoDataHandlerHandleMessageCall{Call: call} } -// CryptoDataHandlerHandleMessageCall wrap *gomock.Call -type CryptoDataHandlerHandleMessageCall struct { +// MockCryptoDataHandlerHandleMessageCall wrap *gomock.Call +type MockCryptoDataHandlerHandleMessageCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoDataHandlerHandleMessageCall) Return(arg0 error) *CryptoDataHandlerHandleMessageCall { +func (c *MockCryptoDataHandlerHandleMessageCall) Return(arg0 error) *MockCryptoDataHandlerHandleMessageCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoDataHandlerHandleMessageCall) Do(f func([]byte, protocol.EncryptionLevel) error) *CryptoDataHandlerHandleMessageCall { +func (c *MockCryptoDataHandlerHandleMessageCall) Do(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoDataHandlerHandleMessageCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoDataHandlerHandleMessageCall) DoAndReturn(f func([]byte, protocol.EncryptionLevel) error) *CryptoDataHandlerHandleMessageCall { +func (c *MockCryptoDataHandlerHandleMessageCall) DoAndReturn(f func([]byte, protocol.EncryptionLevel) error) *MockCryptoDataHandlerHandleMessageCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockCryptoDataHandler) NextEvent() handshake.Event { } // NextEvent indicates an expected call of NextEvent. -func (mr *MockCryptoDataHandlerMockRecorder) NextEvent() *CryptoDataHandlerNextEventCall { +func (mr *MockCryptoDataHandlerMockRecorder) NextEvent() *MockCryptoDataHandlerNextEventCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextEvent", reflect.TypeOf((*MockCryptoDataHandler)(nil).NextEvent)) - return &CryptoDataHandlerNextEventCall{Call: call} + return &MockCryptoDataHandlerNextEventCall{Call: call} } -// CryptoDataHandlerNextEventCall wrap *gomock.Call -type CryptoDataHandlerNextEventCall struct { +// MockCryptoDataHandlerNextEventCall wrap *gomock.Call +type MockCryptoDataHandlerNextEventCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoDataHandlerNextEventCall) Return(arg0 handshake.Event) *CryptoDataHandlerNextEventCall { +func (c *MockCryptoDataHandlerNextEventCall) Return(arg0 handshake.Event) *MockCryptoDataHandlerNextEventCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoDataHandlerNextEventCall) Do(f func() handshake.Event) *CryptoDataHandlerNextEventCall { +func (c *MockCryptoDataHandlerNextEventCall) Do(f func() handshake.Event) *MockCryptoDataHandlerNextEventCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoDataHandlerNextEventCall) DoAndReturn(f func() handshake.Event) *CryptoDataHandlerNextEventCall { +func (c *MockCryptoDataHandlerNextEventCall) DoAndReturn(f func() handshake.Event) *MockCryptoDataHandlerNextEventCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_crypto_stream_test.go b/mock_crypto_stream_test.go index 0e93650c..bd762d64 100644 --- a/mock_crypto_stream_test.go +++ b/mock_crypto_stream_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_crypto_stream_test.go github.com/quic-go/quic-go CryptoStream // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockCryptoStream) Finish() error { } // Finish indicates an expected call of Finish. -func (mr *MockCryptoStreamMockRecorder) Finish() *CryptoStreamFinishCall { +func (mr *MockCryptoStreamMockRecorder) Finish() *MockCryptoStreamFinishCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Finish", reflect.TypeOf((*MockCryptoStream)(nil).Finish)) - return &CryptoStreamFinishCall{Call: call} + return &MockCryptoStreamFinishCall{Call: call} } -// CryptoStreamFinishCall wrap *gomock.Call -type CryptoStreamFinishCall struct { +// MockCryptoStreamFinishCall wrap *gomock.Call +type MockCryptoStreamFinishCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamFinishCall) Return(arg0 error) *CryptoStreamFinishCall { +func (c *MockCryptoStreamFinishCall) Return(arg0 error) *MockCryptoStreamFinishCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamFinishCall) Do(f func() error) *CryptoStreamFinishCall { +func (c *MockCryptoStreamFinishCall) Do(f func() error) *MockCryptoStreamFinishCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamFinishCall) DoAndReturn(f func() error) *CryptoStreamFinishCall { +func (c *MockCryptoStreamFinishCall) DoAndReturn(f func() error) *MockCryptoStreamFinishCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockCryptoStream) GetCryptoData() []byte { } // GetCryptoData indicates an expected call of GetCryptoData. -func (mr *MockCryptoStreamMockRecorder) GetCryptoData() *CryptoStreamGetCryptoDataCall { +func (mr *MockCryptoStreamMockRecorder) GetCryptoData() *MockCryptoStreamGetCryptoDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCryptoData", reflect.TypeOf((*MockCryptoStream)(nil).GetCryptoData)) - return &CryptoStreamGetCryptoDataCall{Call: call} + return &MockCryptoStreamGetCryptoDataCall{Call: call} } -// CryptoStreamGetCryptoDataCall wrap *gomock.Call -type CryptoStreamGetCryptoDataCall struct { +// MockCryptoStreamGetCryptoDataCall wrap *gomock.Call +type MockCryptoStreamGetCryptoDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamGetCryptoDataCall) Return(arg0 []byte) *CryptoStreamGetCryptoDataCall { +func (c *MockCryptoStreamGetCryptoDataCall) Return(arg0 []byte) *MockCryptoStreamGetCryptoDataCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamGetCryptoDataCall) Do(f func() []byte) *CryptoStreamGetCryptoDataCall { +func (c *MockCryptoStreamGetCryptoDataCall) Do(f func() []byte) *MockCryptoStreamGetCryptoDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamGetCryptoDataCall) DoAndReturn(f func() []byte) *CryptoStreamGetCryptoDataCall { +func (c *MockCryptoStreamGetCryptoDataCall) DoAndReturn(f func() []byte) *MockCryptoStreamGetCryptoDataCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockCryptoStream) HandleCryptoFrame(arg0 *wire.CryptoFrame) error { } // HandleCryptoFrame indicates an expected call of HandleCryptoFrame. -func (mr *MockCryptoStreamMockRecorder) HandleCryptoFrame(arg0 any) *CryptoStreamHandleCryptoFrameCall { +func (mr *MockCryptoStreamMockRecorder) HandleCryptoFrame(arg0 any) *MockCryptoStreamHandleCryptoFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleCryptoFrame", reflect.TypeOf((*MockCryptoStream)(nil).HandleCryptoFrame), arg0) - return &CryptoStreamHandleCryptoFrameCall{Call: call} + return &MockCryptoStreamHandleCryptoFrameCall{Call: call} } -// CryptoStreamHandleCryptoFrameCall wrap *gomock.Call -type CryptoStreamHandleCryptoFrameCall struct { +// MockCryptoStreamHandleCryptoFrameCall wrap *gomock.Call +type MockCryptoStreamHandleCryptoFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamHandleCryptoFrameCall) Return(arg0 error) *CryptoStreamHandleCryptoFrameCall { +func (c *MockCryptoStreamHandleCryptoFrameCall) Return(arg0 error) *MockCryptoStreamHandleCryptoFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamHandleCryptoFrameCall) Do(f func(*wire.CryptoFrame) error) *CryptoStreamHandleCryptoFrameCall { +func (c *MockCryptoStreamHandleCryptoFrameCall) Do(f func(*wire.CryptoFrame) error) *MockCryptoStreamHandleCryptoFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamHandleCryptoFrameCall) DoAndReturn(f func(*wire.CryptoFrame) error) *CryptoStreamHandleCryptoFrameCall { +func (c *MockCryptoStreamHandleCryptoFrameCall) DoAndReturn(f func(*wire.CryptoFrame) error) *MockCryptoStreamHandleCryptoFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockCryptoStream) HasData() bool { } // HasData indicates an expected call of HasData. -func (mr *MockCryptoStreamMockRecorder) HasData() *CryptoStreamHasDataCall { +func (mr *MockCryptoStreamMockRecorder) HasData() *MockCryptoStreamHasDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasData", reflect.TypeOf((*MockCryptoStream)(nil).HasData)) - return &CryptoStreamHasDataCall{Call: call} + return &MockCryptoStreamHasDataCall{Call: call} } -// CryptoStreamHasDataCall wrap *gomock.Call -type CryptoStreamHasDataCall struct { +// MockCryptoStreamHasDataCall wrap *gomock.Call +type MockCryptoStreamHasDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamHasDataCall) Return(arg0 bool) *CryptoStreamHasDataCall { +func (c *MockCryptoStreamHasDataCall) Return(arg0 bool) *MockCryptoStreamHasDataCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamHasDataCall) Do(f func() bool) *CryptoStreamHasDataCall { +func (c *MockCryptoStreamHasDataCall) Do(f func() bool) *MockCryptoStreamHasDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamHasDataCall) DoAndReturn(f func() bool) *CryptoStreamHasDataCall { +func (c *MockCryptoStreamHasDataCall) DoAndReturn(f func() bool) *MockCryptoStreamHasDataCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -200,31 +201,31 @@ func (m *MockCryptoStream) PopCryptoFrame(arg0 protocol.ByteCount) *wire.CryptoF } // PopCryptoFrame indicates an expected call of PopCryptoFrame. -func (mr *MockCryptoStreamMockRecorder) PopCryptoFrame(arg0 any) *CryptoStreamPopCryptoFrameCall { +func (mr *MockCryptoStreamMockRecorder) PopCryptoFrame(arg0 any) *MockCryptoStreamPopCryptoFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopCryptoFrame", reflect.TypeOf((*MockCryptoStream)(nil).PopCryptoFrame), arg0) - return &CryptoStreamPopCryptoFrameCall{Call: call} + return &MockCryptoStreamPopCryptoFrameCall{Call: call} } -// CryptoStreamPopCryptoFrameCall wrap *gomock.Call -type CryptoStreamPopCryptoFrameCall struct { +// MockCryptoStreamPopCryptoFrameCall wrap *gomock.Call +type MockCryptoStreamPopCryptoFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamPopCryptoFrameCall) Return(arg0 *wire.CryptoFrame) *CryptoStreamPopCryptoFrameCall { +func (c *MockCryptoStreamPopCryptoFrameCall) Return(arg0 *wire.CryptoFrame) *MockCryptoStreamPopCryptoFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamPopCryptoFrameCall) Do(f func(protocol.ByteCount) *wire.CryptoFrame) *CryptoStreamPopCryptoFrameCall { +func (c *MockCryptoStreamPopCryptoFrameCall) Do(f func(protocol.ByteCount) *wire.CryptoFrame) *MockCryptoStreamPopCryptoFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamPopCryptoFrameCall) DoAndReturn(f func(protocol.ByteCount) *wire.CryptoFrame) *CryptoStreamPopCryptoFrameCall { +func (c *MockCryptoStreamPopCryptoFrameCall) DoAndReturn(f func(protocol.ByteCount) *wire.CryptoFrame) *MockCryptoStreamPopCryptoFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -239,31 +240,31 @@ func (m *MockCryptoStream) Write(arg0 []byte) (int, error) { } // Write indicates an expected call of Write. -func (mr *MockCryptoStreamMockRecorder) Write(arg0 any) *CryptoStreamWriteCall { +func (mr *MockCryptoStreamMockRecorder) Write(arg0 any) *MockCryptoStreamWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockCryptoStream)(nil).Write), arg0) - return &CryptoStreamWriteCall{Call: call} + return &MockCryptoStreamWriteCall{Call: call} } -// CryptoStreamWriteCall wrap *gomock.Call -type CryptoStreamWriteCall struct { +// MockCryptoStreamWriteCall wrap *gomock.Call +type MockCryptoStreamWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *CryptoStreamWriteCall) Return(arg0 int, arg1 error) *CryptoStreamWriteCall { +func (c *MockCryptoStreamWriteCall) Return(arg0 int, arg1 error) *MockCryptoStreamWriteCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *CryptoStreamWriteCall) Do(f func([]byte) (int, error)) *CryptoStreamWriteCall { +func (c *MockCryptoStreamWriteCall) Do(f func([]byte) (int, error)) *MockCryptoStreamWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *CryptoStreamWriteCall) DoAndReturn(f func([]byte) (int, error)) *CryptoStreamWriteCall { +func (c *MockCryptoStreamWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockCryptoStreamWriteCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_frame_source_test.go b/mock_frame_source_test.go index cc6acc6a..9aa8be71 100644 --- a/mock_frame_source_test.go +++ b/mock_frame_source_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_frame_source_test.go github.com/quic-go/quic-go FrameSource // + // Package quic is a generated GoMock package. package quic @@ -49,31 +50,31 @@ func (m *MockFrameSource) AppendControlFrames(arg0 []ackhandler.Frame, arg1 prot } // AppendControlFrames indicates an expected call of AppendControlFrames. -func (mr *MockFrameSourceMockRecorder) AppendControlFrames(arg0, arg1, arg2 any) *FrameSourceAppendControlFramesCall { +func (mr *MockFrameSourceMockRecorder) AppendControlFrames(arg0, arg1, arg2 any) *MockFrameSourceAppendControlFramesCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendControlFrames", reflect.TypeOf((*MockFrameSource)(nil).AppendControlFrames), arg0, arg1, arg2) - return &FrameSourceAppendControlFramesCall{Call: call} + return &MockFrameSourceAppendControlFramesCall{Call: call} } -// FrameSourceAppendControlFramesCall wrap *gomock.Call -type FrameSourceAppendControlFramesCall struct { +// MockFrameSourceAppendControlFramesCall wrap *gomock.Call +type MockFrameSourceAppendControlFramesCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *FrameSourceAppendControlFramesCall) Return(arg0 []ackhandler.Frame, arg1 protocol.ByteCount) *FrameSourceAppendControlFramesCall { +func (c *MockFrameSourceAppendControlFramesCall) Return(arg0 []ackhandler.Frame, arg1 protocol.ByteCount) *MockFrameSourceAppendControlFramesCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *FrameSourceAppendControlFramesCall) Do(f func([]ackhandler.Frame, protocol.ByteCount, protocol.Version) ([]ackhandler.Frame, protocol.ByteCount)) *FrameSourceAppendControlFramesCall { +func (c *MockFrameSourceAppendControlFramesCall) Do(f func([]ackhandler.Frame, protocol.ByteCount, protocol.Version) ([]ackhandler.Frame, protocol.ByteCount)) *MockFrameSourceAppendControlFramesCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *FrameSourceAppendControlFramesCall) DoAndReturn(f func([]ackhandler.Frame, protocol.ByteCount, protocol.Version) ([]ackhandler.Frame, protocol.ByteCount)) *FrameSourceAppendControlFramesCall { +func (c *MockFrameSourceAppendControlFramesCall) DoAndReturn(f func([]ackhandler.Frame, protocol.ByteCount, protocol.Version) ([]ackhandler.Frame, protocol.ByteCount)) *MockFrameSourceAppendControlFramesCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -88,31 +89,31 @@ func (m *MockFrameSource) AppendStreamFrames(arg0 []ackhandler.StreamFrame, arg1 } // AppendStreamFrames indicates an expected call of AppendStreamFrames. -func (mr *MockFrameSourceMockRecorder) AppendStreamFrames(arg0, arg1, arg2 any) *FrameSourceAppendStreamFramesCall { +func (mr *MockFrameSourceMockRecorder) AppendStreamFrames(arg0, arg1, arg2 any) *MockFrameSourceAppendStreamFramesCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendStreamFrames", reflect.TypeOf((*MockFrameSource)(nil).AppendStreamFrames), arg0, arg1, arg2) - return &FrameSourceAppendStreamFramesCall{Call: call} + return &MockFrameSourceAppendStreamFramesCall{Call: call} } -// FrameSourceAppendStreamFramesCall wrap *gomock.Call -type FrameSourceAppendStreamFramesCall struct { +// MockFrameSourceAppendStreamFramesCall wrap *gomock.Call +type MockFrameSourceAppendStreamFramesCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *FrameSourceAppendStreamFramesCall) Return(arg0 []ackhandler.StreamFrame, arg1 protocol.ByteCount) *FrameSourceAppendStreamFramesCall { +func (c *MockFrameSourceAppendStreamFramesCall) Return(arg0 []ackhandler.StreamFrame, arg1 protocol.ByteCount) *MockFrameSourceAppendStreamFramesCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *FrameSourceAppendStreamFramesCall) Do(f func([]ackhandler.StreamFrame, protocol.ByteCount, protocol.Version) ([]ackhandler.StreamFrame, protocol.ByteCount)) *FrameSourceAppendStreamFramesCall { +func (c *MockFrameSourceAppendStreamFramesCall) Do(f func([]ackhandler.StreamFrame, protocol.ByteCount, protocol.Version) ([]ackhandler.StreamFrame, protocol.ByteCount)) *MockFrameSourceAppendStreamFramesCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *FrameSourceAppendStreamFramesCall) DoAndReturn(f func([]ackhandler.StreamFrame, protocol.ByteCount, protocol.Version) ([]ackhandler.StreamFrame, protocol.ByteCount)) *FrameSourceAppendStreamFramesCall { +func (c *MockFrameSourceAppendStreamFramesCall) DoAndReturn(f func([]ackhandler.StreamFrame, protocol.ByteCount, protocol.Version) ([]ackhandler.StreamFrame, protocol.ByteCount)) *MockFrameSourceAppendStreamFramesCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockFrameSource) HasData() bool { } // HasData indicates an expected call of HasData. -func (mr *MockFrameSourceMockRecorder) HasData() *FrameSourceHasDataCall { +func (mr *MockFrameSourceMockRecorder) HasData() *MockFrameSourceHasDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasData", reflect.TypeOf((*MockFrameSource)(nil).HasData)) - return &FrameSourceHasDataCall{Call: call} + return &MockFrameSourceHasDataCall{Call: call} } -// FrameSourceHasDataCall wrap *gomock.Call -type FrameSourceHasDataCall struct { +// MockFrameSourceHasDataCall wrap *gomock.Call +type MockFrameSourceHasDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *FrameSourceHasDataCall) Return(arg0 bool) *FrameSourceHasDataCall { +func (c *MockFrameSourceHasDataCall) Return(arg0 bool) *MockFrameSourceHasDataCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *FrameSourceHasDataCall) Do(f func() bool) *FrameSourceHasDataCall { +func (c *MockFrameSourceHasDataCall) Do(f func() bool) *MockFrameSourceHasDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *FrameSourceHasDataCall) DoAndReturn(f func() bool) *FrameSourceHasDataCall { +func (c *MockFrameSourceHasDataCall) DoAndReturn(f func() bool) *MockFrameSourceHasDataCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_mtu_discoverer_test.go b/mock_mtu_discoverer_test.go index 3e6035b0..6dadae16 100644 --- a/mock_mtu_discoverer_test.go +++ b/mock_mtu_discoverer_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_mtu_discoverer_test.go github.com/quic-go/quic-go MTUDiscoverer // + // Package quic is a generated GoMock package. package quic @@ -49,31 +50,31 @@ func (m *MockMTUDiscoverer) CurrentSize() protocol.ByteCount { } // CurrentSize indicates an expected call of CurrentSize. -func (mr *MockMTUDiscovererMockRecorder) CurrentSize() *MTUDiscovererCurrentSizeCall { +func (mr *MockMTUDiscovererMockRecorder) CurrentSize() *MockMTUDiscovererCurrentSizeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentSize", reflect.TypeOf((*MockMTUDiscoverer)(nil).CurrentSize)) - return &MTUDiscovererCurrentSizeCall{Call: call} + return &MockMTUDiscovererCurrentSizeCall{Call: call} } -// MTUDiscovererCurrentSizeCall wrap *gomock.Call -type MTUDiscovererCurrentSizeCall struct { +// MockMTUDiscovererCurrentSizeCall wrap *gomock.Call +type MockMTUDiscovererCurrentSizeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *MTUDiscovererCurrentSizeCall) Return(arg0 protocol.ByteCount) *MTUDiscovererCurrentSizeCall { +func (c *MockMTUDiscovererCurrentSizeCall) Return(arg0 protocol.ByteCount) *MockMTUDiscovererCurrentSizeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *MTUDiscovererCurrentSizeCall) Do(f func() protocol.ByteCount) *MTUDiscovererCurrentSizeCall { +func (c *MockMTUDiscovererCurrentSizeCall) Do(f func() protocol.ByteCount) *MockMTUDiscovererCurrentSizeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MTUDiscovererCurrentSizeCall) DoAndReturn(f func() protocol.ByteCount) *MTUDiscovererCurrentSizeCall { +func (c *MockMTUDiscovererCurrentSizeCall) DoAndReturn(f func() protocol.ByteCount) *MockMTUDiscovererCurrentSizeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -88,31 +89,31 @@ func (m *MockMTUDiscoverer) GetPing() (ackhandler.Frame, protocol.ByteCount) { } // GetPing indicates an expected call of GetPing. -func (mr *MockMTUDiscovererMockRecorder) GetPing() *MTUDiscovererGetPingCall { +func (mr *MockMTUDiscovererMockRecorder) GetPing() *MockMTUDiscovererGetPingCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPing", reflect.TypeOf((*MockMTUDiscoverer)(nil).GetPing)) - return &MTUDiscovererGetPingCall{Call: call} + return &MockMTUDiscovererGetPingCall{Call: call} } -// MTUDiscovererGetPingCall wrap *gomock.Call -type MTUDiscovererGetPingCall struct { +// MockMTUDiscovererGetPingCall wrap *gomock.Call +type MockMTUDiscovererGetPingCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *MTUDiscovererGetPingCall) Return(arg0 ackhandler.Frame, arg1 protocol.ByteCount) *MTUDiscovererGetPingCall { +func (c *MockMTUDiscovererGetPingCall) Return(arg0 ackhandler.Frame, arg1 protocol.ByteCount) *MockMTUDiscovererGetPingCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *MTUDiscovererGetPingCall) Do(f func() (ackhandler.Frame, protocol.ByteCount)) *MTUDiscovererGetPingCall { +func (c *MockMTUDiscovererGetPingCall) Do(f func() (ackhandler.Frame, protocol.ByteCount)) *MockMTUDiscovererGetPingCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MTUDiscovererGetPingCall) DoAndReturn(f func() (ackhandler.Frame, protocol.ByteCount)) *MTUDiscovererGetPingCall { +func (c *MockMTUDiscovererGetPingCall) DoAndReturn(f func() (ackhandler.Frame, protocol.ByteCount)) *MockMTUDiscovererGetPingCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockMTUDiscoverer) ShouldSendProbe(arg0 time.Time) bool { } // ShouldSendProbe indicates an expected call of ShouldSendProbe. -func (mr *MockMTUDiscovererMockRecorder) ShouldSendProbe(arg0 any) *MTUDiscovererShouldSendProbeCall { +func (mr *MockMTUDiscovererMockRecorder) ShouldSendProbe(arg0 any) *MockMTUDiscovererShouldSendProbeCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShouldSendProbe", reflect.TypeOf((*MockMTUDiscoverer)(nil).ShouldSendProbe), arg0) - return &MTUDiscovererShouldSendProbeCall{Call: call} + return &MockMTUDiscovererShouldSendProbeCall{Call: call} } -// MTUDiscovererShouldSendProbeCall wrap *gomock.Call -type MTUDiscovererShouldSendProbeCall struct { +// MockMTUDiscovererShouldSendProbeCall wrap *gomock.Call +type MockMTUDiscovererShouldSendProbeCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *MTUDiscovererShouldSendProbeCall) Return(arg0 bool) *MTUDiscovererShouldSendProbeCall { +func (c *MockMTUDiscovererShouldSendProbeCall) Return(arg0 bool) *MockMTUDiscovererShouldSendProbeCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *MTUDiscovererShouldSendProbeCall) Do(f func(time.Time) bool) *MTUDiscovererShouldSendProbeCall { +func (c *MockMTUDiscovererShouldSendProbeCall) Do(f func(time.Time) bool) *MockMTUDiscovererShouldSendProbeCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MTUDiscovererShouldSendProbeCall) DoAndReturn(f func(time.Time) bool) *MTUDiscovererShouldSendProbeCall { +func (c *MockMTUDiscovererShouldSendProbeCall) DoAndReturn(f func(time.Time) bool) *MockMTUDiscovererShouldSendProbeCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockMTUDiscoverer) Start(arg0 protocol.ByteCount) { } // Start indicates an expected call of Start. -func (mr *MockMTUDiscovererMockRecorder) Start(arg0 any) *MTUDiscovererStartCall { +func (mr *MockMTUDiscovererMockRecorder) Start(arg0 any) *MockMTUDiscovererStartCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockMTUDiscoverer)(nil).Start), arg0) - return &MTUDiscovererStartCall{Call: call} + return &MockMTUDiscovererStartCall{Call: call} } -// MTUDiscovererStartCall wrap *gomock.Call -type MTUDiscovererStartCall struct { +// MockMTUDiscovererStartCall wrap *gomock.Call +type MockMTUDiscovererStartCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *MTUDiscovererStartCall) Return() *MTUDiscovererStartCall { +func (c *MockMTUDiscovererStartCall) Return() *MockMTUDiscovererStartCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *MTUDiscovererStartCall) Do(f func(protocol.ByteCount)) *MTUDiscovererStartCall { +func (c *MockMTUDiscovererStartCall) Do(f func(protocol.ByteCount)) *MockMTUDiscovererStartCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MTUDiscovererStartCall) DoAndReturn(f func(protocol.ByteCount)) *MTUDiscovererStartCall { +func (c *MockMTUDiscovererStartCall) DoAndReturn(f func(protocol.ByteCount)) *MockMTUDiscovererStartCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_packer_test.go b/mock_packer_test.go index 4e846b37..1d9ec1cc 100644 --- a/mock_packer_test.go +++ b/mock_packer_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_packer_test.go github.com/quic-go/quic-go Packer // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockPacker) AppendPacket(arg0 *packetBuffer, arg1 protocol.ByteCount, a } // AppendPacket indicates an expected call of AppendPacket. -func (mr *MockPackerMockRecorder) AppendPacket(arg0, arg1, arg2 any) *PackerAppendPacketCall { +func (mr *MockPackerMockRecorder) AppendPacket(arg0, arg1, arg2 any) *MockPackerAppendPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPacket", reflect.TypeOf((*MockPacker)(nil).AppendPacket), arg0, arg1, arg2) - return &PackerAppendPacketCall{Call: call} + return &MockPackerAppendPacketCall{Call: call} } -// PackerAppendPacketCall wrap *gomock.Call -type PackerAppendPacketCall struct { +// MockPackerAppendPacketCall wrap *gomock.Call +type MockPackerAppendPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerAppendPacketCall) Return(arg0 shortHeaderPacket, arg1 error) *PackerAppendPacketCall { +func (c *MockPackerAppendPacketCall) Return(arg0 shortHeaderPacket, arg1 error) *MockPackerAppendPacketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PackerAppendPacketCall) Do(f func(*packetBuffer, protocol.ByteCount, protocol.Version) (shortHeaderPacket, error)) *PackerAppendPacketCall { +func (c *MockPackerAppendPacketCall) Do(f func(*packetBuffer, protocol.ByteCount, protocol.Version) (shortHeaderPacket, error)) *MockPackerAppendPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerAppendPacketCall) DoAndReturn(f func(*packetBuffer, protocol.ByteCount, protocol.Version) (shortHeaderPacket, error)) *PackerAppendPacketCall { +func (c *MockPackerAppendPacketCall) DoAndReturn(f func(*packetBuffer, protocol.ByteCount, protocol.Version) (shortHeaderPacket, error)) *MockPackerAppendPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -89,31 +90,31 @@ func (m *MockPacker) MaybePackProbePacket(arg0 protocol.EncryptionLevel, arg1 pr } // MaybePackProbePacket indicates an expected call of MaybePackProbePacket. -func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0, arg1, arg2 any) *PackerMaybePackProbePacketCall { +func (mr *MockPackerMockRecorder) MaybePackProbePacket(arg0, arg1, arg2 any) *MockPackerMaybePackProbePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MaybePackProbePacket", reflect.TypeOf((*MockPacker)(nil).MaybePackProbePacket), arg0, arg1, arg2) - return &PackerMaybePackProbePacketCall{Call: call} + return &MockPackerMaybePackProbePacketCall{Call: call} } -// PackerMaybePackProbePacketCall wrap *gomock.Call -type PackerMaybePackProbePacketCall struct { +// MockPackerMaybePackProbePacketCall wrap *gomock.Call +type MockPackerMaybePackProbePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerMaybePackProbePacketCall) Return(arg0 *coalescedPacket, arg1 error) *PackerMaybePackProbePacketCall { +func (c *MockPackerMaybePackProbePacketCall) Return(arg0 *coalescedPacket, arg1 error) *MockPackerMaybePackProbePacketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PackerMaybePackProbePacketCall) Do(f func(protocol.EncryptionLevel, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerMaybePackProbePacketCall { +func (c *MockPackerMaybePackProbePacketCall) Do(f func(protocol.EncryptionLevel, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerMaybePackProbePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerMaybePackProbePacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerMaybePackProbePacketCall { +func (c *MockPackerMaybePackProbePacketCall) DoAndReturn(f func(protocol.EncryptionLevel, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerMaybePackProbePacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -129,31 +130,31 @@ func (m *MockPacker) PackAckOnlyPacket(arg0 protocol.ByteCount, arg1 protocol.Ve } // PackAckOnlyPacket indicates an expected call of PackAckOnlyPacket. -func (mr *MockPackerMockRecorder) PackAckOnlyPacket(arg0, arg1 any) *PackerPackAckOnlyPacketCall { +func (mr *MockPackerMockRecorder) PackAckOnlyPacket(arg0, arg1 any) *MockPackerPackAckOnlyPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackAckOnlyPacket", reflect.TypeOf((*MockPacker)(nil).PackAckOnlyPacket), arg0, arg1) - return &PackerPackAckOnlyPacketCall{Call: call} + return &MockPackerPackAckOnlyPacketCall{Call: call} } -// PackerPackAckOnlyPacketCall wrap *gomock.Call -type PackerPackAckOnlyPacketCall struct { +// MockPackerPackAckOnlyPacketCall wrap *gomock.Call +type MockPackerPackAckOnlyPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerPackAckOnlyPacketCall) Return(arg0 shortHeaderPacket, arg1 *packetBuffer, arg2 error) *PackerPackAckOnlyPacketCall { +func (c *MockPackerPackAckOnlyPacketCall) Return(arg0 shortHeaderPacket, arg1 *packetBuffer, arg2 error) *MockPackerPackAckOnlyPacketCall { c.Call = c.Call.Return(arg0, arg1, arg2) return c } // Do rewrite *gomock.Call.Do -func (c *PackerPackAckOnlyPacketCall) Do(f func(protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *PackerPackAckOnlyPacketCall { +func (c *MockPackerPackAckOnlyPacketCall) Do(f func(protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *MockPackerPackAckOnlyPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerPackAckOnlyPacketCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *PackerPackAckOnlyPacketCall { +func (c *MockPackerPackAckOnlyPacketCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *MockPackerPackAckOnlyPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -168,31 +169,31 @@ func (m *MockPacker) PackApplicationClose(arg0 *qerr.ApplicationError, arg1 prot } // PackApplicationClose indicates an expected call of PackApplicationClose. -func (mr *MockPackerMockRecorder) PackApplicationClose(arg0, arg1, arg2 any) *PackerPackApplicationCloseCall { +func (mr *MockPackerMockRecorder) PackApplicationClose(arg0, arg1, arg2 any) *MockPackerPackApplicationCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackApplicationClose", reflect.TypeOf((*MockPacker)(nil).PackApplicationClose), arg0, arg1, arg2) - return &PackerPackApplicationCloseCall{Call: call} + return &MockPackerPackApplicationCloseCall{Call: call} } -// PackerPackApplicationCloseCall wrap *gomock.Call -type PackerPackApplicationCloseCall struct { +// MockPackerPackApplicationCloseCall wrap *gomock.Call +type MockPackerPackApplicationCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerPackApplicationCloseCall) Return(arg0 *coalescedPacket, arg1 error) *PackerPackApplicationCloseCall { +func (c *MockPackerPackApplicationCloseCall) Return(arg0 *coalescedPacket, arg1 error) *MockPackerPackApplicationCloseCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PackerPackApplicationCloseCall) Do(f func(*qerr.ApplicationError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackApplicationCloseCall { +func (c *MockPackerPackApplicationCloseCall) Do(f func(*qerr.ApplicationError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackApplicationCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerPackApplicationCloseCall) DoAndReturn(f func(*qerr.ApplicationError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackApplicationCloseCall { +func (c *MockPackerPackApplicationCloseCall) DoAndReturn(f func(*qerr.ApplicationError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackApplicationCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -207,31 +208,31 @@ func (m *MockPacker) PackCoalescedPacket(arg0 bool, arg1 protocol.ByteCount, arg } // PackCoalescedPacket indicates an expected call of PackCoalescedPacket. -func (mr *MockPackerMockRecorder) PackCoalescedPacket(arg0, arg1, arg2 any) *PackerPackCoalescedPacketCall { +func (mr *MockPackerMockRecorder) PackCoalescedPacket(arg0, arg1, arg2 any) *MockPackerPackCoalescedPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackCoalescedPacket", reflect.TypeOf((*MockPacker)(nil).PackCoalescedPacket), arg0, arg1, arg2) - return &PackerPackCoalescedPacketCall{Call: call} + return &MockPackerPackCoalescedPacketCall{Call: call} } -// PackerPackCoalescedPacketCall wrap *gomock.Call -type PackerPackCoalescedPacketCall struct { +// MockPackerPackCoalescedPacketCall wrap *gomock.Call +type MockPackerPackCoalescedPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerPackCoalescedPacketCall) Return(arg0 *coalescedPacket, arg1 error) *PackerPackCoalescedPacketCall { +func (c *MockPackerPackCoalescedPacketCall) Return(arg0 *coalescedPacket, arg1 error) *MockPackerPackCoalescedPacketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PackerPackCoalescedPacketCall) Do(f func(bool, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackCoalescedPacketCall { +func (c *MockPackerPackCoalescedPacketCall) Do(f func(bool, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackCoalescedPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerPackCoalescedPacketCall) DoAndReturn(f func(bool, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackCoalescedPacketCall { +func (c *MockPackerPackCoalescedPacketCall) DoAndReturn(f func(bool, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackCoalescedPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -246,31 +247,31 @@ func (m *MockPacker) PackConnectionClose(arg0 *qerr.TransportError, arg1 protoco } // PackConnectionClose indicates an expected call of PackConnectionClose. -func (mr *MockPackerMockRecorder) PackConnectionClose(arg0, arg1, arg2 any) *PackerPackConnectionCloseCall { +func (mr *MockPackerMockRecorder) PackConnectionClose(arg0, arg1, arg2 any) *MockPackerPackConnectionCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackConnectionClose", reflect.TypeOf((*MockPacker)(nil).PackConnectionClose), arg0, arg1, arg2) - return &PackerPackConnectionCloseCall{Call: call} + return &MockPackerPackConnectionCloseCall{Call: call} } -// PackerPackConnectionCloseCall wrap *gomock.Call -type PackerPackConnectionCloseCall struct { +// MockPackerPackConnectionCloseCall wrap *gomock.Call +type MockPackerPackConnectionCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerPackConnectionCloseCall) Return(arg0 *coalescedPacket, arg1 error) *PackerPackConnectionCloseCall { +func (c *MockPackerPackConnectionCloseCall) Return(arg0 *coalescedPacket, arg1 error) *MockPackerPackConnectionCloseCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PackerPackConnectionCloseCall) Do(f func(*qerr.TransportError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackConnectionCloseCall { +func (c *MockPackerPackConnectionCloseCall) Do(f func(*qerr.TransportError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackConnectionCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerPackConnectionCloseCall) DoAndReturn(f func(*qerr.TransportError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *PackerPackConnectionCloseCall { +func (c *MockPackerPackConnectionCloseCall) DoAndReturn(f func(*qerr.TransportError, protocol.ByteCount, protocol.Version) (*coalescedPacket, error)) *MockPackerPackConnectionCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -286,31 +287,31 @@ func (m *MockPacker) PackMTUProbePacket(arg0 ackhandler.Frame, arg1 protocol.Byt } // PackMTUProbePacket indicates an expected call of PackMTUProbePacket. -func (mr *MockPackerMockRecorder) PackMTUProbePacket(arg0, arg1, arg2 any) *PackerPackMTUProbePacketCall { +func (mr *MockPackerMockRecorder) PackMTUProbePacket(arg0, arg1, arg2 any) *MockPackerPackMTUProbePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackMTUProbePacket", reflect.TypeOf((*MockPacker)(nil).PackMTUProbePacket), arg0, arg1, arg2) - return &PackerPackMTUProbePacketCall{Call: call} + return &MockPackerPackMTUProbePacketCall{Call: call} } -// PackerPackMTUProbePacketCall wrap *gomock.Call -type PackerPackMTUProbePacketCall struct { +// MockPackerPackMTUProbePacketCall wrap *gomock.Call +type MockPackerPackMTUProbePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerPackMTUProbePacketCall) Return(arg0 shortHeaderPacket, arg1 *packetBuffer, arg2 error) *PackerPackMTUProbePacketCall { +func (c *MockPackerPackMTUProbePacketCall) Return(arg0 shortHeaderPacket, arg1 *packetBuffer, arg2 error) *MockPackerPackMTUProbePacketCall { c.Call = c.Call.Return(arg0, arg1, arg2) return c } // Do rewrite *gomock.Call.Do -func (c *PackerPackMTUProbePacketCall) Do(f func(ackhandler.Frame, protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *PackerPackMTUProbePacketCall { +func (c *MockPackerPackMTUProbePacketCall) Do(f func(ackhandler.Frame, protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *MockPackerPackMTUProbePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerPackMTUProbePacketCall) DoAndReturn(f func(ackhandler.Frame, protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *PackerPackMTUProbePacketCall { +func (c *MockPackerPackMTUProbePacketCall) DoAndReturn(f func(ackhandler.Frame, protocol.ByteCount, protocol.Version) (shortHeaderPacket, *packetBuffer, error)) *MockPackerPackMTUProbePacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -322,31 +323,31 @@ func (m *MockPacker) SetToken(arg0 []byte) { } // SetToken indicates an expected call of SetToken. -func (mr *MockPackerMockRecorder) SetToken(arg0 any) *PackerSetTokenCall { +func (mr *MockPackerMockRecorder) SetToken(arg0 any) *MockPackerSetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetToken", reflect.TypeOf((*MockPacker)(nil).SetToken), arg0) - return &PackerSetTokenCall{Call: call} + return &MockPackerSetTokenCall{Call: call} } -// PackerSetTokenCall wrap *gomock.Call -type PackerSetTokenCall struct { +// MockPackerSetTokenCall wrap *gomock.Call +type MockPackerSetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PackerSetTokenCall) Return() *PackerSetTokenCall { +func (c *MockPackerSetTokenCall) Return() *MockPackerSetTokenCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PackerSetTokenCall) Do(f func([]byte)) *PackerSetTokenCall { +func (c *MockPackerSetTokenCall) Do(f func([]byte)) *MockPackerSetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PackerSetTokenCall) DoAndReturn(f func([]byte)) *PackerSetTokenCall { +func (c *MockPackerSetTokenCall) DoAndReturn(f func([]byte)) *MockPackerSetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_packet_handler_manager_test.go b/mock_packet_handler_manager_test.go index 6170981f..465a3865 100644 --- a/mock_packet_handler_manager_test.go +++ b/mock_packet_handler_manager_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_packet_handler_manager_test.go github.com/quic-go/quic-go PacketHandlerManager // + // Package quic is a generated GoMock package. package quic @@ -47,31 +48,31 @@ func (m *MockPacketHandlerManager) Add(arg0 protocol.ConnectionID, arg1 packetHa } // Add indicates an expected call of Add. -func (mr *MockPacketHandlerManagerMockRecorder) Add(arg0, arg1 any) *PacketHandlerManagerAddCall { +func (mr *MockPacketHandlerManagerMockRecorder) Add(arg0, arg1 any) *MockPacketHandlerManagerAddCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockPacketHandlerManager)(nil).Add), arg0, arg1) - return &PacketHandlerManagerAddCall{Call: call} + return &MockPacketHandlerManagerAddCall{Call: call} } -// PacketHandlerManagerAddCall wrap *gomock.Call -type PacketHandlerManagerAddCall struct { +// MockPacketHandlerManagerAddCall wrap *gomock.Call +type MockPacketHandlerManagerAddCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerAddCall) Return(arg0 bool) *PacketHandlerManagerAddCall { +func (c *MockPacketHandlerManagerAddCall) Return(arg0 bool) *MockPacketHandlerManagerAddCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerAddCall) Do(f func(protocol.ConnectionID, packetHandler) bool) *PacketHandlerManagerAddCall { +func (c *MockPacketHandlerManagerAddCall) Do(f func(protocol.ConnectionID, packetHandler) bool) *MockPacketHandlerManagerAddCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerAddCall) DoAndReturn(f func(protocol.ConnectionID, packetHandler) bool) *PacketHandlerManagerAddCall { +func (c *MockPacketHandlerManagerAddCall) DoAndReturn(f func(protocol.ConnectionID, packetHandler) bool) *MockPacketHandlerManagerAddCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockPacketHandlerManager) AddResetToken(arg0 protocol.StatelessResetTok } // AddResetToken indicates an expected call of AddResetToken. -func (mr *MockPacketHandlerManagerMockRecorder) AddResetToken(arg0, arg1 any) *PacketHandlerManagerAddResetTokenCall { +func (mr *MockPacketHandlerManagerMockRecorder) AddResetToken(arg0, arg1 any) *MockPacketHandlerManagerAddResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).AddResetToken), arg0, arg1) - return &PacketHandlerManagerAddResetTokenCall{Call: call} + return &MockPacketHandlerManagerAddResetTokenCall{Call: call} } -// PacketHandlerManagerAddResetTokenCall wrap *gomock.Call -type PacketHandlerManagerAddResetTokenCall struct { +// MockPacketHandlerManagerAddResetTokenCall wrap *gomock.Call +type MockPacketHandlerManagerAddResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerAddResetTokenCall) Return() *PacketHandlerManagerAddResetTokenCall { +func (c *MockPacketHandlerManagerAddResetTokenCall) Return() *MockPacketHandlerManagerAddResetTokenCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerAddResetTokenCall) Do(f func(protocol.StatelessResetToken, packetHandler)) *PacketHandlerManagerAddResetTokenCall { +func (c *MockPacketHandlerManagerAddResetTokenCall) Do(f func(protocol.StatelessResetToken, packetHandler)) *MockPacketHandlerManagerAddResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerAddResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken, packetHandler)) *PacketHandlerManagerAddResetTokenCall { +func (c *MockPacketHandlerManagerAddResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken, packetHandler)) *MockPacketHandlerManagerAddResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -121,31 +122,31 @@ func (m *MockPacketHandlerManager) AddWithConnID(arg0, arg1 protocol.ConnectionI } // AddWithConnID indicates an expected call of AddWithConnID. -func (mr *MockPacketHandlerManagerMockRecorder) AddWithConnID(arg0, arg1, arg2 any) *PacketHandlerManagerAddWithConnIDCall { +func (mr *MockPacketHandlerManagerMockRecorder) AddWithConnID(arg0, arg1, arg2 any) *MockPacketHandlerManagerAddWithConnIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddWithConnID", reflect.TypeOf((*MockPacketHandlerManager)(nil).AddWithConnID), arg0, arg1, arg2) - return &PacketHandlerManagerAddWithConnIDCall{Call: call} + return &MockPacketHandlerManagerAddWithConnIDCall{Call: call} } -// PacketHandlerManagerAddWithConnIDCall wrap *gomock.Call -type PacketHandlerManagerAddWithConnIDCall struct { +// MockPacketHandlerManagerAddWithConnIDCall wrap *gomock.Call +type MockPacketHandlerManagerAddWithConnIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerAddWithConnIDCall) Return(arg0 bool) *PacketHandlerManagerAddWithConnIDCall { +func (c *MockPacketHandlerManagerAddWithConnIDCall) Return(arg0 bool) *MockPacketHandlerManagerAddWithConnIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerAddWithConnIDCall) Do(f func(protocol.ConnectionID, protocol.ConnectionID, packetHandler) bool) *PacketHandlerManagerAddWithConnIDCall { +func (c *MockPacketHandlerManagerAddWithConnIDCall) Do(f func(protocol.ConnectionID, protocol.ConnectionID, packetHandler) bool) *MockPacketHandlerManagerAddWithConnIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerAddWithConnIDCall) DoAndReturn(f func(protocol.ConnectionID, protocol.ConnectionID, packetHandler) bool) *PacketHandlerManagerAddWithConnIDCall { +func (c *MockPacketHandlerManagerAddWithConnIDCall) DoAndReturn(f func(protocol.ConnectionID, protocol.ConnectionID, packetHandler) bool) *MockPacketHandlerManagerAddWithConnIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -157,31 +158,31 @@ func (m *MockPacketHandlerManager) Close(arg0 error) { } // Close indicates an expected call of Close. -func (mr *MockPacketHandlerManagerMockRecorder) Close(arg0 any) *PacketHandlerManagerCloseCall { +func (mr *MockPacketHandlerManagerMockRecorder) Close(arg0 any) *MockPacketHandlerManagerCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPacketHandlerManager)(nil).Close), arg0) - return &PacketHandlerManagerCloseCall{Call: call} + return &MockPacketHandlerManagerCloseCall{Call: call} } -// PacketHandlerManagerCloseCall wrap *gomock.Call -type PacketHandlerManagerCloseCall struct { +// MockPacketHandlerManagerCloseCall wrap *gomock.Call +type MockPacketHandlerManagerCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerCloseCall) Return() *PacketHandlerManagerCloseCall { +func (c *MockPacketHandlerManagerCloseCall) Return() *MockPacketHandlerManagerCloseCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerCloseCall) Do(f func(error)) *PacketHandlerManagerCloseCall { +func (c *MockPacketHandlerManagerCloseCall) Do(f func(error)) *MockPacketHandlerManagerCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerCloseCall) DoAndReturn(f func(error)) *PacketHandlerManagerCloseCall { +func (c *MockPacketHandlerManagerCloseCall) DoAndReturn(f func(error)) *MockPacketHandlerManagerCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -196,31 +197,31 @@ func (m *MockPacketHandlerManager) Get(arg0 protocol.ConnectionID) (packetHandle } // Get indicates an expected call of Get. -func (mr *MockPacketHandlerManagerMockRecorder) Get(arg0 any) *PacketHandlerManagerGetCall { +func (mr *MockPacketHandlerManagerMockRecorder) Get(arg0 any) *MockPacketHandlerManagerGetCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPacketHandlerManager)(nil).Get), arg0) - return &PacketHandlerManagerGetCall{Call: call} + return &MockPacketHandlerManagerGetCall{Call: call} } -// PacketHandlerManagerGetCall wrap *gomock.Call -type PacketHandlerManagerGetCall struct { +// MockPacketHandlerManagerGetCall wrap *gomock.Call +type MockPacketHandlerManagerGetCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerGetCall) Return(arg0 packetHandler, arg1 bool) *PacketHandlerManagerGetCall { +func (c *MockPacketHandlerManagerGetCall) Return(arg0 packetHandler, arg1 bool) *MockPacketHandlerManagerGetCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerGetCall) Do(f func(protocol.ConnectionID) (packetHandler, bool)) *PacketHandlerManagerGetCall { +func (c *MockPacketHandlerManagerGetCall) Do(f func(protocol.ConnectionID) (packetHandler, bool)) *MockPacketHandlerManagerGetCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerGetCall) DoAndReturn(f func(protocol.ConnectionID) (packetHandler, bool)) *PacketHandlerManagerGetCall { +func (c *MockPacketHandlerManagerGetCall) DoAndReturn(f func(protocol.ConnectionID) (packetHandler, bool)) *MockPacketHandlerManagerGetCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -235,31 +236,31 @@ func (m *MockPacketHandlerManager) GetByResetToken(arg0 protocol.StatelessResetT } // GetByResetToken indicates an expected call of GetByResetToken. -func (mr *MockPacketHandlerManagerMockRecorder) GetByResetToken(arg0 any) *PacketHandlerManagerGetByResetTokenCall { +func (mr *MockPacketHandlerManagerMockRecorder) GetByResetToken(arg0 any) *MockPacketHandlerManagerGetByResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).GetByResetToken), arg0) - return &PacketHandlerManagerGetByResetTokenCall{Call: call} + return &MockPacketHandlerManagerGetByResetTokenCall{Call: call} } -// PacketHandlerManagerGetByResetTokenCall wrap *gomock.Call -type PacketHandlerManagerGetByResetTokenCall struct { +// MockPacketHandlerManagerGetByResetTokenCall wrap *gomock.Call +type MockPacketHandlerManagerGetByResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerGetByResetTokenCall) Return(arg0 packetHandler, arg1 bool) *PacketHandlerManagerGetByResetTokenCall { +func (c *MockPacketHandlerManagerGetByResetTokenCall) Return(arg0 packetHandler, arg1 bool) *MockPacketHandlerManagerGetByResetTokenCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerGetByResetTokenCall) Do(f func(protocol.StatelessResetToken) (packetHandler, bool)) *PacketHandlerManagerGetByResetTokenCall { +func (c *MockPacketHandlerManagerGetByResetTokenCall) Do(f func(protocol.StatelessResetToken) (packetHandler, bool)) *MockPacketHandlerManagerGetByResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerGetByResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken) (packetHandler, bool)) *PacketHandlerManagerGetByResetTokenCall { +func (c *MockPacketHandlerManagerGetByResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken) (packetHandler, bool)) *MockPacketHandlerManagerGetByResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -273,31 +274,31 @@ func (m *MockPacketHandlerManager) GetStatelessResetToken(arg0 protocol.Connecti } // GetStatelessResetToken indicates an expected call of GetStatelessResetToken. -func (mr *MockPacketHandlerManagerMockRecorder) GetStatelessResetToken(arg0 any) *PacketHandlerManagerGetStatelessResetTokenCall { +func (mr *MockPacketHandlerManagerMockRecorder) GetStatelessResetToken(arg0 any) *MockPacketHandlerManagerGetStatelessResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatelessResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).GetStatelessResetToken), arg0) - return &PacketHandlerManagerGetStatelessResetTokenCall{Call: call} + return &MockPacketHandlerManagerGetStatelessResetTokenCall{Call: call} } -// PacketHandlerManagerGetStatelessResetTokenCall wrap *gomock.Call -type PacketHandlerManagerGetStatelessResetTokenCall struct { +// MockPacketHandlerManagerGetStatelessResetTokenCall wrap *gomock.Call +type MockPacketHandlerManagerGetStatelessResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerGetStatelessResetTokenCall) Return(arg0 protocol.StatelessResetToken) *PacketHandlerManagerGetStatelessResetTokenCall { +func (c *MockPacketHandlerManagerGetStatelessResetTokenCall) Return(arg0 protocol.StatelessResetToken) *MockPacketHandlerManagerGetStatelessResetTokenCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerGetStatelessResetTokenCall) Do(f func(protocol.ConnectionID) protocol.StatelessResetToken) *PacketHandlerManagerGetStatelessResetTokenCall { +func (c *MockPacketHandlerManagerGetStatelessResetTokenCall) Do(f func(protocol.ConnectionID) protocol.StatelessResetToken) *MockPacketHandlerManagerGetStatelessResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerGetStatelessResetTokenCall) DoAndReturn(f func(protocol.ConnectionID) protocol.StatelessResetToken) *PacketHandlerManagerGetStatelessResetTokenCall { +func (c *MockPacketHandlerManagerGetStatelessResetTokenCall) DoAndReturn(f func(protocol.ConnectionID) protocol.StatelessResetToken) *MockPacketHandlerManagerGetStatelessResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -309,31 +310,31 @@ func (m *MockPacketHandlerManager) Remove(arg0 protocol.ConnectionID) { } // Remove indicates an expected call of Remove. -func (mr *MockPacketHandlerManagerMockRecorder) Remove(arg0 any) *PacketHandlerManagerRemoveCall { +func (mr *MockPacketHandlerManagerMockRecorder) Remove(arg0 any) *MockPacketHandlerManagerRemoveCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockPacketHandlerManager)(nil).Remove), arg0) - return &PacketHandlerManagerRemoveCall{Call: call} + return &MockPacketHandlerManagerRemoveCall{Call: call} } -// PacketHandlerManagerRemoveCall wrap *gomock.Call -type PacketHandlerManagerRemoveCall struct { +// MockPacketHandlerManagerRemoveCall wrap *gomock.Call +type MockPacketHandlerManagerRemoveCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerRemoveCall) Return() *PacketHandlerManagerRemoveCall { +func (c *MockPacketHandlerManagerRemoveCall) Return() *MockPacketHandlerManagerRemoveCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerRemoveCall) Do(f func(protocol.ConnectionID)) *PacketHandlerManagerRemoveCall { +func (c *MockPacketHandlerManagerRemoveCall) Do(f func(protocol.ConnectionID)) *MockPacketHandlerManagerRemoveCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerRemoveCall) DoAndReturn(f func(protocol.ConnectionID)) *PacketHandlerManagerRemoveCall { +func (c *MockPacketHandlerManagerRemoveCall) DoAndReturn(f func(protocol.ConnectionID)) *MockPacketHandlerManagerRemoveCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -345,31 +346,31 @@ func (m *MockPacketHandlerManager) RemoveResetToken(arg0 protocol.StatelessReset } // RemoveResetToken indicates an expected call of RemoveResetToken. -func (mr *MockPacketHandlerManagerMockRecorder) RemoveResetToken(arg0 any) *PacketHandlerManagerRemoveResetTokenCall { +func (mr *MockPacketHandlerManagerMockRecorder) RemoveResetToken(arg0 any) *MockPacketHandlerManagerRemoveResetTokenCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveResetToken", reflect.TypeOf((*MockPacketHandlerManager)(nil).RemoveResetToken), arg0) - return &PacketHandlerManagerRemoveResetTokenCall{Call: call} + return &MockPacketHandlerManagerRemoveResetTokenCall{Call: call} } -// PacketHandlerManagerRemoveResetTokenCall wrap *gomock.Call -type PacketHandlerManagerRemoveResetTokenCall struct { +// MockPacketHandlerManagerRemoveResetTokenCall wrap *gomock.Call +type MockPacketHandlerManagerRemoveResetTokenCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerRemoveResetTokenCall) Return() *PacketHandlerManagerRemoveResetTokenCall { +func (c *MockPacketHandlerManagerRemoveResetTokenCall) Return() *MockPacketHandlerManagerRemoveResetTokenCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerRemoveResetTokenCall) Do(f func(protocol.StatelessResetToken)) *PacketHandlerManagerRemoveResetTokenCall { +func (c *MockPacketHandlerManagerRemoveResetTokenCall) Do(f func(protocol.StatelessResetToken)) *MockPacketHandlerManagerRemoveResetTokenCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerRemoveResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken)) *PacketHandlerManagerRemoveResetTokenCall { +func (c *MockPacketHandlerManagerRemoveResetTokenCall) DoAndReturn(f func(protocol.StatelessResetToken)) *MockPacketHandlerManagerRemoveResetTokenCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -381,31 +382,31 @@ func (m *MockPacketHandlerManager) ReplaceWithClosed(arg0 []protocol.ConnectionI } // ReplaceWithClosed indicates an expected call of ReplaceWithClosed. -func (mr *MockPacketHandlerManagerMockRecorder) ReplaceWithClosed(arg0, arg1 any) *PacketHandlerManagerReplaceWithClosedCall { +func (mr *MockPacketHandlerManagerMockRecorder) ReplaceWithClosed(arg0, arg1 any) *MockPacketHandlerManagerReplaceWithClosedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceWithClosed", reflect.TypeOf((*MockPacketHandlerManager)(nil).ReplaceWithClosed), arg0, arg1) - return &PacketHandlerManagerReplaceWithClosedCall{Call: call} + return &MockPacketHandlerManagerReplaceWithClosedCall{Call: call} } -// PacketHandlerManagerReplaceWithClosedCall wrap *gomock.Call -type PacketHandlerManagerReplaceWithClosedCall struct { +// MockPacketHandlerManagerReplaceWithClosedCall wrap *gomock.Call +type MockPacketHandlerManagerReplaceWithClosedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerReplaceWithClosedCall) Return() *PacketHandlerManagerReplaceWithClosedCall { +func (c *MockPacketHandlerManagerReplaceWithClosedCall) Return() *MockPacketHandlerManagerReplaceWithClosedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerReplaceWithClosedCall) Do(f func([]protocol.ConnectionID, []byte)) *PacketHandlerManagerReplaceWithClosedCall { +func (c *MockPacketHandlerManagerReplaceWithClosedCall) Do(f func([]protocol.ConnectionID, []byte)) *MockPacketHandlerManagerReplaceWithClosedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerReplaceWithClosedCall) DoAndReturn(f func([]protocol.ConnectionID, []byte)) *PacketHandlerManagerReplaceWithClosedCall { +func (c *MockPacketHandlerManagerReplaceWithClosedCall) DoAndReturn(f func([]protocol.ConnectionID, []byte)) *MockPacketHandlerManagerReplaceWithClosedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -417,31 +418,31 @@ func (m *MockPacketHandlerManager) Retire(arg0 protocol.ConnectionID) { } // Retire indicates an expected call of Retire. -func (mr *MockPacketHandlerManagerMockRecorder) Retire(arg0 any) *PacketHandlerManagerRetireCall { +func (mr *MockPacketHandlerManagerMockRecorder) Retire(arg0 any) *MockPacketHandlerManagerRetireCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retire", reflect.TypeOf((*MockPacketHandlerManager)(nil).Retire), arg0) - return &PacketHandlerManagerRetireCall{Call: call} + return &MockPacketHandlerManagerRetireCall{Call: call} } -// PacketHandlerManagerRetireCall wrap *gomock.Call -type PacketHandlerManagerRetireCall struct { +// MockPacketHandlerManagerRetireCall wrap *gomock.Call +type MockPacketHandlerManagerRetireCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerManagerRetireCall) Return() *PacketHandlerManagerRetireCall { +func (c *MockPacketHandlerManagerRetireCall) Return() *MockPacketHandlerManagerRetireCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerManagerRetireCall) Do(f func(protocol.ConnectionID)) *PacketHandlerManagerRetireCall { +func (c *MockPacketHandlerManagerRetireCall) Do(f func(protocol.ConnectionID)) *MockPacketHandlerManagerRetireCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerManagerRetireCall) DoAndReturn(f func(protocol.ConnectionID)) *PacketHandlerManagerRetireCall { +func (c *MockPacketHandlerManagerRetireCall) DoAndReturn(f func(protocol.ConnectionID)) *MockPacketHandlerManagerRetireCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_packet_handler_test.go b/mock_packet_handler_test.go index dec5937b..46c99f8c 100644 --- a/mock_packet_handler_test.go +++ b/mock_packet_handler_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_packet_handler_test.go github.com/quic-go/quic-go PacketHandler // + // Package quic is a generated GoMock package. package quic @@ -45,31 +46,31 @@ func (m *MockPacketHandler) closeWithTransportError(arg0 qerr.TransportErrorCode } // closeWithTransportError indicates an expected call of closeWithTransportError. -func (mr *MockPacketHandlerMockRecorder) closeWithTransportError(arg0 any) *PacketHandlercloseWithTransportErrorCall { +func (mr *MockPacketHandlerMockRecorder) closeWithTransportError(arg0 any) *MockPacketHandlercloseWithTransportErrorCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeWithTransportError", reflect.TypeOf((*MockPacketHandler)(nil).closeWithTransportError), arg0) - return &PacketHandlercloseWithTransportErrorCall{Call: call} + return &MockPacketHandlercloseWithTransportErrorCall{Call: call} } -// PacketHandlercloseWithTransportErrorCall wrap *gomock.Call -type PacketHandlercloseWithTransportErrorCall struct { +// MockPacketHandlercloseWithTransportErrorCall wrap *gomock.Call +type MockPacketHandlercloseWithTransportErrorCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlercloseWithTransportErrorCall) Return() *PacketHandlercloseWithTransportErrorCall { +func (c *MockPacketHandlercloseWithTransportErrorCall) Return() *MockPacketHandlercloseWithTransportErrorCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlercloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *PacketHandlercloseWithTransportErrorCall { +func (c *MockPacketHandlercloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *MockPacketHandlercloseWithTransportErrorCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlercloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *PacketHandlercloseWithTransportErrorCall { +func (c *MockPacketHandlercloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *MockPacketHandlercloseWithTransportErrorCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -81,31 +82,31 @@ func (m *MockPacketHandler) destroy(arg0 error) { } // destroy indicates an expected call of destroy. -func (mr *MockPacketHandlerMockRecorder) destroy(arg0 any) *PacketHandlerdestroyCall { +func (mr *MockPacketHandlerMockRecorder) destroy(arg0 any) *MockPacketHandlerdestroyCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "destroy", reflect.TypeOf((*MockPacketHandler)(nil).destroy), arg0) - return &PacketHandlerdestroyCall{Call: call} + return &MockPacketHandlerdestroyCall{Call: call} } -// PacketHandlerdestroyCall wrap *gomock.Call -type PacketHandlerdestroyCall struct { +// MockPacketHandlerdestroyCall wrap *gomock.Call +type MockPacketHandlerdestroyCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerdestroyCall) Return() *PacketHandlerdestroyCall { +func (c *MockPacketHandlerdestroyCall) Return() *MockPacketHandlerdestroyCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerdestroyCall) Do(f func(error)) *PacketHandlerdestroyCall { +func (c *MockPacketHandlerdestroyCall) Do(f func(error)) *MockPacketHandlerdestroyCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerdestroyCall) DoAndReturn(f func(error)) *PacketHandlerdestroyCall { +func (c *MockPacketHandlerdestroyCall) DoAndReturn(f func(error)) *MockPacketHandlerdestroyCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -117,31 +118,31 @@ func (m *MockPacketHandler) handlePacket(arg0 receivedPacket) { } // handlePacket indicates an expected call of handlePacket. -func (mr *MockPacketHandlerMockRecorder) handlePacket(arg0 any) *PacketHandlerhandlePacketCall { +func (mr *MockPacketHandlerMockRecorder) handlePacket(arg0 any) *MockPacketHandlerhandlePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handlePacket", reflect.TypeOf((*MockPacketHandler)(nil).handlePacket), arg0) - return &PacketHandlerhandlePacketCall{Call: call} + return &MockPacketHandlerhandlePacketCall{Call: call} } -// PacketHandlerhandlePacketCall wrap *gomock.Call -type PacketHandlerhandlePacketCall struct { +// MockPacketHandlerhandlePacketCall wrap *gomock.Call +type MockPacketHandlerhandlePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketHandlerhandlePacketCall) Return() *PacketHandlerhandlePacketCall { +func (c *MockPacketHandlerhandlePacketCall) Return() *MockPacketHandlerhandlePacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *PacketHandlerhandlePacketCall) Do(f func(receivedPacket)) *PacketHandlerhandlePacketCall { +func (c *MockPacketHandlerhandlePacketCall) Do(f func(receivedPacket)) *MockPacketHandlerhandlePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketHandlerhandlePacketCall) DoAndReturn(f func(receivedPacket)) *PacketHandlerhandlePacketCall { +func (c *MockPacketHandlerhandlePacketCall) DoAndReturn(f func(receivedPacket)) *MockPacketHandlerhandlePacketCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_packetconn_test.go b/mock_packetconn_test.go index 0af42487..45d36cba 100644 --- a/mock_packetconn_test.go +++ b/mock_packetconn_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -package quic -self_package github.com/quic-go/quic-go -self_package github.com/quic-go/quic-go -destination mock_packetconn_test.go net PacketConn // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockPacketConn) Close() error { } // Close indicates an expected call of Close. -func (mr *MockPacketConnMockRecorder) Close() *PacketConnCloseCall { +func (mr *MockPacketConnMockRecorder) Close() *MockPacketConnCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockPacketConn)(nil).Close)) - return &PacketConnCloseCall{Call: call} + return &MockPacketConnCloseCall{Call: call} } -// PacketConnCloseCall wrap *gomock.Call -type PacketConnCloseCall struct { +// MockPacketConnCloseCall wrap *gomock.Call +type MockPacketConnCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnCloseCall) Return(arg0 error) *PacketConnCloseCall { +func (c *MockPacketConnCloseCall) Return(arg0 error) *MockPacketConnCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnCloseCall) Do(f func() error) *PacketConnCloseCall { +func (c *MockPacketConnCloseCall) Do(f func() error) *MockPacketConnCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnCloseCall) DoAndReturn(f func() error) *PacketConnCloseCall { +func (c *MockPacketConnCloseCall) DoAndReturn(f func() error) *MockPacketConnCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockPacketConn) LocalAddr() net.Addr { } // LocalAddr indicates an expected call of LocalAddr. -func (mr *MockPacketConnMockRecorder) LocalAddr() *PacketConnLocalAddrCall { +func (mr *MockPacketConnMockRecorder) LocalAddr() *MockPacketConnLocalAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockPacketConn)(nil).LocalAddr)) - return &PacketConnLocalAddrCall{Call: call} + return &MockPacketConnLocalAddrCall{Call: call} } -// PacketConnLocalAddrCall wrap *gomock.Call -type PacketConnLocalAddrCall struct { +// MockPacketConnLocalAddrCall wrap *gomock.Call +type MockPacketConnLocalAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnLocalAddrCall) Return(arg0 net.Addr) *PacketConnLocalAddrCall { +func (c *MockPacketConnLocalAddrCall) Return(arg0 net.Addr) *MockPacketConnLocalAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnLocalAddrCall) Do(f func() net.Addr) *PacketConnLocalAddrCall { +func (c *MockPacketConnLocalAddrCall) Do(f func() net.Addr) *MockPacketConnLocalAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnLocalAddrCall) DoAndReturn(f func() net.Addr) *PacketConnLocalAddrCall { +func (c *MockPacketConnLocalAddrCall) DoAndReturn(f func() net.Addr) *MockPacketConnLocalAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockPacketConn) ReadFrom(arg0 []byte) (int, net.Addr, error) { } // ReadFrom indicates an expected call of ReadFrom. -func (mr *MockPacketConnMockRecorder) ReadFrom(arg0 any) *PacketConnReadFromCall { +func (mr *MockPacketConnMockRecorder) ReadFrom(arg0 any) *MockPacketConnReadFromCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFrom", reflect.TypeOf((*MockPacketConn)(nil).ReadFrom), arg0) - return &PacketConnReadFromCall{Call: call} + return &MockPacketConnReadFromCall{Call: call} } -// PacketConnReadFromCall wrap *gomock.Call -type PacketConnReadFromCall struct { +// MockPacketConnReadFromCall wrap *gomock.Call +type MockPacketConnReadFromCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnReadFromCall) Return(arg0 int, arg1 net.Addr, arg2 error) *PacketConnReadFromCall { +func (c *MockPacketConnReadFromCall) Return(arg0 int, arg1 net.Addr, arg2 error) *MockPacketConnReadFromCall { c.Call = c.Call.Return(arg0, arg1, arg2) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnReadFromCall) Do(f func([]byte) (int, net.Addr, error)) *PacketConnReadFromCall { +func (c *MockPacketConnReadFromCall) Do(f func([]byte) (int, net.Addr, error)) *MockPacketConnReadFromCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnReadFromCall) DoAndReturn(f func([]byte) (int, net.Addr, error)) *PacketConnReadFromCall { +func (c *MockPacketConnReadFromCall) DoAndReturn(f func([]byte) (int, net.Addr, error)) *MockPacketConnReadFromCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -164,31 +165,31 @@ func (m *MockPacketConn) SetDeadline(arg0 time.Time) error { } // SetDeadline indicates an expected call of SetDeadline. -func (mr *MockPacketConnMockRecorder) SetDeadline(arg0 any) *PacketConnSetDeadlineCall { +func (mr *MockPacketConnMockRecorder) SetDeadline(arg0 any) *MockPacketConnSetDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetDeadline), arg0) - return &PacketConnSetDeadlineCall{Call: call} + return &MockPacketConnSetDeadlineCall{Call: call} } -// PacketConnSetDeadlineCall wrap *gomock.Call -type PacketConnSetDeadlineCall struct { +// MockPacketConnSetDeadlineCall wrap *gomock.Call +type MockPacketConnSetDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnSetDeadlineCall) Return(arg0 error) *PacketConnSetDeadlineCall { +func (c *MockPacketConnSetDeadlineCall) Return(arg0 error) *MockPacketConnSetDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnSetDeadlineCall) Do(f func(time.Time) error) *PacketConnSetDeadlineCall { +func (c *MockPacketConnSetDeadlineCall) Do(f func(time.Time) error) *MockPacketConnSetDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnSetDeadlineCall) DoAndReturn(f func(time.Time) error) *PacketConnSetDeadlineCall { +func (c *MockPacketConnSetDeadlineCall) DoAndReturn(f func(time.Time) error) *MockPacketConnSetDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -202,31 +203,31 @@ func (m *MockPacketConn) SetReadDeadline(arg0 time.Time) error { } // SetReadDeadline indicates an expected call of SetReadDeadline. -func (mr *MockPacketConnMockRecorder) SetReadDeadline(arg0 any) *PacketConnSetReadDeadlineCall { +func (mr *MockPacketConnMockRecorder) SetReadDeadline(arg0 any) *MockPacketConnSetReadDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetReadDeadline), arg0) - return &PacketConnSetReadDeadlineCall{Call: call} + return &MockPacketConnSetReadDeadlineCall{Call: call} } -// PacketConnSetReadDeadlineCall wrap *gomock.Call -type PacketConnSetReadDeadlineCall struct { +// MockPacketConnSetReadDeadlineCall wrap *gomock.Call +type MockPacketConnSetReadDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnSetReadDeadlineCall) Return(arg0 error) *PacketConnSetReadDeadlineCall { +func (c *MockPacketConnSetReadDeadlineCall) Return(arg0 error) *MockPacketConnSetReadDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnSetReadDeadlineCall) Do(f func(time.Time) error) *PacketConnSetReadDeadlineCall { +func (c *MockPacketConnSetReadDeadlineCall) Do(f func(time.Time) error) *MockPacketConnSetReadDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *PacketConnSetReadDeadlineCall { +func (c *MockPacketConnSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockPacketConnSetReadDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -240,31 +241,31 @@ func (m *MockPacketConn) SetWriteDeadline(arg0 time.Time) error { } // SetWriteDeadline indicates an expected call of SetWriteDeadline. -func (mr *MockPacketConnMockRecorder) SetWriteDeadline(arg0 any) *PacketConnSetWriteDeadlineCall { +func (mr *MockPacketConnMockRecorder) SetWriteDeadline(arg0 any) *MockPacketConnSetWriteDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockPacketConn)(nil).SetWriteDeadline), arg0) - return &PacketConnSetWriteDeadlineCall{Call: call} + return &MockPacketConnSetWriteDeadlineCall{Call: call} } -// PacketConnSetWriteDeadlineCall wrap *gomock.Call -type PacketConnSetWriteDeadlineCall struct { +// MockPacketConnSetWriteDeadlineCall wrap *gomock.Call +type MockPacketConnSetWriteDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnSetWriteDeadlineCall) Return(arg0 error) *PacketConnSetWriteDeadlineCall { +func (c *MockPacketConnSetWriteDeadlineCall) Return(arg0 error) *MockPacketConnSetWriteDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnSetWriteDeadlineCall) Do(f func(time.Time) error) *PacketConnSetWriteDeadlineCall { +func (c *MockPacketConnSetWriteDeadlineCall) Do(f func(time.Time) error) *MockPacketConnSetWriteDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *PacketConnSetWriteDeadlineCall { +func (c *MockPacketConnSetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockPacketConnSetWriteDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -279,31 +280,31 @@ func (m *MockPacketConn) WriteTo(arg0 []byte, arg1 net.Addr) (int, error) { } // WriteTo indicates an expected call of WriteTo. -func (mr *MockPacketConnMockRecorder) WriteTo(arg0, arg1 any) *PacketConnWriteToCall { +func (mr *MockPacketConnMockRecorder) WriteTo(arg0, arg1 any) *MockPacketConnWriteToCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTo", reflect.TypeOf((*MockPacketConn)(nil).WriteTo), arg0, arg1) - return &PacketConnWriteToCall{Call: call} + return &MockPacketConnWriteToCall{Call: call} } -// PacketConnWriteToCall wrap *gomock.Call -type PacketConnWriteToCall struct { +// MockPacketConnWriteToCall wrap *gomock.Call +type MockPacketConnWriteToCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *PacketConnWriteToCall) Return(arg0 int, arg1 error) *PacketConnWriteToCall { +func (c *MockPacketConnWriteToCall) Return(arg0 int, arg1 error) *MockPacketConnWriteToCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *PacketConnWriteToCall) Do(f func([]byte, net.Addr) (int, error)) *PacketConnWriteToCall { +func (c *MockPacketConnWriteToCall) Do(f func([]byte, net.Addr) (int, error)) *MockPacketConnWriteToCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *PacketConnWriteToCall) DoAndReturn(f func([]byte, net.Addr) (int, error)) *PacketConnWriteToCall { +func (c *MockPacketConnWriteToCall) DoAndReturn(f func([]byte, net.Addr) (int, error)) *MockPacketConnWriteToCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_quic_conn_test.go b/mock_quic_conn_test.go index 41fcadac..179f26ee 100644 --- a/mock_quic_conn_test.go +++ b/mock_quic_conn_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_quic_conn_test.go github.com/quic-go/quic-go QUICConn // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockQUICConn) AcceptStream(arg0 context.Context) (Stream, error) { } // AcceptStream indicates an expected call of AcceptStream. -func (mr *MockQUICConnMockRecorder) AcceptStream(arg0 any) *QUICConnAcceptStreamCall { +func (mr *MockQUICConnMockRecorder) AcceptStream(arg0 any) *MockQUICConnAcceptStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockQUICConn)(nil).AcceptStream), arg0) - return &QUICConnAcceptStreamCall{Call: call} + return &MockQUICConnAcceptStreamCall{Call: call} } -// QUICConnAcceptStreamCall wrap *gomock.Call -type QUICConnAcceptStreamCall struct { +// MockQUICConnAcceptStreamCall wrap *gomock.Call +type MockQUICConnAcceptStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnAcceptStreamCall) Return(arg0 Stream, arg1 error) *QUICConnAcceptStreamCall { +func (c *MockQUICConnAcceptStreamCall) Return(arg0 Stream, arg1 error) *MockQUICConnAcceptStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnAcceptStreamCall) Do(f func(context.Context) (Stream, error)) *QUICConnAcceptStreamCall { +func (c *MockQUICConnAcceptStreamCall) Do(f func(context.Context) (Stream, error)) *MockQUICConnAcceptStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnAcceptStreamCall) DoAndReturn(f func(context.Context) (Stream, error)) *QUICConnAcceptStreamCall { +func (c *MockQUICConnAcceptStreamCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockQUICConnAcceptStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -89,31 +90,31 @@ func (m *MockQUICConn) AcceptUniStream(arg0 context.Context) (ReceiveStream, err } // AcceptUniStream indicates an expected call of AcceptUniStream. -func (mr *MockQUICConnMockRecorder) AcceptUniStream(arg0 any) *QUICConnAcceptUniStreamCall { +func (mr *MockQUICConnMockRecorder) AcceptUniStream(arg0 any) *MockQUICConnAcceptUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockQUICConn)(nil).AcceptUniStream), arg0) - return &QUICConnAcceptUniStreamCall{Call: call} + return &MockQUICConnAcceptUniStreamCall{Call: call} } -// QUICConnAcceptUniStreamCall wrap *gomock.Call -type QUICConnAcceptUniStreamCall struct { +// MockQUICConnAcceptUniStreamCall wrap *gomock.Call +type MockQUICConnAcceptUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnAcceptUniStreamCall) Return(arg0 ReceiveStream, arg1 error) *QUICConnAcceptUniStreamCall { +func (c *MockQUICConnAcceptUniStreamCall) Return(arg0 ReceiveStream, arg1 error) *MockQUICConnAcceptUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnAcceptUniStreamCall) Do(f func(context.Context) (ReceiveStream, error)) *QUICConnAcceptUniStreamCall { +func (c *MockQUICConnAcceptUniStreamCall) Do(f func(context.Context) (ReceiveStream, error)) *MockQUICConnAcceptUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnAcceptUniStreamCall) DoAndReturn(f func(context.Context) (ReceiveStream, error)) *QUICConnAcceptUniStreamCall { +func (c *MockQUICConnAcceptUniStreamCall) DoAndReturn(f func(context.Context) (ReceiveStream, error)) *MockQUICConnAcceptUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -127,31 +128,31 @@ func (m *MockQUICConn) CloseWithError(arg0 qerr.ApplicationErrorCode, arg1 strin } // CloseWithError indicates an expected call of CloseWithError. -func (mr *MockQUICConnMockRecorder) CloseWithError(arg0, arg1 any) *QUICConnCloseWithErrorCall { +func (mr *MockQUICConnMockRecorder) CloseWithError(arg0, arg1 any) *MockQUICConnCloseWithErrorCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockQUICConn)(nil).CloseWithError), arg0, arg1) - return &QUICConnCloseWithErrorCall{Call: call} + return &MockQUICConnCloseWithErrorCall{Call: call} } -// QUICConnCloseWithErrorCall wrap *gomock.Call -type QUICConnCloseWithErrorCall struct { +// MockQUICConnCloseWithErrorCall wrap *gomock.Call +type MockQUICConnCloseWithErrorCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnCloseWithErrorCall) Return(arg0 error) *QUICConnCloseWithErrorCall { +func (c *MockQUICConnCloseWithErrorCall) Return(arg0 error) *MockQUICConnCloseWithErrorCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *QUICConnCloseWithErrorCall { +func (c *MockQUICConnCloseWithErrorCall) Do(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *QUICConnCloseWithErrorCall { +func (c *MockQUICConnCloseWithErrorCall) DoAndReturn(f func(qerr.ApplicationErrorCode, string) error) *MockQUICConnCloseWithErrorCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -165,31 +166,31 @@ func (m *MockQUICConn) ConnectionState() ConnectionState { } // ConnectionState indicates an expected call of ConnectionState. -func (mr *MockQUICConnMockRecorder) ConnectionState() *QUICConnConnectionStateCall { +func (mr *MockQUICConnMockRecorder) ConnectionState() *MockQUICConnConnectionStateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectionState", reflect.TypeOf((*MockQUICConn)(nil).ConnectionState)) - return &QUICConnConnectionStateCall{Call: call} + return &MockQUICConnConnectionStateCall{Call: call} } -// QUICConnConnectionStateCall wrap *gomock.Call -type QUICConnConnectionStateCall struct { +// MockQUICConnConnectionStateCall wrap *gomock.Call +type MockQUICConnConnectionStateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnConnectionStateCall) Return(arg0 ConnectionState) *QUICConnConnectionStateCall { +func (c *MockQUICConnConnectionStateCall) Return(arg0 ConnectionState) *MockQUICConnConnectionStateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnConnectionStateCall) Do(f func() ConnectionState) *QUICConnConnectionStateCall { +func (c *MockQUICConnConnectionStateCall) Do(f func() ConnectionState) *MockQUICConnConnectionStateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnConnectionStateCall) DoAndReturn(f func() ConnectionState) *QUICConnConnectionStateCall { +func (c *MockQUICConnConnectionStateCall) DoAndReturn(f func() ConnectionState) *MockQUICConnConnectionStateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -203,31 +204,31 @@ func (m *MockQUICConn) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockQUICConnMockRecorder) Context() *QUICConnContextCall { +func (mr *MockQUICConnMockRecorder) Context() *MockQUICConnContextCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockQUICConn)(nil).Context)) - return &QUICConnContextCall{Call: call} + return &MockQUICConnContextCall{Call: call} } -// QUICConnContextCall wrap *gomock.Call -type QUICConnContextCall struct { +// MockQUICConnContextCall wrap *gomock.Call +type MockQUICConnContextCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnContextCall) Return(arg0 context.Context) *QUICConnContextCall { +func (c *MockQUICConnContextCall) Return(arg0 context.Context) *MockQUICConnContextCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnContextCall) Do(f func() context.Context) *QUICConnContextCall { +func (c *MockQUICConnContextCall) Do(f func() context.Context) *MockQUICConnContextCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnContextCall) DoAndReturn(f func() context.Context) *QUICConnContextCall { +func (c *MockQUICConnContextCall) DoAndReturn(f func() context.Context) *MockQUICConnContextCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -241,31 +242,31 @@ func (m *MockQUICConn) HandshakeComplete() <-chan struct{} { } // HandshakeComplete indicates an expected call of HandshakeComplete. -func (mr *MockQUICConnMockRecorder) HandshakeComplete() *QUICConnHandshakeCompleteCall { +func (mr *MockQUICConnMockRecorder) HandshakeComplete() *MockQUICConnHandshakeCompleteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandshakeComplete", reflect.TypeOf((*MockQUICConn)(nil).HandshakeComplete)) - return &QUICConnHandshakeCompleteCall{Call: call} + return &MockQUICConnHandshakeCompleteCall{Call: call} } -// QUICConnHandshakeCompleteCall wrap *gomock.Call -type QUICConnHandshakeCompleteCall struct { +// MockQUICConnHandshakeCompleteCall wrap *gomock.Call +type MockQUICConnHandshakeCompleteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnHandshakeCompleteCall) Return(arg0 <-chan struct{}) *QUICConnHandshakeCompleteCall { +func (c *MockQUICConnHandshakeCompleteCall) Return(arg0 <-chan struct{}) *MockQUICConnHandshakeCompleteCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnHandshakeCompleteCall) Do(f func() <-chan struct{}) *QUICConnHandshakeCompleteCall { +func (c *MockQUICConnHandshakeCompleteCall) Do(f func() <-chan struct{}) *MockQUICConnHandshakeCompleteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnHandshakeCompleteCall) DoAndReturn(f func() <-chan struct{}) *QUICConnHandshakeCompleteCall { +func (c *MockQUICConnHandshakeCompleteCall) DoAndReturn(f func() <-chan struct{}) *MockQUICConnHandshakeCompleteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -279,31 +280,31 @@ func (m *MockQUICConn) LocalAddr() net.Addr { } // LocalAddr indicates an expected call of LocalAddr. -func (mr *MockQUICConnMockRecorder) LocalAddr() *QUICConnLocalAddrCall { +func (mr *MockQUICConnMockRecorder) LocalAddr() *MockQUICConnLocalAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockQUICConn)(nil).LocalAddr)) - return &QUICConnLocalAddrCall{Call: call} + return &MockQUICConnLocalAddrCall{Call: call} } -// QUICConnLocalAddrCall wrap *gomock.Call -type QUICConnLocalAddrCall struct { +// MockQUICConnLocalAddrCall wrap *gomock.Call +type MockQUICConnLocalAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnLocalAddrCall) Return(arg0 net.Addr) *QUICConnLocalAddrCall { +func (c *MockQUICConnLocalAddrCall) Return(arg0 net.Addr) *MockQUICConnLocalAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnLocalAddrCall) Do(f func() net.Addr) *QUICConnLocalAddrCall { +func (c *MockQUICConnLocalAddrCall) Do(f func() net.Addr) *MockQUICConnLocalAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnLocalAddrCall) DoAndReturn(f func() net.Addr) *QUICConnLocalAddrCall { +func (c *MockQUICConnLocalAddrCall) DoAndReturn(f func() net.Addr) *MockQUICConnLocalAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -317,31 +318,31 @@ func (m *MockQUICConn) NextConnection() Connection { } // NextConnection indicates an expected call of NextConnection. -func (mr *MockQUICConnMockRecorder) NextConnection() *QUICConnNextConnectionCall { +func (mr *MockQUICConnMockRecorder) NextConnection() *MockQUICConnNextConnectionCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextConnection", reflect.TypeOf((*MockQUICConn)(nil).NextConnection)) - return &QUICConnNextConnectionCall{Call: call} + return &MockQUICConnNextConnectionCall{Call: call} } -// QUICConnNextConnectionCall wrap *gomock.Call -type QUICConnNextConnectionCall struct { +// MockQUICConnNextConnectionCall wrap *gomock.Call +type MockQUICConnNextConnectionCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnNextConnectionCall) Return(arg0 Connection) *QUICConnNextConnectionCall { +func (c *MockQUICConnNextConnectionCall) Return(arg0 Connection) *MockQUICConnNextConnectionCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnNextConnectionCall) Do(f func() Connection) *QUICConnNextConnectionCall { +func (c *MockQUICConnNextConnectionCall) Do(f func() Connection) *MockQUICConnNextConnectionCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnNextConnectionCall) DoAndReturn(f func() Connection) *QUICConnNextConnectionCall { +func (c *MockQUICConnNextConnectionCall) DoAndReturn(f func() Connection) *MockQUICConnNextConnectionCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -356,31 +357,31 @@ func (m *MockQUICConn) OpenStream() (Stream, error) { } // OpenStream indicates an expected call of OpenStream. -func (mr *MockQUICConnMockRecorder) OpenStream() *QUICConnOpenStreamCall { +func (mr *MockQUICConnMockRecorder) OpenStream() *MockQUICConnOpenStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockQUICConn)(nil).OpenStream)) - return &QUICConnOpenStreamCall{Call: call} + return &MockQUICConnOpenStreamCall{Call: call} } -// QUICConnOpenStreamCall wrap *gomock.Call -type QUICConnOpenStreamCall struct { +// MockQUICConnOpenStreamCall wrap *gomock.Call +type MockQUICConnOpenStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnOpenStreamCall) Return(arg0 Stream, arg1 error) *QUICConnOpenStreamCall { +func (c *MockQUICConnOpenStreamCall) Return(arg0 Stream, arg1 error) *MockQUICConnOpenStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnOpenStreamCall) Do(f func() (Stream, error)) *QUICConnOpenStreamCall { +func (c *MockQUICConnOpenStreamCall) Do(f func() (Stream, error)) *MockQUICConnOpenStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnOpenStreamCall) DoAndReturn(f func() (Stream, error)) *QUICConnOpenStreamCall { +func (c *MockQUICConnOpenStreamCall) DoAndReturn(f func() (Stream, error)) *MockQUICConnOpenStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -395,31 +396,31 @@ func (m *MockQUICConn) OpenStreamSync(arg0 context.Context) (Stream, error) { } // OpenStreamSync indicates an expected call of OpenStreamSync. -func (mr *MockQUICConnMockRecorder) OpenStreamSync(arg0 any) *QUICConnOpenStreamSyncCall { +func (mr *MockQUICConnMockRecorder) OpenStreamSync(arg0 any) *MockQUICConnOpenStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockQUICConn)(nil).OpenStreamSync), arg0) - return &QUICConnOpenStreamSyncCall{Call: call} + return &MockQUICConnOpenStreamSyncCall{Call: call} } -// QUICConnOpenStreamSyncCall wrap *gomock.Call -type QUICConnOpenStreamSyncCall struct { +// MockQUICConnOpenStreamSyncCall wrap *gomock.Call +type MockQUICConnOpenStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnOpenStreamSyncCall) Return(arg0 Stream, arg1 error) *QUICConnOpenStreamSyncCall { +func (c *MockQUICConnOpenStreamSyncCall) Return(arg0 Stream, arg1 error) *MockQUICConnOpenStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnOpenStreamSyncCall) Do(f func(context.Context) (Stream, error)) *QUICConnOpenStreamSyncCall { +func (c *MockQUICConnOpenStreamSyncCall) Do(f func(context.Context) (Stream, error)) *MockQUICConnOpenStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnOpenStreamSyncCall) DoAndReturn(f func(context.Context) (Stream, error)) *QUICConnOpenStreamSyncCall { +func (c *MockQUICConnOpenStreamSyncCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockQUICConnOpenStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -434,31 +435,31 @@ func (m *MockQUICConn) OpenUniStream() (SendStream, error) { } // OpenUniStream indicates an expected call of OpenUniStream. -func (mr *MockQUICConnMockRecorder) OpenUniStream() *QUICConnOpenUniStreamCall { +func (mr *MockQUICConnMockRecorder) OpenUniStream() *MockQUICConnOpenUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockQUICConn)(nil).OpenUniStream)) - return &QUICConnOpenUniStreamCall{Call: call} + return &MockQUICConnOpenUniStreamCall{Call: call} } -// QUICConnOpenUniStreamCall wrap *gomock.Call -type QUICConnOpenUniStreamCall struct { +// MockQUICConnOpenUniStreamCall wrap *gomock.Call +type MockQUICConnOpenUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnOpenUniStreamCall) Return(arg0 SendStream, arg1 error) *QUICConnOpenUniStreamCall { +func (c *MockQUICConnOpenUniStreamCall) Return(arg0 SendStream, arg1 error) *MockQUICConnOpenUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnOpenUniStreamCall) Do(f func() (SendStream, error)) *QUICConnOpenUniStreamCall { +func (c *MockQUICConnOpenUniStreamCall) Do(f func() (SendStream, error)) *MockQUICConnOpenUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnOpenUniStreamCall) DoAndReturn(f func() (SendStream, error)) *QUICConnOpenUniStreamCall { +func (c *MockQUICConnOpenUniStreamCall) DoAndReturn(f func() (SendStream, error)) *MockQUICConnOpenUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -473,31 +474,31 @@ func (m *MockQUICConn) OpenUniStreamSync(arg0 context.Context) (SendStream, erro } // OpenUniStreamSync indicates an expected call of OpenUniStreamSync. -func (mr *MockQUICConnMockRecorder) OpenUniStreamSync(arg0 any) *QUICConnOpenUniStreamSyncCall { +func (mr *MockQUICConnMockRecorder) OpenUniStreamSync(arg0 any) *MockQUICConnOpenUniStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockQUICConn)(nil).OpenUniStreamSync), arg0) - return &QUICConnOpenUniStreamSyncCall{Call: call} + return &MockQUICConnOpenUniStreamSyncCall{Call: call} } -// QUICConnOpenUniStreamSyncCall wrap *gomock.Call -type QUICConnOpenUniStreamSyncCall struct { +// MockQUICConnOpenUniStreamSyncCall wrap *gomock.Call +type MockQUICConnOpenUniStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnOpenUniStreamSyncCall) Return(arg0 SendStream, arg1 error) *QUICConnOpenUniStreamSyncCall { +func (c *MockQUICConnOpenUniStreamSyncCall) Return(arg0 SendStream, arg1 error) *MockQUICConnOpenUniStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnOpenUniStreamSyncCall) Do(f func(context.Context) (SendStream, error)) *QUICConnOpenUniStreamSyncCall { +func (c *MockQUICConnOpenUniStreamSyncCall) Do(f func(context.Context) (SendStream, error)) *MockQUICConnOpenUniStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (SendStream, error)) *QUICConnOpenUniStreamSyncCall { +func (c *MockQUICConnOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (SendStream, error)) *MockQUICConnOpenUniStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -512,31 +513,31 @@ func (m *MockQUICConn) ReceiveDatagram(arg0 context.Context) ([]byte, error) { } // ReceiveDatagram indicates an expected call of ReceiveDatagram. -func (mr *MockQUICConnMockRecorder) ReceiveDatagram(arg0 any) *QUICConnReceiveDatagramCall { +func (mr *MockQUICConnMockRecorder) ReceiveDatagram(arg0 any) *MockQUICConnReceiveDatagramCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveDatagram", reflect.TypeOf((*MockQUICConn)(nil).ReceiveDatagram), arg0) - return &QUICConnReceiveDatagramCall{Call: call} + return &MockQUICConnReceiveDatagramCall{Call: call} } -// QUICConnReceiveDatagramCall wrap *gomock.Call -type QUICConnReceiveDatagramCall struct { +// MockQUICConnReceiveDatagramCall wrap *gomock.Call +type MockQUICConnReceiveDatagramCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnReceiveDatagramCall) Return(arg0 []byte, arg1 error) *QUICConnReceiveDatagramCall { +func (c *MockQUICConnReceiveDatagramCall) Return(arg0 []byte, arg1 error) *MockQUICConnReceiveDatagramCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnReceiveDatagramCall) Do(f func(context.Context) ([]byte, error)) *QUICConnReceiveDatagramCall { +func (c *MockQUICConnReceiveDatagramCall) Do(f func(context.Context) ([]byte, error)) *MockQUICConnReceiveDatagramCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnReceiveDatagramCall) DoAndReturn(f func(context.Context) ([]byte, error)) *QUICConnReceiveDatagramCall { +func (c *MockQUICConnReceiveDatagramCall) DoAndReturn(f func(context.Context) ([]byte, error)) *MockQUICConnReceiveDatagramCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -550,31 +551,31 @@ func (m *MockQUICConn) RemoteAddr() net.Addr { } // RemoteAddr indicates an expected call of RemoteAddr. -func (mr *MockQUICConnMockRecorder) RemoteAddr() *QUICConnRemoteAddrCall { +func (mr *MockQUICConnMockRecorder) RemoteAddr() *MockQUICConnRemoteAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockQUICConn)(nil).RemoteAddr)) - return &QUICConnRemoteAddrCall{Call: call} + return &MockQUICConnRemoteAddrCall{Call: call} } -// QUICConnRemoteAddrCall wrap *gomock.Call -type QUICConnRemoteAddrCall struct { +// MockQUICConnRemoteAddrCall wrap *gomock.Call +type MockQUICConnRemoteAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnRemoteAddrCall) Return(arg0 net.Addr) *QUICConnRemoteAddrCall { +func (c *MockQUICConnRemoteAddrCall) Return(arg0 net.Addr) *MockQUICConnRemoteAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnRemoteAddrCall) Do(f func() net.Addr) *QUICConnRemoteAddrCall { +func (c *MockQUICConnRemoteAddrCall) Do(f func() net.Addr) *MockQUICConnRemoteAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnRemoteAddrCall) DoAndReturn(f func() net.Addr) *QUICConnRemoteAddrCall { +func (c *MockQUICConnRemoteAddrCall) DoAndReturn(f func() net.Addr) *MockQUICConnRemoteAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -588,31 +589,31 @@ func (m *MockQUICConn) SendDatagram(arg0 []byte) error { } // SendDatagram indicates an expected call of SendDatagram. -func (mr *MockQUICConnMockRecorder) SendDatagram(arg0 any) *QUICConnSendDatagramCall { +func (mr *MockQUICConnMockRecorder) SendDatagram(arg0 any) *MockQUICConnSendDatagramCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDatagram", reflect.TypeOf((*MockQUICConn)(nil).SendDatagram), arg0) - return &QUICConnSendDatagramCall{Call: call} + return &MockQUICConnSendDatagramCall{Call: call} } -// QUICConnSendDatagramCall wrap *gomock.Call -type QUICConnSendDatagramCall struct { +// MockQUICConnSendDatagramCall wrap *gomock.Call +type MockQUICConnSendDatagramCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnSendDatagramCall) Return(arg0 error) *QUICConnSendDatagramCall { +func (c *MockQUICConnSendDatagramCall) Return(arg0 error) *MockQUICConnSendDatagramCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnSendDatagramCall) Do(f func([]byte) error) *QUICConnSendDatagramCall { +func (c *MockQUICConnSendDatagramCall) Do(f func([]byte) error) *MockQUICConnSendDatagramCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnSendDatagramCall) DoAndReturn(f func([]byte) error) *QUICConnSendDatagramCall { +func (c *MockQUICConnSendDatagramCall) DoAndReturn(f func([]byte) error) *MockQUICConnSendDatagramCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -624,31 +625,31 @@ func (m *MockQUICConn) closeWithTransportError(arg0 qerr.TransportErrorCode) { } // closeWithTransportError indicates an expected call of closeWithTransportError. -func (mr *MockQUICConnMockRecorder) closeWithTransportError(arg0 any) *QUICConncloseWithTransportErrorCall { +func (mr *MockQUICConnMockRecorder) closeWithTransportError(arg0 any) *MockQUICConncloseWithTransportErrorCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeWithTransportError", reflect.TypeOf((*MockQUICConn)(nil).closeWithTransportError), arg0) - return &QUICConncloseWithTransportErrorCall{Call: call} + return &MockQUICConncloseWithTransportErrorCall{Call: call} } -// QUICConncloseWithTransportErrorCall wrap *gomock.Call -type QUICConncloseWithTransportErrorCall struct { +// MockQUICConncloseWithTransportErrorCall wrap *gomock.Call +type MockQUICConncloseWithTransportErrorCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConncloseWithTransportErrorCall) Return() *QUICConncloseWithTransportErrorCall { +func (c *MockQUICConncloseWithTransportErrorCall) Return() *MockQUICConncloseWithTransportErrorCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *QUICConncloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *QUICConncloseWithTransportErrorCall { +func (c *MockQUICConncloseWithTransportErrorCall) Do(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConncloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *QUICConncloseWithTransportErrorCall { +func (c *MockQUICConncloseWithTransportErrorCall) DoAndReturn(f func(qerr.TransportErrorCode)) *MockQUICConncloseWithTransportErrorCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -660,31 +661,31 @@ func (m *MockQUICConn) destroy(arg0 error) { } // destroy indicates an expected call of destroy. -func (mr *MockQUICConnMockRecorder) destroy(arg0 any) *QUICConndestroyCall { +func (mr *MockQUICConnMockRecorder) destroy(arg0 any) *MockQUICConndestroyCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "destroy", reflect.TypeOf((*MockQUICConn)(nil).destroy), arg0) - return &QUICConndestroyCall{Call: call} + return &MockQUICConndestroyCall{Call: call} } -// QUICConndestroyCall wrap *gomock.Call -type QUICConndestroyCall struct { +// MockQUICConndestroyCall wrap *gomock.Call +type MockQUICConndestroyCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConndestroyCall) Return() *QUICConndestroyCall { +func (c *MockQUICConndestroyCall) Return() *MockQUICConndestroyCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *QUICConndestroyCall) Do(f func(error)) *QUICConndestroyCall { +func (c *MockQUICConndestroyCall) Do(f func(error)) *MockQUICConndestroyCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConndestroyCall) DoAndReturn(f func(error)) *QUICConndestroyCall { +func (c *MockQUICConndestroyCall) DoAndReturn(f func(error)) *MockQUICConndestroyCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -698,31 +699,31 @@ func (m *MockQUICConn) earlyConnReady() <-chan struct{} { } // earlyConnReady indicates an expected call of earlyConnReady. -func (mr *MockQUICConnMockRecorder) earlyConnReady() *QUICConnearlyConnReadyCall { +func (mr *MockQUICConnMockRecorder) earlyConnReady() *MockQUICConnearlyConnReadyCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "earlyConnReady", reflect.TypeOf((*MockQUICConn)(nil).earlyConnReady)) - return &QUICConnearlyConnReadyCall{Call: call} + return &MockQUICConnearlyConnReadyCall{Call: call} } -// QUICConnearlyConnReadyCall wrap *gomock.Call -type QUICConnearlyConnReadyCall struct { +// MockQUICConnearlyConnReadyCall wrap *gomock.Call +type MockQUICConnearlyConnReadyCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnearlyConnReadyCall) Return(arg0 <-chan struct{}) *QUICConnearlyConnReadyCall { +func (c *MockQUICConnearlyConnReadyCall) Return(arg0 <-chan struct{}) *MockQUICConnearlyConnReadyCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnearlyConnReadyCall) Do(f func() <-chan struct{}) *QUICConnearlyConnReadyCall { +func (c *MockQUICConnearlyConnReadyCall) Do(f func() <-chan struct{}) *MockQUICConnearlyConnReadyCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnearlyConnReadyCall) DoAndReturn(f func() <-chan struct{}) *QUICConnearlyConnReadyCall { +func (c *MockQUICConnearlyConnReadyCall) DoAndReturn(f func() <-chan struct{}) *MockQUICConnearlyConnReadyCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -734,31 +735,31 @@ func (m *MockQUICConn) handlePacket(arg0 receivedPacket) { } // handlePacket indicates an expected call of handlePacket. -func (mr *MockQUICConnMockRecorder) handlePacket(arg0 any) *QUICConnhandlePacketCall { +func (mr *MockQUICConnMockRecorder) handlePacket(arg0 any) *MockQUICConnhandlePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handlePacket", reflect.TypeOf((*MockQUICConn)(nil).handlePacket), arg0) - return &QUICConnhandlePacketCall{Call: call} + return &MockQUICConnhandlePacketCall{Call: call} } -// QUICConnhandlePacketCall wrap *gomock.Call -type QUICConnhandlePacketCall struct { +// MockQUICConnhandlePacketCall wrap *gomock.Call +type MockQUICConnhandlePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnhandlePacketCall) Return() *QUICConnhandlePacketCall { +func (c *MockQUICConnhandlePacketCall) Return() *MockQUICConnhandlePacketCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnhandlePacketCall) Do(f func(receivedPacket)) *QUICConnhandlePacketCall { +func (c *MockQUICConnhandlePacketCall) Do(f func(receivedPacket)) *MockQUICConnhandlePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnhandlePacketCall) DoAndReturn(f func(receivedPacket)) *QUICConnhandlePacketCall { +func (c *MockQUICConnhandlePacketCall) DoAndReturn(f func(receivedPacket)) *MockQUICConnhandlePacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -772,31 +773,31 @@ func (m *MockQUICConn) run() error { } // run indicates an expected call of run. -func (mr *MockQUICConnMockRecorder) run() *QUICConnrunCall { +func (mr *MockQUICConnMockRecorder) run() *MockQUICConnrunCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "run", reflect.TypeOf((*MockQUICConn)(nil).run)) - return &QUICConnrunCall{Call: call} + return &MockQUICConnrunCall{Call: call} } -// QUICConnrunCall wrap *gomock.Call -type QUICConnrunCall struct { +// MockQUICConnrunCall wrap *gomock.Call +type MockQUICConnrunCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *QUICConnrunCall) Return(arg0 error) *QUICConnrunCall { +func (c *MockQUICConnrunCall) Return(arg0 error) *MockQUICConnrunCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *QUICConnrunCall) Do(f func() error) *QUICConnrunCall { +func (c *MockQUICConnrunCall) Do(f func() error) *MockQUICConnrunCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *QUICConnrunCall) DoAndReturn(f func() error) *QUICConnrunCall { +func (c *MockQUICConnrunCall) DoAndReturn(f func() error) *MockQUICConnrunCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_raw_conn_test.go b/mock_raw_conn_test.go index 4d76dd16..68f76ec2 100644 --- a/mock_raw_conn_test.go +++ b/mock_raw_conn_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_raw_conn_test.go github.com/quic-go/quic-go RawConn // + // Package quic is a generated GoMock package. package quic @@ -49,31 +50,31 @@ func (m *MockRawConn) Close() error { } // Close indicates an expected call of Close. -func (mr *MockRawConnMockRecorder) Close() *RawConnCloseCall { +func (mr *MockRawConnMockRecorder) Close() *MockRawConnCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockRawConn)(nil).Close)) - return &RawConnCloseCall{Call: call} + return &MockRawConnCloseCall{Call: call} } -// RawConnCloseCall wrap *gomock.Call -type RawConnCloseCall struct { +// MockRawConnCloseCall wrap *gomock.Call +type MockRawConnCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConnCloseCall) Return(arg0 error) *RawConnCloseCall { +func (c *MockRawConnCloseCall) Return(arg0 error) *MockRawConnCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RawConnCloseCall) Do(f func() error) *RawConnCloseCall { +func (c *MockRawConnCloseCall) Do(f func() error) *MockRawConnCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConnCloseCall) DoAndReturn(f func() error) *RawConnCloseCall { +func (c *MockRawConnCloseCall) DoAndReturn(f func() error) *MockRawConnCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -87,31 +88,31 @@ func (m *MockRawConn) LocalAddr() net.Addr { } // LocalAddr indicates an expected call of LocalAddr. -func (mr *MockRawConnMockRecorder) LocalAddr() *RawConnLocalAddrCall { +func (mr *MockRawConnMockRecorder) LocalAddr() *MockRawConnLocalAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockRawConn)(nil).LocalAddr)) - return &RawConnLocalAddrCall{Call: call} + return &MockRawConnLocalAddrCall{Call: call} } -// RawConnLocalAddrCall wrap *gomock.Call -type RawConnLocalAddrCall struct { +// MockRawConnLocalAddrCall wrap *gomock.Call +type MockRawConnLocalAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConnLocalAddrCall) Return(arg0 net.Addr) *RawConnLocalAddrCall { +func (c *MockRawConnLocalAddrCall) Return(arg0 net.Addr) *MockRawConnLocalAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RawConnLocalAddrCall) Do(f func() net.Addr) *RawConnLocalAddrCall { +func (c *MockRawConnLocalAddrCall) Do(f func() net.Addr) *MockRawConnLocalAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConnLocalAddrCall) DoAndReturn(f func() net.Addr) *RawConnLocalAddrCall { +func (c *MockRawConnLocalAddrCall) DoAndReturn(f func() net.Addr) *MockRawConnLocalAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockRawConn) ReadPacket() (receivedPacket, error) { } // ReadPacket indicates an expected call of ReadPacket. -func (mr *MockRawConnMockRecorder) ReadPacket() *RawConnReadPacketCall { +func (mr *MockRawConnMockRecorder) ReadPacket() *MockRawConnReadPacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPacket", reflect.TypeOf((*MockRawConn)(nil).ReadPacket)) - return &RawConnReadPacketCall{Call: call} + return &MockRawConnReadPacketCall{Call: call} } -// RawConnReadPacketCall wrap *gomock.Call -type RawConnReadPacketCall struct { +// MockRawConnReadPacketCall wrap *gomock.Call +type MockRawConnReadPacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConnReadPacketCall) Return(arg0 receivedPacket, arg1 error) *RawConnReadPacketCall { +func (c *MockRawConnReadPacketCall) Return(arg0 receivedPacket, arg1 error) *MockRawConnReadPacketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *RawConnReadPacketCall) Do(f func() (receivedPacket, error)) *RawConnReadPacketCall { +func (c *MockRawConnReadPacketCall) Do(f func() (receivedPacket, error)) *MockRawConnReadPacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConnReadPacketCall) DoAndReturn(f func() (receivedPacket, error)) *RawConnReadPacketCall { +func (c *MockRawConnReadPacketCall) DoAndReturn(f func() (receivedPacket, error)) *MockRawConnReadPacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -164,31 +165,31 @@ func (m *MockRawConn) SetReadDeadline(arg0 time.Time) error { } // SetReadDeadline indicates an expected call of SetReadDeadline. -func (mr *MockRawConnMockRecorder) SetReadDeadline(arg0 any) *RawConnSetReadDeadlineCall { +func (mr *MockRawConnMockRecorder) SetReadDeadline(arg0 any) *MockRawConnSetReadDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockRawConn)(nil).SetReadDeadline), arg0) - return &RawConnSetReadDeadlineCall{Call: call} + return &MockRawConnSetReadDeadlineCall{Call: call} } -// RawConnSetReadDeadlineCall wrap *gomock.Call -type RawConnSetReadDeadlineCall struct { +// MockRawConnSetReadDeadlineCall wrap *gomock.Call +type MockRawConnSetReadDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConnSetReadDeadlineCall) Return(arg0 error) *RawConnSetReadDeadlineCall { +func (c *MockRawConnSetReadDeadlineCall) Return(arg0 error) *MockRawConnSetReadDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RawConnSetReadDeadlineCall) Do(f func(time.Time) error) *RawConnSetReadDeadlineCall { +func (c *MockRawConnSetReadDeadlineCall) Do(f func(time.Time) error) *MockRawConnSetReadDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConnSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *RawConnSetReadDeadlineCall { +func (c *MockRawConnSetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockRawConnSetReadDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -203,31 +204,31 @@ func (m *MockRawConn) WritePacket(arg0 []byte, arg1 net.Addr, arg2 []byte, arg3 } // WritePacket indicates an expected call of WritePacket. -func (mr *MockRawConnMockRecorder) WritePacket(arg0, arg1, arg2, arg3, arg4 any) *RawConnWritePacketCall { +func (mr *MockRawConnMockRecorder) WritePacket(arg0, arg1, arg2, arg3, arg4 any) *MockRawConnWritePacketCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WritePacket", reflect.TypeOf((*MockRawConn)(nil).WritePacket), arg0, arg1, arg2, arg3, arg4) - return &RawConnWritePacketCall{Call: call} + return &MockRawConnWritePacketCall{Call: call} } -// RawConnWritePacketCall wrap *gomock.Call -type RawConnWritePacketCall struct { +// MockRawConnWritePacketCall wrap *gomock.Call +type MockRawConnWritePacketCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConnWritePacketCall) Return(arg0 int, arg1 error) *RawConnWritePacketCall { +func (c *MockRawConnWritePacketCall) Return(arg0 int, arg1 error) *MockRawConnWritePacketCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *RawConnWritePacketCall) Do(f func([]byte, net.Addr, []byte, uint16, protocol.ECN) (int, error)) *RawConnWritePacketCall { +func (c *MockRawConnWritePacketCall) Do(f func([]byte, net.Addr, []byte, uint16, protocol.ECN) (int, error)) *MockRawConnWritePacketCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConnWritePacketCall) DoAndReturn(f func([]byte, net.Addr, []byte, uint16, protocol.ECN) (int, error)) *RawConnWritePacketCall { +func (c *MockRawConnWritePacketCall) DoAndReturn(f func([]byte, net.Addr, []byte, uint16, protocol.ECN) (int, error)) *MockRawConnWritePacketCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -241,31 +242,31 @@ func (m *MockRawConn) capabilities() connCapabilities { } // capabilities indicates an expected call of capabilities. -func (mr *MockRawConnMockRecorder) capabilities() *RawConncapabilitiesCall { +func (mr *MockRawConnMockRecorder) capabilities() *MockRawConncapabilitiesCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "capabilities", reflect.TypeOf((*MockRawConn)(nil).capabilities)) - return &RawConncapabilitiesCall{Call: call} + return &MockRawConncapabilitiesCall{Call: call} } -// RawConncapabilitiesCall wrap *gomock.Call -type RawConncapabilitiesCall struct { +// MockRawConncapabilitiesCall wrap *gomock.Call +type MockRawConncapabilitiesCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *RawConncapabilitiesCall) Return(arg0 connCapabilities) *RawConncapabilitiesCall { +func (c *MockRawConncapabilitiesCall) Return(arg0 connCapabilities) *MockRawConncapabilitiesCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *RawConncapabilitiesCall) Do(f func() connCapabilities) *RawConncapabilitiesCall { +func (c *MockRawConncapabilitiesCall) Do(f func() connCapabilities) *MockRawConncapabilitiesCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *RawConncapabilitiesCall) DoAndReturn(f func() connCapabilities) *RawConncapabilitiesCall { +func (c *MockRawConncapabilitiesCall) DoAndReturn(f func() connCapabilities) *MockRawConncapabilitiesCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_receive_stream_internal_test.go b/mock_receive_stream_internal_test.go index 4d7d8b98..c2faf380 100644 --- a/mock_receive_stream_internal_test.go +++ b/mock_receive_stream_internal_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_receive_stream_internal_test.go github.com/quic-go/quic-go ReceiveStreamI // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockReceiveStreamI) CancelRead(arg0 qerr.StreamErrorCode) { } // CancelRead indicates an expected call of CancelRead. -func (mr *MockReceiveStreamIMockRecorder) CancelRead(arg0 any) *ReceiveStreamICancelReadCall { +func (mr *MockReceiveStreamIMockRecorder) CancelRead(arg0 any) *MockReceiveStreamICancelReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockReceiveStreamI)(nil).CancelRead), arg0) - return &ReceiveStreamICancelReadCall{Call: call} + return &MockReceiveStreamICancelReadCall{Call: call} } -// ReceiveStreamICancelReadCall wrap *gomock.Call -type ReceiveStreamICancelReadCall struct { +// MockReceiveStreamICancelReadCall wrap *gomock.Call +type MockReceiveStreamICancelReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamICancelReadCall) Return() *ReceiveStreamICancelReadCall { +func (c *MockReceiveStreamICancelReadCall) Return() *MockReceiveStreamICancelReadCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *ReceiveStreamICancelReadCall { +func (c *MockReceiveStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *ReceiveStreamICancelReadCall { +func (c *MockReceiveStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockReceiveStreamICancelReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -87,31 +88,31 @@ func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) { } // Read indicates an expected call of Read. -func (mr *MockReceiveStreamIMockRecorder) Read(arg0 any) *ReceiveStreamIReadCall { +func (mr *MockReceiveStreamIMockRecorder) Read(arg0 any) *MockReceiveStreamIReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockReceiveStreamI)(nil).Read), arg0) - return &ReceiveStreamIReadCall{Call: call} + return &MockReceiveStreamIReadCall{Call: call} } -// ReceiveStreamIReadCall wrap *gomock.Call -type ReceiveStreamIReadCall struct { +// MockReceiveStreamIReadCall wrap *gomock.Call +type MockReceiveStreamIReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIReadCall) Return(arg0 int, arg1 error) *ReceiveStreamIReadCall { +func (c *MockReceiveStreamIReadCall) Return(arg0 int, arg1 error) *MockReceiveStreamIReadCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIReadCall) Do(f func([]byte) (int, error)) *ReceiveStreamIReadCall { +func (c *MockReceiveStreamIReadCall) Do(f func([]byte) (int, error)) *MockReceiveStreamIReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *ReceiveStreamIReadCall { +func (c *MockReceiveStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *MockReceiveStreamIReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -125,31 +126,31 @@ func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error { } // SetReadDeadline indicates an expected call of SetReadDeadline. -func (mr *MockReceiveStreamIMockRecorder) SetReadDeadline(arg0 any) *ReceiveStreamISetReadDeadlineCall { +func (mr *MockReceiveStreamIMockRecorder) SetReadDeadline(arg0 any) *MockReceiveStreamISetReadDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockReceiveStreamI)(nil).SetReadDeadline), arg0) - return &ReceiveStreamISetReadDeadlineCall{Call: call} + return &MockReceiveStreamISetReadDeadlineCall{Call: call} } -// ReceiveStreamISetReadDeadlineCall wrap *gomock.Call -type ReceiveStreamISetReadDeadlineCall struct { +// MockReceiveStreamISetReadDeadlineCall wrap *gomock.Call +type MockReceiveStreamISetReadDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamISetReadDeadlineCall) Return(arg0 error) *ReceiveStreamISetReadDeadlineCall { +func (c *MockReceiveStreamISetReadDeadlineCall) Return(arg0 error) *MockReceiveStreamISetReadDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamISetReadDeadlineCall) Do(f func(time.Time) error) *ReceiveStreamISetReadDeadlineCall { +func (c *MockReceiveStreamISetReadDeadlineCall) Do(f func(time.Time) error) *MockReceiveStreamISetReadDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *ReceiveStreamISetReadDeadlineCall { +func (c *MockReceiveStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockReceiveStreamISetReadDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -163,31 +164,31 @@ func (m *MockReceiveStreamI) StreamID() protocol.StreamID { } // StreamID indicates an expected call of StreamID. -func (mr *MockReceiveStreamIMockRecorder) StreamID() *ReceiveStreamIStreamIDCall { +func (mr *MockReceiveStreamIMockRecorder) StreamID() *MockReceiveStreamIStreamIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockReceiveStreamI)(nil).StreamID)) - return &ReceiveStreamIStreamIDCall{Call: call} + return &MockReceiveStreamIStreamIDCall{Call: call} } -// ReceiveStreamIStreamIDCall wrap *gomock.Call -type ReceiveStreamIStreamIDCall struct { +// MockReceiveStreamIStreamIDCall wrap *gomock.Call +type MockReceiveStreamIStreamIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIStreamIDCall) Return(arg0 protocol.StreamID) *ReceiveStreamIStreamIDCall { +func (c *MockReceiveStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockReceiveStreamIStreamIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIStreamIDCall) Do(f func() protocol.StreamID) *ReceiveStreamIStreamIDCall { +func (c *MockReceiveStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *ReceiveStreamIStreamIDCall { +func (c *MockReceiveStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockReceiveStreamIStreamIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -199,31 +200,31 @@ func (m *MockReceiveStreamI) closeForShutdown(arg0 error) { } // closeForShutdown indicates an expected call of closeForShutdown. -func (mr *MockReceiveStreamIMockRecorder) closeForShutdown(arg0 any) *ReceiveStreamIcloseForShutdownCall { +func (mr *MockReceiveStreamIMockRecorder) closeForShutdown(arg0 any) *MockReceiveStreamIcloseForShutdownCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockReceiveStreamI)(nil).closeForShutdown), arg0) - return &ReceiveStreamIcloseForShutdownCall{Call: call} + return &MockReceiveStreamIcloseForShutdownCall{Call: call} } -// ReceiveStreamIcloseForShutdownCall wrap *gomock.Call -type ReceiveStreamIcloseForShutdownCall struct { +// MockReceiveStreamIcloseForShutdownCall wrap *gomock.Call +type MockReceiveStreamIcloseForShutdownCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIcloseForShutdownCall) Return() *ReceiveStreamIcloseForShutdownCall { +func (c *MockReceiveStreamIcloseForShutdownCall) Return() *MockReceiveStreamIcloseForShutdownCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIcloseForShutdownCall) Do(f func(error)) *ReceiveStreamIcloseForShutdownCall { +func (c *MockReceiveStreamIcloseForShutdownCall) Do(f func(error)) *MockReceiveStreamIcloseForShutdownCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *ReceiveStreamIcloseForShutdownCall { +func (c *MockReceiveStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *MockReceiveStreamIcloseForShutdownCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -237,31 +238,31 @@ func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount { } // getWindowUpdate indicates an expected call of getWindowUpdate. -func (mr *MockReceiveStreamIMockRecorder) getWindowUpdate() *ReceiveStreamIgetWindowUpdateCall { +func (mr *MockReceiveStreamIMockRecorder) getWindowUpdate() *MockReceiveStreamIgetWindowUpdateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockReceiveStreamI)(nil).getWindowUpdate)) - return &ReceiveStreamIgetWindowUpdateCall{Call: call} + return &MockReceiveStreamIgetWindowUpdateCall{Call: call} } -// ReceiveStreamIgetWindowUpdateCall wrap *gomock.Call -type ReceiveStreamIgetWindowUpdateCall struct { +// MockReceiveStreamIgetWindowUpdateCall wrap *gomock.Call +type MockReceiveStreamIgetWindowUpdateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { +func (c *MockReceiveStreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockReceiveStreamIgetWindowUpdateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { +func (c *MockReceiveStreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockReceiveStreamIgetWindowUpdateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { +func (c *MockReceiveStreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockReceiveStreamIgetWindowUpdateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -275,31 +276,31 @@ func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) } // handleResetStreamFrame indicates an expected call of handleResetStreamFrame. -func (mr *MockReceiveStreamIMockRecorder) handleResetStreamFrame(arg0 any) *ReceiveStreamIhandleResetStreamFrameCall { +func (mr *MockReceiveStreamIMockRecorder) handleResetStreamFrame(arg0 any) *MockReceiveStreamIhandleResetStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleResetStreamFrame), arg0) - return &ReceiveStreamIhandleResetStreamFrameCall{Call: call} + return &MockReceiveStreamIhandleResetStreamFrameCall{Call: call} } -// ReceiveStreamIhandleResetStreamFrameCall wrap *gomock.Call -type ReceiveStreamIhandleResetStreamFrameCall struct { +// MockReceiveStreamIhandleResetStreamFrameCall wrap *gomock.Call +type MockReceiveStreamIhandleResetStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIhandleResetStreamFrameCall) Return(arg0 error) *ReceiveStreamIhandleResetStreamFrameCall { +func (c *MockReceiveStreamIhandleResetStreamFrameCall) Return(arg0 error) *MockReceiveStreamIhandleResetStreamFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *ReceiveStreamIhandleResetStreamFrameCall { +func (c *MockReceiveStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *MockReceiveStreamIhandleResetStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *ReceiveStreamIhandleResetStreamFrameCall { +func (c *MockReceiveStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *MockReceiveStreamIhandleResetStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -313,31 +314,31 @@ func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { } // handleStreamFrame indicates an expected call of handleStreamFrame. -func (mr *MockReceiveStreamIMockRecorder) handleStreamFrame(arg0 any) *ReceiveStreamIhandleStreamFrameCall { +func (mr *MockReceiveStreamIMockRecorder) handleStreamFrame(arg0 any) *MockReceiveStreamIhandleStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleStreamFrame), arg0) - return &ReceiveStreamIhandleStreamFrameCall{Call: call} + return &MockReceiveStreamIhandleStreamFrameCall{Call: call} } -// ReceiveStreamIhandleStreamFrameCall wrap *gomock.Call -type ReceiveStreamIhandleStreamFrameCall struct { +// MockReceiveStreamIhandleStreamFrameCall wrap *gomock.Call +type MockReceiveStreamIhandleStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *ReceiveStreamIhandleStreamFrameCall) Return(arg0 error) *ReceiveStreamIhandleStreamFrameCall { +func (c *MockReceiveStreamIhandleStreamFrameCall) Return(arg0 error) *MockReceiveStreamIhandleStreamFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *ReceiveStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *ReceiveStreamIhandleStreamFrameCall { +func (c *MockReceiveStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *MockReceiveStreamIhandleStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *ReceiveStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *ReceiveStreamIhandleStreamFrameCall { +func (c *MockReceiveStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *MockReceiveStreamIhandleStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_sealing_manager_test.go b/mock_sealing_manager_test.go index aea943bc..0c209ea5 100644 --- a/mock_sealing_manager_test.go +++ b/mock_sealing_manager_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_sealing_manager_test.go github.com/quic-go/quic-go SealingManager // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockSealingManager) Get0RTTSealer() (handshake.LongHeaderSealer, error) } // Get0RTTSealer indicates an expected call of Get0RTTSealer. -func (mr *MockSealingManagerMockRecorder) Get0RTTSealer() *SealingManagerGet0RTTSealerCall { +func (mr *MockSealingManagerMockRecorder) Get0RTTSealer() *MockSealingManagerGet0RTTSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get0RTTSealer", reflect.TypeOf((*MockSealingManager)(nil).Get0RTTSealer)) - return &SealingManagerGet0RTTSealerCall{Call: call} + return &MockSealingManagerGet0RTTSealerCall{Call: call} } -// SealingManagerGet0RTTSealerCall wrap *gomock.Call -type SealingManagerGet0RTTSealerCall struct { +// MockSealingManagerGet0RTTSealerCall wrap *gomock.Call +type MockSealingManagerGet0RTTSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SealingManagerGet0RTTSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *SealingManagerGet0RTTSealerCall { +func (c *MockSealingManagerGet0RTTSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockSealingManagerGet0RTTSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SealingManagerGet0RTTSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGet0RTTSealerCall { +func (c *MockSealingManagerGet0RTTSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGet0RTTSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SealingManagerGet0RTTSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGet0RTTSealerCall { +func (c *MockSealingManagerGet0RTTSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGet0RTTSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -87,31 +88,31 @@ func (m *MockSealingManager) Get1RTTSealer() (handshake.ShortHeaderSealer, error } // Get1RTTSealer indicates an expected call of Get1RTTSealer. -func (mr *MockSealingManagerMockRecorder) Get1RTTSealer() *SealingManagerGet1RTTSealerCall { +func (mr *MockSealingManagerMockRecorder) Get1RTTSealer() *MockSealingManagerGet1RTTSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get1RTTSealer", reflect.TypeOf((*MockSealingManager)(nil).Get1RTTSealer)) - return &SealingManagerGet1RTTSealerCall{Call: call} + return &MockSealingManagerGet1RTTSealerCall{Call: call} } -// SealingManagerGet1RTTSealerCall wrap *gomock.Call -type SealingManagerGet1RTTSealerCall struct { +// MockSealingManagerGet1RTTSealerCall wrap *gomock.Call +type MockSealingManagerGet1RTTSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SealingManagerGet1RTTSealerCall) Return(arg0 handshake.ShortHeaderSealer, arg1 error) *SealingManagerGet1RTTSealerCall { +func (c *MockSealingManagerGet1RTTSealerCall) Return(arg0 handshake.ShortHeaderSealer, arg1 error) *MockSealingManagerGet1RTTSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SealingManagerGet1RTTSealerCall) Do(f func() (handshake.ShortHeaderSealer, error)) *SealingManagerGet1RTTSealerCall { +func (c *MockSealingManagerGet1RTTSealerCall) Do(f func() (handshake.ShortHeaderSealer, error)) *MockSealingManagerGet1RTTSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SealingManagerGet1RTTSealerCall) DoAndReturn(f func() (handshake.ShortHeaderSealer, error)) *SealingManagerGet1RTTSealerCall { +func (c *MockSealingManagerGet1RTTSealerCall) DoAndReturn(f func() (handshake.ShortHeaderSealer, error)) *MockSealingManagerGet1RTTSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockSealingManager) GetHandshakeSealer() (handshake.LongHeaderSealer, e } // GetHandshakeSealer indicates an expected call of GetHandshakeSealer. -func (mr *MockSealingManagerMockRecorder) GetHandshakeSealer() *SealingManagerGetHandshakeSealerCall { +func (mr *MockSealingManagerMockRecorder) GetHandshakeSealer() *MockSealingManagerGetHandshakeSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeSealer", reflect.TypeOf((*MockSealingManager)(nil).GetHandshakeSealer)) - return &SealingManagerGetHandshakeSealerCall{Call: call} + return &MockSealingManagerGetHandshakeSealerCall{Call: call} } -// SealingManagerGetHandshakeSealerCall wrap *gomock.Call -type SealingManagerGetHandshakeSealerCall struct { +// MockSealingManagerGetHandshakeSealerCall wrap *gomock.Call +type MockSealingManagerGetHandshakeSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SealingManagerGetHandshakeSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *SealingManagerGetHandshakeSealerCall { +func (c *MockSealingManagerGetHandshakeSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockSealingManagerGetHandshakeSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SealingManagerGetHandshakeSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGetHandshakeSealerCall { +func (c *MockSealingManagerGetHandshakeSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGetHandshakeSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SealingManagerGetHandshakeSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGetHandshakeSealerCall { +func (c *MockSealingManagerGetHandshakeSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGetHandshakeSealerCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -165,31 +166,31 @@ func (m *MockSealingManager) GetInitialSealer() (handshake.LongHeaderSealer, err } // GetInitialSealer indicates an expected call of GetInitialSealer. -func (mr *MockSealingManagerMockRecorder) GetInitialSealer() *SealingManagerGetInitialSealerCall { +func (mr *MockSealingManagerMockRecorder) GetInitialSealer() *MockSealingManagerGetInitialSealerCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInitialSealer", reflect.TypeOf((*MockSealingManager)(nil).GetInitialSealer)) - return &SealingManagerGetInitialSealerCall{Call: call} + return &MockSealingManagerGetInitialSealerCall{Call: call} } -// SealingManagerGetInitialSealerCall wrap *gomock.Call -type SealingManagerGetInitialSealerCall struct { +// MockSealingManagerGetInitialSealerCall wrap *gomock.Call +type MockSealingManagerGetInitialSealerCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SealingManagerGetInitialSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *SealingManagerGetInitialSealerCall { +func (c *MockSealingManagerGetInitialSealerCall) Return(arg0 handshake.LongHeaderSealer, arg1 error) *MockSealingManagerGetInitialSealerCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SealingManagerGetInitialSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGetInitialSealerCall { +func (c *MockSealingManagerGetInitialSealerCall) Do(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGetInitialSealerCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SealingManagerGetInitialSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *SealingManagerGetInitialSealerCall { +func (c *MockSealingManagerGetInitialSealerCall) DoAndReturn(f func() (handshake.LongHeaderSealer, error)) *MockSealingManagerGetInitialSealerCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_send_conn_test.go b/mock_send_conn_test.go index d9495841..302bafa2 100644 --- a/mock_send_conn_test.go +++ b/mock_send_conn_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_send_conn_test.go github.com/quic-go/quic-go SendConn // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockSendConn) Close() error { } // Close indicates an expected call of Close. -func (mr *MockSendConnMockRecorder) Close() *SendConnCloseCall { +func (mr *MockSendConnMockRecorder) Close() *MockSendConnCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSendConn)(nil).Close)) - return &SendConnCloseCall{Call: call} + return &MockSendConnCloseCall{Call: call} } -// SendConnCloseCall wrap *gomock.Call -type SendConnCloseCall struct { +// MockSendConnCloseCall wrap *gomock.Call +type MockSendConnCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendConnCloseCall) Return(arg0 error) *SendConnCloseCall { +func (c *MockSendConnCloseCall) Return(arg0 error) *MockSendConnCloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendConnCloseCall) Do(f func() error) *SendConnCloseCall { +func (c *MockSendConnCloseCall) Do(f func() error) *MockSendConnCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendConnCloseCall) DoAndReturn(f func() error) *SendConnCloseCall { +func (c *MockSendConnCloseCall) DoAndReturn(f func() error) *MockSendConnCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockSendConn) LocalAddr() net.Addr { } // LocalAddr indicates an expected call of LocalAddr. -func (mr *MockSendConnMockRecorder) LocalAddr() *SendConnLocalAddrCall { +func (mr *MockSendConnMockRecorder) LocalAddr() *MockSendConnLocalAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockSendConn)(nil).LocalAddr)) - return &SendConnLocalAddrCall{Call: call} + return &MockSendConnLocalAddrCall{Call: call} } -// SendConnLocalAddrCall wrap *gomock.Call -type SendConnLocalAddrCall struct { +// MockSendConnLocalAddrCall wrap *gomock.Call +type MockSendConnLocalAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendConnLocalAddrCall) Return(arg0 net.Addr) *SendConnLocalAddrCall { +func (c *MockSendConnLocalAddrCall) Return(arg0 net.Addr) *MockSendConnLocalAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendConnLocalAddrCall) Do(f func() net.Addr) *SendConnLocalAddrCall { +func (c *MockSendConnLocalAddrCall) Do(f func() net.Addr) *MockSendConnLocalAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendConnLocalAddrCall) DoAndReturn(f func() net.Addr) *SendConnLocalAddrCall { +func (c *MockSendConnLocalAddrCall) DoAndReturn(f func() net.Addr) *MockSendConnLocalAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockSendConn) RemoteAddr() net.Addr { } // RemoteAddr indicates an expected call of RemoteAddr. -func (mr *MockSendConnMockRecorder) RemoteAddr() *SendConnRemoteAddrCall { +func (mr *MockSendConnMockRecorder) RemoteAddr() *MockSendConnRemoteAddrCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockSendConn)(nil).RemoteAddr)) - return &SendConnRemoteAddrCall{Call: call} + return &MockSendConnRemoteAddrCall{Call: call} } -// SendConnRemoteAddrCall wrap *gomock.Call -type SendConnRemoteAddrCall struct { +// MockSendConnRemoteAddrCall wrap *gomock.Call +type MockSendConnRemoteAddrCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendConnRemoteAddrCall) Return(arg0 net.Addr) *SendConnRemoteAddrCall { +func (c *MockSendConnRemoteAddrCall) Return(arg0 net.Addr) *MockSendConnRemoteAddrCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendConnRemoteAddrCall) Do(f func() net.Addr) *SendConnRemoteAddrCall { +func (c *MockSendConnRemoteAddrCall) Do(f func() net.Addr) *MockSendConnRemoteAddrCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendConnRemoteAddrCall) DoAndReturn(f func() net.Addr) *SendConnRemoteAddrCall { +func (c *MockSendConnRemoteAddrCall) DoAndReturn(f func() net.Addr) *MockSendConnRemoteAddrCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockSendConn) Write(arg0 []byte, arg1 uint16, arg2 protocol.ECN) error } // Write indicates an expected call of Write. -func (mr *MockSendConnMockRecorder) Write(arg0, arg1, arg2 any) *SendConnWriteCall { +func (mr *MockSendConnMockRecorder) Write(arg0, arg1, arg2 any) *MockSendConnWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockSendConn)(nil).Write), arg0, arg1, arg2) - return &SendConnWriteCall{Call: call} + return &MockSendConnWriteCall{Call: call} } -// SendConnWriteCall wrap *gomock.Call -type SendConnWriteCall struct { +// MockSendConnWriteCall wrap *gomock.Call +type MockSendConnWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendConnWriteCall) Return(arg0 error) *SendConnWriteCall { +func (c *MockSendConnWriteCall) Return(arg0 error) *MockSendConnWriteCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendConnWriteCall) Do(f func([]byte, uint16, protocol.ECN) error) *SendConnWriteCall { +func (c *MockSendConnWriteCall) Do(f func([]byte, uint16, protocol.ECN) error) *MockSendConnWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendConnWriteCall) DoAndReturn(f func([]byte, uint16, protocol.ECN) error) *SendConnWriteCall { +func (c *MockSendConnWriteCall) DoAndReturn(f func([]byte, uint16, protocol.ECN) error) *MockSendConnWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -200,31 +201,31 @@ func (m *MockSendConn) capabilities() connCapabilities { } // capabilities indicates an expected call of capabilities. -func (mr *MockSendConnMockRecorder) capabilities() *SendConncapabilitiesCall { +func (mr *MockSendConnMockRecorder) capabilities() *MockSendConncapabilitiesCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "capabilities", reflect.TypeOf((*MockSendConn)(nil).capabilities)) - return &SendConncapabilitiesCall{Call: call} + return &MockSendConncapabilitiesCall{Call: call} } -// SendConncapabilitiesCall wrap *gomock.Call -type SendConncapabilitiesCall struct { +// MockSendConncapabilitiesCall wrap *gomock.Call +type MockSendConncapabilitiesCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendConncapabilitiesCall) Return(arg0 connCapabilities) *SendConncapabilitiesCall { +func (c *MockSendConncapabilitiesCall) Return(arg0 connCapabilities) *MockSendConncapabilitiesCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendConncapabilitiesCall) Do(f func() connCapabilities) *SendConncapabilitiesCall { +func (c *MockSendConncapabilitiesCall) Do(f func() connCapabilities) *MockSendConncapabilitiesCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendConncapabilitiesCall) DoAndReturn(f func() connCapabilities) *SendConncapabilitiesCall { +func (c *MockSendConncapabilitiesCall) DoAndReturn(f func() connCapabilities) *MockSendConncapabilitiesCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_send_stream_internal_test.go b/mock_send_stream_internal_test.go index a8013965..51a67cc1 100644 --- a/mock_send_stream_internal_test.go +++ b/mock_send_stream_internal_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_send_stream_internal_test.go github.com/quic-go/quic-go SendStreamI // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockSendStreamI) CancelWrite(arg0 qerr.StreamErrorCode) { } // CancelWrite indicates an expected call of CancelWrite. -func (mr *MockSendStreamIMockRecorder) CancelWrite(arg0 any) *SendStreamICancelWriteCall { +func (mr *MockSendStreamIMockRecorder) CancelWrite(arg0 any) *MockSendStreamICancelWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockSendStreamI)(nil).CancelWrite), arg0) - return &SendStreamICancelWriteCall{Call: call} + return &MockSendStreamICancelWriteCall{Call: call} } -// SendStreamICancelWriteCall wrap *gomock.Call -type SendStreamICancelWriteCall struct { +// MockSendStreamICancelWriteCall wrap *gomock.Call +type MockSendStreamICancelWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamICancelWriteCall) Return() *SendStreamICancelWriteCall { +func (c *MockSendStreamICancelWriteCall) Return() *MockSendStreamICancelWriteCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *SendStreamICancelWriteCall { +func (c *MockSendStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *SendStreamICancelWriteCall { +func (c *MockSendStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockSendStreamICancelWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -88,31 +89,31 @@ func (m *MockSendStreamI) Close() error { } // Close indicates an expected call of Close. -func (mr *MockSendStreamIMockRecorder) Close() *SendStreamICloseCall { +func (mr *MockSendStreamIMockRecorder) Close() *MockSendStreamICloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSendStreamI)(nil).Close)) - return &SendStreamICloseCall{Call: call} + return &MockSendStreamICloseCall{Call: call} } -// SendStreamICloseCall wrap *gomock.Call -type SendStreamICloseCall struct { +// MockSendStreamICloseCall wrap *gomock.Call +type MockSendStreamICloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamICloseCall) Return(arg0 error) *SendStreamICloseCall { +func (c *MockSendStreamICloseCall) Return(arg0 error) *MockSendStreamICloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamICloseCall) Do(f func() error) *SendStreamICloseCall { +func (c *MockSendStreamICloseCall) Do(f func() error) *MockSendStreamICloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamICloseCall) DoAndReturn(f func() error) *SendStreamICloseCall { +func (c *MockSendStreamICloseCall) DoAndReturn(f func() error) *MockSendStreamICloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -126,31 +127,31 @@ func (m *MockSendStreamI) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockSendStreamIMockRecorder) Context() *SendStreamIContextCall { +func (mr *MockSendStreamIMockRecorder) Context() *MockSendStreamIContextCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockSendStreamI)(nil).Context)) - return &SendStreamIContextCall{Call: call} + return &MockSendStreamIContextCall{Call: call} } -// SendStreamIContextCall wrap *gomock.Call -type SendStreamIContextCall struct { +// MockSendStreamIContextCall wrap *gomock.Call +type MockSendStreamIContextCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIContextCall) Return(arg0 context.Context) *SendStreamIContextCall { +func (c *MockSendStreamIContextCall) Return(arg0 context.Context) *MockSendStreamIContextCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIContextCall) Do(f func() context.Context) *SendStreamIContextCall { +func (c *MockSendStreamIContextCall) Do(f func() context.Context) *MockSendStreamIContextCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIContextCall) DoAndReturn(f func() context.Context) *SendStreamIContextCall { +func (c *MockSendStreamIContextCall) DoAndReturn(f func() context.Context) *MockSendStreamIContextCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -164,31 +165,31 @@ func (m *MockSendStreamI) SetWriteDeadline(arg0 time.Time) error { } // SetWriteDeadline indicates an expected call of SetWriteDeadline. -func (mr *MockSendStreamIMockRecorder) SetWriteDeadline(arg0 any) *SendStreamISetWriteDeadlineCall { +func (mr *MockSendStreamIMockRecorder) SetWriteDeadline(arg0 any) *MockSendStreamISetWriteDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockSendStreamI)(nil).SetWriteDeadline), arg0) - return &SendStreamISetWriteDeadlineCall{Call: call} + return &MockSendStreamISetWriteDeadlineCall{Call: call} } -// SendStreamISetWriteDeadlineCall wrap *gomock.Call -type SendStreamISetWriteDeadlineCall struct { +// MockSendStreamISetWriteDeadlineCall wrap *gomock.Call +type MockSendStreamISetWriteDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamISetWriteDeadlineCall) Return(arg0 error) *SendStreamISetWriteDeadlineCall { +func (c *MockSendStreamISetWriteDeadlineCall) Return(arg0 error) *MockSendStreamISetWriteDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamISetWriteDeadlineCall) Do(f func(time.Time) error) *SendStreamISetWriteDeadlineCall { +func (c *MockSendStreamISetWriteDeadlineCall) Do(f func(time.Time) error) *MockSendStreamISetWriteDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *SendStreamISetWriteDeadlineCall { +func (c *MockSendStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockSendStreamISetWriteDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -202,31 +203,31 @@ func (m *MockSendStreamI) StreamID() protocol.StreamID { } // StreamID indicates an expected call of StreamID. -func (mr *MockSendStreamIMockRecorder) StreamID() *SendStreamIStreamIDCall { +func (mr *MockSendStreamIMockRecorder) StreamID() *MockSendStreamIStreamIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockSendStreamI)(nil).StreamID)) - return &SendStreamIStreamIDCall{Call: call} + return &MockSendStreamIStreamIDCall{Call: call} } -// SendStreamIStreamIDCall wrap *gomock.Call -type SendStreamIStreamIDCall struct { +// MockSendStreamIStreamIDCall wrap *gomock.Call +type MockSendStreamIStreamIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIStreamIDCall) Return(arg0 protocol.StreamID) *SendStreamIStreamIDCall { +func (c *MockSendStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockSendStreamIStreamIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIStreamIDCall) Do(f func() protocol.StreamID) *SendStreamIStreamIDCall { +func (c *MockSendStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockSendStreamIStreamIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *SendStreamIStreamIDCall { +func (c *MockSendStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockSendStreamIStreamIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -241,31 +242,31 @@ func (m *MockSendStreamI) Write(arg0 []byte) (int, error) { } // Write indicates an expected call of Write. -func (mr *MockSendStreamIMockRecorder) Write(arg0 any) *SendStreamIWriteCall { +func (mr *MockSendStreamIMockRecorder) Write(arg0 any) *MockSendStreamIWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockSendStreamI)(nil).Write), arg0) - return &SendStreamIWriteCall{Call: call} + return &MockSendStreamIWriteCall{Call: call} } -// SendStreamIWriteCall wrap *gomock.Call -type SendStreamIWriteCall struct { +// MockSendStreamIWriteCall wrap *gomock.Call +type MockSendStreamIWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIWriteCall) Return(arg0 int, arg1 error) *SendStreamIWriteCall { +func (c *MockSendStreamIWriteCall) Return(arg0 int, arg1 error) *MockSendStreamIWriteCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIWriteCall) Do(f func([]byte) (int, error)) *SendStreamIWriteCall { +func (c *MockSendStreamIWriteCall) Do(f func([]byte) (int, error)) *MockSendStreamIWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *SendStreamIWriteCall { +func (c *MockSendStreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockSendStreamIWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -277,31 +278,31 @@ func (m *MockSendStreamI) closeForShutdown(arg0 error) { } // closeForShutdown indicates an expected call of closeForShutdown. -func (mr *MockSendStreamIMockRecorder) closeForShutdown(arg0 any) *SendStreamIcloseForShutdownCall { +func (mr *MockSendStreamIMockRecorder) closeForShutdown(arg0 any) *MockSendStreamIcloseForShutdownCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockSendStreamI)(nil).closeForShutdown), arg0) - return &SendStreamIcloseForShutdownCall{Call: call} + return &MockSendStreamIcloseForShutdownCall{Call: call} } -// SendStreamIcloseForShutdownCall wrap *gomock.Call -type SendStreamIcloseForShutdownCall struct { +// MockSendStreamIcloseForShutdownCall wrap *gomock.Call +type MockSendStreamIcloseForShutdownCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIcloseForShutdownCall) Return() *SendStreamIcloseForShutdownCall { +func (c *MockSendStreamIcloseForShutdownCall) Return() *MockSendStreamIcloseForShutdownCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIcloseForShutdownCall) Do(f func(error)) *SendStreamIcloseForShutdownCall { +func (c *MockSendStreamIcloseForShutdownCall) Do(f func(error)) *MockSendStreamIcloseForShutdownCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *SendStreamIcloseForShutdownCall { +func (c *MockSendStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *MockSendStreamIcloseForShutdownCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -313,31 +314,31 @@ func (m *MockSendStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) { } // handleStopSendingFrame indicates an expected call of handleStopSendingFrame. -func (mr *MockSendStreamIMockRecorder) handleStopSendingFrame(arg0 any) *SendStreamIhandleStopSendingFrameCall { +func (mr *MockSendStreamIMockRecorder) handleStopSendingFrame(arg0 any) *MockSendStreamIhandleStopSendingFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockSendStreamI)(nil).handleStopSendingFrame), arg0) - return &SendStreamIhandleStopSendingFrameCall{Call: call} + return &MockSendStreamIhandleStopSendingFrameCall{Call: call} } -// SendStreamIhandleStopSendingFrameCall wrap *gomock.Call -type SendStreamIhandleStopSendingFrameCall struct { +// MockSendStreamIhandleStopSendingFrameCall wrap *gomock.Call +type MockSendStreamIhandleStopSendingFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIhandleStopSendingFrameCall) Return() *SendStreamIhandleStopSendingFrameCall { +func (c *MockSendStreamIhandleStopSendingFrameCall) Return() *MockSendStreamIhandleStopSendingFrameCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *SendStreamIhandleStopSendingFrameCall { +func (c *MockSendStreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *MockSendStreamIhandleStopSendingFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *SendStreamIhandleStopSendingFrameCall { +func (c *MockSendStreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *MockSendStreamIhandleStopSendingFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -351,31 +352,31 @@ func (m *MockSendStreamI) hasData() bool { } // hasData indicates an expected call of hasData. -func (mr *MockSendStreamIMockRecorder) hasData() *SendStreamIhasDataCall { +func (mr *MockSendStreamIMockRecorder) hasData() *MockSendStreamIhasDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockSendStreamI)(nil).hasData)) - return &SendStreamIhasDataCall{Call: call} + return &MockSendStreamIhasDataCall{Call: call} } -// SendStreamIhasDataCall wrap *gomock.Call -type SendStreamIhasDataCall struct { +// MockSendStreamIhasDataCall wrap *gomock.Call +type MockSendStreamIhasDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIhasDataCall) Return(arg0 bool) *SendStreamIhasDataCall { +func (c *MockSendStreamIhasDataCall) Return(arg0 bool) *MockSendStreamIhasDataCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIhasDataCall) Do(f func() bool) *SendStreamIhasDataCall { +func (c *MockSendStreamIhasDataCall) Do(f func() bool) *MockSendStreamIhasDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIhasDataCall) DoAndReturn(f func() bool) *SendStreamIhasDataCall { +func (c *MockSendStreamIhasDataCall) DoAndReturn(f func() bool) *MockSendStreamIhasDataCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -391,31 +392,31 @@ func (m *MockSendStreamI) popStreamFrame(arg0 protocol.ByteCount, arg1 protocol. } // popStreamFrame indicates an expected call of popStreamFrame. -func (mr *MockSendStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *SendStreamIpopStreamFrameCall { +func (mr *MockSendStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *MockSendStreamIpopStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockSendStreamI)(nil).popStreamFrame), arg0, arg1) - return &SendStreamIpopStreamFrameCall{Call: call} + return &MockSendStreamIpopStreamFrameCall{Call: call} } -// SendStreamIpopStreamFrameCall wrap *gomock.Call -type SendStreamIpopStreamFrameCall struct { +// MockSendStreamIpopStreamFrameCall wrap *gomock.Call +type MockSendStreamIpopStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *SendStreamIpopStreamFrameCall { +func (c *MockSendStreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *MockSendStreamIpopStreamFrameCall { c.Call = c.Call.Return(arg0, arg1, arg2) return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *SendStreamIpopStreamFrameCall { +func (c *MockSendStreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockSendStreamIpopStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *SendStreamIpopStreamFrameCall { +func (c *MockSendStreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockSendStreamIpopStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -427,31 +428,31 @@ func (m *MockSendStreamI) updateSendWindow(arg0 protocol.ByteCount) { } // updateSendWindow indicates an expected call of updateSendWindow. -func (mr *MockSendStreamIMockRecorder) updateSendWindow(arg0 any) *SendStreamIupdateSendWindowCall { +func (mr *MockSendStreamIMockRecorder) updateSendWindow(arg0 any) *MockSendStreamIupdateSendWindowCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "updateSendWindow", reflect.TypeOf((*MockSendStreamI)(nil).updateSendWindow), arg0) - return &SendStreamIupdateSendWindowCall{Call: call} + return &MockSendStreamIupdateSendWindowCall{Call: call} } -// SendStreamIupdateSendWindowCall wrap *gomock.Call -type SendStreamIupdateSendWindowCall struct { +// MockSendStreamIupdateSendWindowCall wrap *gomock.Call +type MockSendStreamIupdateSendWindowCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SendStreamIupdateSendWindowCall) Return() *SendStreamIupdateSendWindowCall { +func (c *MockSendStreamIupdateSendWindowCall) Return() *MockSendStreamIupdateSendWindowCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SendStreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *SendStreamIupdateSendWindowCall { +func (c *MockSendStreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *MockSendStreamIupdateSendWindowCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SendStreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *SendStreamIupdateSendWindowCall { +func (c *MockSendStreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *MockSendStreamIupdateSendWindowCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_sender_test.go b/mock_sender_test.go index aa3c8780..02cce86e 100644 --- a/mock_sender_test.go +++ b/mock_sender_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_sender_test.go github.com/quic-go/quic-go Sender // + // Package quic is a generated GoMock package. package quic @@ -47,31 +48,31 @@ func (m *MockSender) Available() <-chan struct{} { } // Available indicates an expected call of Available. -func (mr *MockSenderMockRecorder) Available() *SenderAvailableCall { +func (mr *MockSenderMockRecorder) Available() *MockSenderAvailableCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Available", reflect.TypeOf((*MockSender)(nil).Available)) - return &SenderAvailableCall{Call: call} + return &MockSenderAvailableCall{Call: call} } -// SenderAvailableCall wrap *gomock.Call -type SenderAvailableCall struct { +// MockSenderAvailableCall wrap *gomock.Call +type MockSenderAvailableCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SenderAvailableCall) Return(arg0 <-chan struct{}) *SenderAvailableCall { +func (c *MockSenderAvailableCall) Return(arg0 <-chan struct{}) *MockSenderAvailableCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SenderAvailableCall) Do(f func() <-chan struct{}) *SenderAvailableCall { +func (c *MockSenderAvailableCall) Do(f func() <-chan struct{}) *MockSenderAvailableCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SenderAvailableCall) DoAndReturn(f func() <-chan struct{}) *SenderAvailableCall { +func (c *MockSenderAvailableCall) DoAndReturn(f func() <-chan struct{}) *MockSenderAvailableCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -83,31 +84,31 @@ func (m *MockSender) Close() { } // Close indicates an expected call of Close. -func (mr *MockSenderMockRecorder) Close() *SenderCloseCall { +func (mr *MockSenderMockRecorder) Close() *MockSenderCloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSender)(nil).Close)) - return &SenderCloseCall{Call: call} + return &MockSenderCloseCall{Call: call} } -// SenderCloseCall wrap *gomock.Call -type SenderCloseCall struct { +// MockSenderCloseCall wrap *gomock.Call +type MockSenderCloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SenderCloseCall) Return() *SenderCloseCall { +func (c *MockSenderCloseCall) Return() *MockSenderCloseCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SenderCloseCall) Do(f func()) *SenderCloseCall { +func (c *MockSenderCloseCall) Do(f func()) *MockSenderCloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SenderCloseCall) DoAndReturn(f func()) *SenderCloseCall { +func (c *MockSenderCloseCall) DoAndReturn(f func()) *MockSenderCloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -121,31 +122,31 @@ func (m *MockSender) Run() error { } // Run indicates an expected call of Run. -func (mr *MockSenderMockRecorder) Run() *SenderRunCall { +func (mr *MockSenderMockRecorder) Run() *MockSenderRunCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSender)(nil).Run)) - return &SenderRunCall{Call: call} + return &MockSenderRunCall{Call: call} } -// SenderRunCall wrap *gomock.Call -type SenderRunCall struct { +// MockSenderRunCall wrap *gomock.Call +type MockSenderRunCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SenderRunCall) Return(arg0 error) *SenderRunCall { +func (c *MockSenderRunCall) Return(arg0 error) *MockSenderRunCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SenderRunCall) Do(f func() error) *SenderRunCall { +func (c *MockSenderRunCall) Do(f func() error) *MockSenderRunCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SenderRunCall) DoAndReturn(f func() error) *SenderRunCall { +func (c *MockSenderRunCall) DoAndReturn(f func() error) *MockSenderRunCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -157,31 +158,31 @@ func (m *MockSender) Send(arg0 *packetBuffer, arg1 uint16, arg2 protocol.ECN) { } // Send indicates an expected call of Send. -func (mr *MockSenderMockRecorder) Send(arg0, arg1, arg2 any) *SenderSendCall { +func (mr *MockSenderMockRecorder) Send(arg0, arg1, arg2 any) *MockSenderSendCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockSender)(nil).Send), arg0, arg1, arg2) - return &SenderSendCall{Call: call} + return &MockSenderSendCall{Call: call} } -// SenderSendCall wrap *gomock.Call -type SenderSendCall struct { +// MockSenderSendCall wrap *gomock.Call +type MockSenderSendCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SenderSendCall) Return() *SenderSendCall { +func (c *MockSenderSendCall) Return() *MockSenderSendCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *SenderSendCall) Do(f func(*packetBuffer, uint16, protocol.ECN)) *SenderSendCall { +func (c *MockSenderSendCall) Do(f func(*packetBuffer, uint16, protocol.ECN)) *MockSenderSendCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SenderSendCall) DoAndReturn(f func(*packetBuffer, uint16, protocol.ECN)) *SenderSendCall { +func (c *MockSenderSendCall) DoAndReturn(f func(*packetBuffer, uint16, protocol.ECN)) *MockSenderSendCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -195,31 +196,31 @@ func (m *MockSender) WouldBlock() bool { } // WouldBlock indicates an expected call of WouldBlock. -func (mr *MockSenderMockRecorder) WouldBlock() *SenderWouldBlockCall { +func (mr *MockSenderMockRecorder) WouldBlock() *MockSenderWouldBlockCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WouldBlock", reflect.TypeOf((*MockSender)(nil).WouldBlock)) - return &SenderWouldBlockCall{Call: call} + return &MockSenderWouldBlockCall{Call: call} } -// SenderWouldBlockCall wrap *gomock.Call -type SenderWouldBlockCall struct { +// MockSenderWouldBlockCall wrap *gomock.Call +type MockSenderWouldBlockCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *SenderWouldBlockCall) Return(arg0 bool) *SenderWouldBlockCall { +func (c *MockSenderWouldBlockCall) Return(arg0 bool) *MockSenderWouldBlockCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *SenderWouldBlockCall) Do(f func() bool) *SenderWouldBlockCall { +func (c *MockSenderWouldBlockCall) Do(f func() bool) *MockSenderWouldBlockCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *SenderWouldBlockCall) DoAndReturn(f func() bool) *SenderWouldBlockCall { +func (c *MockSenderWouldBlockCall) DoAndReturn(f func() bool) *MockSenderWouldBlockCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_stream_getter_test.go b/mock_stream_getter_test.go index dc3270f6..8eaf121a 100644 --- a/mock_stream_getter_test.go +++ b/mock_stream_getter_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_getter_test.go github.com/quic-go/quic-go StreamGetter // + // Package quic is a generated GoMock package. package quic @@ -48,31 +49,31 @@ func (m *MockStreamGetter) GetOrOpenReceiveStream(arg0 protocol.StreamID) (recei } // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream. -func (mr *MockStreamGetterMockRecorder) GetOrOpenReceiveStream(arg0 any) *StreamGetterGetOrOpenReceiveStreamCall { +func (mr *MockStreamGetterMockRecorder) GetOrOpenReceiveStream(arg0 any) *MockStreamGetterGetOrOpenReceiveStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamGetter)(nil).GetOrOpenReceiveStream), arg0) - return &StreamGetterGetOrOpenReceiveStreamCall{Call: call} + return &MockStreamGetterGetOrOpenReceiveStreamCall{Call: call} } -// StreamGetterGetOrOpenReceiveStreamCall wrap *gomock.Call -type StreamGetterGetOrOpenReceiveStreamCall struct { +// MockStreamGetterGetOrOpenReceiveStreamCall wrap *gomock.Call +type MockStreamGetterGetOrOpenReceiveStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamGetterGetOrOpenReceiveStreamCall) Return(arg0 receiveStreamI, arg1 error) *StreamGetterGetOrOpenReceiveStreamCall { +func (c *MockStreamGetterGetOrOpenReceiveStreamCall) Return(arg0 receiveStreamI, arg1 error) *MockStreamGetterGetOrOpenReceiveStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamGetterGetOrOpenReceiveStreamCall) Do(f func(protocol.StreamID) (receiveStreamI, error)) *StreamGetterGetOrOpenReceiveStreamCall { +func (c *MockStreamGetterGetOrOpenReceiveStreamCall) Do(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamGetterGetOrOpenReceiveStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamGetterGetOrOpenReceiveStreamCall) DoAndReturn(f func(protocol.StreamID) (receiveStreamI, error)) *StreamGetterGetOrOpenReceiveStreamCall { +func (c *MockStreamGetterGetOrOpenReceiveStreamCall) DoAndReturn(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamGetterGetOrOpenReceiveStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -87,31 +88,31 @@ func (m *MockStreamGetter) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStre } // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream. -func (mr *MockStreamGetterMockRecorder) GetOrOpenSendStream(arg0 any) *StreamGetterGetOrOpenSendStreamCall { +func (mr *MockStreamGetterMockRecorder) GetOrOpenSendStream(arg0 any) *MockStreamGetterGetOrOpenSendStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamGetter)(nil).GetOrOpenSendStream), arg0) - return &StreamGetterGetOrOpenSendStreamCall{Call: call} + return &MockStreamGetterGetOrOpenSendStreamCall{Call: call} } -// StreamGetterGetOrOpenSendStreamCall wrap *gomock.Call -type StreamGetterGetOrOpenSendStreamCall struct { +// MockStreamGetterGetOrOpenSendStreamCall wrap *gomock.Call +type MockStreamGetterGetOrOpenSendStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamGetterGetOrOpenSendStreamCall) Return(arg0 sendStreamI, arg1 error) *StreamGetterGetOrOpenSendStreamCall { +func (c *MockStreamGetterGetOrOpenSendStreamCall) Return(arg0 sendStreamI, arg1 error) *MockStreamGetterGetOrOpenSendStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamGetterGetOrOpenSendStreamCall) Do(f func(protocol.StreamID) (sendStreamI, error)) *StreamGetterGetOrOpenSendStreamCall { +func (c *MockStreamGetterGetOrOpenSendStreamCall) Do(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamGetterGetOrOpenSendStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamGetterGetOrOpenSendStreamCall) DoAndReturn(f func(protocol.StreamID) (sendStreamI, error)) *StreamGetterGetOrOpenSendStreamCall { +func (c *MockStreamGetterGetOrOpenSendStreamCall) DoAndReturn(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamGetterGetOrOpenSendStreamCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_stream_internal_test.go b/mock_stream_internal_test.go index 886528a8..212256d8 100644 --- a/mock_stream_internal_test.go +++ b/mock_stream_internal_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_internal_test.go github.com/quic-go/quic-go StreamI // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockStreamI) CancelRead(arg0 qerr.StreamErrorCode) { } // CancelRead indicates an expected call of CancelRead. -func (mr *MockStreamIMockRecorder) CancelRead(arg0 any) *StreamICancelReadCall { +func (mr *MockStreamIMockRecorder) CancelRead(arg0 any) *MockStreamICancelReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStreamI)(nil).CancelRead), arg0) - return &StreamICancelReadCall{Call: call} + return &MockStreamICancelReadCall{Call: call} } -// StreamICancelReadCall wrap *gomock.Call -type StreamICancelReadCall struct { +// MockStreamICancelReadCall wrap *gomock.Call +type MockStreamICancelReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamICancelReadCall) Return() *StreamICancelReadCall { +func (c *MockStreamICancelReadCall) Return() *MockStreamICancelReadCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *StreamICancelReadCall { +func (c *MockStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *StreamICancelReadCall { +func (c *MockStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -86,31 +87,31 @@ func (m *MockStreamI) CancelWrite(arg0 qerr.StreamErrorCode) { } // CancelWrite indicates an expected call of CancelWrite. -func (mr *MockStreamIMockRecorder) CancelWrite(arg0 any) *StreamICancelWriteCall { +func (mr *MockStreamIMockRecorder) CancelWrite(arg0 any) *MockStreamICancelWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStreamI)(nil).CancelWrite), arg0) - return &StreamICancelWriteCall{Call: call} + return &MockStreamICancelWriteCall{Call: call} } -// StreamICancelWriteCall wrap *gomock.Call -type StreamICancelWriteCall struct { +// MockStreamICancelWriteCall wrap *gomock.Call +type MockStreamICancelWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamICancelWriteCall) Return() *StreamICancelWriteCall { +func (c *MockStreamICancelWriteCall) Return() *MockStreamICancelWriteCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *StreamICancelWriteCall { +func (c *MockStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *StreamICancelWriteCall { +func (c *MockStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -124,31 +125,31 @@ func (m *MockStreamI) Close() error { } // Close indicates an expected call of Close. -func (mr *MockStreamIMockRecorder) Close() *StreamICloseCall { +func (mr *MockStreamIMockRecorder) Close() *MockStreamICloseCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamI)(nil).Close)) - return &StreamICloseCall{Call: call} + return &MockStreamICloseCall{Call: call} } -// StreamICloseCall wrap *gomock.Call -type StreamICloseCall struct { +// MockStreamICloseCall wrap *gomock.Call +type MockStreamICloseCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamICloseCall) Return(arg0 error) *StreamICloseCall { +func (c *MockStreamICloseCall) Return(arg0 error) *MockStreamICloseCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamICloseCall) Do(f func() error) *StreamICloseCall { +func (c *MockStreamICloseCall) Do(f func() error) *MockStreamICloseCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamICloseCall) DoAndReturn(f func() error) *StreamICloseCall { +func (c *MockStreamICloseCall) DoAndReturn(f func() error) *MockStreamICloseCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -162,31 +163,31 @@ func (m *MockStreamI) Context() context.Context { } // Context indicates an expected call of Context. -func (mr *MockStreamIMockRecorder) Context() *StreamIContextCall { +func (mr *MockStreamIMockRecorder) Context() *MockStreamIContextCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStreamI)(nil).Context)) - return &StreamIContextCall{Call: call} + return &MockStreamIContextCall{Call: call} } -// StreamIContextCall wrap *gomock.Call -type StreamIContextCall struct { +// MockStreamIContextCall wrap *gomock.Call +type MockStreamIContextCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIContextCall) Return(arg0 context.Context) *StreamIContextCall { +func (c *MockStreamIContextCall) Return(arg0 context.Context) *MockStreamIContextCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIContextCall) Do(f func() context.Context) *StreamIContextCall { +func (c *MockStreamIContextCall) Do(f func() context.Context) *MockStreamIContextCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIContextCall) DoAndReturn(f func() context.Context) *StreamIContextCall { +func (c *MockStreamIContextCall) DoAndReturn(f func() context.Context) *MockStreamIContextCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -201,31 +202,31 @@ func (m *MockStreamI) Read(arg0 []byte) (int, error) { } // Read indicates an expected call of Read. -func (mr *MockStreamIMockRecorder) Read(arg0 any) *StreamIReadCall { +func (mr *MockStreamIMockRecorder) Read(arg0 any) *MockStreamIReadCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStreamI)(nil).Read), arg0) - return &StreamIReadCall{Call: call} + return &MockStreamIReadCall{Call: call} } -// StreamIReadCall wrap *gomock.Call -type StreamIReadCall struct { +// MockStreamIReadCall wrap *gomock.Call +type MockStreamIReadCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIReadCall) Return(arg0 int, arg1 error) *StreamIReadCall { +func (c *MockStreamIReadCall) Return(arg0 int, arg1 error) *MockStreamIReadCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIReadCall) Do(f func([]byte) (int, error)) *StreamIReadCall { +func (c *MockStreamIReadCall) Do(f func([]byte) (int, error)) *MockStreamIReadCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *StreamIReadCall { +func (c *MockStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIReadCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -239,31 +240,31 @@ func (m *MockStreamI) SetDeadline(arg0 time.Time) error { } // SetDeadline indicates an expected call of SetDeadline. -func (mr *MockStreamIMockRecorder) SetDeadline(arg0 any) *StreamISetDeadlineCall { +func (mr *MockStreamIMockRecorder) SetDeadline(arg0 any) *MockStreamISetDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStreamI)(nil).SetDeadline), arg0) - return &StreamISetDeadlineCall{Call: call} + return &MockStreamISetDeadlineCall{Call: call} } -// StreamISetDeadlineCall wrap *gomock.Call -type StreamISetDeadlineCall struct { +// MockStreamISetDeadlineCall wrap *gomock.Call +type MockStreamISetDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamISetDeadlineCall) Return(arg0 error) *StreamISetDeadlineCall { +func (c *MockStreamISetDeadlineCall) Return(arg0 error) *MockStreamISetDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamISetDeadlineCall) Do(f func(time.Time) error) *StreamISetDeadlineCall { +func (c *MockStreamISetDeadlineCall) Do(f func(time.Time) error) *MockStreamISetDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamISetDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamISetDeadlineCall { +func (c *MockStreamISetDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -277,31 +278,31 @@ func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error { } // SetReadDeadline indicates an expected call of SetReadDeadline. -func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 any) *StreamISetReadDeadlineCall { +func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 any) *MockStreamISetReadDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStreamI)(nil).SetReadDeadline), arg0) - return &StreamISetReadDeadlineCall{Call: call} + return &MockStreamISetReadDeadlineCall{Call: call} } -// StreamISetReadDeadlineCall wrap *gomock.Call -type StreamISetReadDeadlineCall struct { +// MockStreamISetReadDeadlineCall wrap *gomock.Call +type MockStreamISetReadDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamISetReadDeadlineCall) Return(arg0 error) *StreamISetReadDeadlineCall { +func (c *MockStreamISetReadDeadlineCall) Return(arg0 error) *MockStreamISetReadDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamISetReadDeadlineCall) Do(f func(time.Time) error) *StreamISetReadDeadlineCall { +func (c *MockStreamISetReadDeadlineCall) Do(f func(time.Time) error) *MockStreamISetReadDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamISetReadDeadlineCall { +func (c *MockStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetReadDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -315,31 +316,31 @@ func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error { } // SetWriteDeadline indicates an expected call of SetWriteDeadline. -func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 any) *StreamISetWriteDeadlineCall { +func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 any) *MockStreamISetWriteDeadlineCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStreamI)(nil).SetWriteDeadline), arg0) - return &StreamISetWriteDeadlineCall{Call: call} + return &MockStreamISetWriteDeadlineCall{Call: call} } -// StreamISetWriteDeadlineCall wrap *gomock.Call -type StreamISetWriteDeadlineCall struct { +// MockStreamISetWriteDeadlineCall wrap *gomock.Call +type MockStreamISetWriteDeadlineCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamISetWriteDeadlineCall) Return(arg0 error) *StreamISetWriteDeadlineCall { +func (c *MockStreamISetWriteDeadlineCall) Return(arg0 error) *MockStreamISetWriteDeadlineCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamISetWriteDeadlineCall) Do(f func(time.Time) error) *StreamISetWriteDeadlineCall { +func (c *MockStreamISetWriteDeadlineCall) Do(f func(time.Time) error) *MockStreamISetWriteDeadlineCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamISetWriteDeadlineCall { +func (c *MockStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetWriteDeadlineCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -353,31 +354,31 @@ func (m *MockStreamI) StreamID() protocol.StreamID { } // StreamID indicates an expected call of StreamID. -func (mr *MockStreamIMockRecorder) StreamID() *StreamIStreamIDCall { +func (mr *MockStreamIMockRecorder) StreamID() *MockStreamIStreamIDCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStreamI)(nil).StreamID)) - return &StreamIStreamIDCall{Call: call} + return &MockStreamIStreamIDCall{Call: call} } -// StreamIStreamIDCall wrap *gomock.Call -type StreamIStreamIDCall struct { +// MockStreamIStreamIDCall wrap *gomock.Call +type MockStreamIStreamIDCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIStreamIDCall) Return(arg0 protocol.StreamID) *StreamIStreamIDCall { +func (c *MockStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamIStreamIDCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIStreamIDCall) Do(f func() protocol.StreamID) *StreamIStreamIDCall { +func (c *MockStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockStreamIStreamIDCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *StreamIStreamIDCall { +func (c *MockStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamIStreamIDCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -392,31 +393,31 @@ func (m *MockStreamI) Write(arg0 []byte) (int, error) { } // Write indicates an expected call of Write. -func (mr *MockStreamIMockRecorder) Write(arg0 any) *StreamIWriteCall { +func (mr *MockStreamIMockRecorder) Write(arg0 any) *MockStreamIWriteCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStreamI)(nil).Write), arg0) - return &StreamIWriteCall{Call: call} + return &MockStreamIWriteCall{Call: call} } -// StreamIWriteCall wrap *gomock.Call -type StreamIWriteCall struct { +// MockStreamIWriteCall wrap *gomock.Call +type MockStreamIWriteCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIWriteCall) Return(arg0 int, arg1 error) *StreamIWriteCall { +func (c *MockStreamIWriteCall) Return(arg0 int, arg1 error) *MockStreamIWriteCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIWriteCall) Do(f func([]byte) (int, error)) *StreamIWriteCall { +func (c *MockStreamIWriteCall) Do(f func([]byte) (int, error)) *MockStreamIWriteCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *StreamIWriteCall { +func (c *MockStreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIWriteCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -428,31 +429,31 @@ func (m *MockStreamI) closeForShutdown(arg0 error) { } // closeForShutdown indicates an expected call of closeForShutdown. -func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 any) *StreamIcloseForShutdownCall { +func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 any) *MockStreamIcloseForShutdownCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockStreamI)(nil).closeForShutdown), arg0) - return &StreamIcloseForShutdownCall{Call: call} + return &MockStreamIcloseForShutdownCall{Call: call} } -// StreamIcloseForShutdownCall wrap *gomock.Call -type StreamIcloseForShutdownCall struct { +// MockStreamIcloseForShutdownCall wrap *gomock.Call +type MockStreamIcloseForShutdownCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIcloseForShutdownCall) Return() *StreamIcloseForShutdownCall { +func (c *MockStreamIcloseForShutdownCall) Return() *MockStreamIcloseForShutdownCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamIcloseForShutdownCall) Do(f func(error)) *StreamIcloseForShutdownCall { +func (c *MockStreamIcloseForShutdownCall) Do(f func(error)) *MockStreamIcloseForShutdownCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIcloseForShutdownCall) DoAndReturn(f func(error)) *StreamIcloseForShutdownCall { +func (c *MockStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *MockStreamIcloseForShutdownCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -466,31 +467,31 @@ func (m *MockStreamI) getWindowUpdate() protocol.ByteCount { } // getWindowUpdate indicates an expected call of getWindowUpdate. -func (mr *MockStreamIMockRecorder) getWindowUpdate() *StreamIgetWindowUpdateCall { +func (mr *MockStreamIMockRecorder) getWindowUpdate() *MockStreamIgetWindowUpdateCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockStreamI)(nil).getWindowUpdate)) - return &StreamIgetWindowUpdateCall{Call: call} + return &MockStreamIgetWindowUpdateCall{Call: call} } -// StreamIgetWindowUpdateCall wrap *gomock.Call -type StreamIgetWindowUpdateCall struct { +// MockStreamIgetWindowUpdateCall wrap *gomock.Call +type MockStreamIgetWindowUpdateCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *StreamIgetWindowUpdateCall { +func (c *MockStreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockStreamIgetWindowUpdateCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *StreamIgetWindowUpdateCall { +func (c *MockStreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockStreamIgetWindowUpdateCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *StreamIgetWindowUpdateCall { +func (c *MockStreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamIgetWindowUpdateCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -504,31 +505,31 @@ func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error } // handleResetStreamFrame indicates an expected call of handleResetStreamFrame. -func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 any) *StreamIhandleResetStreamFrameCall { +func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 any) *MockStreamIhandleResetStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleResetStreamFrame), arg0) - return &StreamIhandleResetStreamFrameCall{Call: call} + return &MockStreamIhandleResetStreamFrameCall{Call: call} } -// StreamIhandleResetStreamFrameCall wrap *gomock.Call -type StreamIhandleResetStreamFrameCall struct { +// MockStreamIhandleResetStreamFrameCall wrap *gomock.Call +type MockStreamIhandleResetStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIhandleResetStreamFrameCall) Return(arg0 error) *StreamIhandleResetStreamFrameCall { +func (c *MockStreamIhandleResetStreamFrameCall) Return(arg0 error) *MockStreamIhandleResetStreamFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *StreamIhandleResetStreamFrameCall { +func (c *MockStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *StreamIhandleResetStreamFrameCall { +func (c *MockStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -540,31 +541,31 @@ func (m *MockStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) { } // handleStopSendingFrame indicates an expected call of handleStopSendingFrame. -func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 any) *StreamIhandleStopSendingFrameCall { +func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 any) *MockStreamIhandleStopSendingFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockStreamI)(nil).handleStopSendingFrame), arg0) - return &StreamIhandleStopSendingFrameCall{Call: call} + return &MockStreamIhandleStopSendingFrameCall{Call: call} } -// StreamIhandleStopSendingFrameCall wrap *gomock.Call -type StreamIhandleStopSendingFrameCall struct { +// MockStreamIhandleStopSendingFrameCall wrap *gomock.Call +type MockStreamIhandleStopSendingFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIhandleStopSendingFrameCall) Return() *StreamIhandleStopSendingFrameCall { +func (c *MockStreamIhandleStopSendingFrameCall) Return() *MockStreamIhandleStopSendingFrameCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *StreamIhandleStopSendingFrameCall { +func (c *MockStreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *StreamIhandleStopSendingFrameCall { +func (c *MockStreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -578,31 +579,31 @@ func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { } // handleStreamFrame indicates an expected call of handleStreamFrame. -func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 any) *StreamIhandleStreamFrameCall { +func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 any) *MockStreamIhandleStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleStreamFrame), arg0) - return &StreamIhandleStreamFrameCall{Call: call} + return &MockStreamIhandleStreamFrameCall{Call: call} } -// StreamIhandleStreamFrameCall wrap *gomock.Call -type StreamIhandleStreamFrameCall struct { +// MockStreamIhandleStreamFrameCall wrap *gomock.Call +type MockStreamIhandleStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIhandleStreamFrameCall) Return(arg0 error) *StreamIhandleStreamFrameCall { +func (c *MockStreamIhandleStreamFrameCall) Return(arg0 error) *MockStreamIhandleStreamFrameCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *StreamIhandleStreamFrameCall { +func (c *MockStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *StreamIhandleStreamFrameCall { +func (c *MockStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -616,31 +617,31 @@ func (m *MockStreamI) hasData() bool { } // hasData indicates an expected call of hasData. -func (mr *MockStreamIMockRecorder) hasData() *StreamIhasDataCall { +func (mr *MockStreamIMockRecorder) hasData() *MockStreamIhasDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockStreamI)(nil).hasData)) - return &StreamIhasDataCall{Call: call} + return &MockStreamIhasDataCall{Call: call} } -// StreamIhasDataCall wrap *gomock.Call -type StreamIhasDataCall struct { +// MockStreamIhasDataCall wrap *gomock.Call +type MockStreamIhasDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIhasDataCall) Return(arg0 bool) *StreamIhasDataCall { +func (c *MockStreamIhasDataCall) Return(arg0 bool) *MockStreamIhasDataCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIhasDataCall) Do(f func() bool) *StreamIhasDataCall { +func (c *MockStreamIhasDataCall) Do(f func() bool) *MockStreamIhasDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIhasDataCall) DoAndReturn(f func() bool) *StreamIhasDataCall { +func (c *MockStreamIhasDataCall) DoAndReturn(f func() bool) *MockStreamIhasDataCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -656,31 +657,31 @@ func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount, arg1 protocol.Vers } // popStreamFrame indicates an expected call of popStreamFrame. -func (mr *MockStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *StreamIpopStreamFrameCall { +func (mr *MockStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *MockStreamIpopStreamFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockStreamI)(nil).popStreamFrame), arg0, arg1) - return &StreamIpopStreamFrameCall{Call: call} + return &MockStreamIpopStreamFrameCall{Call: call} } -// StreamIpopStreamFrameCall wrap *gomock.Call -type StreamIpopStreamFrameCall struct { +// MockStreamIpopStreamFrameCall wrap *gomock.Call +type MockStreamIpopStreamFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *StreamIpopStreamFrameCall { +func (c *MockStreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *MockStreamIpopStreamFrameCall { c.Call = c.Call.Return(arg0, arg1, arg2) return c } // Do rewrite *gomock.Call.Do -func (c *StreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *StreamIpopStreamFrameCall { +func (c *MockStreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *StreamIpopStreamFrameCall { +func (c *MockStreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -692,31 +693,31 @@ func (m *MockStreamI) updateSendWindow(arg0 protocol.ByteCount) { } // updateSendWindow indicates an expected call of updateSendWindow. -func (mr *MockStreamIMockRecorder) updateSendWindow(arg0 any) *StreamIupdateSendWindowCall { +func (mr *MockStreamIMockRecorder) updateSendWindow(arg0 any) *MockStreamIupdateSendWindowCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "updateSendWindow", reflect.TypeOf((*MockStreamI)(nil).updateSendWindow), arg0) - return &StreamIupdateSendWindowCall{Call: call} + return &MockStreamIupdateSendWindowCall{Call: call} } -// StreamIupdateSendWindowCall wrap *gomock.Call -type StreamIupdateSendWindowCall struct { +// MockStreamIupdateSendWindowCall wrap *gomock.Call +type MockStreamIupdateSendWindowCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamIupdateSendWindowCall) Return() *StreamIupdateSendWindowCall { +func (c *MockStreamIupdateSendWindowCall) Return() *MockStreamIupdateSendWindowCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *StreamIupdateSendWindowCall { +func (c *MockStreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *StreamIupdateSendWindowCall { +func (c *MockStreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_stream_manager_test.go b/mock_stream_manager_test.go index 62ecf632..6bafb60d 100644 --- a/mock_stream_manager_test.go +++ b/mock_stream_manager_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_manager_test.go github.com/quic-go/quic-go StreamManager // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockStreamManager) AcceptStream(arg0 context.Context) (Stream, error) { } // AcceptStream indicates an expected call of AcceptStream. -func (mr *MockStreamManagerMockRecorder) AcceptStream(arg0 any) *StreamManagerAcceptStreamCall { +func (mr *MockStreamManagerMockRecorder) AcceptStream(arg0 any) *MockStreamManagerAcceptStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptStream), arg0) - return &StreamManagerAcceptStreamCall{Call: call} + return &MockStreamManagerAcceptStreamCall{Call: call} } -// StreamManagerAcceptStreamCall wrap *gomock.Call -type StreamManagerAcceptStreamCall struct { +// MockStreamManagerAcceptStreamCall wrap *gomock.Call +type MockStreamManagerAcceptStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerAcceptStreamCall) Return(arg0 Stream, arg1 error) *StreamManagerAcceptStreamCall { +func (c *MockStreamManagerAcceptStreamCall) Return(arg0 Stream, arg1 error) *MockStreamManagerAcceptStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerAcceptStreamCall) Do(f func(context.Context) (Stream, error)) *StreamManagerAcceptStreamCall { +func (c *MockStreamManagerAcceptStreamCall) Do(f func(context.Context) (Stream, error)) *MockStreamManagerAcceptStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerAcceptStreamCall) DoAndReturn(f func(context.Context) (Stream, error)) *StreamManagerAcceptStreamCall { +func (c *MockStreamManagerAcceptStreamCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockStreamManagerAcceptStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -89,31 +90,31 @@ func (m *MockStreamManager) AcceptUniStream(arg0 context.Context) (ReceiveStream } // AcceptUniStream indicates an expected call of AcceptUniStream. -func (mr *MockStreamManagerMockRecorder) AcceptUniStream(arg0 any) *StreamManagerAcceptUniStreamCall { +func (mr *MockStreamManagerMockRecorder) AcceptUniStream(arg0 any) *MockStreamManagerAcceptUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptUniStream), arg0) - return &StreamManagerAcceptUniStreamCall{Call: call} + return &MockStreamManagerAcceptUniStreamCall{Call: call} } -// StreamManagerAcceptUniStreamCall wrap *gomock.Call -type StreamManagerAcceptUniStreamCall struct { +// MockStreamManagerAcceptUniStreamCall wrap *gomock.Call +type MockStreamManagerAcceptUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerAcceptUniStreamCall) Return(arg0 ReceiveStream, arg1 error) *StreamManagerAcceptUniStreamCall { +func (c *MockStreamManagerAcceptUniStreamCall) Return(arg0 ReceiveStream, arg1 error) *MockStreamManagerAcceptUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerAcceptUniStreamCall) Do(f func(context.Context) (ReceiveStream, error)) *StreamManagerAcceptUniStreamCall { +func (c *MockStreamManagerAcceptUniStreamCall) Do(f func(context.Context) (ReceiveStream, error)) *MockStreamManagerAcceptUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerAcceptUniStreamCall) DoAndReturn(f func(context.Context) (ReceiveStream, error)) *StreamManagerAcceptUniStreamCall { +func (c *MockStreamManagerAcceptUniStreamCall) DoAndReturn(f func(context.Context) (ReceiveStream, error)) *MockStreamManagerAcceptUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -125,31 +126,31 @@ func (m *MockStreamManager) CloseWithError(arg0 error) { } // CloseWithError indicates an expected call of CloseWithError. -func (mr *MockStreamManagerMockRecorder) CloseWithError(arg0 any) *StreamManagerCloseWithErrorCall { +func (mr *MockStreamManagerMockRecorder) CloseWithError(arg0 any) *MockStreamManagerCloseWithErrorCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockStreamManager)(nil).CloseWithError), arg0) - return &StreamManagerCloseWithErrorCall{Call: call} + return &MockStreamManagerCloseWithErrorCall{Call: call} } -// StreamManagerCloseWithErrorCall wrap *gomock.Call -type StreamManagerCloseWithErrorCall struct { +// MockStreamManagerCloseWithErrorCall wrap *gomock.Call +type MockStreamManagerCloseWithErrorCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerCloseWithErrorCall) Return() *StreamManagerCloseWithErrorCall { +func (c *MockStreamManagerCloseWithErrorCall) Return() *MockStreamManagerCloseWithErrorCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerCloseWithErrorCall) Do(f func(error)) *StreamManagerCloseWithErrorCall { +func (c *MockStreamManagerCloseWithErrorCall) Do(f func(error)) *MockStreamManagerCloseWithErrorCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerCloseWithErrorCall) DoAndReturn(f func(error)) *StreamManagerCloseWithErrorCall { +func (c *MockStreamManagerCloseWithErrorCall) DoAndReturn(f func(error)) *MockStreamManagerCloseWithErrorCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -163,31 +164,31 @@ func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error { } // DeleteStream indicates an expected call of DeleteStream. -func (mr *MockStreamManagerMockRecorder) DeleteStream(arg0 any) *StreamManagerDeleteStreamCall { +func (mr *MockStreamManagerMockRecorder) DeleteStream(arg0 any) *MockStreamManagerDeleteStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStream", reflect.TypeOf((*MockStreamManager)(nil).DeleteStream), arg0) - return &StreamManagerDeleteStreamCall{Call: call} + return &MockStreamManagerDeleteStreamCall{Call: call} } -// StreamManagerDeleteStreamCall wrap *gomock.Call -type StreamManagerDeleteStreamCall struct { +// MockStreamManagerDeleteStreamCall wrap *gomock.Call +type MockStreamManagerDeleteStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerDeleteStreamCall) Return(arg0 error) *StreamManagerDeleteStreamCall { +func (c *MockStreamManagerDeleteStreamCall) Return(arg0 error) *MockStreamManagerDeleteStreamCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerDeleteStreamCall) Do(f func(protocol.StreamID) error) *StreamManagerDeleteStreamCall { +func (c *MockStreamManagerDeleteStreamCall) Do(f func(protocol.StreamID) error) *MockStreamManagerDeleteStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerDeleteStreamCall) DoAndReturn(f func(protocol.StreamID) error) *StreamManagerDeleteStreamCall { +func (c *MockStreamManagerDeleteStreamCall) DoAndReturn(f func(protocol.StreamID) error) *MockStreamManagerDeleteStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -202,31 +203,31 @@ func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (rece } // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream. -func (mr *MockStreamManagerMockRecorder) GetOrOpenReceiveStream(arg0 any) *StreamManagerGetOrOpenReceiveStreamCall { +func (mr *MockStreamManagerMockRecorder) GetOrOpenReceiveStream(arg0 any) *MockStreamManagerGetOrOpenReceiveStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenReceiveStream), arg0) - return &StreamManagerGetOrOpenReceiveStreamCall{Call: call} + return &MockStreamManagerGetOrOpenReceiveStreamCall{Call: call} } -// StreamManagerGetOrOpenReceiveStreamCall wrap *gomock.Call -type StreamManagerGetOrOpenReceiveStreamCall struct { +// MockStreamManagerGetOrOpenReceiveStreamCall wrap *gomock.Call +type MockStreamManagerGetOrOpenReceiveStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerGetOrOpenReceiveStreamCall) Return(arg0 receiveStreamI, arg1 error) *StreamManagerGetOrOpenReceiveStreamCall { +func (c *MockStreamManagerGetOrOpenReceiveStreamCall) Return(arg0 receiveStreamI, arg1 error) *MockStreamManagerGetOrOpenReceiveStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerGetOrOpenReceiveStreamCall) Do(f func(protocol.StreamID) (receiveStreamI, error)) *StreamManagerGetOrOpenReceiveStreamCall { +func (c *MockStreamManagerGetOrOpenReceiveStreamCall) Do(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamManagerGetOrOpenReceiveStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerGetOrOpenReceiveStreamCall) DoAndReturn(f func(protocol.StreamID) (receiveStreamI, error)) *StreamManagerGetOrOpenReceiveStreamCall { +func (c *MockStreamManagerGetOrOpenReceiveStreamCall) DoAndReturn(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamManagerGetOrOpenReceiveStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -241,31 +242,31 @@ func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStr } // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream. -func (mr *MockStreamManagerMockRecorder) GetOrOpenSendStream(arg0 any) *StreamManagerGetOrOpenSendStreamCall { +func (mr *MockStreamManagerMockRecorder) GetOrOpenSendStream(arg0 any) *MockStreamManagerGetOrOpenSendStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenSendStream), arg0) - return &StreamManagerGetOrOpenSendStreamCall{Call: call} + return &MockStreamManagerGetOrOpenSendStreamCall{Call: call} } -// StreamManagerGetOrOpenSendStreamCall wrap *gomock.Call -type StreamManagerGetOrOpenSendStreamCall struct { +// MockStreamManagerGetOrOpenSendStreamCall wrap *gomock.Call +type MockStreamManagerGetOrOpenSendStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerGetOrOpenSendStreamCall) Return(arg0 sendStreamI, arg1 error) *StreamManagerGetOrOpenSendStreamCall { +func (c *MockStreamManagerGetOrOpenSendStreamCall) Return(arg0 sendStreamI, arg1 error) *MockStreamManagerGetOrOpenSendStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerGetOrOpenSendStreamCall) Do(f func(protocol.StreamID) (sendStreamI, error)) *StreamManagerGetOrOpenSendStreamCall { +func (c *MockStreamManagerGetOrOpenSendStreamCall) Do(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamManagerGetOrOpenSendStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerGetOrOpenSendStreamCall) DoAndReturn(f func(protocol.StreamID) (sendStreamI, error)) *StreamManagerGetOrOpenSendStreamCall { +func (c *MockStreamManagerGetOrOpenSendStreamCall) DoAndReturn(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamManagerGetOrOpenSendStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -277,31 +278,31 @@ func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) { } // HandleMaxStreamsFrame indicates an expected call of HandleMaxStreamsFrame. -func (mr *MockStreamManagerMockRecorder) HandleMaxStreamsFrame(arg0 any) *StreamManagerHandleMaxStreamsFrameCall { +func (mr *MockStreamManagerMockRecorder) HandleMaxStreamsFrame(arg0 any) *MockStreamManagerHandleMaxStreamsFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMaxStreamsFrame", reflect.TypeOf((*MockStreamManager)(nil).HandleMaxStreamsFrame), arg0) - return &StreamManagerHandleMaxStreamsFrameCall{Call: call} + return &MockStreamManagerHandleMaxStreamsFrameCall{Call: call} } -// StreamManagerHandleMaxStreamsFrameCall wrap *gomock.Call -type StreamManagerHandleMaxStreamsFrameCall struct { +// MockStreamManagerHandleMaxStreamsFrameCall wrap *gomock.Call +type MockStreamManagerHandleMaxStreamsFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerHandleMaxStreamsFrameCall) Return() *StreamManagerHandleMaxStreamsFrameCall { +func (c *MockStreamManagerHandleMaxStreamsFrameCall) Return() *MockStreamManagerHandleMaxStreamsFrameCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerHandleMaxStreamsFrameCall) Do(f func(*wire.MaxStreamsFrame)) *StreamManagerHandleMaxStreamsFrameCall { +func (c *MockStreamManagerHandleMaxStreamsFrameCall) Do(f func(*wire.MaxStreamsFrame)) *MockStreamManagerHandleMaxStreamsFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerHandleMaxStreamsFrameCall) DoAndReturn(f func(*wire.MaxStreamsFrame)) *StreamManagerHandleMaxStreamsFrameCall { +func (c *MockStreamManagerHandleMaxStreamsFrameCall) DoAndReturn(f func(*wire.MaxStreamsFrame)) *MockStreamManagerHandleMaxStreamsFrameCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -316,31 +317,31 @@ func (m *MockStreamManager) OpenStream() (Stream, error) { } // OpenStream indicates an expected call of OpenStream. -func (mr *MockStreamManagerMockRecorder) OpenStream() *StreamManagerOpenStreamCall { +func (mr *MockStreamManagerMockRecorder) OpenStream() *MockStreamManagerOpenStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockStreamManager)(nil).OpenStream)) - return &StreamManagerOpenStreamCall{Call: call} + return &MockStreamManagerOpenStreamCall{Call: call} } -// StreamManagerOpenStreamCall wrap *gomock.Call -type StreamManagerOpenStreamCall struct { +// MockStreamManagerOpenStreamCall wrap *gomock.Call +type MockStreamManagerOpenStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerOpenStreamCall) Return(arg0 Stream, arg1 error) *StreamManagerOpenStreamCall { +func (c *MockStreamManagerOpenStreamCall) Return(arg0 Stream, arg1 error) *MockStreamManagerOpenStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerOpenStreamCall) Do(f func() (Stream, error)) *StreamManagerOpenStreamCall { +func (c *MockStreamManagerOpenStreamCall) Do(f func() (Stream, error)) *MockStreamManagerOpenStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerOpenStreamCall) DoAndReturn(f func() (Stream, error)) *StreamManagerOpenStreamCall { +func (c *MockStreamManagerOpenStreamCall) DoAndReturn(f func() (Stream, error)) *MockStreamManagerOpenStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -355,31 +356,31 @@ func (m *MockStreamManager) OpenStreamSync(arg0 context.Context) (Stream, error) } // OpenStreamSync indicates an expected call of OpenStreamSync. -func (mr *MockStreamManagerMockRecorder) OpenStreamSync(arg0 any) *StreamManagerOpenStreamSyncCall { +func (mr *MockStreamManagerMockRecorder) OpenStreamSync(arg0 any) *MockStreamManagerOpenStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenStreamSync), arg0) - return &StreamManagerOpenStreamSyncCall{Call: call} + return &MockStreamManagerOpenStreamSyncCall{Call: call} } -// StreamManagerOpenStreamSyncCall wrap *gomock.Call -type StreamManagerOpenStreamSyncCall struct { +// MockStreamManagerOpenStreamSyncCall wrap *gomock.Call +type MockStreamManagerOpenStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerOpenStreamSyncCall) Return(arg0 Stream, arg1 error) *StreamManagerOpenStreamSyncCall { +func (c *MockStreamManagerOpenStreamSyncCall) Return(arg0 Stream, arg1 error) *MockStreamManagerOpenStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerOpenStreamSyncCall) Do(f func(context.Context) (Stream, error)) *StreamManagerOpenStreamSyncCall { +func (c *MockStreamManagerOpenStreamSyncCall) Do(f func(context.Context) (Stream, error)) *MockStreamManagerOpenStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerOpenStreamSyncCall) DoAndReturn(f func(context.Context) (Stream, error)) *StreamManagerOpenStreamSyncCall { +func (c *MockStreamManagerOpenStreamSyncCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockStreamManagerOpenStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -394,31 +395,31 @@ func (m *MockStreamManager) OpenUniStream() (SendStream, error) { } // OpenUniStream indicates an expected call of OpenUniStream. -func (mr *MockStreamManagerMockRecorder) OpenUniStream() *StreamManagerOpenUniStreamCall { +func (mr *MockStreamManagerMockRecorder) OpenUniStream() *MockStreamManagerOpenUniStreamCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStream)) - return &StreamManagerOpenUniStreamCall{Call: call} + return &MockStreamManagerOpenUniStreamCall{Call: call} } -// StreamManagerOpenUniStreamCall wrap *gomock.Call -type StreamManagerOpenUniStreamCall struct { +// MockStreamManagerOpenUniStreamCall wrap *gomock.Call +type MockStreamManagerOpenUniStreamCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerOpenUniStreamCall) Return(arg0 SendStream, arg1 error) *StreamManagerOpenUniStreamCall { +func (c *MockStreamManagerOpenUniStreamCall) Return(arg0 SendStream, arg1 error) *MockStreamManagerOpenUniStreamCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerOpenUniStreamCall) Do(f func() (SendStream, error)) *StreamManagerOpenUniStreamCall { +func (c *MockStreamManagerOpenUniStreamCall) Do(f func() (SendStream, error)) *MockStreamManagerOpenUniStreamCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerOpenUniStreamCall) DoAndReturn(f func() (SendStream, error)) *StreamManagerOpenUniStreamCall { +func (c *MockStreamManagerOpenUniStreamCall) DoAndReturn(f func() (SendStream, error)) *MockStreamManagerOpenUniStreamCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -433,31 +434,31 @@ func (m *MockStreamManager) OpenUniStreamSync(arg0 context.Context) (SendStream, } // OpenUniStreamSync indicates an expected call of OpenUniStreamSync. -func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync(arg0 any) *StreamManagerOpenUniStreamSyncCall { +func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync(arg0 any) *MockStreamManagerOpenUniStreamSyncCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStreamSync), arg0) - return &StreamManagerOpenUniStreamSyncCall{Call: call} + return &MockStreamManagerOpenUniStreamSyncCall{Call: call} } -// StreamManagerOpenUniStreamSyncCall wrap *gomock.Call -type StreamManagerOpenUniStreamSyncCall struct { +// MockStreamManagerOpenUniStreamSyncCall wrap *gomock.Call +type MockStreamManagerOpenUniStreamSyncCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerOpenUniStreamSyncCall) Return(arg0 SendStream, arg1 error) *StreamManagerOpenUniStreamSyncCall { +func (c *MockStreamManagerOpenUniStreamSyncCall) Return(arg0 SendStream, arg1 error) *MockStreamManagerOpenUniStreamSyncCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerOpenUniStreamSyncCall) Do(f func(context.Context) (SendStream, error)) *StreamManagerOpenUniStreamSyncCall { +func (c *MockStreamManagerOpenUniStreamSyncCall) Do(f func(context.Context) (SendStream, error)) *MockStreamManagerOpenUniStreamSyncCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (SendStream, error)) *StreamManagerOpenUniStreamSyncCall { +func (c *MockStreamManagerOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (SendStream, error)) *MockStreamManagerOpenUniStreamSyncCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -469,31 +470,31 @@ func (m *MockStreamManager) ResetFor0RTT() { } // ResetFor0RTT indicates an expected call of ResetFor0RTT. -func (mr *MockStreamManagerMockRecorder) ResetFor0RTT() *StreamManagerResetFor0RTTCall { +func (mr *MockStreamManagerMockRecorder) ResetFor0RTT() *MockStreamManagerResetFor0RTTCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFor0RTT", reflect.TypeOf((*MockStreamManager)(nil).ResetFor0RTT)) - return &StreamManagerResetFor0RTTCall{Call: call} + return &MockStreamManagerResetFor0RTTCall{Call: call} } -// StreamManagerResetFor0RTTCall wrap *gomock.Call -type StreamManagerResetFor0RTTCall struct { +// MockStreamManagerResetFor0RTTCall wrap *gomock.Call +type MockStreamManagerResetFor0RTTCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerResetFor0RTTCall) Return() *StreamManagerResetFor0RTTCall { +func (c *MockStreamManagerResetFor0RTTCall) Return() *MockStreamManagerResetFor0RTTCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerResetFor0RTTCall) Do(f func()) *StreamManagerResetFor0RTTCall { +func (c *MockStreamManagerResetFor0RTTCall) Do(f func()) *MockStreamManagerResetFor0RTTCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerResetFor0RTTCall) DoAndReturn(f func()) *StreamManagerResetFor0RTTCall { +func (c *MockStreamManagerResetFor0RTTCall) DoAndReturn(f func()) *MockStreamManagerResetFor0RTTCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -505,31 +506,31 @@ func (m *MockStreamManager) UpdateLimits(arg0 *wire.TransportParameters) { } // UpdateLimits indicates an expected call of UpdateLimits. -func (mr *MockStreamManagerMockRecorder) UpdateLimits(arg0 any) *StreamManagerUpdateLimitsCall { +func (mr *MockStreamManagerMockRecorder) UpdateLimits(arg0 any) *MockStreamManagerUpdateLimitsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLimits", reflect.TypeOf((*MockStreamManager)(nil).UpdateLimits), arg0) - return &StreamManagerUpdateLimitsCall{Call: call} + return &MockStreamManagerUpdateLimitsCall{Call: call} } -// StreamManagerUpdateLimitsCall wrap *gomock.Call -type StreamManagerUpdateLimitsCall struct { +// MockStreamManagerUpdateLimitsCall wrap *gomock.Call +type MockStreamManagerUpdateLimitsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerUpdateLimitsCall) Return() *StreamManagerUpdateLimitsCall { +func (c *MockStreamManagerUpdateLimitsCall) Return() *MockStreamManagerUpdateLimitsCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerUpdateLimitsCall) Do(f func(*wire.TransportParameters)) *StreamManagerUpdateLimitsCall { +func (c *MockStreamManagerUpdateLimitsCall) Do(f func(*wire.TransportParameters)) *MockStreamManagerUpdateLimitsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerUpdateLimitsCall) DoAndReturn(f func(*wire.TransportParameters)) *StreamManagerUpdateLimitsCall { +func (c *MockStreamManagerUpdateLimitsCall) DoAndReturn(f func(*wire.TransportParameters)) *MockStreamManagerUpdateLimitsCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -541,31 +542,31 @@ func (m *MockStreamManager) UseResetMaps() { } // UseResetMaps indicates an expected call of UseResetMaps. -func (mr *MockStreamManagerMockRecorder) UseResetMaps() *StreamManagerUseResetMapsCall { +func (mr *MockStreamManagerMockRecorder) UseResetMaps() *MockStreamManagerUseResetMapsCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseResetMaps", reflect.TypeOf((*MockStreamManager)(nil).UseResetMaps)) - return &StreamManagerUseResetMapsCall{Call: call} + return &MockStreamManagerUseResetMapsCall{Call: call} } -// StreamManagerUseResetMapsCall wrap *gomock.Call -type StreamManagerUseResetMapsCall struct { +// MockStreamManagerUseResetMapsCall wrap *gomock.Call +type MockStreamManagerUseResetMapsCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamManagerUseResetMapsCall) Return() *StreamManagerUseResetMapsCall { +func (c *MockStreamManagerUseResetMapsCall) Return() *MockStreamManagerUseResetMapsCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamManagerUseResetMapsCall) Do(f func()) *StreamManagerUseResetMapsCall { +func (c *MockStreamManagerUseResetMapsCall) Do(f func()) *MockStreamManagerUseResetMapsCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamManagerUseResetMapsCall) DoAndReturn(f func()) *StreamManagerUseResetMapsCall { +func (c *MockStreamManagerUseResetMapsCall) DoAndReturn(f func()) *MockStreamManagerUseResetMapsCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_stream_sender_test.go b/mock_stream_sender_test.go index eca614fd..79002118 100644 --- a/mock_stream_sender_test.go +++ b/mock_stream_sender_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_stream_sender_test.go github.com/quic-go/quic-go StreamSender // + // Package quic is a generated GoMock package. package quic @@ -46,31 +47,31 @@ func (m *MockStreamSender) onHasStreamData(arg0 protocol.StreamID) { } // onHasStreamData indicates an expected call of onHasStreamData. -func (mr *MockStreamSenderMockRecorder) onHasStreamData(arg0 any) *StreamSenderonHasStreamDataCall { +func (mr *MockStreamSenderMockRecorder) onHasStreamData(arg0 any) *MockStreamSenderonHasStreamDataCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "onHasStreamData", reflect.TypeOf((*MockStreamSender)(nil).onHasStreamData), arg0) - return &StreamSenderonHasStreamDataCall{Call: call} + return &MockStreamSenderonHasStreamDataCall{Call: call} } -// StreamSenderonHasStreamDataCall wrap *gomock.Call -type StreamSenderonHasStreamDataCall struct { +// MockStreamSenderonHasStreamDataCall wrap *gomock.Call +type MockStreamSenderonHasStreamDataCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSenderonHasStreamDataCall) Return() *StreamSenderonHasStreamDataCall { +func (c *MockStreamSenderonHasStreamDataCall) Return() *MockStreamSenderonHasStreamDataCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamSenderonHasStreamDataCall) Do(f func(protocol.StreamID)) *StreamSenderonHasStreamDataCall { +func (c *MockStreamSenderonHasStreamDataCall) Do(f func(protocol.StreamID)) *MockStreamSenderonHasStreamDataCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSenderonHasStreamDataCall) DoAndReturn(f func(protocol.StreamID)) *StreamSenderonHasStreamDataCall { +func (c *MockStreamSenderonHasStreamDataCall) DoAndReturn(f func(protocol.StreamID)) *MockStreamSenderonHasStreamDataCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -82,31 +83,31 @@ func (m *MockStreamSender) onStreamCompleted(arg0 protocol.StreamID) { } // onStreamCompleted indicates an expected call of onStreamCompleted. -func (mr *MockStreamSenderMockRecorder) onStreamCompleted(arg0 any) *StreamSenderonStreamCompletedCall { +func (mr *MockStreamSenderMockRecorder) onStreamCompleted(arg0 any) *MockStreamSenderonStreamCompletedCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "onStreamCompleted", reflect.TypeOf((*MockStreamSender)(nil).onStreamCompleted), arg0) - return &StreamSenderonStreamCompletedCall{Call: call} + return &MockStreamSenderonStreamCompletedCall{Call: call} } -// StreamSenderonStreamCompletedCall wrap *gomock.Call -type StreamSenderonStreamCompletedCall struct { +// MockStreamSenderonStreamCompletedCall wrap *gomock.Call +type MockStreamSenderonStreamCompletedCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSenderonStreamCompletedCall) Return() *StreamSenderonStreamCompletedCall { +func (c *MockStreamSenderonStreamCompletedCall) Return() *MockStreamSenderonStreamCompletedCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamSenderonStreamCompletedCall) Do(f func(protocol.StreamID)) *StreamSenderonStreamCompletedCall { +func (c *MockStreamSenderonStreamCompletedCall) Do(f func(protocol.StreamID)) *MockStreamSenderonStreamCompletedCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSenderonStreamCompletedCall) DoAndReturn(f func(protocol.StreamID)) *StreamSenderonStreamCompletedCall { +func (c *MockStreamSenderonStreamCompletedCall) DoAndReturn(f func(protocol.StreamID)) *MockStreamSenderonStreamCompletedCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -118,31 +119,31 @@ func (m *MockStreamSender) queueControlFrame(arg0 wire.Frame) { } // queueControlFrame indicates an expected call of queueControlFrame. -func (mr *MockStreamSenderMockRecorder) queueControlFrame(arg0 any) *StreamSenderqueueControlFrameCall { +func (mr *MockStreamSenderMockRecorder) queueControlFrame(arg0 any) *MockStreamSenderqueueControlFrameCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "queueControlFrame", reflect.TypeOf((*MockStreamSender)(nil).queueControlFrame), arg0) - return &StreamSenderqueueControlFrameCall{Call: call} + return &MockStreamSenderqueueControlFrameCall{Call: call} } -// StreamSenderqueueControlFrameCall wrap *gomock.Call -type StreamSenderqueueControlFrameCall struct { +// MockStreamSenderqueueControlFrameCall wrap *gomock.Call +type MockStreamSenderqueueControlFrameCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *StreamSenderqueueControlFrameCall) Return() *StreamSenderqueueControlFrameCall { +func (c *MockStreamSenderqueueControlFrameCall) Return() *MockStreamSenderqueueControlFrameCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *StreamSenderqueueControlFrameCall) Do(f func(wire.Frame)) *StreamSenderqueueControlFrameCall { +func (c *MockStreamSenderqueueControlFrameCall) Do(f func(wire.Frame)) *MockStreamSenderqueueControlFrameCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *StreamSenderqueueControlFrameCall) DoAndReturn(f func(wire.Frame)) *StreamSenderqueueControlFrameCall { +func (c *MockStreamSenderqueueControlFrameCall) DoAndReturn(f func(wire.Frame)) *MockStreamSenderqueueControlFrameCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_token_store_test.go b/mock_token_store_test.go index b5f2dbab..b2a3a30c 100644 --- a/mock_token_store_test.go +++ b/mock_token_store_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -package quic -self_package github.com/quic-go/quic-go -self_package github.com/quic-go/quic-go -destination mock_token_store_test.go github.com/quic-go/quic-go TokenStore // + // Package quic is a generated GoMock package. package quic @@ -46,31 +47,31 @@ func (m *MockTokenStore) Pop(arg0 string) *ClientToken { } // Pop indicates an expected call of Pop. -func (mr *MockTokenStoreMockRecorder) Pop(arg0 any) *TokenStorePopCall { +func (mr *MockTokenStoreMockRecorder) Pop(arg0 any) *MockTokenStorePopCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pop", reflect.TypeOf((*MockTokenStore)(nil).Pop), arg0) - return &TokenStorePopCall{Call: call} + return &MockTokenStorePopCall{Call: call} } -// TokenStorePopCall wrap *gomock.Call -type TokenStorePopCall struct { +// MockTokenStorePopCall wrap *gomock.Call +type MockTokenStorePopCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TokenStorePopCall) Return(arg0 *ClientToken) *TokenStorePopCall { +func (c *MockTokenStorePopCall) Return(arg0 *ClientToken) *MockTokenStorePopCall { c.Call = c.Call.Return(arg0) return c } // Do rewrite *gomock.Call.Do -func (c *TokenStorePopCall) Do(f func(string) *ClientToken) *TokenStorePopCall { +func (c *MockTokenStorePopCall) Do(f func(string) *ClientToken) *MockTokenStorePopCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TokenStorePopCall) DoAndReturn(f func(string) *ClientToken) *TokenStorePopCall { +func (c *MockTokenStorePopCall) DoAndReturn(f func(string) *ClientToken) *MockTokenStorePopCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -82,31 +83,31 @@ func (m *MockTokenStore) Put(arg0 string, arg1 *ClientToken) { } // Put indicates an expected call of Put. -func (mr *MockTokenStoreMockRecorder) Put(arg0, arg1 any) *TokenStorePutCall { +func (mr *MockTokenStoreMockRecorder) Put(arg0, arg1 any) *MockTokenStorePutCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockTokenStore)(nil).Put), arg0, arg1) - return &TokenStorePutCall{Call: call} + return &MockTokenStorePutCall{Call: call} } -// TokenStorePutCall wrap *gomock.Call -type TokenStorePutCall struct { +// MockTokenStorePutCall wrap *gomock.Call +type MockTokenStorePutCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *TokenStorePutCall) Return() *TokenStorePutCall { +func (c *MockTokenStorePutCall) Return() *MockTokenStorePutCall { c.Call = c.Call.Return() return c } // Do rewrite *gomock.Call.Do -func (c *TokenStorePutCall) Do(f func(string, *ClientToken)) *TokenStorePutCall { +func (c *MockTokenStorePutCall) Do(f func(string, *ClientToken)) *MockTokenStorePutCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *TokenStorePutCall) DoAndReturn(f func(string, *ClientToken)) *TokenStorePutCall { +func (c *MockTokenStorePutCall) DoAndReturn(f func(string, *ClientToken)) *MockTokenStorePutCall { c.Call = c.Call.DoAndReturn(f) return c } diff --git a/mock_unpacker_test.go b/mock_unpacker_test.go index 43d2ce69..4923fdcf 100644 --- a/mock_unpacker_test.go +++ b/mock_unpacker_test.go @@ -5,6 +5,7 @@ // // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/quic-go/quic-go -destination mock_unpacker_test.go github.com/quic-go/quic-go Unpacker // + // Package quic is a generated GoMock package. package quic @@ -50,31 +51,31 @@ func (m *MockUnpacker) UnpackLongHeader(arg0 *wire.Header, arg1 time.Time, arg2 } // UnpackLongHeader indicates an expected call of UnpackLongHeader. -func (mr *MockUnpackerMockRecorder) UnpackLongHeader(arg0, arg1, arg2, arg3 any) *UnpackerUnpackLongHeaderCall { +func (mr *MockUnpackerMockRecorder) UnpackLongHeader(arg0, arg1, arg2, arg3 any) *MockUnpackerUnpackLongHeaderCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackLongHeader", reflect.TypeOf((*MockUnpacker)(nil).UnpackLongHeader), arg0, arg1, arg2, arg3) - return &UnpackerUnpackLongHeaderCall{Call: call} + return &MockUnpackerUnpackLongHeaderCall{Call: call} } -// UnpackerUnpackLongHeaderCall wrap *gomock.Call -type UnpackerUnpackLongHeaderCall struct { +// MockUnpackerUnpackLongHeaderCall wrap *gomock.Call +type MockUnpackerUnpackLongHeaderCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *UnpackerUnpackLongHeaderCall) Return(arg0 *unpackedPacket, arg1 error) *UnpackerUnpackLongHeaderCall { +func (c *MockUnpackerUnpackLongHeaderCall) Return(arg0 *unpackedPacket, arg1 error) *MockUnpackerUnpackLongHeaderCall { c.Call = c.Call.Return(arg0, arg1) return c } // Do rewrite *gomock.Call.Do -func (c *UnpackerUnpackLongHeaderCall) Do(f func(*wire.Header, time.Time, []byte, protocol.Version) (*unpackedPacket, error)) *UnpackerUnpackLongHeaderCall { +func (c *MockUnpackerUnpackLongHeaderCall) Do(f func(*wire.Header, time.Time, []byte, protocol.Version) (*unpackedPacket, error)) *MockUnpackerUnpackLongHeaderCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *UnpackerUnpackLongHeaderCall) DoAndReturn(f func(*wire.Header, time.Time, []byte, protocol.Version) (*unpackedPacket, error)) *UnpackerUnpackLongHeaderCall { +func (c *MockUnpackerUnpackLongHeaderCall) DoAndReturn(f func(*wire.Header, time.Time, []byte, protocol.Version) (*unpackedPacket, error)) *MockUnpackerUnpackLongHeaderCall { c.Call = c.Call.DoAndReturn(f) return c } @@ -92,31 +93,31 @@ func (m *MockUnpacker) UnpackShortHeader(arg0 time.Time, arg1 []byte) (protocol. } // UnpackShortHeader indicates an expected call of UnpackShortHeader. -func (mr *MockUnpackerMockRecorder) UnpackShortHeader(arg0, arg1 any) *UnpackerUnpackShortHeaderCall { +func (mr *MockUnpackerMockRecorder) UnpackShortHeader(arg0, arg1 any) *MockUnpackerUnpackShortHeaderCall { mr.mock.ctrl.T.Helper() call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpackShortHeader", reflect.TypeOf((*MockUnpacker)(nil).UnpackShortHeader), arg0, arg1) - return &UnpackerUnpackShortHeaderCall{Call: call} + return &MockUnpackerUnpackShortHeaderCall{Call: call} } -// UnpackerUnpackShortHeaderCall wrap *gomock.Call -type UnpackerUnpackShortHeaderCall struct { +// MockUnpackerUnpackShortHeaderCall wrap *gomock.Call +type MockUnpackerUnpackShortHeaderCall struct { *gomock.Call } // Return rewrite *gomock.Call.Return -func (c *UnpackerUnpackShortHeaderCall) Return(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen, arg2 protocol.KeyPhaseBit, arg3 []byte, arg4 error) *UnpackerUnpackShortHeaderCall { +func (c *MockUnpackerUnpackShortHeaderCall) Return(arg0 protocol.PacketNumber, arg1 protocol.PacketNumberLen, arg2 protocol.KeyPhaseBit, arg3 []byte, arg4 error) *MockUnpackerUnpackShortHeaderCall { c.Call = c.Call.Return(arg0, arg1, arg2, arg3, arg4) return c } // Do rewrite *gomock.Call.Do -func (c *UnpackerUnpackShortHeaderCall) Do(f func(time.Time, []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error)) *UnpackerUnpackShortHeaderCall { +func (c *MockUnpackerUnpackShortHeaderCall) Do(f func(time.Time, []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error)) *MockUnpackerUnpackShortHeaderCall { c.Call = c.Call.Do(f) return c } // DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *UnpackerUnpackShortHeaderCall) DoAndReturn(f func(time.Time, []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error)) *UnpackerUnpackShortHeaderCall { +func (c *MockUnpackerUnpackShortHeaderCall) DoAndReturn(f func(time.Time, []byte) (protocol.PacketNumber, protocol.PacketNumberLen, protocol.KeyPhaseBit, []byte, error)) *MockUnpackerUnpackShortHeaderCall { c.Call = c.Call.DoAndReturn(f) return c }