github.com/TugasAkhir-QUIC/quic-go@v0.0.2-0.20240215011318-d20e25a9054c/mock_stream_internal_test.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: github.com/TugasAkhir-QUIC/quic-go (interfaces: StreamI) 3 // 4 // Generated by this command: 5 // 6 // mockgen.exe -typed -build_flags=-tags=gomock -package quic -self_package github.com/TugasAkhir-QUIC/quic-go -destination mock_stream_internal_test.go github.com/TugasAkhir-QUIC/quic-go 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/TugasAkhir-QUIC/quic-go/internal/ackhandler" 17 protocol "github.com/TugasAkhir-QUIC/quic-go/internal/protocol" 18 qerr "github.com/TugasAkhir-QUIC/quic-go/internal/qerr" 19 wire "github.com/TugasAkhir-QUIC/quic-go/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 // SetPriority mocks base method. 272 func (m *MockStreamI) SetPriority(arg0 int) { 273 m.ctrl.T.Helper() 274 m.ctrl.Call(m, "SetPriority", arg0) 275 } 276 277 // SetPriority indicates an expected call of SetPriority. 278 func (mr *MockStreamIMockRecorder) SetPriority(arg0 any) *StreamISetPriorityCall { 279 mr.mock.ctrl.T.Helper() 280 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockStreamI)(nil).SetPriority), arg0) 281 return &StreamISetPriorityCall{Call: call} 282 } 283 284 // StreamISetPriorityCall wrap *gomock.Call 285 type StreamISetPriorityCall struct { 286 *gomock.Call 287 } 288 289 // Return rewrite *gomock.Call.Return 290 func (c *StreamISetPriorityCall) Return() *StreamISetPriorityCall { 291 c.Call = c.Call.Return() 292 return c 293 } 294 295 // Do rewrite *gomock.Call.Do 296 func (c *StreamISetPriorityCall) Do(f func(int)) *StreamISetPriorityCall { 297 c.Call = c.Call.Do(f) 298 return c 299 } 300 301 // DoAndReturn rewrite *gomock.Call.DoAndReturn 302 func (c *StreamISetPriorityCall) DoAndReturn(f func(int)) *StreamISetPriorityCall { 303 c.Call = c.Call.DoAndReturn(f) 304 return c 305 } 306 307 // SetReadDeadline mocks base method. 308 func (m *MockStreamI) SetReadDeadline(arg0 time.Time) error { 309 m.ctrl.T.Helper() 310 ret := m.ctrl.Call(m, "SetReadDeadline", arg0) 311 ret0, _ := ret[0].(error) 312 return ret0 313 } 314 315 // SetReadDeadline indicates an expected call of SetReadDeadline. 316 func (mr *MockStreamIMockRecorder) SetReadDeadline(arg0 any) *StreamISetReadDeadlineCall { 317 mr.mock.ctrl.T.Helper() 318 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockStreamI)(nil).SetReadDeadline), arg0) 319 return &StreamISetReadDeadlineCall{Call: call} 320 } 321 322 // StreamISetReadDeadlineCall wrap *gomock.Call 323 type StreamISetReadDeadlineCall struct { 324 *gomock.Call 325 } 326 327 // Return rewrite *gomock.Call.Return 328 func (c *StreamISetReadDeadlineCall) Return(arg0 error) *StreamISetReadDeadlineCall { 329 c.Call = c.Call.Return(arg0) 330 return c 331 } 332 333 // Do rewrite *gomock.Call.Do 334 func (c *StreamISetReadDeadlineCall) Do(f func(time.Time) error) *StreamISetReadDeadlineCall { 335 c.Call = c.Call.Do(f) 336 return c 337 } 338 339 // DoAndReturn rewrite *gomock.Call.DoAndReturn 340 func (c *StreamISetReadDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamISetReadDeadlineCall { 341 c.Call = c.Call.DoAndReturn(f) 342 return c 343 } 344 345 // SetWriteDeadline mocks base method. 346 func (m *MockStreamI) SetWriteDeadline(arg0 time.Time) error { 347 m.ctrl.T.Helper() 348 ret := m.ctrl.Call(m, "SetWriteDeadline", arg0) 349 ret0, _ := ret[0].(error) 350 return ret0 351 } 352 353 // SetWriteDeadline indicates an expected call of SetWriteDeadline. 354 func (mr *MockStreamIMockRecorder) SetWriteDeadline(arg0 any) *StreamISetWriteDeadlineCall { 355 mr.mock.ctrl.T.Helper() 356 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockStreamI)(nil).SetWriteDeadline), arg0) 357 return &StreamISetWriteDeadlineCall{Call: call} 358 } 359 360 // StreamISetWriteDeadlineCall wrap *gomock.Call 361 type StreamISetWriteDeadlineCall struct { 362 *gomock.Call 363 } 364 365 // Return rewrite *gomock.Call.Return 366 func (c *StreamISetWriteDeadlineCall) Return(arg0 error) *StreamISetWriteDeadlineCall { 367 c.Call = c.Call.Return(arg0) 368 return c 369 } 370 371 // Do rewrite *gomock.Call.Do 372 func (c *StreamISetWriteDeadlineCall) Do(f func(time.Time) error) *StreamISetWriteDeadlineCall { 373 c.Call = c.Call.Do(f) 374 return c 375 } 376 377 // DoAndReturn rewrite *gomock.Call.DoAndReturn 378 func (c *StreamISetWriteDeadlineCall) DoAndReturn(f func(time.Time) error) *StreamISetWriteDeadlineCall { 379 c.Call = c.Call.DoAndReturn(f) 380 return c 381 } 382 383 // StreamID mocks base method. 384 func (m *MockStreamI) StreamID() protocol.StreamID { 385 m.ctrl.T.Helper() 386 ret := m.ctrl.Call(m, "StreamID") 387 ret0, _ := ret[0].(protocol.StreamID) 388 return ret0 389 } 390 391 // StreamID indicates an expected call of StreamID. 392 func (mr *MockStreamIMockRecorder) StreamID() *StreamIStreamIDCall { 393 mr.mock.ctrl.T.Helper() 394 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamID", reflect.TypeOf((*MockStreamI)(nil).StreamID)) 395 return &StreamIStreamIDCall{Call: call} 396 } 397 398 // StreamIStreamIDCall wrap *gomock.Call 399 type StreamIStreamIDCall struct { 400 *gomock.Call 401 } 402 403 // Return rewrite *gomock.Call.Return 404 func (c *StreamIStreamIDCall) Return(arg0 protocol.StreamID) *StreamIStreamIDCall { 405 c.Call = c.Call.Return(arg0) 406 return c 407 } 408 409 // Do rewrite *gomock.Call.Do 410 func (c *StreamIStreamIDCall) Do(f func() protocol.StreamID) *StreamIStreamIDCall { 411 c.Call = c.Call.Do(f) 412 return c 413 } 414 415 // DoAndReturn rewrite *gomock.Call.DoAndReturn 416 func (c *StreamIStreamIDCall) DoAndReturn(f func() protocol.StreamID) *StreamIStreamIDCall { 417 c.Call = c.Call.DoAndReturn(f) 418 return c 419 } 420 421 // Write mocks base method. 422 func (m *MockStreamI) Write(arg0 []byte) (int, error) { 423 m.ctrl.T.Helper() 424 ret := m.ctrl.Call(m, "Write", arg0) 425 ret0, _ := ret[0].(int) 426 ret1, _ := ret[1].(error) 427 return ret0, ret1 428 } 429 430 // Write indicates an expected call of Write. 431 func (mr *MockStreamIMockRecorder) Write(arg0 any) *StreamIWriteCall { 432 mr.mock.ctrl.T.Helper() 433 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockStreamI)(nil).Write), arg0) 434 return &StreamIWriteCall{Call: call} 435 } 436 437 // StreamIWriteCall wrap *gomock.Call 438 type StreamIWriteCall struct { 439 *gomock.Call 440 } 441 442 // Return rewrite *gomock.Call.Return 443 func (c *StreamIWriteCall) Return(arg0 int, arg1 error) *StreamIWriteCall { 444 c.Call = c.Call.Return(arg0, arg1) 445 return c 446 } 447 448 // Do rewrite *gomock.Call.Do 449 func (c *StreamIWriteCall) Do(f func([]byte) (int, error)) *StreamIWriteCall { 450 c.Call = c.Call.Do(f) 451 return c 452 } 453 454 // DoAndReturn rewrite *gomock.Call.DoAndReturn 455 func (c *StreamIWriteCall) DoAndReturn(f func([]byte) (int, error)) *StreamIWriteCall { 456 c.Call = c.Call.DoAndReturn(f) 457 return c 458 } 459 460 // closeForShutdown mocks base method. 461 func (m *MockStreamI) closeForShutdown(arg0 error) { 462 m.ctrl.T.Helper() 463 m.ctrl.Call(m, "closeForShutdown", arg0) 464 } 465 466 // closeForShutdown indicates an expected call of closeForShutdown. 467 func (mr *MockStreamIMockRecorder) closeForShutdown(arg0 any) *StreamIcloseForShutdownCall { 468 mr.mock.ctrl.T.Helper() 469 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "closeForShutdown", reflect.TypeOf((*MockStreamI)(nil).closeForShutdown), arg0) 470 return &StreamIcloseForShutdownCall{Call: call} 471 } 472 473 // StreamIcloseForShutdownCall wrap *gomock.Call 474 type StreamIcloseForShutdownCall struct { 475 *gomock.Call 476 } 477 478 // Return rewrite *gomock.Call.Return 479 func (c *StreamIcloseForShutdownCall) Return() *StreamIcloseForShutdownCall { 480 c.Call = c.Call.Return() 481 return c 482 } 483 484 // Do rewrite *gomock.Call.Do 485 func (c *StreamIcloseForShutdownCall) Do(f func(error)) *StreamIcloseForShutdownCall { 486 c.Call = c.Call.Do(f) 487 return c 488 } 489 490 // DoAndReturn rewrite *gomock.Call.DoAndReturn 491 func (c *StreamIcloseForShutdownCall) DoAndReturn(f func(error)) *StreamIcloseForShutdownCall { 492 c.Call = c.Call.DoAndReturn(f) 493 return c 494 } 495 496 // getPriority mocks base method. 497 func (m *MockStreamI) getPriority() int { 498 m.ctrl.T.Helper() 499 ret := m.ctrl.Call(m, "getPriority") 500 ret0, _ := ret[0].(int) 501 return ret0 502 } 503 504 // getPriority indicates an expected call of getPriority. 505 func (mr *MockStreamIMockRecorder) getPriority() *StreamIgetPriorityCall { 506 mr.mock.ctrl.T.Helper() 507 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getPriority", reflect.TypeOf((*MockStreamI)(nil).getPriority)) 508 return &StreamIgetPriorityCall{Call: call} 509 } 510 511 // StreamIgetPriorityCall wrap *gomock.Call 512 type StreamIgetPriorityCall struct { 513 *gomock.Call 514 } 515 516 // Return rewrite *gomock.Call.Return 517 func (c *StreamIgetPriorityCall) Return(arg0 int) *StreamIgetPriorityCall { 518 c.Call = c.Call.Return(arg0) 519 return c 520 } 521 522 // Do rewrite *gomock.Call.Do 523 func (c *StreamIgetPriorityCall) Do(f func() int) *StreamIgetPriorityCall { 524 c.Call = c.Call.Do(f) 525 return c 526 } 527 528 // DoAndReturn rewrite *gomock.Call.DoAndReturn 529 func (c *StreamIgetPriorityCall) DoAndReturn(f func() int) *StreamIgetPriorityCall { 530 c.Call = c.Call.DoAndReturn(f) 531 return c 532 } 533 534 // getWindowUpdate mocks base method. 535 func (m *MockStreamI) getWindowUpdate() protocol.ByteCount { 536 m.ctrl.T.Helper() 537 ret := m.ctrl.Call(m, "getWindowUpdate") 538 ret0, _ := ret[0].(protocol.ByteCount) 539 return ret0 540 } 541 542 // getWindowUpdate indicates an expected call of getWindowUpdate. 543 func (mr *MockStreamIMockRecorder) getWindowUpdate() *StreamIgetWindowUpdateCall { 544 mr.mock.ctrl.T.Helper() 545 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "getWindowUpdate", reflect.TypeOf((*MockStreamI)(nil).getWindowUpdate)) 546 return &StreamIgetWindowUpdateCall{Call: call} 547 } 548 549 // StreamIgetWindowUpdateCall wrap *gomock.Call 550 type StreamIgetWindowUpdateCall struct { 551 *gomock.Call 552 } 553 554 // Return rewrite *gomock.Call.Return 555 func (c *StreamIgetWindowUpdateCall) Return(arg0 protocol.ByteCount) *StreamIgetWindowUpdateCall { 556 c.Call = c.Call.Return(arg0) 557 return c 558 } 559 560 // Do rewrite *gomock.Call.Do 561 func (c *StreamIgetWindowUpdateCall) Do(f func() protocol.ByteCount) *StreamIgetWindowUpdateCall { 562 c.Call = c.Call.Do(f) 563 return c 564 } 565 566 // DoAndReturn rewrite *gomock.Call.DoAndReturn 567 func (c *StreamIgetWindowUpdateCall) DoAndReturn(f func() protocol.ByteCount) *StreamIgetWindowUpdateCall { 568 c.Call = c.Call.DoAndReturn(f) 569 return c 570 } 571 572 // handleResetStreamFrame mocks base method. 573 func (m *MockStreamI) handleResetStreamFrame(arg0 *wire.ResetStreamFrame) error { 574 m.ctrl.T.Helper() 575 ret := m.ctrl.Call(m, "handleResetStreamFrame", arg0) 576 ret0, _ := ret[0].(error) 577 return ret0 578 } 579 580 // handleResetStreamFrame indicates an expected call of handleResetStreamFrame. 581 func (mr *MockStreamIMockRecorder) handleResetStreamFrame(arg0 any) *StreamIhandleResetStreamFrameCall { 582 mr.mock.ctrl.T.Helper() 583 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleResetStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleResetStreamFrame), arg0) 584 return &StreamIhandleResetStreamFrameCall{Call: call} 585 } 586 587 // StreamIhandleResetStreamFrameCall wrap *gomock.Call 588 type StreamIhandleResetStreamFrameCall struct { 589 *gomock.Call 590 } 591 592 // Return rewrite *gomock.Call.Return 593 func (c *StreamIhandleResetStreamFrameCall) Return(arg0 error) *StreamIhandleResetStreamFrameCall { 594 c.Call = c.Call.Return(arg0) 595 return c 596 } 597 598 // Do rewrite *gomock.Call.Do 599 func (c *StreamIhandleResetStreamFrameCall) Do(f func(*wire.ResetStreamFrame) error) *StreamIhandleResetStreamFrameCall { 600 c.Call = c.Call.Do(f) 601 return c 602 } 603 604 // DoAndReturn rewrite *gomock.Call.DoAndReturn 605 func (c *StreamIhandleResetStreamFrameCall) DoAndReturn(f func(*wire.ResetStreamFrame) error) *StreamIhandleResetStreamFrameCall { 606 c.Call = c.Call.DoAndReturn(f) 607 return c 608 } 609 610 // handleStopSendingFrame mocks base method. 611 func (m *MockStreamI) handleStopSendingFrame(arg0 *wire.StopSendingFrame) { 612 m.ctrl.T.Helper() 613 m.ctrl.Call(m, "handleStopSendingFrame", arg0) 614 } 615 616 // handleStopSendingFrame indicates an expected call of handleStopSendingFrame. 617 func (mr *MockStreamIMockRecorder) handleStopSendingFrame(arg0 any) *StreamIhandleStopSendingFrameCall { 618 mr.mock.ctrl.T.Helper() 619 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStopSendingFrame", reflect.TypeOf((*MockStreamI)(nil).handleStopSendingFrame), arg0) 620 return &StreamIhandleStopSendingFrameCall{Call: call} 621 } 622 623 // StreamIhandleStopSendingFrameCall wrap *gomock.Call 624 type StreamIhandleStopSendingFrameCall struct { 625 *gomock.Call 626 } 627 628 // Return rewrite *gomock.Call.Return 629 func (c *StreamIhandleStopSendingFrameCall) Return() *StreamIhandleStopSendingFrameCall { 630 c.Call = c.Call.Return() 631 return c 632 } 633 634 // Do rewrite *gomock.Call.Do 635 func (c *StreamIhandleStopSendingFrameCall) Do(f func(*wire.StopSendingFrame)) *StreamIhandleStopSendingFrameCall { 636 c.Call = c.Call.Do(f) 637 return c 638 } 639 640 // DoAndReturn rewrite *gomock.Call.DoAndReturn 641 func (c *StreamIhandleStopSendingFrameCall) DoAndReturn(f func(*wire.StopSendingFrame)) *StreamIhandleStopSendingFrameCall { 642 c.Call = c.Call.DoAndReturn(f) 643 return c 644 } 645 646 // handleStreamFrame mocks base method. 647 func (m *MockStreamI) handleStreamFrame(arg0 *wire.StreamFrame) error { 648 m.ctrl.T.Helper() 649 ret := m.ctrl.Call(m, "handleStreamFrame", arg0) 650 ret0, _ := ret[0].(error) 651 return ret0 652 } 653 654 // handleStreamFrame indicates an expected call of handleStreamFrame. 655 func (mr *MockStreamIMockRecorder) handleStreamFrame(arg0 any) *StreamIhandleStreamFrameCall { 656 mr.mock.ctrl.T.Helper() 657 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handleStreamFrame", reflect.TypeOf((*MockStreamI)(nil).handleStreamFrame), arg0) 658 return &StreamIhandleStreamFrameCall{Call: call} 659 } 660 661 // StreamIhandleStreamFrameCall wrap *gomock.Call 662 type StreamIhandleStreamFrameCall struct { 663 *gomock.Call 664 } 665 666 // Return rewrite *gomock.Call.Return 667 func (c *StreamIhandleStreamFrameCall) Return(arg0 error) *StreamIhandleStreamFrameCall { 668 c.Call = c.Call.Return(arg0) 669 return c 670 } 671 672 // Do rewrite *gomock.Call.Do 673 func (c *StreamIhandleStreamFrameCall) Do(f func(*wire.StreamFrame) error) *StreamIhandleStreamFrameCall { 674 c.Call = c.Call.Do(f) 675 return c 676 } 677 678 // DoAndReturn rewrite *gomock.Call.DoAndReturn 679 func (c *StreamIhandleStreamFrameCall) DoAndReturn(f func(*wire.StreamFrame) error) *StreamIhandleStreamFrameCall { 680 c.Call = c.Call.DoAndReturn(f) 681 return c 682 } 683 684 // hasData mocks base method. 685 func (m *MockStreamI) hasData() bool { 686 m.ctrl.T.Helper() 687 ret := m.ctrl.Call(m, "hasData") 688 ret0, _ := ret[0].(bool) 689 return ret0 690 } 691 692 // hasData indicates an expected call of hasData. 693 func (mr *MockStreamIMockRecorder) hasData() *StreamIhasDataCall { 694 mr.mock.ctrl.T.Helper() 695 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "hasData", reflect.TypeOf((*MockStreamI)(nil).hasData)) 696 return &StreamIhasDataCall{Call: call} 697 } 698 699 // StreamIhasDataCall wrap *gomock.Call 700 type StreamIhasDataCall struct { 701 *gomock.Call 702 } 703 704 // Return rewrite *gomock.Call.Return 705 func (c *StreamIhasDataCall) Return(arg0 bool) *StreamIhasDataCall { 706 c.Call = c.Call.Return(arg0) 707 return c 708 } 709 710 // Do rewrite *gomock.Call.Do 711 func (c *StreamIhasDataCall) Do(f func() bool) *StreamIhasDataCall { 712 c.Call = c.Call.Do(f) 713 return c 714 } 715 716 // DoAndReturn rewrite *gomock.Call.DoAndReturn 717 func (c *StreamIhasDataCall) DoAndReturn(f func() bool) *StreamIhasDataCall { 718 c.Call = c.Call.DoAndReturn(f) 719 return c 720 } 721 722 // popStreamFrame mocks base method. 723 func (m *MockStreamI) popStreamFrame(arg0 protocol.ByteCount, arg1 protocol.Version) (ackhandler.StreamFrame, bool, bool) { 724 m.ctrl.T.Helper() 725 ret := m.ctrl.Call(m, "popStreamFrame", arg0, arg1) 726 ret0, _ := ret[0].(ackhandler.StreamFrame) 727 ret1, _ := ret[1].(bool) 728 ret2, _ := ret[2].(bool) 729 return ret0, ret1, ret2 730 } 731 732 // popStreamFrame indicates an expected call of popStreamFrame. 733 func (mr *MockStreamIMockRecorder) popStreamFrame(arg0, arg1 any) *StreamIpopStreamFrameCall { 734 mr.mock.ctrl.T.Helper() 735 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "popStreamFrame", reflect.TypeOf((*MockStreamI)(nil).popStreamFrame), arg0, arg1) 736 return &StreamIpopStreamFrameCall{Call: call} 737 } 738 739 // StreamIpopStreamFrameCall wrap *gomock.Call 740 type StreamIpopStreamFrameCall struct { 741 *gomock.Call 742 } 743 744 // Return rewrite *gomock.Call.Return 745 func (c *StreamIpopStreamFrameCall) Return(arg0 ackhandler.StreamFrame, arg1, arg2 bool) *StreamIpopStreamFrameCall { 746 c.Call = c.Call.Return(arg0, arg1, arg2) 747 return c 748 } 749 750 // Do rewrite *gomock.Call.Do 751 func (c *StreamIpopStreamFrameCall) Do(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *StreamIpopStreamFrameCall { 752 c.Call = c.Call.Do(f) 753 return c 754 } 755 756 // DoAndReturn rewrite *gomock.Call.DoAndReturn 757 func (c *StreamIpopStreamFrameCall) DoAndReturn(f func(protocol.ByteCount, protocol.Version) (ackhandler.StreamFrame, bool, bool)) *StreamIpopStreamFrameCall { 758 c.Call = c.Call.DoAndReturn(f) 759 return c 760 } 761 762 // updateSendWindow mocks base method. 763 func (m *MockStreamI) updateSendWindow(arg0 protocol.ByteCount) { 764 m.ctrl.T.Helper() 765 m.ctrl.Call(m, "updateSendWindow", arg0) 766 } 767 768 // updateSendWindow indicates an expected call of updateSendWindow. 769 func (mr *MockStreamIMockRecorder) updateSendWindow(arg0 any) *StreamIupdateSendWindowCall { 770 mr.mock.ctrl.T.Helper() 771 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "updateSendWindow", reflect.TypeOf((*MockStreamI)(nil).updateSendWindow), arg0) 772 return &StreamIupdateSendWindowCall{Call: call} 773 } 774 775 // StreamIupdateSendWindowCall wrap *gomock.Call 776 type StreamIupdateSendWindowCall struct { 777 *gomock.Call 778 } 779 780 // Return rewrite *gomock.Call.Return 781 func (c *StreamIupdateSendWindowCall) Return() *StreamIupdateSendWindowCall { 782 c.Call = c.Call.Return() 783 return c 784 } 785 786 // Do rewrite *gomock.Call.Do 787 func (c *StreamIupdateSendWindowCall) Do(f func(protocol.ByteCount)) *StreamIupdateSendWindowCall { 788 c.Call = c.Call.Do(f) 789 return c 790 } 791 792 // DoAndReturn rewrite *gomock.Call.DoAndReturn 793 func (c *StreamIupdateSendWindowCall) DoAndReturn(f func(protocol.ByteCount)) *StreamIupdateSendWindowCall { 794 c.Call = c.Call.DoAndReturn(f) 795 return c 796 }