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