github.com/quic-go/quic-go@v0.44.0/mock_stream_internal_test.go (about)

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/quic-go/quic-go (interfaces: StreamI)
     3  //
     4  // Generated by this command:
     5  //
     6  //	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
     7  //
     8  
     9  // Package quic is a generated GoMock package.
    10  package quic
    11  
    12  import (
    13  	context "context"
    14  	reflect "reflect"
    15  	time "time"
    16  
    17  	ackhandler "github.com/quic-go/quic-go/internal/ackhandler"
    18  	protocol "github.com/quic-go/quic-go/internal/protocol"
    19  	qerr "github.com/quic-go/quic-go/internal/qerr"
    20  	wire "github.com/quic-go/quic-go/internal/wire"
    21  	gomock "go.uber.org/mock/gomock"
    22  )
    23  
    24  // MockStreamI is a mock of StreamI interface.
    25  type MockStreamI struct {
    26  	ctrl     *gomock.Controller
    27  	recorder *MockStreamIMockRecorder
    28  }
    29  
    30  // MockStreamIMockRecorder is the mock recorder for MockStreamI.
    31  type MockStreamIMockRecorder struct {
    32  	mock *MockStreamI
    33  }
    34  
    35  // NewMockStreamI creates a new mock instance.
    36  func NewMockStreamI(ctrl *gomock.Controller) *MockStreamI {
    37  	mock := &MockStreamI{ctrl: ctrl}
    38  	mock.recorder = &MockStreamIMockRecorder{mock}
    39  	return mock
    40  }
    41  
    42  // EXPECT returns an object that allows the caller to indicate expected use.
    43  func (m *MockStreamI) EXPECT() *MockStreamIMockRecorder {
    44  	return m.recorder
    45  }
    46  
    47  // CancelRead mocks base method.
    48  func (m *MockStreamI) CancelRead(arg0 qerr.StreamErrorCode) {
    49  	m.ctrl.T.Helper()
    50  	m.ctrl.Call(m, "CancelRead", arg0)
    51  }
    52  
    53  // CancelRead indicates an expected call of CancelRead.
    54  func (mr *MockStreamIMockRecorder) CancelRead(arg0 any) *MockStreamICancelReadCall {
    55  	mr.mock.ctrl.T.Helper()
    56  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockStreamI)(nil).CancelRead), arg0)
    57  	return &MockStreamICancelReadCall{Call: call}
    58  }
    59  
    60  // MockStreamICancelReadCall wrap *gomock.Call
    61  type MockStreamICancelReadCall struct {
    62  	*gomock.Call
    63  }
    64  
    65  // Return rewrite *gomock.Call.Return
    66  func (c *MockStreamICancelReadCall) Return() *MockStreamICancelReadCall {
    67  	c.Call = c.Call.Return()
    68  	return c
    69  }
    70  
    71  // Do rewrite *gomock.Call.Do
    72  func (c *MockStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
    73  	c.Call = c.Call.Do(f)
    74  	return c
    75  }
    76  
    77  // DoAndReturn rewrite *gomock.Call.DoAndReturn
    78  func (c *MockStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelReadCall {
    79  	c.Call = c.Call.DoAndReturn(f)
    80  	return c
    81  }
    82  
    83  // CancelWrite mocks base method.
    84  func (m *MockStreamI) CancelWrite(arg0 qerr.StreamErrorCode) {
    85  	m.ctrl.T.Helper()
    86  	m.ctrl.Call(m, "CancelWrite", arg0)
    87  }
    88  
    89  // CancelWrite indicates an expected call of CancelWrite.
    90  func (mr *MockStreamIMockRecorder) CancelWrite(arg0 any) *MockStreamICancelWriteCall {
    91  	mr.mock.ctrl.T.Helper()
    92  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelWrite", reflect.TypeOf((*MockStreamI)(nil).CancelWrite), arg0)
    93  	return &MockStreamICancelWriteCall{Call: call}
    94  }
    95  
    96  // MockStreamICancelWriteCall wrap *gomock.Call
    97  type MockStreamICancelWriteCall struct {
    98  	*gomock.Call
    99  }
   100  
   101  // Return rewrite *gomock.Call.Return
   102  func (c *MockStreamICancelWriteCall) Return() *MockStreamICancelWriteCall {
   103  	c.Call = c.Call.Return()
   104  	return c
   105  }
   106  
   107  // Do rewrite *gomock.Call.Do
   108  func (c *MockStreamICancelWriteCall) Do(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
   109  	c.Call = c.Call.Do(f)
   110  	return c
   111  }
   112  
   113  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   114  func (c *MockStreamICancelWriteCall) DoAndReturn(f func(qerr.StreamErrorCode)) *MockStreamICancelWriteCall {
   115  	c.Call = c.Call.DoAndReturn(f)
   116  	return c
   117  }
   118  
   119  // Close mocks base method.
   120  func (m *MockStreamI) Close() error {
   121  	m.ctrl.T.Helper()
   122  	ret := m.ctrl.Call(m, "Close")
   123  	ret0, _ := ret[0].(error)
   124  	return ret0
   125  }
   126  
   127  // Close indicates an expected call of Close.
   128  func (mr *MockStreamIMockRecorder) Close() *MockStreamICloseCall {
   129  	mr.mock.ctrl.T.Helper()
   130  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStreamI)(nil).Close))
   131  	return &MockStreamICloseCall{Call: call}
   132  }
   133  
   134  // MockStreamICloseCall wrap *gomock.Call
   135  type MockStreamICloseCall struct {
   136  	*gomock.Call
   137  }
   138  
   139  // Return rewrite *gomock.Call.Return
   140  func (c *MockStreamICloseCall) Return(arg0 error) *MockStreamICloseCall {
   141  	c.Call = c.Call.Return(arg0)
   142  	return c
   143  }
   144  
   145  // Do rewrite *gomock.Call.Do
   146  func (c *MockStreamICloseCall) Do(f func() error) *MockStreamICloseCall {
   147  	c.Call = c.Call.Do(f)
   148  	return c
   149  }
   150  
   151  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   152  func (c *MockStreamICloseCall) DoAndReturn(f func() error) *MockStreamICloseCall {
   153  	c.Call = c.Call.DoAndReturn(f)
   154  	return c
   155  }
   156  
   157  // Context mocks base method.
   158  func (m *MockStreamI) Context() context.Context {
   159  	m.ctrl.T.Helper()
   160  	ret := m.ctrl.Call(m, "Context")
   161  	ret0, _ := ret[0].(context.Context)
   162  	return ret0
   163  }
   164  
   165  // Context indicates an expected call of Context.
   166  func (mr *MockStreamIMockRecorder) Context() *MockStreamIContextCall {
   167  	mr.mock.ctrl.T.Helper()
   168  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockStreamI)(nil).Context))
   169  	return &MockStreamIContextCall{Call: call}
   170  }
   171  
   172  // MockStreamIContextCall wrap *gomock.Call
   173  type MockStreamIContextCall struct {
   174  	*gomock.Call
   175  }
   176  
   177  // Return rewrite *gomock.Call.Return
   178  func (c *MockStreamIContextCall) Return(arg0 context.Context) *MockStreamIContextCall {
   179  	c.Call = c.Call.Return(arg0)
   180  	return c
   181  }
   182  
   183  // Do rewrite *gomock.Call.Do
   184  func (c *MockStreamIContextCall) Do(f func() context.Context) *MockStreamIContextCall {
   185  	c.Call = c.Call.Do(f)
   186  	return c
   187  }
   188  
   189  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   190  func (c *MockStreamIContextCall) DoAndReturn(f func() context.Context) *MockStreamIContextCall {
   191  	c.Call = c.Call.DoAndReturn(f)
   192  	return c
   193  }
   194  
   195  // Read mocks base method.
   196  func (m *MockStreamI) Read(arg0 []byte) (int, error) {
   197  	m.ctrl.T.Helper()
   198  	ret := m.ctrl.Call(m, "Read", arg0)
   199  	ret0, _ := ret[0].(int)
   200  	ret1, _ := ret[1].(error)
   201  	return ret0, ret1
   202  }
   203  
   204  // Read indicates an expected call of Read.
   205  func (mr *MockStreamIMockRecorder) Read(arg0 any) *MockStreamIReadCall {
   206  	mr.mock.ctrl.T.Helper()
   207  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockStreamI)(nil).Read), arg0)
   208  	return &MockStreamIReadCall{Call: call}
   209  }
   210  
   211  // MockStreamIReadCall wrap *gomock.Call
   212  type MockStreamIReadCall struct {
   213  	*gomock.Call
   214  }
   215  
   216  // Return rewrite *gomock.Call.Return
   217  func (c *MockStreamIReadCall) Return(arg0 int, arg1 error) *MockStreamIReadCall {
   218  	c.Call = c.Call.Return(arg0, arg1)
   219  	return c
   220  }
   221  
   222  // Do rewrite *gomock.Call.Do
   223  func (c *MockStreamIReadCall) Do(f func([]byte) (int, error)) *MockStreamIReadCall {
   224  	c.Call = c.Call.Do(f)
   225  	return c
   226  }
   227  
   228  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   229  func (c *MockStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIReadCall {
   230  	c.Call = c.Call.DoAndReturn(f)
   231  	return c
   232  }
   233  
   234  // SetDeadline mocks base method.
   235  func (m *MockStreamI) SetDeadline(arg0 time.Time) error {
   236  	m.ctrl.T.Helper()
   237  	ret := m.ctrl.Call(m, "SetDeadline", arg0)
   238  	ret0, _ := ret[0].(error)
   239  	return ret0
   240  }
   241  
   242  // SetDeadline indicates an expected call of SetDeadline.
   243  func (mr *MockStreamIMockRecorder) SetDeadline(arg0 any) *MockStreamISetDeadlineCall {
   244  	mr.mock.ctrl.T.Helper()
   245  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockStreamI)(nil).SetDeadline), arg0)
   246  	return &MockStreamISetDeadlineCall{Call: call}
   247  }
   248  
   249  // MockStreamISetDeadlineCall wrap *gomock.Call
   250  type MockStreamISetDeadlineCall struct {
   251  	*gomock.Call
   252  }
   253  
   254  // Return rewrite *gomock.Call.Return
   255  func (c *MockStreamISetDeadlineCall) Return(arg0 error) *MockStreamISetDeadlineCall {
   256  	c.Call = c.Call.Return(arg0)
   257  	return c
   258  }
   259  
   260  // Do rewrite *gomock.Call.Do
   261  func (c *MockStreamISetDeadlineCall) Do(f func(time.Time) error) *MockStreamISetDeadlineCall {
   262  	c.Call = c.Call.Do(f)
   263  	return c
   264  }
   265  
   266  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   267  func (c *MockStreamISetDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetDeadlineCall {
   268  	c.Call = c.Call.DoAndReturn(f)
   269  	return c
   270  }
   271  
   272  // SetReadDeadline mocks base method.
   273  func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error {
   274  	m.ctrl.T.Helper()
   275  	ret := m.ctrl.Call(m, "SetReadDeadline", arg0)
   276  	ret0, _ := ret[0].(error)
   277  	return ret0
   278  }
   279  
   280  // SetReadDeadline indicates an expected call of SetReadDeadline.
   281  func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 any) *MockStreamISetReadDeadlineCall {
   282  	mr.mock.ctrl.T.Helper()
   283  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStreamI)(nil).SetReadDeadline), arg0)
   284  	return &MockStreamISetReadDeadlineCall{Call: call}
   285  }
   286  
   287  // MockStreamISetReadDeadlineCall wrap *gomock.Call
   288  type MockStreamISetReadDeadlineCall struct {
   289  	*gomock.Call
   290  }
   291  
   292  // Return rewrite *gomock.Call.Return
   293  func (c *MockStreamISetReadDeadlineCall) Return(arg0 error) *MockStreamISetReadDeadlineCall {
   294  	c.Call = c.Call.Return(arg0)
   295  	return c
   296  }
   297  
   298  // Do rewrite *gomock.Call.Do
   299  func (c *MockStreamISetReadDeadlineCall) Do(f func(time.Time) error) *MockStreamISetReadDeadlineCall {
   300  	c.Call = c.Call.Do(f)
   301  	return c
   302  }
   303  
   304  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   305  func (c *MockStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetReadDeadlineCall {
   306  	c.Call = c.Call.DoAndReturn(f)
   307  	return c
   308  }
   309  
   310  // SetWriteDeadline mocks base method.
   311  func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error {
   312  	m.ctrl.T.Helper()
   313  	ret := m.ctrl.Call(m, "SetWriteDeadline", arg0)
   314  	ret0, _ := ret[0].(error)
   315  	return ret0
   316  }
   317  
   318  // SetWriteDeadline indicates an expected call of SetWriteDeadline.
   319  func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 any) *MockStreamISetWriteDeadlineCall {
   320  	mr.mock.ctrl.T.Helper()
   321  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStreamI)(nil).SetWriteDeadline), arg0)
   322  	return &MockStreamISetWriteDeadlineCall{Call: call}
   323  }
   324  
   325  // MockStreamISetWriteDeadlineCall wrap *gomock.Call
   326  type MockStreamISetWriteDeadlineCall struct {
   327  	*gomock.Call
   328  }
   329  
   330  // Return rewrite *gomock.Call.Return
   331  func (c *MockStreamISetWriteDeadlineCall) Return(arg0 error) *MockStreamISetWriteDeadlineCall {
   332  	c.Call = c.Call.Return(arg0)
   333  	return c
   334  }
   335  
   336  // Do rewrite *gomock.Call.Do
   337  func (c *MockStreamISetWriteDeadlineCall) Do(f func(time.Time) error) *MockStreamISetWriteDeadlineCall {
   338  	c.Call = c.Call.Do(f)
   339  	return c
   340  }
   341  
   342  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   343  func (c *MockStreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *MockStreamISetWriteDeadlineCall {
   344  	c.Call = c.Call.DoAndReturn(f)
   345  	return c
   346  }
   347  
   348  // StreamID mocks base method.
   349  func (m *MockStreamI) StreamID() protocol.StreamID {
   350  	m.ctrl.T.Helper()
   351  	ret := m.ctrl.Call(m, "StreamID")
   352  	ret0, _ := ret[0].(protocol.StreamID)
   353  	return ret0
   354  }
   355  
   356  // StreamID indicates an expected call of StreamID.
   357  func (mr *MockStreamIMockRecorder) StreamID() *MockStreamIStreamIDCall {
   358  	mr.mock.ctrl.T.Helper()
   359  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStreamI)(nil).StreamID))
   360  	return &MockStreamIStreamIDCall{Call: call}
   361  }
   362  
   363  // MockStreamIStreamIDCall wrap *gomock.Call
   364  type MockStreamIStreamIDCall struct {
   365  	*gomock.Call
   366  }
   367  
   368  // Return rewrite *gomock.Call.Return
   369  func (c *MockStreamIStreamIDCall) Return(arg0 protocol.StreamID) *MockStreamIStreamIDCall {
   370  	c.Call = c.Call.Return(arg0)
   371  	return c
   372  }
   373  
   374  // Do rewrite *gomock.Call.Do
   375  func (c *MockStreamIStreamIDCall) Do(f func() protocol.StreamID) *MockStreamIStreamIDCall {
   376  	c.Call = c.Call.Do(f)
   377  	return c
   378  }
   379  
   380  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   381  func (c *MockStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *MockStreamIStreamIDCall {
   382  	c.Call = c.Call.DoAndReturn(f)
   383  	return c
   384  }
   385  
   386  // Write mocks base method.
   387  func (m *MockStreamI) Write(arg0 []byte) (int, error) {
   388  	m.ctrl.T.Helper()
   389  	ret := m.ctrl.Call(m, "Write", arg0)
   390  	ret0, _ := ret[0].(int)
   391  	ret1, _ := ret[1].(error)
   392  	return ret0, ret1
   393  }
   394  
   395  // Write indicates an expected call of Write.
   396  func (mr *MockStreamIMockRecorder) Write(arg0 any) *MockStreamIWriteCall {
   397  	mr.mock.ctrl.T.Helper()
   398  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStreamI)(nil).Write), arg0)
   399  	return &MockStreamIWriteCall{Call: call}
   400  }
   401  
   402  // MockStreamIWriteCall wrap *gomock.Call
   403  type MockStreamIWriteCall struct {
   404  	*gomock.Call
   405  }
   406  
   407  // Return rewrite *gomock.Call.Return
   408  func (c *MockStreamIWriteCall) Return(arg0 int, arg1 error) *MockStreamIWriteCall {
   409  	c.Call = c.Call.Return(arg0, arg1)
   410  	return c
   411  }
   412  
   413  // Do rewrite *gomock.Call.Do
   414  func (c *MockStreamIWriteCall) Do(f func([]byte) (int, error)) *MockStreamIWriteCall {
   415  	c.Call = c.Call.Do(f)
   416  	return c
   417  }
   418  
   419  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   420  func (c *MockStreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *MockStreamIWriteCall {
   421  	c.Call = c.Call.DoAndReturn(f)
   422  	return c
   423  }
   424  
   425  // closeForShutdown mocks base method.
   426  func (m *MockStreamI) closeForShutdown(arg0 error) {
   427  	m.ctrl.T.Helper()
   428  	m.ctrl.Call(m, "closeForShutdown", arg0)
   429  }
   430  
   431  // closeForShutdown indicates an expected call of closeForShutdown.
   432  func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 any) *MockStreamIcloseForShutdownCall {
   433  	mr.mock.ctrl.T.Helper()
   434  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockStreamI)(nil).closeForShutdown), arg0)
   435  	return &MockStreamIcloseForShutdownCall{Call: call}
   436  }
   437  
   438  // MockStreamIcloseForShutdownCall wrap *gomock.Call
   439  type MockStreamIcloseForShutdownCall struct {
   440  	*gomock.Call
   441  }
   442  
   443  // Return rewrite *gomock.Call.Return
   444  func (c *MockStreamIcloseForShutdownCall) Return() *MockStreamIcloseForShutdownCall {
   445  	c.Call = c.Call.Return()
   446  	return c
   447  }
   448  
   449  // Do rewrite *gomock.Call.Do
   450  func (c *MockStreamIcloseForShutdownCall) Do(f func(error)) *MockStreamIcloseForShutdownCall {
   451  	c.Call = c.Call.Do(f)
   452  	return c
   453  }
   454  
   455  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   456  func (c *MockStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *MockStreamIcloseForShutdownCall {
   457  	c.Call = c.Call.DoAndReturn(f)
   458  	return c
   459  }
   460  
   461  // getWindowUpdate mocks base method.
   462  func (m *MockStreamI) getWindowUpdate() protocol.ByteCount {
   463  	m.ctrl.T.Helper()
   464  	ret := m.ctrl.Call(m, "getWindowUpdate")
   465  	ret0, _ := ret[0].(protocol.ByteCount)
   466  	return ret0
   467  }
   468  
   469  // getWindowUpdate indicates an expected call of getWindowUpdate.
   470  func (mr *MockStreamIMockRecorder) getWindowUpdate() *MockStreamIgetWindowUpdateCall {
   471  	mr.mock.ctrl.T.Helper()
   472  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockStreamI)(nil).getWindowUpdate))
   473  	return &MockStreamIgetWindowUpdateCall{Call: call}
   474  }
   475  
   476  // MockStreamIgetWindowUpdateCall wrap *gomock.Call
   477  type MockStreamIgetWindowUpdateCall struct {
   478  	*gomock.Call
   479  }
   480  
   481  // Return rewrite *gomock.Call.Return
   482  func (c *MockStreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *MockStreamIgetWindowUpdateCall {
   483  	c.Call = c.Call.Return(arg0)
   484  	return c
   485  }
   486  
   487  // Do rewrite *gomock.Call.Do
   488  func (c *MockStreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *MockStreamIgetWindowUpdateCall {
   489  	c.Call = c.Call.Do(f)
   490  	return c
   491  }
   492  
   493  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   494  func (c *MockStreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *MockStreamIgetWindowUpdateCall {
   495  	c.Call = c.Call.DoAndReturn(f)
   496  	return c
   497  }
   498  
   499  // handleResetStreamFrame mocks base method.
   500  func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error {
   501  	m.ctrl.T.Helper()
   502  	ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0)
   503  	ret0, _ := ret[0].(error)
   504  	return ret0
   505  }
   506  
   507  // handleResetStreamFrame indicates an expected call of handleResetStreamFrame.
   508  func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 any) *MockStreamIhandleResetStreamFrameCall {
   509  	mr.mock.ctrl.T.Helper()
   510  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleResetStreamFrame), arg0)
   511  	return &MockStreamIhandleResetStreamFrameCall{Call: call}
   512  }
   513  
   514  // MockStreamIhandleResetStreamFrameCall wrap *gomock.Call
   515  type MockStreamIhandleResetStreamFrameCall struct {
   516  	*gomock.Call
   517  }
   518  
   519  // Return rewrite *gomock.Call.Return
   520  func (c *MockStreamIhandleResetStreamFrameCall) Return(arg0 error) *MockStreamIhandleResetStreamFrameCall {
   521  	c.Call = c.Call.Return(arg0)
   522  	return c
   523  }
   524  
   525  // Do rewrite *gomock.Call.Do
   526  func (c *MockStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall {
   527  	c.Call = c.Call.Do(f)
   528  	return c
   529  }
   530  
   531  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   532  func (c *MockStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *MockStreamIhandleResetStreamFrameCall {
   533  	c.Call = c.Call.DoAndReturn(f)
   534  	return c
   535  }
   536  
   537  // handleStopSendingFrame mocks base method.
   538  func (m *MockStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) {
   539  	m.ctrl.T.Helper()
   540  	m.ctrl.Call(m, "handleStopSendingFrame", arg0)
   541  }
   542  
   543  // handleStopSendingFrame indicates an expected call of handleStopSendingFrame.
   544  func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 any) *MockStreamIhandleStopSendingFrameCall {
   545  	mr.mock.ctrl.T.Helper()
   546  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockStreamI)(nil).handleStopSendingFrame), arg0)
   547  	return &MockStreamIhandleStopSendingFrameCall{Call: call}
   548  }
   549  
   550  // MockStreamIhandleStopSendingFrameCall wrap *gomock.Call
   551  type MockStreamIhandleStopSendingFrameCall struct {
   552  	*gomock.Call
   553  }
   554  
   555  // Return rewrite *gomock.Call.Return
   556  func (c *MockStreamIhandleStopSendingFrameCall) Return() *MockStreamIhandleStopSendingFrameCall {
   557  	c.Call = c.Call.Return()
   558  	return c
   559  }
   560  
   561  // Do rewrite *gomock.Call.Do
   562  func (c *MockStreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall {
   563  	c.Call = c.Call.Do(f)
   564  	return c
   565  }
   566  
   567  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   568  func (c *MockStreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *MockStreamIhandleStopSendingFrameCall {
   569  	c.Call = c.Call.DoAndReturn(f)
   570  	return c
   571  }
   572  
   573  // handleStreamFrame mocks base method.
   574  func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error {
   575  	m.ctrl.T.Helper()
   576  	ret := m.ctrl.Call(m, "handleStreamFrame", arg0)
   577  	ret0, _ := ret[0].(error)
   578  	return ret0
   579  }
   580  
   581  // handleStreamFrame indicates an expected call of handleStreamFrame.
   582  func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 any) *MockStreamIhandleStreamFrameCall {
   583  	mr.mock.ctrl.T.Helper()
   584  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleStreamFrame), arg0)
   585  	return &MockStreamIhandleStreamFrameCall{Call: call}
   586  }
   587  
   588  // MockStreamIhandleStreamFrameCall wrap *gomock.Call
   589  type MockStreamIhandleStreamFrameCall struct {
   590  	*gomock.Call
   591  }
   592  
   593  // Return rewrite *gomock.Call.Return
   594  func (c *MockStreamIhandleStreamFrameCall) Return(arg0 error) *MockStreamIhandleStreamFrameCall {
   595  	c.Call = c.Call.Return(arg0)
   596  	return c
   597  }
   598  
   599  // Do rewrite *gomock.Call.Do
   600  func (c *MockStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall {
   601  	c.Call = c.Call.Do(f)
   602  	return c
   603  }
   604  
   605  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   606  func (c *MockStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *MockStreamIhandleStreamFrameCall {
   607  	c.Call = c.Call.DoAndReturn(f)
   608  	return c
   609  }
   610  
   611  // hasData mocks base method.
   612  func (m *MockStreamI) hasData() bool {
   613  	m.ctrl.T.Helper()
   614  	ret := m.ctrl.Call(m, "hasData")
   615  	ret0, _ := ret[0].(bool)
   616  	return ret0
   617  }
   618  
   619  // hasData indicates an expected call of hasData.
   620  func (mr *MockStreamIMockRecorder) hasData() *MockStreamIhasDataCall {
   621  	mr.mock.ctrl.T.Helper()
   622  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockStreamI)(nil).hasData))
   623  	return &MockStreamIhasDataCall{Call: call}
   624  }
   625  
   626  // MockStreamIhasDataCall wrap *gomock.Call
   627  type MockStreamIhasDataCall struct {
   628  	*gomock.Call
   629  }
   630  
   631  // Return rewrite *gomock.Call.Return
   632  func (c *MockStreamIhasDataCall) Return(arg0 bool) *MockStreamIhasDataCall {
   633  	c.Call = c.Call.Return(arg0)
   634  	return c
   635  }
   636  
   637  // Do rewrite *gomock.Call.Do
   638  func (c *MockStreamIhasDataCall) Do(f func() bool) *MockStreamIhasDataCall {
   639  	c.Call = c.Call.Do(f)
   640  	return c
   641  }
   642  
   643  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   644  func (c *MockStreamIhasDataCall) DoAndReturn(f func() bool) *MockStreamIhasDataCall {
   645  	c.Call = c.Call.DoAndReturn(f)
   646  	return c
   647  }
   648  
   649  // popStreamFrame mocks base method.
   650  func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount, arg1 protocol.Version) (ackhandler.StreamFrame, bool, bool) {
   651  	m.ctrl.T.Helper()
   652  	ret := m.ctrl.Call(m, "popStreamFrame", arg0, arg1)
   653  	ret0, _ := ret[0].(ackhandler.StreamFrame)
   654  	ret1, _ := ret[1].(bool)
   655  	ret2, _ := ret[2].(bool)
   656  	return ret0, ret1, ret2
   657  }
   658  
   659  // popStreamFrame indicates an expected call of popStreamFrame.
   660  func (mr *MockStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *MockStreamIpopStreamFrameCall {
   661  	mr.mock.ctrl.T.Helper()
   662  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockStreamI)(nil).popStreamFrame), arg0, arg1)
   663  	return &MockStreamIpopStreamFrameCall{Call: call}
   664  }
   665  
   666  // MockStreamIpopStreamFrameCall wrap *gomock.Call
   667  type MockStreamIpopStreamFrameCall struct {
   668  	*gomock.Call
   669  }
   670  
   671  // Return rewrite *gomock.Call.Return
   672  func (c *MockStreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *MockStreamIpopStreamFrameCall {
   673  	c.Call = c.Call.Return(arg0, arg1, arg2)
   674  	return c
   675  }
   676  
   677  // Do rewrite *gomock.Call.Do
   678  func (c *MockStreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall {
   679  	c.Call = c.Call.Do(f)
   680  	return c
   681  }
   682  
   683  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   684  func (c *MockStreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *MockStreamIpopStreamFrameCall {
   685  	c.Call = c.Call.DoAndReturn(f)
   686  	return c
   687  }
   688  
   689  // updateSendWindow mocks base method.
   690  func (m *MockStreamI) updateSendWindow(arg0 protocol.ByteCount) {
   691  	m.ctrl.T.Helper()
   692  	m.ctrl.Call(m, "updateSendWindow", arg0)
   693  }
   694  
   695  // updateSendWindow indicates an expected call of updateSendWindow.
   696  func (mr *MockStreamIMockRecorder) updateSendWindow(arg0 any) *MockStreamIupdateSendWindowCall {
   697  	mr.mock.ctrl.T.Helper()
   698  	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "updateSendWindow", reflect.TypeOf((*MockStreamI)(nil).updateSendWindow), arg0)
   699  	return &MockStreamIupdateSendWindowCall{Call: call}
   700  }
   701  
   702  // MockStreamIupdateSendWindowCall wrap *gomock.Call
   703  type MockStreamIupdateSendWindowCall struct {
   704  	*gomock.Call
   705  }
   706  
   707  // Return rewrite *gomock.Call.Return
   708  func (c *MockStreamIupdateSendWindowCall) Return() *MockStreamIupdateSendWindowCall {
   709  	c.Call = c.Call.Return()
   710  	return c
   711  }
   712  
   713  // Do rewrite *gomock.Call.Do
   714  func (c *MockStreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall {
   715  	c.Call = c.Call.Do(f)
   716  	return c
   717  }
   718  
   719  // DoAndReturn rewrite *gomock.Call.DoAndReturn
   720  func (c *MockStreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *MockStreamIupdateSendWindowCall {
   721  	c.Call = c.Call.DoAndReturn(f)
   722  	return c
   723  }