github.com/danielpfeifer02/quic-go-prio-packs@v0.41.0-28/mock_receive_stream_internal_test.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: github.com/danielpfeifer02/quic-go-prio-packs (interfaces: ReceiveStreamI) 3 // 4 // Generated by this command: 5 // 6 // mockgen -typed -build_flags=-tags=gomock -package quic -self_package github.com/danielpfeifer02/quic-go-prio-packs -destination mock_receive_stream_internal_test.go github.com/danielpfeifer02/quic-go-prio-packs ReceiveStreamI 7 // 8 // Package quic is a generated GoMock package. 9 package quic 10 11 import ( 12 reflect "reflect" 13 time "time" 14 15 protocol "github.com/danielpfeifer02/quic-go-prio-packs/internal/protocol" 16 qerr "github.com/danielpfeifer02/quic-go-prio-packs/internal/qerr" 17 wire "github.com/danielpfeifer02/quic-go-prio-packs/internal/wire" 18 gomock "go.uber.org/mock/gomock" 19 ) 20 21 // MockReceiveStreamI is a mock of ReceiveStreamI interface. 22 type MockReceiveStreamI struct { 23 ctrl *gomock.Controller 24 recorder *MockReceiveStreamIMockRecorder 25 } 26 27 // MockReceiveStreamIMockRecorder is the mock recorder for MockReceiveStreamI. 28 type MockReceiveStreamIMockRecorder struct { 29 mock *MockReceiveStreamI 30 } 31 32 // NewMockReceiveStreamI creates a new mock instance. 33 func NewMockReceiveStreamI(ctrl *gomock.Controller) *MockReceiveStreamI { 34 mock := &MockReceiveStreamI{ctrl: ctrl} 35 mock.recorder = &MockReceiveStreamIMockRecorder{mock} 36 return mock 37 } 38 39 // EXPECT returns an object that allows the caller to indicate expected use. 40 func (m *MockReceiveStreamI) EXPECT() *MockReceiveStreamIMockRecorder { 41 return m.recorder 42 } 43 44 // CancelRead mocks base method. 45 func (m *MockReceiveStreamI) CancelRead(arg0 qerr.StreamErrorCode) { 46 m.ctrl.T.Helper() 47 m.ctrl.Call(m, "CancelRead", arg0) 48 } 49 50 // CancelRead indicates an expected call of CancelRead. 51 func (mr *MockReceiveStreamIMockRecorder) CancelRead(arg0 any) *ReceiveStreamICancelReadCall { 52 mr.mock.ctrl.T.Helper() 53 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelRead", reflect.TypeOf((*MockReceiveStreamI)(nil).CancelRead), arg0) 54 return &ReceiveStreamICancelReadCall{Call: call} 55 } 56 57 // ReceiveStreamICancelReadCall wrap *gomock.Call 58 type ReceiveStreamICancelReadCall struct { 59 *gomock.Call 60 } 61 62 // Return rewrite *gomock.Call.Return 63 func (c *ReceiveStreamICancelReadCall) Return() *ReceiveStreamICancelReadCall { 64 c.Call = c.Call.Return() 65 return c 66 } 67 68 // Do rewrite *gomock.Call.Do 69 func (c *ReceiveStreamICancelReadCall) Do(f func(qerr.StreamErrorCode)) *ReceiveStreamICancelReadCall { 70 c.Call = c.Call.Do(f) 71 return c 72 } 73 74 // DoAndReturn rewrite *gomock.Call.DoAndReturn 75 func (c *ReceiveStreamICancelReadCall) DoAndReturn(f func(qerr.StreamErrorCode)) *ReceiveStreamICancelReadCall { 76 c.Call = c.Call.DoAndReturn(f) 77 return c 78 } 79 80 // Read mocks base method. 81 func (m *MockReceiveStreamI) Read(arg0 []byte) (int, error) { 82 m.ctrl.T.Helper() 83 ret := m.ctrl.Call(m, "Read", arg0) 84 ret0, _ := ret[0].(int) 85 ret1, _ := ret[1].(error) 86 return ret0, ret1 87 } 88 89 // Read indicates an expected call of Read. 90 func (mr *MockReceiveStreamIMockRecorder) Read(arg0 any) *ReceiveStreamIReadCall { 91 mr.mock.ctrl.T.Helper() 92 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockReceiveStreamI)(nil).Read), arg0) 93 return &ReceiveStreamIReadCall{Call: call} 94 } 95 96 // ReceiveStreamIReadCall wrap *gomock.Call 97 type ReceiveStreamIReadCall struct { 98 *gomock.Call 99 } 100 101 // Return rewrite *gomock.Call.Return 102 func (c *ReceiveStreamIReadCall) Return(arg0 int, arg1 error) *ReceiveStreamIReadCall { 103 c.Call = c.Call.Return(arg0, arg1) 104 return c 105 } 106 107 // Do rewrite *gomock.Call.Do 108 func (c *ReceiveStreamIReadCall) Do(f func([]byte) (int, error)) *ReceiveStreamIReadCall { 109 c.Call = c.Call.Do(f) 110 return c 111 } 112 113 // DoAndReturn rewrite *gomock.Call.DoAndReturn 114 func (c *ReceiveStreamIReadCall) DoAndReturn(f func([]byte) (int, error)) *ReceiveStreamIReadCall { 115 c.Call = c.Call.DoAndReturn(f) 116 return c 117 } 118 119 // SetReadDeadline mocks base method. 120 func (m *MockReceiveStreamI) SetReadDeadline(arg0 time.Time) error { 121 m.ctrl.T.Helper() 122 ret := m.ctrl.Call(m, "SetReadDeadline", arg0) 123 ret0, _ := ret[0].(error) 124 return ret0 125 } 126 127 // SetReadDeadline indicates an expected call of SetReadDeadline. 128 func (mr *MockReceiveStreamIMockRecorder) SetReadDeadline(arg0 any) *ReceiveStreamISetReadDeadlineCall { 129 mr.mock.ctrl.T.Helper() 130 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockReceiveStreamI)(nil).SetReadDeadline), arg0) 131 return &ReceiveStreamISetReadDeadlineCall{Call: call} 132 } 133 134 // ReceiveStreamISetReadDeadlineCall wrap *gomock.Call 135 type ReceiveStreamISetReadDeadlineCall struct { 136 *gomock.Call 137 } 138 139 // Return rewrite *gomock.Call.Return 140 func (c *ReceiveStreamISetReadDeadlineCall) Return(arg0 error) *ReceiveStreamISetReadDeadlineCall { 141 c.Call = c.Call.Return(arg0) 142 return c 143 } 144 145 // Do rewrite *gomock.Call.Do 146 func (c *ReceiveStreamISetReadDeadlineCall) Do(f func(time.Time) error) *ReceiveStreamISetReadDeadlineCall { 147 c.Call = c.Call.Do(f) 148 return c 149 } 150 151 // DoAndReturn rewrite *gomock.Call.DoAndReturn 152 func (c *ReceiveStreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *ReceiveStreamISetReadDeadlineCall { 153 c.Call = c.Call.DoAndReturn(f) 154 return c 155 } 156 157 // StreamID mocks base method. 158 func (m *MockReceiveStreamI) StreamID() protocol.StreamID { 159 m.ctrl.T.Helper() 160 ret := m.ctrl.Call(m, "StreamID") 161 ret0, _ := ret[0].(protocol.StreamID) 162 return ret0 163 } 164 165 // StreamID indicates an expected call of StreamID. 166 func (mr *MockReceiveStreamIMockRecorder) StreamID() *ReceiveStreamIStreamIDCall { 167 mr.mock.ctrl.T.Helper() 168 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockReceiveStreamI)(nil).StreamID)) 169 return &ReceiveStreamIStreamIDCall{Call: call} 170 } 171 172 // ReceiveStreamIStreamIDCall wrap *gomock.Call 173 type ReceiveStreamIStreamIDCall struct { 174 *gomock.Call 175 } 176 177 // Return rewrite *gomock.Call.Return 178 func (c *ReceiveStreamIStreamIDCall) Return(arg0 protocol.StreamID) *ReceiveStreamIStreamIDCall { 179 c.Call = c.Call.Return(arg0) 180 return c 181 } 182 183 // Do rewrite *gomock.Call.Do 184 func (c *ReceiveStreamIStreamIDCall) Do(f func() protocol.StreamID) *ReceiveStreamIStreamIDCall { 185 c.Call = c.Call.Do(f) 186 return c 187 } 188 189 // DoAndReturn rewrite *gomock.Call.DoAndReturn 190 func (c *ReceiveStreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *ReceiveStreamIStreamIDCall { 191 c.Call = c.Call.DoAndReturn(f) 192 return c 193 } 194 195 // closeForShutdown mocks base method. 196 func (m *MockReceiveStreamI) closeForShutdown(arg0 error) { 197 m.ctrl.T.Helper() 198 m.ctrl.Call(m, "closeForShutdown", arg0) 199 } 200 201 // closeForShutdown indicates an expected call of closeForShutdown. 202 func (mr *MockReceiveStreamIMockRecorder) closeForShutdown(arg0 any) *ReceiveStreamIcloseForShutdownCall { 203 mr.mock.ctrl.T.Helper() 204 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockReceiveStreamI)(nil).closeForShutdown), arg0) 205 return &ReceiveStreamIcloseForShutdownCall{Call: call} 206 } 207 208 // ReceiveStreamIcloseForShutdownCall wrap *gomock.Call 209 type ReceiveStreamIcloseForShutdownCall struct { 210 *gomock.Call 211 } 212 213 // Return rewrite *gomock.Call.Return 214 func (c *ReceiveStreamIcloseForShutdownCall) Return() *ReceiveStreamIcloseForShutdownCall { 215 c.Call = c.Call.Return() 216 return c 217 } 218 219 // Do rewrite *gomock.Call.Do 220 func (c *ReceiveStreamIcloseForShutdownCall) Do(f func(error)) *ReceiveStreamIcloseForShutdownCall { 221 c.Call = c.Call.Do(f) 222 return c 223 } 224 225 // DoAndReturn rewrite *gomock.Call.DoAndReturn 226 func (c *ReceiveStreamIcloseForShutdownCall) DoAndReturn(f func(error)) *ReceiveStreamIcloseForShutdownCall { 227 c.Call = c.Call.DoAndReturn(f) 228 return c 229 } 230 231 // getWindowUpdate mocks base method. 232 func (m *MockReceiveStreamI) getWindowUpdate() protocol.ByteCount { 233 m.ctrl.T.Helper() 234 ret := m.ctrl.Call(m, "getWindowUpdate") 235 ret0, _ := ret[0].(protocol.ByteCount) 236 return ret0 237 } 238 239 // getWindowUpdate indicates an expected call of getWindowUpdate. 240 func (mr *MockReceiveStreamIMockRecorder) getWindowUpdate() *ReceiveStreamIgetWindowUpdateCall { 241 mr.mock.ctrl.T.Helper() 242 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockReceiveStreamI)(nil).getWindowUpdate)) 243 return &ReceiveStreamIgetWindowUpdateCall{Call: call} 244 } 245 246 // ReceiveStreamIgetWindowUpdateCall wrap *gomock.Call 247 type ReceiveStreamIgetWindowUpdateCall struct { 248 *gomock.Call 249 } 250 251 // Return rewrite *gomock.Call.Return 252 func (c *ReceiveStreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { 253 c.Call = c.Call.Return(arg0) 254 return c 255 } 256 257 // Do rewrite *gomock.Call.Do 258 func (c *ReceiveStreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { 259 c.Call = c.Call.Do(f) 260 return c 261 } 262 263 // DoAndReturn rewrite *gomock.Call.DoAndReturn 264 func (c *ReceiveStreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *ReceiveStreamIgetWindowUpdateCall { 265 c.Call = c.Call.DoAndReturn(f) 266 return c 267 } 268 269 // handleResetStreamFrame mocks base method. 270 func (m *MockReceiveStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error { 271 m.ctrl.T.Helper() 272 ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0) 273 ret0, _ := ret[0].(error) 274 return ret0 275 } 276 277 // handleResetStreamFrame indicates an expected call of handleResetStreamFrame. 278 func (mr *MockReceiveStreamIMockRecorder) handleResetStreamFrame(arg0 any) *ReceiveStreamIhandleResetStreamFrameCall { 279 mr.mock.ctrl.T.Helper() 280 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleResetStreamFrame), arg0) 281 return &ReceiveStreamIhandleResetStreamFrameCall{Call: call} 282 } 283 284 // ReceiveStreamIhandleResetStreamFrameCall wrap *gomock.Call 285 type ReceiveStreamIhandleResetStreamFrameCall struct { 286 *gomock.Call 287 } 288 289 // Return rewrite *gomock.Call.Return 290 func (c *ReceiveStreamIhandleResetStreamFrameCall) Return(arg0 error) *ReceiveStreamIhandleResetStreamFrameCall { 291 c.Call = c.Call.Return(arg0) 292 return c 293 } 294 295 // Do rewrite *gomock.Call.Do 296 func (c *ReceiveStreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *ReceiveStreamIhandleResetStreamFrameCall { 297 c.Call = c.Call.Do(f) 298 return c 299 } 300 301 // DoAndReturn rewrite *gomock.Call.DoAndReturn 302 func (c *ReceiveStreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *ReceiveStreamIhandleResetStreamFrameCall { 303 c.Call = c.Call.DoAndReturn(f) 304 return c 305 } 306 307 // handleStreamFrame mocks base method. 308 func (m *MockReceiveStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { 309 m.ctrl.T.Helper() 310 ret := m.ctrl.Call(m, "handleStreamFrame", arg0) 311 ret0, _ := ret[0].(error) 312 return ret0 313 } 314 315 // handleStreamFrame indicates an expected call of handleStreamFrame. 316 func (mr *MockReceiveStreamIMockRecorder) handleStreamFrame(arg0 any) *ReceiveStreamIhandleStreamFrameCall { 317 mr.mock.ctrl.T.Helper() 318 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockReceiveStreamI)(nil).handleStreamFrame), arg0) 319 return &ReceiveStreamIhandleStreamFrameCall{Call: call} 320 } 321 322 // ReceiveStreamIhandleStreamFrameCall wrap *gomock.Call 323 type ReceiveStreamIhandleStreamFrameCall struct { 324 *gomock.Call 325 } 326 327 // Return rewrite *gomock.Call.Return 328 func (c *ReceiveStreamIhandleStreamFrameCall) Return(arg0 error) *ReceiveStreamIhandleStreamFrameCall { 329 c.Call = c.Call.Return(arg0) 330 return c 331 } 332 333 // Do rewrite *gomock.Call.Do 334 func (c *ReceiveStreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *ReceiveStreamIhandleStreamFrameCall { 335 c.Call = c.Call.Do(f) 336 return c 337 } 338 339 // DoAndReturn rewrite *gomock.Call.DoAndReturn 340 func (c *ReceiveStreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *ReceiveStreamIhandleStreamFrameCall { 341 c.Call = c.Call.DoAndReturn(f) 342 return c 343 }