github.com/apernet/quic-go@v0.43.1-0.20240515053213-5e9e635fd9f0/mock_stream_manager_test.go (about)

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/apernet/quic-go (interfaces: StreamManager)
     3  //
     4  // Generated by this command:
     5  //
     6  //	mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/apernet/quic-go -destination mock_stream_manager_test.go github.com/apernet/quic-go StreamManager
     7  //
     8  
     9  // Package quic is a generated GoMock package.
    10  package quic
    11  
    12  import (
    13  	context "context"
    14  	reflect "reflect"
    15  
    16  	protocol "github.com/apernet/quic-go/internal/protocol"
    17  	wire "github.com/apernet/quic-go/internal/wire"
    18  	gomock "go.uber.org/mock/gomock"
    19  )
    20  
    21  // MockStreamManager is a mock of StreamManager interface.
    22  type MockStreamManager struct {
    23  	ctrl     *gomock.Controller
    24  	recorder *MockStreamManagerMockRecorder
    25  }
    26  
    27  // MockStreamManagerMockRecorder is the mock recorder for MockStreamManager.
    28  type MockStreamManagerMockRecorder struct {
    29  	mock *MockStreamManager
    30  }
    31  
    32  // NewMockStreamManager creates a new mock instance.
    33  func NewMockStreamManager(ctrl *gomock.Controller) *MockStreamManager {
    34  	mock := &MockStreamManager{ctrl: ctrl}
    35  	mock.recorder = &MockStreamManagerMockRecorder{mock}
    36  	return mock
    37  }
    38  
    39  // EXPECT returns an object that allows the caller to indicate expected use.
    40  func (m *MockStreamManager) EXPECT() *MockStreamManagerMockRecorder {
    41  	return m.recorder
    42  }
    43  
    44  // AcceptStream mocks base method.
    45  func (m *MockStreamManager) AcceptStream(arg0 context.Context) (Stream, error) {
    46  	m.ctrl.T.Helper()
    47  	ret := m.ctrl.Call(m, "AcceptStream", arg0)
    48  	ret0, _ := ret[0].(Stream)
    49  	ret1, _ := ret[1].(error)
    50  	return ret0, ret1
    51  }
    52  
    53  // AcceptStream indicates an expected call of AcceptStream.
    54  func (mr *MockStreamManagerMockRecorder) AcceptStream(arg0 any) *MockStreamManagerAcceptStreamCall {
    55  	mr.mock.ctrl.T.Helper()
    56  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptStream), arg0)
    57  	return &MockStreamManagerAcceptStreamCall{Call: call}
    58  }
    59  
    60  // MockStreamManagerAcceptStreamCall wrap *gomock.Call
    61  type MockStreamManagerAcceptStreamCall struct {
    62  	*gomock.Call
    63  }
    64  
    65  // Return rewrite *gomock.Call.Return
    66  func (c *MockStreamManagerAcceptStreamCall) Return(arg0 Stream, arg1 error) *MockStreamManagerAcceptStreamCall {
    67  	c.Call = c.Call.Return(arg0, arg1)
    68  	return c
    69  }
    70  
    71  // Do rewrite *gomock.Call.Do
    72  func (c *MockStreamManagerAcceptStreamCall) Do(f func(context.Context) (Stream, error)) *MockStreamManagerAcceptStreamCall {
    73  	c.Call = c.Call.Do(f)
    74  	return c
    75  }
    76  
    77  // DoAndReturn rewrite *gomock.Call.DoAndReturn
    78  func (c *MockStreamManagerAcceptStreamCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockStreamManagerAcceptStreamCall {
    79  	c.Call = c.Call.DoAndReturn(f)
    80  	return c
    81  }
    82  
    83  // AcceptUniStream mocks base method.
    84  func (m *MockStreamManager) AcceptUniStream(arg0 context.Context) (ReceiveStream, error) {
    85  	m.ctrl.T.Helper()
    86  	ret := m.ctrl.Call(m, "AcceptUniStream", arg0)
    87  	ret0, _ := ret[0].(ReceiveStream)
    88  	ret1, _ := ret[1].(error)
    89  	return ret0, ret1
    90  }
    91  
    92  // AcceptUniStream indicates an expected call of AcceptUniStream.
    93  func (mr *MockStreamManagerMockRecorder) AcceptUniStream(arg0 any) *MockStreamManagerAcceptUniStreamCall {
    94  	mr.mock.ctrl.T.Helper()
    95  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptUniStream), arg0)
    96  	return &MockStreamManagerAcceptUniStreamCall{Call: call}
    97  }
    98  
    99  // MockStreamManagerAcceptUniStreamCall wrap *gomock.Call
   100  type MockStreamManagerAcceptUniStreamCall struct {
   101  	*gomock.Call
   102  }
   103  
   104  // Return rewrite *gomock.Call.Return
   105  func (c *MockStreamManagerAcceptUniStreamCall) Return(arg0 ReceiveStream, arg1 error) *MockStreamManagerAcceptUniStreamCall {
   106  	c.Call = c.Call.Return(arg0, arg1)
   107  	return c
   108  }
   109  
   110  // Do rewrite *gomock.Call.Do
   111  func (c *MockStreamManagerAcceptUniStreamCall) Do(f func(context.Context) (ReceiveStream, error)) *MockStreamManagerAcceptUniStreamCall {
   112  	c.Call = c.Call.Do(f)
   113  	return c
   114  }
   115  
   116  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   117  func (c *MockStreamManagerAcceptUniStreamCall) DoAndReturn(f func(context.Context) (ReceiveStream, error)) *MockStreamManagerAcceptUniStreamCall {
   118  	c.Call = c.Call.DoAndReturn(f)
   119  	return c
   120  }
   121  
   122  // CloseWithError mocks base method.
   123  func (m *MockStreamManager) CloseWithError(arg0 error) {
   124  	m.ctrl.T.Helper()
   125  	m.ctrl.Call(m, "CloseWithError", arg0)
   126  }
   127  
   128  // CloseWithError indicates an expected call of CloseWithError.
   129  func (mr *MockStreamManagerMockRecorder) CloseWithError(arg0 any) *MockStreamManagerCloseWithErrorCall {
   130  	mr.mock.ctrl.T.Helper()
   131  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockStreamManager)(nil).CloseWithError), arg0)
   132  	return &MockStreamManagerCloseWithErrorCall{Call: call}
   133  }
   134  
   135  // MockStreamManagerCloseWithErrorCall wrap *gomock.Call
   136  type MockStreamManagerCloseWithErrorCall struct {
   137  	*gomock.Call
   138  }
   139  
   140  // Return rewrite *gomock.Call.Return
   141  func (c *MockStreamManagerCloseWithErrorCall) Return() *MockStreamManagerCloseWithErrorCall {
   142  	c.Call = c.Call.Return()
   143  	return c
   144  }
   145  
   146  // Do rewrite *gomock.Call.Do
   147  func (c *MockStreamManagerCloseWithErrorCall) Do(f func(error)) *MockStreamManagerCloseWithErrorCall {
   148  	c.Call = c.Call.Do(f)
   149  	return c
   150  }
   151  
   152  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   153  func (c *MockStreamManagerCloseWithErrorCall) DoAndReturn(f func(error)) *MockStreamManagerCloseWithErrorCall {
   154  	c.Call = c.Call.DoAndReturn(f)
   155  	return c
   156  }
   157  
   158  // DeleteStream mocks base method.
   159  func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error {
   160  	m.ctrl.T.Helper()
   161  	ret := m.ctrl.Call(m, "DeleteStream", arg0)
   162  	ret0, _ := ret[0].(error)
   163  	return ret0
   164  }
   165  
   166  // DeleteStream indicates an expected call of DeleteStream.
   167  func (mr *MockStreamManagerMockRecorder) DeleteStream(arg0 any) *MockStreamManagerDeleteStreamCall {
   168  	mr.mock.ctrl.T.Helper()
   169  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStream", reflect.TypeOf((*MockStreamManager)(nil).DeleteStream), arg0)
   170  	return &MockStreamManagerDeleteStreamCall{Call: call}
   171  }
   172  
   173  // MockStreamManagerDeleteStreamCall wrap *gomock.Call
   174  type MockStreamManagerDeleteStreamCall struct {
   175  	*gomock.Call
   176  }
   177  
   178  // Return rewrite *gomock.Call.Return
   179  func (c *MockStreamManagerDeleteStreamCall) Return(arg0 error) *MockStreamManagerDeleteStreamCall {
   180  	c.Call = c.Call.Return(arg0)
   181  	return c
   182  }
   183  
   184  // Do rewrite *gomock.Call.Do
   185  func (c *MockStreamManagerDeleteStreamCall) Do(f func(protocol.StreamID) error) *MockStreamManagerDeleteStreamCall {
   186  	c.Call = c.Call.Do(f)
   187  	return c
   188  }
   189  
   190  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   191  func (c *MockStreamManagerDeleteStreamCall) DoAndReturn(f func(protocol.StreamID) error) *MockStreamManagerDeleteStreamCall {
   192  	c.Call = c.Call.DoAndReturn(f)
   193  	return c
   194  }
   195  
   196  // GetOrOpenReceiveStream mocks base method.
   197  func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) {
   198  	m.ctrl.T.Helper()
   199  	ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0)
   200  	ret0, _ := ret[0].(receiveStreamI)
   201  	ret1, _ := ret[1].(error)
   202  	return ret0, ret1
   203  }
   204  
   205  // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream.
   206  func (mr *MockStreamManagerMockRecorder) GetOrOpenReceiveStream(arg0 any) *MockStreamManagerGetOrOpenReceiveStreamCall {
   207  	mr.mock.ctrl.T.Helper()
   208  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenReceiveStream), arg0)
   209  	return &MockStreamManagerGetOrOpenReceiveStreamCall{Call: call}
   210  }
   211  
   212  // MockStreamManagerGetOrOpenReceiveStreamCall wrap *gomock.Call
   213  type MockStreamManagerGetOrOpenReceiveStreamCall struct {
   214  	*gomock.Call
   215  }
   216  
   217  // Return rewrite *gomock.Call.Return
   218  func (c *MockStreamManagerGetOrOpenReceiveStreamCall) Return(arg0 receiveStreamI, arg1 error) *MockStreamManagerGetOrOpenReceiveStreamCall {
   219  	c.Call = c.Call.Return(arg0, arg1)
   220  	return c
   221  }
   222  
   223  // Do rewrite *gomock.Call.Do
   224  func (c *MockStreamManagerGetOrOpenReceiveStreamCall) Do(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamManagerGetOrOpenReceiveStreamCall {
   225  	c.Call = c.Call.Do(f)
   226  	return c
   227  }
   228  
   229  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   230  func (c *MockStreamManagerGetOrOpenReceiveStreamCall) DoAndReturn(f func(protocol.StreamID) (receiveStreamI, error)) *MockStreamManagerGetOrOpenReceiveStreamCall {
   231  	c.Call = c.Call.DoAndReturn(f)
   232  	return c
   233  }
   234  
   235  // GetOrOpenSendStream mocks base method.
   236  func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) {
   237  	m.ctrl.T.Helper()
   238  	ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0)
   239  	ret0, _ := ret[0].(sendStreamI)
   240  	ret1, _ := ret[1].(error)
   241  	return ret0, ret1
   242  }
   243  
   244  // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream.
   245  func (mr *MockStreamManagerMockRecorder) GetOrOpenSendStream(arg0 any) *MockStreamManagerGetOrOpenSendStreamCall {
   246  	mr.mock.ctrl.T.Helper()
   247  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenSendStream), arg0)
   248  	return &MockStreamManagerGetOrOpenSendStreamCall{Call: call}
   249  }
   250  
   251  // MockStreamManagerGetOrOpenSendStreamCall wrap *gomock.Call
   252  type MockStreamManagerGetOrOpenSendStreamCall struct {
   253  	*gomock.Call
   254  }
   255  
   256  // Return rewrite *gomock.Call.Return
   257  func (c *MockStreamManagerGetOrOpenSendStreamCall) Return(arg0 sendStreamI, arg1 error) *MockStreamManagerGetOrOpenSendStreamCall {
   258  	c.Call = c.Call.Return(arg0, arg1)
   259  	return c
   260  }
   261  
   262  // Do rewrite *gomock.Call.Do
   263  func (c *MockStreamManagerGetOrOpenSendStreamCall) Do(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamManagerGetOrOpenSendStreamCall {
   264  	c.Call = c.Call.Do(f)
   265  	return c
   266  }
   267  
   268  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   269  func (c *MockStreamManagerGetOrOpenSendStreamCall) DoAndReturn(f func(protocol.StreamID) (sendStreamI, error)) *MockStreamManagerGetOrOpenSendStreamCall {
   270  	c.Call = c.Call.DoAndReturn(f)
   271  	return c
   272  }
   273  
   274  // HandleMaxStreamsFrame mocks base method.
   275  func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) {
   276  	m.ctrl.T.Helper()
   277  	m.ctrl.Call(m, "HandleMaxStreamsFrame", arg0)
   278  }
   279  
   280  // HandleMaxStreamsFrame indicates an expected call of HandleMaxStreamsFrame.
   281  func (mr *MockStreamManagerMockRecorder) HandleMaxStreamsFrame(arg0 any) *MockStreamManagerHandleMaxStreamsFrameCall {
   282  	mr.mock.ctrl.T.Helper()
   283  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMaxStreamsFrame", reflect.TypeOf((*MockStreamManager)(nil).HandleMaxStreamsFrame), arg0)
   284  	return &MockStreamManagerHandleMaxStreamsFrameCall{Call: call}
   285  }
   286  
   287  // MockStreamManagerHandleMaxStreamsFrameCall wrap *gomock.Call
   288  type MockStreamManagerHandleMaxStreamsFrameCall struct {
   289  	*gomock.Call
   290  }
   291  
   292  // Return rewrite *gomock.Call.Return
   293  func (c *MockStreamManagerHandleMaxStreamsFrameCall) Return() *MockStreamManagerHandleMaxStreamsFrameCall {
   294  	c.Call = c.Call.Return()
   295  	return c
   296  }
   297  
   298  // Do rewrite *gomock.Call.Do
   299  func (c *MockStreamManagerHandleMaxStreamsFrameCall) Do(f func(*wire.MaxStreamsFrame)) *MockStreamManagerHandleMaxStreamsFrameCall {
   300  	c.Call = c.Call.Do(f)
   301  	return c
   302  }
   303  
   304  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   305  func (c *MockStreamManagerHandleMaxStreamsFrameCall) DoAndReturn(f func(*wire.MaxStreamsFrame)) *MockStreamManagerHandleMaxStreamsFrameCall {
   306  	c.Call = c.Call.DoAndReturn(f)
   307  	return c
   308  }
   309  
   310  // OpenStream mocks base method.
   311  func (m *MockStreamManager) OpenStream() (Stream, error) {
   312  	m.ctrl.T.Helper()
   313  	ret := m.ctrl.Call(m, "OpenStream")
   314  	ret0, _ := ret[0].(Stream)
   315  	ret1, _ := ret[1].(error)
   316  	return ret0, ret1
   317  }
   318  
   319  // OpenStream indicates an expected call of OpenStream.
   320  func (mr *MockStreamManagerMockRecorder) OpenStream() *MockStreamManagerOpenStreamCall {
   321  	mr.mock.ctrl.T.Helper()
   322  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockStreamManager)(nil).OpenStream))
   323  	return &MockStreamManagerOpenStreamCall{Call: call}
   324  }
   325  
   326  // MockStreamManagerOpenStreamCall wrap *gomock.Call
   327  type MockStreamManagerOpenStreamCall struct {
   328  	*gomock.Call
   329  }
   330  
   331  // Return rewrite *gomock.Call.Return
   332  func (c *MockStreamManagerOpenStreamCall) Return(arg0 Stream, arg1 error) *MockStreamManagerOpenStreamCall {
   333  	c.Call = c.Call.Return(arg0, arg1)
   334  	return c
   335  }
   336  
   337  // Do rewrite *gomock.Call.Do
   338  func (c *MockStreamManagerOpenStreamCall) Do(f func() (Stream, error)) *MockStreamManagerOpenStreamCall {
   339  	c.Call = c.Call.Do(f)
   340  	return c
   341  }
   342  
   343  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   344  func (c *MockStreamManagerOpenStreamCall) DoAndReturn(f func() (Stream, error)) *MockStreamManagerOpenStreamCall {
   345  	c.Call = c.Call.DoAndReturn(f)
   346  	return c
   347  }
   348  
   349  // OpenStreamSync mocks base method.
   350  func (m *MockStreamManager) OpenStreamSync(arg0 context.Context) (Stream, error) {
   351  	m.ctrl.T.Helper()
   352  	ret := m.ctrl.Call(m, "OpenStreamSync", arg0)
   353  	ret0, _ := ret[0].(Stream)
   354  	ret1, _ := ret[1].(error)
   355  	return ret0, ret1
   356  }
   357  
   358  // OpenStreamSync indicates an expected call of OpenStreamSync.
   359  func (mr *MockStreamManagerMockRecorder) OpenStreamSync(arg0 any) *MockStreamManagerOpenStreamSyncCall {
   360  	mr.mock.ctrl.T.Helper()
   361  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenStreamSync), arg0)
   362  	return &MockStreamManagerOpenStreamSyncCall{Call: call}
   363  }
   364  
   365  // MockStreamManagerOpenStreamSyncCall wrap *gomock.Call
   366  type MockStreamManagerOpenStreamSyncCall struct {
   367  	*gomock.Call
   368  }
   369  
   370  // Return rewrite *gomock.Call.Return
   371  func (c *MockStreamManagerOpenStreamSyncCall) Return(arg0 Stream, arg1 error) *MockStreamManagerOpenStreamSyncCall {
   372  	c.Call = c.Call.Return(arg0, arg1)
   373  	return c
   374  }
   375  
   376  // Do rewrite *gomock.Call.Do
   377  func (c *MockStreamManagerOpenStreamSyncCall) Do(f func(context.Context) (Stream, error)) *MockStreamManagerOpenStreamSyncCall {
   378  	c.Call = c.Call.Do(f)
   379  	return c
   380  }
   381  
   382  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   383  func (c *MockStreamManagerOpenStreamSyncCall) DoAndReturn(f func(context.Context) (Stream, error)) *MockStreamManagerOpenStreamSyncCall {
   384  	c.Call = c.Call.DoAndReturn(f)
   385  	return c
   386  }
   387  
   388  // OpenUniStream mocks base method.
   389  func (m *MockStreamManager) OpenUniStream() (SendStream, error) {
   390  	m.ctrl.T.Helper()
   391  	ret := m.ctrl.Call(m, "OpenUniStream")
   392  	ret0, _ := ret[0].(SendStream)
   393  	ret1, _ := ret[1].(error)
   394  	return ret0, ret1
   395  }
   396  
   397  // OpenUniStream indicates an expected call of OpenUniStream.
   398  func (mr *MockStreamManagerMockRecorder) OpenUniStream() *MockStreamManagerOpenUniStreamCall {
   399  	mr.mock.ctrl.T.Helper()
   400  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStream))
   401  	return &MockStreamManagerOpenUniStreamCall{Call: call}
   402  }
   403  
   404  // MockStreamManagerOpenUniStreamCall wrap *gomock.Call
   405  type MockStreamManagerOpenUniStreamCall struct {
   406  	*gomock.Call
   407  }
   408  
   409  // Return rewrite *gomock.Call.Return
   410  func (c *MockStreamManagerOpenUniStreamCall) Return(arg0 SendStream, arg1 error) *MockStreamManagerOpenUniStreamCall {
   411  	c.Call = c.Call.Return(arg0, arg1)
   412  	return c
   413  }
   414  
   415  // Do rewrite *gomock.Call.Do
   416  func (c *MockStreamManagerOpenUniStreamCall) Do(f func() (SendStream, error)) *MockStreamManagerOpenUniStreamCall {
   417  	c.Call = c.Call.Do(f)
   418  	return c
   419  }
   420  
   421  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   422  func (c *MockStreamManagerOpenUniStreamCall) DoAndReturn(f func() (SendStream, error)) *MockStreamManagerOpenUniStreamCall {
   423  	c.Call = c.Call.DoAndReturn(f)
   424  	return c
   425  }
   426  
   427  // OpenUniStreamSync mocks base method.
   428  func (m *MockStreamManager) OpenUniStreamSync(arg0 context.Context) (SendStream, error) {
   429  	m.ctrl.T.Helper()
   430  	ret := m.ctrl.Call(m, "OpenUniStreamSync", arg0)
   431  	ret0, _ := ret[0].(SendStream)
   432  	ret1, _ := ret[1].(error)
   433  	return ret0, ret1
   434  }
   435  
   436  // OpenUniStreamSync indicates an expected call of OpenUniStreamSync.
   437  func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync(arg0 any) *MockStreamManagerOpenUniStreamSyncCall {
   438  	mr.mock.ctrl.T.Helper()
   439  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStreamSync), arg0)
   440  	return &MockStreamManagerOpenUniStreamSyncCall{Call: call}
   441  }
   442  
   443  // MockStreamManagerOpenUniStreamSyncCall wrap *gomock.Call
   444  type MockStreamManagerOpenUniStreamSyncCall struct {
   445  	*gomock.Call
   446  }
   447  
   448  // Return rewrite *gomock.Call.Return
   449  func (c *MockStreamManagerOpenUniStreamSyncCall) Return(arg0 SendStream, arg1 error) *MockStreamManagerOpenUniStreamSyncCall {
   450  	c.Call = c.Call.Return(arg0, arg1)
   451  	return c
   452  }
   453  
   454  // Do rewrite *gomock.Call.Do
   455  func (c *MockStreamManagerOpenUniStreamSyncCall) Do(f func(context.Context) (SendStream, error)) *MockStreamManagerOpenUniStreamSyncCall {
   456  	c.Call = c.Call.Do(f)
   457  	return c
   458  }
   459  
   460  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   461  func (c *MockStreamManagerOpenUniStreamSyncCall) DoAndReturn(f func(context.Context) (SendStream, error)) *MockStreamManagerOpenUniStreamSyncCall {
   462  	c.Call = c.Call.DoAndReturn(f)
   463  	return c
   464  }
   465  
   466  // ResetFor0RTT mocks base method.
   467  func (m *MockStreamManager) ResetFor0RTT() {
   468  	m.ctrl.T.Helper()
   469  	m.ctrl.Call(m, "ResetFor0RTT")
   470  }
   471  
   472  // ResetFor0RTT indicates an expected call of ResetFor0RTT.
   473  func (mr *MockStreamManagerMockRecorder) ResetFor0RTT() *MockStreamManagerResetFor0RTTCall {
   474  	mr.mock.ctrl.T.Helper()
   475  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFor0RTT", reflect.TypeOf((*MockStreamManager)(nil).ResetFor0RTT))
   476  	return &MockStreamManagerResetFor0RTTCall{Call: call}
   477  }
   478  
   479  // MockStreamManagerResetFor0RTTCall wrap *gomock.Call
   480  type MockStreamManagerResetFor0RTTCall struct {
   481  	*gomock.Call
   482  }
   483  
   484  // Return rewrite *gomock.Call.Return
   485  func (c *MockStreamManagerResetFor0RTTCall) Return() *MockStreamManagerResetFor0RTTCall {
   486  	c.Call = c.Call.Return()
   487  	return c
   488  }
   489  
   490  // Do rewrite *gomock.Call.Do
   491  func (c *MockStreamManagerResetFor0RTTCall) Do(f func()) *MockStreamManagerResetFor0RTTCall {
   492  	c.Call = c.Call.Do(f)
   493  	return c
   494  }
   495  
   496  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   497  func (c *MockStreamManagerResetFor0RTTCall) DoAndReturn(f func()) *MockStreamManagerResetFor0RTTCall {
   498  	c.Call = c.Call.DoAndReturn(f)
   499  	return c
   500  }
   501  
   502  // UpdateLimits mocks base method.
   503  func (m *MockStreamManager) UpdateLimits(arg0 *wire.TransportParameters) {
   504  	m.ctrl.T.Helper()
   505  	m.ctrl.Call(m, "UpdateLimits", arg0)
   506  }
   507  
   508  // UpdateLimits indicates an expected call of UpdateLimits.
   509  func (mr *MockStreamManagerMockRecorder) UpdateLimits(arg0 any) *MockStreamManagerUpdateLimitsCall {
   510  	mr.mock.ctrl.T.Helper()
   511  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLimits", reflect.TypeOf((*MockStreamManager)(nil).UpdateLimits), arg0)
   512  	return &MockStreamManagerUpdateLimitsCall{Call: call}
   513  }
   514  
   515  // MockStreamManagerUpdateLimitsCall wrap *gomock.Call
   516  type MockStreamManagerUpdateLimitsCall struct {
   517  	*gomock.Call
   518  }
   519  
   520  // Return rewrite *gomock.Call.Return
   521  func (c *MockStreamManagerUpdateLimitsCall) Return() *MockStreamManagerUpdateLimitsCall {
   522  	c.Call = c.Call.Return()
   523  	return c
   524  }
   525  
   526  // Do rewrite *gomock.Call.Do
   527  func (c *MockStreamManagerUpdateLimitsCall) Do(f func(*wire.TransportParameters)) *MockStreamManagerUpdateLimitsCall {
   528  	c.Call = c.Call.Do(f)
   529  	return c
   530  }
   531  
   532  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   533  func (c *MockStreamManagerUpdateLimitsCall) DoAndReturn(f func(*wire.TransportParameters)) *MockStreamManagerUpdateLimitsCall {
   534  	c.Call = c.Call.DoAndReturn(f)
   535  	return c
   536  }
   537  
   538  // UseResetMaps mocks base method.
   539  func (m *MockStreamManager) UseResetMaps() {
   540  	m.ctrl.T.Helper()
   541  	m.ctrl.Call(m, "UseResetMaps")
   542  }
   543  
   544  // UseResetMaps indicates an expected call of UseResetMaps.
   545  func (mr *MockStreamManagerMockRecorder) UseResetMaps() *MockStreamManagerUseResetMapsCall {
   546  	mr.mock.ctrl.T.Helper()
   547  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseResetMaps", reflect.TypeOf((*MockStreamManager)(nil).UseResetMaps))
   548  	return &MockStreamManagerUseResetMapsCall{Call: call}
   549  }
   550  
   551  // MockStreamManagerUseResetMapsCall wrap *gomock.Call
   552  type MockStreamManagerUseResetMapsCall struct {
   553  	*gomock.Call
   554  }
   555  
   556  // Return rewrite *gomock.Call.Return
   557  func (c *MockStreamManagerUseResetMapsCall) Return() *MockStreamManagerUseResetMapsCall {
   558  	c.Call = c.Call.Return()
   559  	return c
   560  }
   561  
   562  // Do rewrite *gomock.Call.Do
   563  func (c *MockStreamManagerUseResetMapsCall) Do(f func()) *MockStreamManagerUseResetMapsCall {
   564  	c.Call = c.Call.Do(f)
   565  	return c
   566  }
   567  
   568  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   569  func (c *MockStreamManagerUseResetMapsCall) DoAndReturn(f func()) *MockStreamManagerUseResetMapsCall {
   570  	c.Call = c.Call.DoAndReturn(f)
   571  	return c
   572  }