github.com/tumi8/quic-go@v0.37.4-tum/mock_stream_manager_test.go (about)

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/tumi8/quic-go (interfaces: StreamManager)
     3  
     4  // Package quic is a generated GoMock package.
     5  package quic
     6  
     7  import (
     8  	context "context"
     9  	reflect "reflect"
    10  
    11  	gomock "github.com/golang/mock/gomock"
    12  	protocol "github.com/tumi8/quic-go/noninternal/protocol"
    13  	wire "github.com/tumi8/quic-go/noninternal/wire"
    14  )
    15  
    16  // MockStreamManager is a mock of StreamManager interface.
    17  type MockStreamManager struct {
    18  	ctrl     *gomock.Controller
    19  	recorder *MockStreamManagerMockRecorder
    20  }
    21  
    22  // MockStreamManagerMockRecorder is the mock recorder for MockStreamManager.
    23  type MockStreamManagerMockRecorder struct {
    24  	mock *MockStreamManager
    25  }
    26  
    27  // NewMockStreamManager creates a new mock instance.
    28  func NewMockStreamManager(ctrl *gomock.Controller) *MockStreamManager {
    29  	mock := &MockStreamManager{ctrl: ctrl}
    30  	mock.recorder = &MockStreamManagerMockRecorder{mock}
    31  	return mock
    32  }
    33  
    34  // EXPECT returns an object that allows the caller to indicate expected use.
    35  func (m *MockStreamManager) EXPECT() *MockStreamManagerMockRecorder {
    36  	return m.recorder
    37  }
    38  
    39  // AcceptStream mocks base method.
    40  func (m *MockStreamManager) AcceptStream(arg0 context.Context) (Stream, error) {
    41  	m.ctrl.T.Helper()
    42  	ret := m.ctrl.Call(m, "AcceptStream", arg0)
    43  	ret0, _ := ret[0].(Stream)
    44  	ret1, _ := ret[1].(error)
    45  	return ret0, ret1
    46  }
    47  
    48  // AcceptStream indicates an expected call of AcceptStream.
    49  func (mr *MockStreamManagerMockRecorder) AcceptStream(arg0 interface{}) *gomock.Call {
    50  	mr.mock.ctrl.T.Helper()
    51  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptStream), arg0)
    52  }
    53  
    54  // AcceptUniStream mocks base method.
    55  func (m *MockStreamManager) AcceptUniStream(arg0 context.Context) (ReceiveStream, error) {
    56  	m.ctrl.T.Helper()
    57  	ret := m.ctrl.Call(m, "AcceptUniStream", arg0)
    58  	ret0, _ := ret[0].(ReceiveStream)
    59  	ret1, _ := ret[1].(error)
    60  	return ret0, ret1
    61  }
    62  
    63  // AcceptUniStream indicates an expected call of AcceptUniStream.
    64  func (mr *MockStreamManagerMockRecorder) AcceptUniStream(arg0 interface{}) *gomock.Call {
    65  	mr.mock.ctrl.T.Helper()
    66  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptUniStream", reflect.TypeOf((*MockStreamManager)(nil).AcceptUniStream), arg0)
    67  }
    68  
    69  // CloseWithError mocks base method.
    70  func (m *MockStreamManager) CloseWithError(arg0 error) {
    71  	m.ctrl.T.Helper()
    72  	m.ctrl.Call(m, "CloseWithError", arg0)
    73  }
    74  
    75  // CloseWithError indicates an expected call of CloseWithError.
    76  func (mr *MockStreamManagerMockRecorder) CloseWithError(arg0 interface{}) *gomock.Call {
    77  	mr.mock.ctrl.T.Helper()
    78  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockStreamManager)(nil).CloseWithError), arg0)
    79  }
    80  
    81  // DeleteStream mocks base method.
    82  func (m *MockStreamManager) DeleteStream(arg0 protocol.StreamID) error {
    83  	m.ctrl.T.Helper()
    84  	ret := m.ctrl.Call(m, "DeleteStream", arg0)
    85  	ret0, _ := ret[0].(error)
    86  	return ret0
    87  }
    88  
    89  // DeleteStream indicates an expected call of DeleteStream.
    90  func (mr *MockStreamManagerMockRecorder) DeleteStream(arg0 interface{}) *gomock.Call {
    91  	mr.mock.ctrl.T.Helper()
    92  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStream", reflect.TypeOf((*MockStreamManager)(nil).DeleteStream), arg0)
    93  }
    94  
    95  // GetOrOpenReceiveStream mocks base method.
    96  func (m *MockStreamManager) GetOrOpenReceiveStream(arg0 protocol.StreamID) (receiveStreamI, error) {
    97  	m.ctrl.T.Helper()
    98  	ret := m.ctrl.Call(m, "GetOrOpenReceiveStream", arg0)
    99  	ret0, _ := ret[0].(receiveStreamI)
   100  	ret1, _ := ret[1].(error)
   101  	return ret0, ret1
   102  }
   103  
   104  // GetOrOpenReceiveStream indicates an expected call of GetOrOpenReceiveStream.
   105  func (mr *MockStreamManagerMockRecorder) GetOrOpenReceiveStream(arg0 interface{}) *gomock.Call {
   106  	mr.mock.ctrl.T.Helper()
   107  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenReceiveStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenReceiveStream), arg0)
   108  }
   109  
   110  // GetOrOpenSendStream mocks base method.
   111  func (m *MockStreamManager) GetOrOpenSendStream(arg0 protocol.StreamID) (sendStreamI, error) {
   112  	m.ctrl.T.Helper()
   113  	ret := m.ctrl.Call(m, "GetOrOpenSendStream", arg0)
   114  	ret0, _ := ret[0].(sendStreamI)
   115  	ret1, _ := ret[1].(error)
   116  	return ret0, ret1
   117  }
   118  
   119  // GetOrOpenSendStream indicates an expected call of GetOrOpenSendStream.
   120  func (mr *MockStreamManagerMockRecorder) GetOrOpenSendStream(arg0 interface{}) *gomock.Call {
   121  	mr.mock.ctrl.T.Helper()
   122  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrOpenSendStream", reflect.TypeOf((*MockStreamManager)(nil).GetOrOpenSendStream), arg0)
   123  }
   124  
   125  // HandleMaxStreamsFrame mocks base method.
   126  func (m *MockStreamManager) HandleMaxStreamsFrame(arg0 *wire.MaxStreamsFrame) {
   127  	m.ctrl.T.Helper()
   128  	m.ctrl.Call(m, "HandleMaxStreamsFrame", arg0)
   129  }
   130  
   131  // HandleMaxStreamsFrame indicates an expected call of HandleMaxStreamsFrame.
   132  func (mr *MockStreamManagerMockRecorder) HandleMaxStreamsFrame(arg0 interface{}) *gomock.Call {
   133  	mr.mock.ctrl.T.Helper()
   134  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMaxStreamsFrame", reflect.TypeOf((*MockStreamManager)(nil).HandleMaxStreamsFrame), arg0)
   135  }
   136  
   137  // OpenStream mocks base method.
   138  func (m *MockStreamManager) OpenStream() (Stream, error) {
   139  	m.ctrl.T.Helper()
   140  	ret := m.ctrl.Call(m, "OpenStream")
   141  	ret0, _ := ret[0].(Stream)
   142  	ret1, _ := ret[1].(error)
   143  	return ret0, ret1
   144  }
   145  
   146  // OpenStream indicates an expected call of OpenStream.
   147  func (mr *MockStreamManagerMockRecorder) OpenStream() *gomock.Call {
   148  	mr.mock.ctrl.T.Helper()
   149  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStream", reflect.TypeOf((*MockStreamManager)(nil).OpenStream))
   150  }
   151  
   152  // OpenStreamSync mocks base method.
   153  func (m *MockStreamManager) OpenStreamSync(arg0 context.Context) (Stream, error) {
   154  	m.ctrl.T.Helper()
   155  	ret := m.ctrl.Call(m, "OpenStreamSync", arg0)
   156  	ret0, _ := ret[0].(Stream)
   157  	ret1, _ := ret[1].(error)
   158  	return ret0, ret1
   159  }
   160  
   161  // OpenStreamSync indicates an expected call of OpenStreamSync.
   162  func (mr *MockStreamManagerMockRecorder) OpenStreamSync(arg0 interface{}) *gomock.Call {
   163  	mr.mock.ctrl.T.Helper()
   164  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenStreamSync), arg0)
   165  }
   166  
   167  // OpenUniStream mocks base method.
   168  func (m *MockStreamManager) OpenUniStream() (SendStream, error) {
   169  	m.ctrl.T.Helper()
   170  	ret := m.ctrl.Call(m, "OpenUniStream")
   171  	ret0, _ := ret[0].(SendStream)
   172  	ret1, _ := ret[1].(error)
   173  	return ret0, ret1
   174  }
   175  
   176  // OpenUniStream indicates an expected call of OpenUniStream.
   177  func (mr *MockStreamManagerMockRecorder) OpenUniStream() *gomock.Call {
   178  	mr.mock.ctrl.T.Helper()
   179  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStream", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStream))
   180  }
   181  
   182  // OpenUniStreamSync mocks base method.
   183  func (m *MockStreamManager) OpenUniStreamSync(arg0 context.Context) (SendStream, error) {
   184  	m.ctrl.T.Helper()
   185  	ret := m.ctrl.Call(m, "OpenUniStreamSync", arg0)
   186  	ret0, _ := ret[0].(SendStream)
   187  	ret1, _ := ret[1].(error)
   188  	return ret0, ret1
   189  }
   190  
   191  // OpenUniStreamSync indicates an expected call of OpenUniStreamSync.
   192  func (mr *MockStreamManagerMockRecorder) OpenUniStreamSync(arg0 interface{}) *gomock.Call {
   193  	mr.mock.ctrl.T.Helper()
   194  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenUniStreamSync", reflect.TypeOf((*MockStreamManager)(nil).OpenUniStreamSync), arg0)
   195  }
   196  
   197  // ResetFor0RTT mocks base method.
   198  func (m *MockStreamManager) ResetFor0RTT() {
   199  	m.ctrl.T.Helper()
   200  	m.ctrl.Call(m, "ResetFor0RTT")
   201  }
   202  
   203  // ResetFor0RTT indicates an expected call of ResetFor0RTT.
   204  func (mr *MockStreamManagerMockRecorder) ResetFor0RTT() *gomock.Call {
   205  	mr.mock.ctrl.T.Helper()
   206  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFor0RTT", reflect.TypeOf((*MockStreamManager)(nil).ResetFor0RTT))
   207  }
   208  
   209  // UpdateLimits mocks base method.
   210  func (m *MockStreamManager) UpdateLimits(arg0 *wire.TransportParameters) {
   211  	m.ctrl.T.Helper()
   212  	m.ctrl.Call(m, "UpdateLimits", arg0)
   213  }
   214  
   215  // UpdateLimits indicates an expected call of UpdateLimits.
   216  func (mr *MockStreamManagerMockRecorder) UpdateLimits(arg0 interface{}) *gomock.Call {
   217  	mr.mock.ctrl.T.Helper()
   218  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateLimits", reflect.TypeOf((*MockStreamManager)(nil).UpdateLimits), arg0)
   219  }
   220  
   221  // UseResetMaps mocks base method.
   222  func (m *MockStreamManager) UseResetMaps() {
   223  	m.ctrl.T.Helper()
   224  	m.ctrl.Call(m, "UseResetMaps")
   225  }
   226  
   227  // UseResetMaps indicates an expected call of UseResetMaps.
   228  func (mr *MockStreamManagerMockRecorder) UseResetMaps() *gomock.Call {
   229  	mr.mock.ctrl.T.Helper()
   230  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseResetMaps", reflect.TypeOf((*MockStreamManager)(nil).UseResetMaps))
   231  }