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