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 }