github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/tsa/tsafakes/fake_conn.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 // Generated by running "go run github.com/maxbrunsfeld/counterfeiter/v6 "golang.org/x/crypto/ssh.Conn" 3 4 package tsafakes 5 6 import ( 7 "net" 8 "sync" 9 10 "golang.org/x/crypto/ssh" 11 ) 12 13 type FakeConn struct { 14 ClientVersionStub func() []byte 15 clientVersionMutex sync.RWMutex 16 clientVersionArgsForCall []struct { 17 } 18 clientVersionReturns struct { 19 result1 []byte 20 } 21 clientVersionReturnsOnCall map[int]struct { 22 result1 []byte 23 } 24 CloseStub func() error 25 closeMutex sync.RWMutex 26 closeArgsForCall []struct { 27 } 28 closeReturns struct { 29 result1 error 30 } 31 closeReturnsOnCall map[int]struct { 32 result1 error 33 } 34 LocalAddrStub func() net.Addr 35 localAddrMutex sync.RWMutex 36 localAddrArgsForCall []struct { 37 } 38 localAddrReturns struct { 39 result1 net.Addr 40 } 41 localAddrReturnsOnCall map[int]struct { 42 result1 net.Addr 43 } 44 OpenChannelStub func(string, []byte) (ssh.Channel, <-chan *ssh.Request, error) 45 openChannelMutex sync.RWMutex 46 openChannelArgsForCall []struct { 47 arg1 string 48 arg2 []byte 49 } 50 openChannelReturns struct { 51 result1 ssh.Channel 52 result2 <-chan *ssh.Request 53 result3 error 54 } 55 openChannelReturnsOnCall map[int]struct { 56 result1 ssh.Channel 57 result2 <-chan *ssh.Request 58 result3 error 59 } 60 RemoteAddrStub func() net.Addr 61 remoteAddrMutex sync.RWMutex 62 remoteAddrArgsForCall []struct { 63 } 64 remoteAddrReturns struct { 65 result1 net.Addr 66 } 67 remoteAddrReturnsOnCall map[int]struct { 68 result1 net.Addr 69 } 70 SendRequestStub func(string, bool, []byte) (bool, []byte, error) 71 sendRequestMutex sync.RWMutex 72 sendRequestArgsForCall []struct { 73 arg1 string 74 arg2 bool 75 arg3 []byte 76 } 77 sendRequestReturns struct { 78 result1 bool 79 result2 []byte 80 result3 error 81 } 82 sendRequestReturnsOnCall map[int]struct { 83 result1 bool 84 result2 []byte 85 result3 error 86 } 87 ServerVersionStub func() []byte 88 serverVersionMutex sync.RWMutex 89 serverVersionArgsForCall []struct { 90 } 91 serverVersionReturns struct { 92 result1 []byte 93 } 94 serverVersionReturnsOnCall map[int]struct { 95 result1 []byte 96 } 97 SessionIDStub func() []byte 98 sessionIDMutex sync.RWMutex 99 sessionIDArgsForCall []struct { 100 } 101 sessionIDReturns struct { 102 result1 []byte 103 } 104 sessionIDReturnsOnCall map[int]struct { 105 result1 []byte 106 } 107 UserStub func() string 108 userMutex sync.RWMutex 109 userArgsForCall []struct { 110 } 111 userReturns struct { 112 result1 string 113 } 114 userReturnsOnCall map[int]struct { 115 result1 string 116 } 117 WaitStub func() error 118 waitMutex sync.RWMutex 119 waitArgsForCall []struct { 120 } 121 waitReturns struct { 122 result1 error 123 } 124 waitReturnsOnCall map[int]struct { 125 result1 error 126 } 127 invocations map[string][][]interface{} 128 invocationsMutex sync.RWMutex 129 } 130 131 func (fake *FakeConn) ClientVersion() []byte { 132 fake.clientVersionMutex.Lock() 133 ret, specificReturn := fake.clientVersionReturnsOnCall[len(fake.clientVersionArgsForCall)] 134 fake.clientVersionArgsForCall = append(fake.clientVersionArgsForCall, struct { 135 }{}) 136 fake.recordInvocation("ClientVersion", []interface{}{}) 137 fake.clientVersionMutex.Unlock() 138 if fake.ClientVersionStub != nil { 139 return fake.ClientVersionStub() 140 } 141 if specificReturn { 142 return ret.result1 143 } 144 fakeReturns := fake.clientVersionReturns 145 return fakeReturns.result1 146 } 147 148 func (fake *FakeConn) ClientVersionCallCount() int { 149 fake.clientVersionMutex.RLock() 150 defer fake.clientVersionMutex.RUnlock() 151 return len(fake.clientVersionArgsForCall) 152 } 153 154 func (fake *FakeConn) ClientVersionCalls(stub func() []byte) { 155 fake.clientVersionMutex.Lock() 156 defer fake.clientVersionMutex.Unlock() 157 fake.ClientVersionStub = stub 158 } 159 160 func (fake *FakeConn) ClientVersionReturns(result1 []byte) { 161 fake.clientVersionMutex.Lock() 162 defer fake.clientVersionMutex.Unlock() 163 fake.ClientVersionStub = nil 164 fake.clientVersionReturns = struct { 165 result1 []byte 166 }{result1} 167 } 168 169 func (fake *FakeConn) ClientVersionReturnsOnCall(i int, result1 []byte) { 170 fake.clientVersionMutex.Lock() 171 defer fake.clientVersionMutex.Unlock() 172 fake.ClientVersionStub = nil 173 if fake.clientVersionReturnsOnCall == nil { 174 fake.clientVersionReturnsOnCall = make(map[int]struct { 175 result1 []byte 176 }) 177 } 178 fake.clientVersionReturnsOnCall[i] = struct { 179 result1 []byte 180 }{result1} 181 } 182 183 func (fake *FakeConn) Close() error { 184 fake.closeMutex.Lock() 185 ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] 186 fake.closeArgsForCall = append(fake.closeArgsForCall, struct { 187 }{}) 188 fake.recordInvocation("Close", []interface{}{}) 189 fake.closeMutex.Unlock() 190 if fake.CloseStub != nil { 191 return fake.CloseStub() 192 } 193 if specificReturn { 194 return ret.result1 195 } 196 fakeReturns := fake.closeReturns 197 return fakeReturns.result1 198 } 199 200 func (fake *FakeConn) CloseCallCount() int { 201 fake.closeMutex.RLock() 202 defer fake.closeMutex.RUnlock() 203 return len(fake.closeArgsForCall) 204 } 205 206 func (fake *FakeConn) CloseCalls(stub func() error) { 207 fake.closeMutex.Lock() 208 defer fake.closeMutex.Unlock() 209 fake.CloseStub = stub 210 } 211 212 func (fake *FakeConn) CloseReturns(result1 error) { 213 fake.closeMutex.Lock() 214 defer fake.closeMutex.Unlock() 215 fake.CloseStub = nil 216 fake.closeReturns = struct { 217 result1 error 218 }{result1} 219 } 220 221 func (fake *FakeConn) CloseReturnsOnCall(i int, result1 error) { 222 fake.closeMutex.Lock() 223 defer fake.closeMutex.Unlock() 224 fake.CloseStub = nil 225 if fake.closeReturnsOnCall == nil { 226 fake.closeReturnsOnCall = make(map[int]struct { 227 result1 error 228 }) 229 } 230 fake.closeReturnsOnCall[i] = struct { 231 result1 error 232 }{result1} 233 } 234 235 func (fake *FakeConn) LocalAddr() net.Addr { 236 fake.localAddrMutex.Lock() 237 ret, specificReturn := fake.localAddrReturnsOnCall[len(fake.localAddrArgsForCall)] 238 fake.localAddrArgsForCall = append(fake.localAddrArgsForCall, struct { 239 }{}) 240 fake.recordInvocation("LocalAddr", []interface{}{}) 241 fake.localAddrMutex.Unlock() 242 if fake.LocalAddrStub != nil { 243 return fake.LocalAddrStub() 244 } 245 if specificReturn { 246 return ret.result1 247 } 248 fakeReturns := fake.localAddrReturns 249 return fakeReturns.result1 250 } 251 252 func (fake *FakeConn) LocalAddrCallCount() int { 253 fake.localAddrMutex.RLock() 254 defer fake.localAddrMutex.RUnlock() 255 return len(fake.localAddrArgsForCall) 256 } 257 258 func (fake *FakeConn) LocalAddrCalls(stub func() net.Addr) { 259 fake.localAddrMutex.Lock() 260 defer fake.localAddrMutex.Unlock() 261 fake.LocalAddrStub = stub 262 } 263 264 func (fake *FakeConn) LocalAddrReturns(result1 net.Addr) { 265 fake.localAddrMutex.Lock() 266 defer fake.localAddrMutex.Unlock() 267 fake.LocalAddrStub = nil 268 fake.localAddrReturns = struct { 269 result1 net.Addr 270 }{result1} 271 } 272 273 func (fake *FakeConn) LocalAddrReturnsOnCall(i int, result1 net.Addr) { 274 fake.localAddrMutex.Lock() 275 defer fake.localAddrMutex.Unlock() 276 fake.LocalAddrStub = nil 277 if fake.localAddrReturnsOnCall == nil { 278 fake.localAddrReturnsOnCall = make(map[int]struct { 279 result1 net.Addr 280 }) 281 } 282 fake.localAddrReturnsOnCall[i] = struct { 283 result1 net.Addr 284 }{result1} 285 } 286 287 func (fake *FakeConn) OpenChannel(arg1 string, arg2 []byte) (ssh.Channel, <-chan *ssh.Request, error) { 288 var arg2Copy []byte 289 if arg2 != nil { 290 arg2Copy = make([]byte, len(arg2)) 291 copy(arg2Copy, arg2) 292 } 293 fake.openChannelMutex.Lock() 294 ret, specificReturn := fake.openChannelReturnsOnCall[len(fake.openChannelArgsForCall)] 295 fake.openChannelArgsForCall = append(fake.openChannelArgsForCall, struct { 296 arg1 string 297 arg2 []byte 298 }{arg1, arg2Copy}) 299 fake.recordInvocation("OpenChannel", []interface{}{arg1, arg2Copy}) 300 fake.openChannelMutex.Unlock() 301 if fake.OpenChannelStub != nil { 302 return fake.OpenChannelStub(arg1, arg2) 303 } 304 if specificReturn { 305 return ret.result1, ret.result2, ret.result3 306 } 307 fakeReturns := fake.openChannelReturns 308 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 309 } 310 311 func (fake *FakeConn) OpenChannelCallCount() int { 312 fake.openChannelMutex.RLock() 313 defer fake.openChannelMutex.RUnlock() 314 return len(fake.openChannelArgsForCall) 315 } 316 317 func (fake *FakeConn) OpenChannelCalls(stub func(string, []byte) (ssh.Channel, <-chan *ssh.Request, error)) { 318 fake.openChannelMutex.Lock() 319 defer fake.openChannelMutex.Unlock() 320 fake.OpenChannelStub = stub 321 } 322 323 func (fake *FakeConn) OpenChannelArgsForCall(i int) (string, []byte) { 324 fake.openChannelMutex.RLock() 325 defer fake.openChannelMutex.RUnlock() 326 argsForCall := fake.openChannelArgsForCall[i] 327 return argsForCall.arg1, argsForCall.arg2 328 } 329 330 func (fake *FakeConn) OpenChannelReturns(result1 ssh.Channel, result2 <-chan *ssh.Request, result3 error) { 331 fake.openChannelMutex.Lock() 332 defer fake.openChannelMutex.Unlock() 333 fake.OpenChannelStub = nil 334 fake.openChannelReturns = struct { 335 result1 ssh.Channel 336 result2 <-chan *ssh.Request 337 result3 error 338 }{result1, result2, result3} 339 } 340 341 func (fake *FakeConn) OpenChannelReturnsOnCall(i int, result1 ssh.Channel, result2 <-chan *ssh.Request, result3 error) { 342 fake.openChannelMutex.Lock() 343 defer fake.openChannelMutex.Unlock() 344 fake.OpenChannelStub = nil 345 if fake.openChannelReturnsOnCall == nil { 346 fake.openChannelReturnsOnCall = make(map[int]struct { 347 result1 ssh.Channel 348 result2 <-chan *ssh.Request 349 result3 error 350 }) 351 } 352 fake.openChannelReturnsOnCall[i] = struct { 353 result1 ssh.Channel 354 result2 <-chan *ssh.Request 355 result3 error 356 }{result1, result2, result3} 357 } 358 359 func (fake *FakeConn) RemoteAddr() net.Addr { 360 fake.remoteAddrMutex.Lock() 361 ret, specificReturn := fake.remoteAddrReturnsOnCall[len(fake.remoteAddrArgsForCall)] 362 fake.remoteAddrArgsForCall = append(fake.remoteAddrArgsForCall, struct { 363 }{}) 364 fake.recordInvocation("RemoteAddr", []interface{}{}) 365 fake.remoteAddrMutex.Unlock() 366 if fake.RemoteAddrStub != nil { 367 return fake.RemoteAddrStub() 368 } 369 if specificReturn { 370 return ret.result1 371 } 372 fakeReturns := fake.remoteAddrReturns 373 return fakeReturns.result1 374 } 375 376 func (fake *FakeConn) RemoteAddrCallCount() int { 377 fake.remoteAddrMutex.RLock() 378 defer fake.remoteAddrMutex.RUnlock() 379 return len(fake.remoteAddrArgsForCall) 380 } 381 382 func (fake *FakeConn) RemoteAddrCalls(stub func() net.Addr) { 383 fake.remoteAddrMutex.Lock() 384 defer fake.remoteAddrMutex.Unlock() 385 fake.RemoteAddrStub = stub 386 } 387 388 func (fake *FakeConn) RemoteAddrReturns(result1 net.Addr) { 389 fake.remoteAddrMutex.Lock() 390 defer fake.remoteAddrMutex.Unlock() 391 fake.RemoteAddrStub = nil 392 fake.remoteAddrReturns = struct { 393 result1 net.Addr 394 }{result1} 395 } 396 397 func (fake *FakeConn) RemoteAddrReturnsOnCall(i int, result1 net.Addr) { 398 fake.remoteAddrMutex.Lock() 399 defer fake.remoteAddrMutex.Unlock() 400 fake.RemoteAddrStub = nil 401 if fake.remoteAddrReturnsOnCall == nil { 402 fake.remoteAddrReturnsOnCall = make(map[int]struct { 403 result1 net.Addr 404 }) 405 } 406 fake.remoteAddrReturnsOnCall[i] = struct { 407 result1 net.Addr 408 }{result1} 409 } 410 411 func (fake *FakeConn) SendRequest(arg1 string, arg2 bool, arg3 []byte) (bool, []byte, error) { 412 var arg3Copy []byte 413 if arg3 != nil { 414 arg3Copy = make([]byte, len(arg3)) 415 copy(arg3Copy, arg3) 416 } 417 fake.sendRequestMutex.Lock() 418 ret, specificReturn := fake.sendRequestReturnsOnCall[len(fake.sendRequestArgsForCall)] 419 fake.sendRequestArgsForCall = append(fake.sendRequestArgsForCall, struct { 420 arg1 string 421 arg2 bool 422 arg3 []byte 423 }{arg1, arg2, arg3Copy}) 424 fake.recordInvocation("SendRequest", []interface{}{arg1, arg2, arg3Copy}) 425 fake.sendRequestMutex.Unlock() 426 if fake.SendRequestStub != nil { 427 return fake.SendRequestStub(arg1, arg2, arg3) 428 } 429 if specificReturn { 430 return ret.result1, ret.result2, ret.result3 431 } 432 fakeReturns := fake.sendRequestReturns 433 return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 434 } 435 436 func (fake *FakeConn) SendRequestCallCount() int { 437 fake.sendRequestMutex.RLock() 438 defer fake.sendRequestMutex.RUnlock() 439 return len(fake.sendRequestArgsForCall) 440 } 441 442 func (fake *FakeConn) SendRequestCalls(stub func(string, bool, []byte) (bool, []byte, error)) { 443 fake.sendRequestMutex.Lock() 444 defer fake.sendRequestMutex.Unlock() 445 fake.SendRequestStub = stub 446 } 447 448 func (fake *FakeConn) SendRequestArgsForCall(i int) (string, bool, []byte) { 449 fake.sendRequestMutex.RLock() 450 defer fake.sendRequestMutex.RUnlock() 451 argsForCall := fake.sendRequestArgsForCall[i] 452 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 453 } 454 455 func (fake *FakeConn) SendRequestReturns(result1 bool, result2 []byte, result3 error) { 456 fake.sendRequestMutex.Lock() 457 defer fake.sendRequestMutex.Unlock() 458 fake.SendRequestStub = nil 459 fake.sendRequestReturns = struct { 460 result1 bool 461 result2 []byte 462 result3 error 463 }{result1, result2, result3} 464 } 465 466 func (fake *FakeConn) SendRequestReturnsOnCall(i int, result1 bool, result2 []byte, result3 error) { 467 fake.sendRequestMutex.Lock() 468 defer fake.sendRequestMutex.Unlock() 469 fake.SendRequestStub = nil 470 if fake.sendRequestReturnsOnCall == nil { 471 fake.sendRequestReturnsOnCall = make(map[int]struct { 472 result1 bool 473 result2 []byte 474 result3 error 475 }) 476 } 477 fake.sendRequestReturnsOnCall[i] = struct { 478 result1 bool 479 result2 []byte 480 result3 error 481 }{result1, result2, result3} 482 } 483 484 func (fake *FakeConn) ServerVersion() []byte { 485 fake.serverVersionMutex.Lock() 486 ret, specificReturn := fake.serverVersionReturnsOnCall[len(fake.serverVersionArgsForCall)] 487 fake.serverVersionArgsForCall = append(fake.serverVersionArgsForCall, struct { 488 }{}) 489 fake.recordInvocation("ServerVersion", []interface{}{}) 490 fake.serverVersionMutex.Unlock() 491 if fake.ServerVersionStub != nil { 492 return fake.ServerVersionStub() 493 } 494 if specificReturn { 495 return ret.result1 496 } 497 fakeReturns := fake.serverVersionReturns 498 return fakeReturns.result1 499 } 500 501 func (fake *FakeConn) ServerVersionCallCount() int { 502 fake.serverVersionMutex.RLock() 503 defer fake.serverVersionMutex.RUnlock() 504 return len(fake.serverVersionArgsForCall) 505 } 506 507 func (fake *FakeConn) ServerVersionCalls(stub func() []byte) { 508 fake.serverVersionMutex.Lock() 509 defer fake.serverVersionMutex.Unlock() 510 fake.ServerVersionStub = stub 511 } 512 513 func (fake *FakeConn) ServerVersionReturns(result1 []byte) { 514 fake.serverVersionMutex.Lock() 515 defer fake.serverVersionMutex.Unlock() 516 fake.ServerVersionStub = nil 517 fake.serverVersionReturns = struct { 518 result1 []byte 519 }{result1} 520 } 521 522 func (fake *FakeConn) ServerVersionReturnsOnCall(i int, result1 []byte) { 523 fake.serverVersionMutex.Lock() 524 defer fake.serverVersionMutex.Unlock() 525 fake.ServerVersionStub = nil 526 if fake.serverVersionReturnsOnCall == nil { 527 fake.serverVersionReturnsOnCall = make(map[int]struct { 528 result1 []byte 529 }) 530 } 531 fake.serverVersionReturnsOnCall[i] = struct { 532 result1 []byte 533 }{result1} 534 } 535 536 func (fake *FakeConn) SessionID() []byte { 537 fake.sessionIDMutex.Lock() 538 ret, specificReturn := fake.sessionIDReturnsOnCall[len(fake.sessionIDArgsForCall)] 539 fake.sessionIDArgsForCall = append(fake.sessionIDArgsForCall, struct { 540 }{}) 541 fake.recordInvocation("SessionID", []interface{}{}) 542 fake.sessionIDMutex.Unlock() 543 if fake.SessionIDStub != nil { 544 return fake.SessionIDStub() 545 } 546 if specificReturn { 547 return ret.result1 548 } 549 fakeReturns := fake.sessionIDReturns 550 return fakeReturns.result1 551 } 552 553 func (fake *FakeConn) SessionIDCallCount() int { 554 fake.sessionIDMutex.RLock() 555 defer fake.sessionIDMutex.RUnlock() 556 return len(fake.sessionIDArgsForCall) 557 } 558 559 func (fake *FakeConn) SessionIDCalls(stub func() []byte) { 560 fake.sessionIDMutex.Lock() 561 defer fake.sessionIDMutex.Unlock() 562 fake.SessionIDStub = stub 563 } 564 565 func (fake *FakeConn) SessionIDReturns(result1 []byte) { 566 fake.sessionIDMutex.Lock() 567 defer fake.sessionIDMutex.Unlock() 568 fake.SessionIDStub = nil 569 fake.sessionIDReturns = struct { 570 result1 []byte 571 }{result1} 572 } 573 574 func (fake *FakeConn) SessionIDReturnsOnCall(i int, result1 []byte) { 575 fake.sessionIDMutex.Lock() 576 defer fake.sessionIDMutex.Unlock() 577 fake.SessionIDStub = nil 578 if fake.sessionIDReturnsOnCall == nil { 579 fake.sessionIDReturnsOnCall = make(map[int]struct { 580 result1 []byte 581 }) 582 } 583 fake.sessionIDReturnsOnCall[i] = struct { 584 result1 []byte 585 }{result1} 586 } 587 588 func (fake *FakeConn) User() string { 589 fake.userMutex.Lock() 590 ret, specificReturn := fake.userReturnsOnCall[len(fake.userArgsForCall)] 591 fake.userArgsForCall = append(fake.userArgsForCall, struct { 592 }{}) 593 fake.recordInvocation("User", []interface{}{}) 594 fake.userMutex.Unlock() 595 if fake.UserStub != nil { 596 return fake.UserStub() 597 } 598 if specificReturn { 599 return ret.result1 600 } 601 fakeReturns := fake.userReturns 602 return fakeReturns.result1 603 } 604 605 func (fake *FakeConn) UserCallCount() int { 606 fake.userMutex.RLock() 607 defer fake.userMutex.RUnlock() 608 return len(fake.userArgsForCall) 609 } 610 611 func (fake *FakeConn) UserCalls(stub func() string) { 612 fake.userMutex.Lock() 613 defer fake.userMutex.Unlock() 614 fake.UserStub = stub 615 } 616 617 func (fake *FakeConn) UserReturns(result1 string) { 618 fake.userMutex.Lock() 619 defer fake.userMutex.Unlock() 620 fake.UserStub = nil 621 fake.userReturns = struct { 622 result1 string 623 }{result1} 624 } 625 626 func (fake *FakeConn) UserReturnsOnCall(i int, result1 string) { 627 fake.userMutex.Lock() 628 defer fake.userMutex.Unlock() 629 fake.UserStub = nil 630 if fake.userReturnsOnCall == nil { 631 fake.userReturnsOnCall = make(map[int]struct { 632 result1 string 633 }) 634 } 635 fake.userReturnsOnCall[i] = struct { 636 result1 string 637 }{result1} 638 } 639 640 func (fake *FakeConn) Wait() error { 641 fake.waitMutex.Lock() 642 ret, specificReturn := fake.waitReturnsOnCall[len(fake.waitArgsForCall)] 643 fake.waitArgsForCall = append(fake.waitArgsForCall, struct { 644 }{}) 645 fake.recordInvocation("Wait", []interface{}{}) 646 fake.waitMutex.Unlock() 647 if fake.WaitStub != nil { 648 return fake.WaitStub() 649 } 650 if specificReturn { 651 return ret.result1 652 } 653 fakeReturns := fake.waitReturns 654 return fakeReturns.result1 655 } 656 657 func (fake *FakeConn) WaitCallCount() int { 658 fake.waitMutex.RLock() 659 defer fake.waitMutex.RUnlock() 660 return len(fake.waitArgsForCall) 661 } 662 663 func (fake *FakeConn) WaitCalls(stub func() error) { 664 fake.waitMutex.Lock() 665 defer fake.waitMutex.Unlock() 666 fake.WaitStub = stub 667 } 668 669 func (fake *FakeConn) WaitReturns(result1 error) { 670 fake.waitMutex.Lock() 671 defer fake.waitMutex.Unlock() 672 fake.WaitStub = nil 673 fake.waitReturns = struct { 674 result1 error 675 }{result1} 676 } 677 678 func (fake *FakeConn) WaitReturnsOnCall(i int, result1 error) { 679 fake.waitMutex.Lock() 680 defer fake.waitMutex.Unlock() 681 fake.WaitStub = nil 682 if fake.waitReturnsOnCall == nil { 683 fake.waitReturnsOnCall = make(map[int]struct { 684 result1 error 685 }) 686 } 687 fake.waitReturnsOnCall[i] = struct { 688 result1 error 689 }{result1} 690 } 691 692 func (fake *FakeConn) Invocations() map[string][][]interface{} { 693 fake.invocationsMutex.RLock() 694 defer fake.invocationsMutex.RUnlock() 695 fake.clientVersionMutex.RLock() 696 defer fake.clientVersionMutex.RUnlock() 697 fake.closeMutex.RLock() 698 defer fake.closeMutex.RUnlock() 699 fake.localAddrMutex.RLock() 700 defer fake.localAddrMutex.RUnlock() 701 fake.openChannelMutex.RLock() 702 defer fake.openChannelMutex.RUnlock() 703 fake.remoteAddrMutex.RLock() 704 defer fake.remoteAddrMutex.RUnlock() 705 fake.sendRequestMutex.RLock() 706 defer fake.sendRequestMutex.RUnlock() 707 fake.serverVersionMutex.RLock() 708 defer fake.serverVersionMutex.RUnlock() 709 fake.sessionIDMutex.RLock() 710 defer fake.sessionIDMutex.RUnlock() 711 fake.userMutex.RLock() 712 defer fake.userMutex.RUnlock() 713 fake.waitMutex.RLock() 714 defer fake.waitMutex.RUnlock() 715 copiedInvocations := map[string][][]interface{}{} 716 for key, value := range fake.invocations { 717 copiedInvocations[key] = value 718 } 719 return copiedInvocations 720 } 721 722 func (fake *FakeConn) recordInvocation(key string, args []interface{}) { 723 fake.invocationsMutex.Lock() 724 defer fake.invocationsMutex.Unlock() 725 if fake.invocations == nil { 726 fake.invocations = map[string][][]interface{}{} 727 } 728 if fake.invocations[key] == nil { 729 fake.invocations[key] = [][]interface{}{} 730 } 731 fake.invocations[key] = append(fake.invocations[key], args) 732 } 733 734 var _ ssh.Conn = new(FakeConn)