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