github.com/jenspinney/cli@v6.42.1-0.20190207184520-7450c600020e+incompatible/command/commandfakes/fake_config.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package commandfakes 3 4 import ( 5 sync "sync" 6 time "time" 7 8 command "code.cloudfoundry.org/cli/command" 9 configv3 "code.cloudfoundry.org/cli/util/configv3" 10 ) 11 12 type FakeConfig struct { 13 APIVersionStub func() string 14 aPIVersionMutex sync.RWMutex 15 aPIVersionArgsForCall []struct { 16 } 17 aPIVersionReturns struct { 18 result1 string 19 } 20 aPIVersionReturnsOnCall map[int]struct { 21 result1 string 22 } 23 AccessTokenStub func() string 24 accessTokenMutex sync.RWMutex 25 accessTokenArgsForCall []struct { 26 } 27 accessTokenReturns struct { 28 result1 string 29 } 30 accessTokenReturnsOnCall map[int]struct { 31 result1 string 32 } 33 AddPluginStub func(configv3.Plugin) 34 addPluginMutex sync.RWMutex 35 addPluginArgsForCall []struct { 36 arg1 configv3.Plugin 37 } 38 AddPluginRepositoryStub func(string, string) 39 addPluginRepositoryMutex sync.RWMutex 40 addPluginRepositoryArgsForCall []struct { 41 arg1 string 42 arg2 string 43 } 44 BinaryNameStub func() string 45 binaryNameMutex sync.RWMutex 46 binaryNameArgsForCall []struct { 47 } 48 binaryNameReturns struct { 49 result1 string 50 } 51 binaryNameReturnsOnCall map[int]struct { 52 result1 string 53 } 54 BinaryVersionStub func() string 55 binaryVersionMutex sync.RWMutex 56 binaryVersionArgsForCall []struct { 57 } 58 binaryVersionReturns struct { 59 result1 string 60 } 61 binaryVersionReturnsOnCall map[int]struct { 62 result1 string 63 } 64 CFPasswordStub func() string 65 cFPasswordMutex sync.RWMutex 66 cFPasswordArgsForCall []struct { 67 } 68 cFPasswordReturns struct { 69 result1 string 70 } 71 cFPasswordReturnsOnCall map[int]struct { 72 result1 string 73 } 74 CFUsernameStub func() string 75 cFUsernameMutex sync.RWMutex 76 cFUsernameArgsForCall []struct { 77 } 78 cFUsernameReturns struct { 79 result1 string 80 } 81 cFUsernameReturnsOnCall map[int]struct { 82 result1 string 83 } 84 ColorEnabledStub func() configv3.ColorSetting 85 colorEnabledMutex sync.RWMutex 86 colorEnabledArgsForCall []struct { 87 } 88 colorEnabledReturns struct { 89 result1 configv3.ColorSetting 90 } 91 colorEnabledReturnsOnCall map[int]struct { 92 result1 configv3.ColorSetting 93 } 94 CurrentUserStub func() (configv3.User, error) 95 currentUserMutex sync.RWMutex 96 currentUserArgsForCall []struct { 97 } 98 currentUserReturns struct { 99 result1 configv3.User 100 result2 error 101 } 102 currentUserReturnsOnCall map[int]struct { 103 result1 configv3.User 104 result2 error 105 } 106 CurrentUserNameStub func() (string, error) 107 currentUserNameMutex sync.RWMutex 108 currentUserNameArgsForCall []struct { 109 } 110 currentUserNameReturns struct { 111 result1 string 112 result2 error 113 } 114 currentUserNameReturnsOnCall map[int]struct { 115 result1 string 116 result2 error 117 } 118 DialTimeoutStub func() time.Duration 119 dialTimeoutMutex sync.RWMutex 120 dialTimeoutArgsForCall []struct { 121 } 122 dialTimeoutReturns struct { 123 result1 time.Duration 124 } 125 dialTimeoutReturnsOnCall map[int]struct { 126 result1 time.Duration 127 } 128 DockerPasswordStub func() string 129 dockerPasswordMutex sync.RWMutex 130 dockerPasswordArgsForCall []struct { 131 } 132 dockerPasswordReturns struct { 133 result1 string 134 } 135 dockerPasswordReturnsOnCall map[int]struct { 136 result1 string 137 } 138 ExperimentalStub func() bool 139 experimentalMutex sync.RWMutex 140 experimentalArgsForCall []struct { 141 } 142 experimentalReturns struct { 143 result1 bool 144 } 145 experimentalReturnsOnCall map[int]struct { 146 result1 bool 147 } 148 GetPluginStub func(string) (configv3.Plugin, bool) 149 getPluginMutex sync.RWMutex 150 getPluginArgsForCall []struct { 151 arg1 string 152 } 153 getPluginReturns struct { 154 result1 configv3.Plugin 155 result2 bool 156 } 157 getPluginReturnsOnCall map[int]struct { 158 result1 configv3.Plugin 159 result2 bool 160 } 161 GetPluginCaseInsensitiveStub func(string) (configv3.Plugin, bool) 162 getPluginCaseInsensitiveMutex sync.RWMutex 163 getPluginCaseInsensitiveArgsForCall []struct { 164 arg1 string 165 } 166 getPluginCaseInsensitiveReturns struct { 167 result1 configv3.Plugin 168 result2 bool 169 } 170 getPluginCaseInsensitiveReturnsOnCall map[int]struct { 171 result1 configv3.Plugin 172 result2 bool 173 } 174 HasTargetedOrganizationStub func() bool 175 hasTargetedOrganizationMutex sync.RWMutex 176 hasTargetedOrganizationArgsForCall []struct { 177 } 178 hasTargetedOrganizationReturns struct { 179 result1 bool 180 } 181 hasTargetedOrganizationReturnsOnCall map[int]struct { 182 result1 bool 183 } 184 HasTargetedSpaceStub func() bool 185 hasTargetedSpaceMutex sync.RWMutex 186 hasTargetedSpaceArgsForCall []struct { 187 } 188 hasTargetedSpaceReturns struct { 189 result1 bool 190 } 191 hasTargetedSpaceReturnsOnCall map[int]struct { 192 result1 bool 193 } 194 LocaleStub func() string 195 localeMutex sync.RWMutex 196 localeArgsForCall []struct { 197 } 198 localeReturns struct { 199 result1 string 200 } 201 localeReturnsOnCall map[int]struct { 202 result1 string 203 } 204 MinCLIVersionStub func() string 205 minCLIVersionMutex sync.RWMutex 206 minCLIVersionArgsForCall []struct { 207 } 208 minCLIVersionReturns struct { 209 result1 string 210 } 211 minCLIVersionReturnsOnCall map[int]struct { 212 result1 string 213 } 214 NOAARequestRetryCountStub func() int 215 nOAARequestRetryCountMutex sync.RWMutex 216 nOAARequestRetryCountArgsForCall []struct { 217 } 218 nOAARequestRetryCountReturns struct { 219 result1 int 220 } 221 nOAARequestRetryCountReturnsOnCall map[int]struct { 222 result1 int 223 } 224 OverallPollingTimeoutStub func() time.Duration 225 overallPollingTimeoutMutex sync.RWMutex 226 overallPollingTimeoutArgsForCall []struct { 227 } 228 overallPollingTimeoutReturns struct { 229 result1 time.Duration 230 } 231 overallPollingTimeoutReturnsOnCall map[int]struct { 232 result1 time.Duration 233 } 234 PluginHomeStub func() string 235 pluginHomeMutex sync.RWMutex 236 pluginHomeArgsForCall []struct { 237 } 238 pluginHomeReturns struct { 239 result1 string 240 } 241 pluginHomeReturnsOnCall map[int]struct { 242 result1 string 243 } 244 PluginRepositoriesStub func() []configv3.PluginRepository 245 pluginRepositoriesMutex sync.RWMutex 246 pluginRepositoriesArgsForCall []struct { 247 } 248 pluginRepositoriesReturns struct { 249 result1 []configv3.PluginRepository 250 } 251 pluginRepositoriesReturnsOnCall map[int]struct { 252 result1 []configv3.PluginRepository 253 } 254 PluginsStub func() []configv3.Plugin 255 pluginsMutex sync.RWMutex 256 pluginsArgsForCall []struct { 257 } 258 pluginsReturns struct { 259 result1 []configv3.Plugin 260 } 261 pluginsReturnsOnCall map[int]struct { 262 result1 []configv3.Plugin 263 } 264 PollingIntervalStub func() time.Duration 265 pollingIntervalMutex sync.RWMutex 266 pollingIntervalArgsForCall []struct { 267 } 268 pollingIntervalReturns struct { 269 result1 time.Duration 270 } 271 pollingIntervalReturnsOnCall map[int]struct { 272 result1 time.Duration 273 } 274 RefreshTokenStub func() string 275 refreshTokenMutex sync.RWMutex 276 refreshTokenArgsForCall []struct { 277 } 278 refreshTokenReturns struct { 279 result1 string 280 } 281 refreshTokenReturnsOnCall map[int]struct { 282 result1 string 283 } 284 RemovePluginStub func(string) 285 removePluginMutex sync.RWMutex 286 removePluginArgsForCall []struct { 287 arg1 string 288 } 289 RequestRetryCountStub func() int 290 requestRetryCountMutex sync.RWMutex 291 requestRetryCountArgsForCall []struct { 292 } 293 requestRetryCountReturns struct { 294 result1 int 295 } 296 requestRetryCountReturnsOnCall map[int]struct { 297 result1 int 298 } 299 RoutingEndpointStub func() string 300 routingEndpointMutex sync.RWMutex 301 routingEndpointArgsForCall []struct { 302 } 303 routingEndpointReturns struct { 304 result1 string 305 } 306 routingEndpointReturnsOnCall map[int]struct { 307 result1 string 308 } 309 SSHOAuthClientStub func() string 310 sSHOAuthClientMutex sync.RWMutex 311 sSHOAuthClientArgsForCall []struct { 312 } 313 sSHOAuthClientReturns struct { 314 result1 string 315 } 316 sSHOAuthClientReturnsOnCall map[int]struct { 317 result1 string 318 } 319 SetAccessTokenStub func(string) 320 setAccessTokenMutex sync.RWMutex 321 setAccessTokenArgsForCall []struct { 322 arg1 string 323 } 324 SetOrganizationInformationStub func(string, string) 325 setOrganizationInformationMutex sync.RWMutex 326 setOrganizationInformationArgsForCall []struct { 327 arg1 string 328 arg2 string 329 } 330 SetRefreshTokenStub func(string) 331 setRefreshTokenMutex sync.RWMutex 332 setRefreshTokenArgsForCall []struct { 333 arg1 string 334 } 335 SetSpaceInformationStub func(string, string, bool) 336 setSpaceInformationMutex sync.RWMutex 337 setSpaceInformationArgsForCall []struct { 338 arg1 string 339 arg2 string 340 arg3 bool 341 } 342 SetTargetInformationStub func(string, string, string, string, string, string, bool) 343 setTargetInformationMutex sync.RWMutex 344 setTargetInformationArgsForCall []struct { 345 arg1 string 346 arg2 string 347 arg3 string 348 arg4 string 349 arg5 string 350 arg6 string 351 arg7 bool 352 } 353 SetTokenInformationStub func(string, string, string) 354 setTokenInformationMutex sync.RWMutex 355 setTokenInformationArgsForCall []struct { 356 arg1 string 357 arg2 string 358 arg3 string 359 } 360 SetUAAClientCredentialsStub func(string, string) 361 setUAAClientCredentialsMutex sync.RWMutex 362 setUAAClientCredentialsArgsForCall []struct { 363 arg1 string 364 arg2 string 365 } 366 SetUAAEndpointStub func(string) 367 setUAAEndpointMutex sync.RWMutex 368 setUAAEndpointArgsForCall []struct { 369 arg1 string 370 } 371 SetUAAGrantTypeStub func(string) 372 setUAAGrantTypeMutex sync.RWMutex 373 setUAAGrantTypeArgsForCall []struct { 374 arg1 string 375 } 376 SkipSSLValidationStub func() bool 377 skipSSLValidationMutex sync.RWMutex 378 skipSSLValidationArgsForCall []struct { 379 } 380 skipSSLValidationReturns struct { 381 result1 bool 382 } 383 skipSSLValidationReturnsOnCall map[int]struct { 384 result1 bool 385 } 386 StagingTimeoutStub func() time.Duration 387 stagingTimeoutMutex sync.RWMutex 388 stagingTimeoutArgsForCall []struct { 389 } 390 stagingTimeoutReturns struct { 391 result1 time.Duration 392 } 393 stagingTimeoutReturnsOnCall map[int]struct { 394 result1 time.Duration 395 } 396 StartupTimeoutStub func() time.Duration 397 startupTimeoutMutex sync.RWMutex 398 startupTimeoutArgsForCall []struct { 399 } 400 startupTimeoutReturns struct { 401 result1 time.Duration 402 } 403 startupTimeoutReturnsOnCall map[int]struct { 404 result1 time.Duration 405 } 406 TargetStub func() string 407 targetMutex sync.RWMutex 408 targetArgsForCall []struct { 409 } 410 targetReturns struct { 411 result1 string 412 } 413 targetReturnsOnCall map[int]struct { 414 result1 string 415 } 416 TargetedOrganizationStub func() configv3.Organization 417 targetedOrganizationMutex sync.RWMutex 418 targetedOrganizationArgsForCall []struct { 419 } 420 targetedOrganizationReturns struct { 421 result1 configv3.Organization 422 } 423 targetedOrganizationReturnsOnCall map[int]struct { 424 result1 configv3.Organization 425 } 426 TargetedOrganizationNameStub func() string 427 targetedOrganizationNameMutex sync.RWMutex 428 targetedOrganizationNameArgsForCall []struct { 429 } 430 targetedOrganizationNameReturns struct { 431 result1 string 432 } 433 targetedOrganizationNameReturnsOnCall map[int]struct { 434 result1 string 435 } 436 TargetedSpaceStub func() configv3.Space 437 targetedSpaceMutex sync.RWMutex 438 targetedSpaceArgsForCall []struct { 439 } 440 targetedSpaceReturns struct { 441 result1 configv3.Space 442 } 443 targetedSpaceReturnsOnCall map[int]struct { 444 result1 configv3.Space 445 } 446 UAADisableKeepAlivesStub func() bool 447 uAADisableKeepAlivesMutex sync.RWMutex 448 uAADisableKeepAlivesArgsForCall []struct { 449 } 450 uAADisableKeepAlivesReturns struct { 451 result1 bool 452 } 453 uAADisableKeepAlivesReturnsOnCall map[int]struct { 454 result1 bool 455 } 456 UAAGrantTypeStub func() string 457 uAAGrantTypeMutex sync.RWMutex 458 uAAGrantTypeArgsForCall []struct { 459 } 460 uAAGrantTypeReturns struct { 461 result1 string 462 } 463 uAAGrantTypeReturnsOnCall map[int]struct { 464 result1 string 465 } 466 UAAOAuthClientStub func() string 467 uAAOAuthClientMutex sync.RWMutex 468 uAAOAuthClientArgsForCall []struct { 469 } 470 uAAOAuthClientReturns struct { 471 result1 string 472 } 473 uAAOAuthClientReturnsOnCall map[int]struct { 474 result1 string 475 } 476 UAAOAuthClientSecretStub func() string 477 uAAOAuthClientSecretMutex sync.RWMutex 478 uAAOAuthClientSecretArgsForCall []struct { 479 } 480 uAAOAuthClientSecretReturns struct { 481 result1 string 482 } 483 uAAOAuthClientSecretReturnsOnCall map[int]struct { 484 result1 string 485 } 486 UnsetOrganizationAndSpaceInformationStub func() 487 unsetOrganizationAndSpaceInformationMutex sync.RWMutex 488 unsetOrganizationAndSpaceInformationArgsForCall []struct { 489 } 490 UnsetSpaceInformationStub func() 491 unsetSpaceInformationMutex sync.RWMutex 492 unsetSpaceInformationArgsForCall []struct { 493 } 494 UnsetUserInformationStub func() 495 unsetUserInformationMutex sync.RWMutex 496 unsetUserInformationArgsForCall []struct { 497 } 498 V7SetSpaceInformationStub func(string, string) 499 v7SetSpaceInformationMutex sync.RWMutex 500 v7SetSpaceInformationArgsForCall []struct { 501 arg1 string 502 arg2 string 503 } 504 VerboseStub func() (bool, []string) 505 verboseMutex sync.RWMutex 506 verboseArgsForCall []struct { 507 } 508 verboseReturns struct { 509 result1 bool 510 result2 []string 511 } 512 verboseReturnsOnCall map[int]struct { 513 result1 bool 514 result2 []string 515 } 516 WritePluginConfigStub func() error 517 writePluginConfigMutex sync.RWMutex 518 writePluginConfigArgsForCall []struct { 519 } 520 writePluginConfigReturns struct { 521 result1 error 522 } 523 writePluginConfigReturnsOnCall map[int]struct { 524 result1 error 525 } 526 invocations map[string][][]interface{} 527 invocationsMutex sync.RWMutex 528 } 529 530 func (fake *FakeConfig) APIVersion() string { 531 fake.aPIVersionMutex.Lock() 532 ret, specificReturn := fake.aPIVersionReturnsOnCall[len(fake.aPIVersionArgsForCall)] 533 fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct { 534 }{}) 535 fake.recordInvocation("APIVersion", []interface{}{}) 536 fake.aPIVersionMutex.Unlock() 537 if fake.APIVersionStub != nil { 538 return fake.APIVersionStub() 539 } 540 if specificReturn { 541 return ret.result1 542 } 543 fakeReturns := fake.aPIVersionReturns 544 return fakeReturns.result1 545 } 546 547 func (fake *FakeConfig) APIVersionCallCount() int { 548 fake.aPIVersionMutex.RLock() 549 defer fake.aPIVersionMutex.RUnlock() 550 return len(fake.aPIVersionArgsForCall) 551 } 552 553 func (fake *FakeConfig) APIVersionCalls(stub func() string) { 554 fake.aPIVersionMutex.Lock() 555 defer fake.aPIVersionMutex.Unlock() 556 fake.APIVersionStub = stub 557 } 558 559 func (fake *FakeConfig) APIVersionReturns(result1 string) { 560 fake.aPIVersionMutex.Lock() 561 defer fake.aPIVersionMutex.Unlock() 562 fake.APIVersionStub = nil 563 fake.aPIVersionReturns = struct { 564 result1 string 565 }{result1} 566 } 567 568 func (fake *FakeConfig) APIVersionReturnsOnCall(i int, result1 string) { 569 fake.aPIVersionMutex.Lock() 570 defer fake.aPIVersionMutex.Unlock() 571 fake.APIVersionStub = nil 572 if fake.aPIVersionReturnsOnCall == nil { 573 fake.aPIVersionReturnsOnCall = make(map[int]struct { 574 result1 string 575 }) 576 } 577 fake.aPIVersionReturnsOnCall[i] = struct { 578 result1 string 579 }{result1} 580 } 581 582 func (fake *FakeConfig) AccessToken() string { 583 fake.accessTokenMutex.Lock() 584 ret, specificReturn := fake.accessTokenReturnsOnCall[len(fake.accessTokenArgsForCall)] 585 fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct { 586 }{}) 587 fake.recordInvocation("AccessToken", []interface{}{}) 588 fake.accessTokenMutex.Unlock() 589 if fake.AccessTokenStub != nil { 590 return fake.AccessTokenStub() 591 } 592 if specificReturn { 593 return ret.result1 594 } 595 fakeReturns := fake.accessTokenReturns 596 return fakeReturns.result1 597 } 598 599 func (fake *FakeConfig) AccessTokenCallCount() int { 600 fake.accessTokenMutex.RLock() 601 defer fake.accessTokenMutex.RUnlock() 602 return len(fake.accessTokenArgsForCall) 603 } 604 605 func (fake *FakeConfig) AccessTokenCalls(stub func() string) { 606 fake.accessTokenMutex.Lock() 607 defer fake.accessTokenMutex.Unlock() 608 fake.AccessTokenStub = stub 609 } 610 611 func (fake *FakeConfig) AccessTokenReturns(result1 string) { 612 fake.accessTokenMutex.Lock() 613 defer fake.accessTokenMutex.Unlock() 614 fake.AccessTokenStub = nil 615 fake.accessTokenReturns = struct { 616 result1 string 617 }{result1} 618 } 619 620 func (fake *FakeConfig) AccessTokenReturnsOnCall(i int, result1 string) { 621 fake.accessTokenMutex.Lock() 622 defer fake.accessTokenMutex.Unlock() 623 fake.AccessTokenStub = nil 624 if fake.accessTokenReturnsOnCall == nil { 625 fake.accessTokenReturnsOnCall = make(map[int]struct { 626 result1 string 627 }) 628 } 629 fake.accessTokenReturnsOnCall[i] = struct { 630 result1 string 631 }{result1} 632 } 633 634 func (fake *FakeConfig) AddPlugin(arg1 configv3.Plugin) { 635 fake.addPluginMutex.Lock() 636 fake.addPluginArgsForCall = append(fake.addPluginArgsForCall, struct { 637 arg1 configv3.Plugin 638 }{arg1}) 639 fake.recordInvocation("AddPlugin", []interface{}{arg1}) 640 fake.addPluginMutex.Unlock() 641 if fake.AddPluginStub != nil { 642 fake.AddPluginStub(arg1) 643 } 644 } 645 646 func (fake *FakeConfig) AddPluginCallCount() int { 647 fake.addPluginMutex.RLock() 648 defer fake.addPluginMutex.RUnlock() 649 return len(fake.addPluginArgsForCall) 650 } 651 652 func (fake *FakeConfig) AddPluginCalls(stub func(configv3.Plugin)) { 653 fake.addPluginMutex.Lock() 654 defer fake.addPluginMutex.Unlock() 655 fake.AddPluginStub = stub 656 } 657 658 func (fake *FakeConfig) AddPluginArgsForCall(i int) configv3.Plugin { 659 fake.addPluginMutex.RLock() 660 defer fake.addPluginMutex.RUnlock() 661 argsForCall := fake.addPluginArgsForCall[i] 662 return argsForCall.arg1 663 } 664 665 func (fake *FakeConfig) AddPluginRepository(arg1 string, arg2 string) { 666 fake.addPluginRepositoryMutex.Lock() 667 fake.addPluginRepositoryArgsForCall = append(fake.addPluginRepositoryArgsForCall, struct { 668 arg1 string 669 arg2 string 670 }{arg1, arg2}) 671 fake.recordInvocation("AddPluginRepository", []interface{}{arg1, arg2}) 672 fake.addPluginRepositoryMutex.Unlock() 673 if fake.AddPluginRepositoryStub != nil { 674 fake.AddPluginRepositoryStub(arg1, arg2) 675 } 676 } 677 678 func (fake *FakeConfig) AddPluginRepositoryCallCount() int { 679 fake.addPluginRepositoryMutex.RLock() 680 defer fake.addPluginRepositoryMutex.RUnlock() 681 return len(fake.addPluginRepositoryArgsForCall) 682 } 683 684 func (fake *FakeConfig) AddPluginRepositoryCalls(stub func(string, string)) { 685 fake.addPluginRepositoryMutex.Lock() 686 defer fake.addPluginRepositoryMutex.Unlock() 687 fake.AddPluginRepositoryStub = stub 688 } 689 690 func (fake *FakeConfig) AddPluginRepositoryArgsForCall(i int) (string, string) { 691 fake.addPluginRepositoryMutex.RLock() 692 defer fake.addPluginRepositoryMutex.RUnlock() 693 argsForCall := fake.addPluginRepositoryArgsForCall[i] 694 return argsForCall.arg1, argsForCall.arg2 695 } 696 697 func (fake *FakeConfig) BinaryName() string { 698 fake.binaryNameMutex.Lock() 699 ret, specificReturn := fake.binaryNameReturnsOnCall[len(fake.binaryNameArgsForCall)] 700 fake.binaryNameArgsForCall = append(fake.binaryNameArgsForCall, struct { 701 }{}) 702 fake.recordInvocation("BinaryName", []interface{}{}) 703 fake.binaryNameMutex.Unlock() 704 if fake.BinaryNameStub != nil { 705 return fake.BinaryNameStub() 706 } 707 if specificReturn { 708 return ret.result1 709 } 710 fakeReturns := fake.binaryNameReturns 711 return fakeReturns.result1 712 } 713 714 func (fake *FakeConfig) BinaryNameCallCount() int { 715 fake.binaryNameMutex.RLock() 716 defer fake.binaryNameMutex.RUnlock() 717 return len(fake.binaryNameArgsForCall) 718 } 719 720 func (fake *FakeConfig) BinaryNameCalls(stub func() string) { 721 fake.binaryNameMutex.Lock() 722 defer fake.binaryNameMutex.Unlock() 723 fake.BinaryNameStub = stub 724 } 725 726 func (fake *FakeConfig) BinaryNameReturns(result1 string) { 727 fake.binaryNameMutex.Lock() 728 defer fake.binaryNameMutex.Unlock() 729 fake.BinaryNameStub = nil 730 fake.binaryNameReturns = struct { 731 result1 string 732 }{result1} 733 } 734 735 func (fake *FakeConfig) BinaryNameReturnsOnCall(i int, result1 string) { 736 fake.binaryNameMutex.Lock() 737 defer fake.binaryNameMutex.Unlock() 738 fake.BinaryNameStub = nil 739 if fake.binaryNameReturnsOnCall == nil { 740 fake.binaryNameReturnsOnCall = make(map[int]struct { 741 result1 string 742 }) 743 } 744 fake.binaryNameReturnsOnCall[i] = struct { 745 result1 string 746 }{result1} 747 } 748 749 func (fake *FakeConfig) BinaryVersion() string { 750 fake.binaryVersionMutex.Lock() 751 ret, specificReturn := fake.binaryVersionReturnsOnCall[len(fake.binaryVersionArgsForCall)] 752 fake.binaryVersionArgsForCall = append(fake.binaryVersionArgsForCall, struct { 753 }{}) 754 fake.recordInvocation("BinaryVersion", []interface{}{}) 755 fake.binaryVersionMutex.Unlock() 756 if fake.BinaryVersionStub != nil { 757 return fake.BinaryVersionStub() 758 } 759 if specificReturn { 760 return ret.result1 761 } 762 fakeReturns := fake.binaryVersionReturns 763 return fakeReturns.result1 764 } 765 766 func (fake *FakeConfig) BinaryVersionCallCount() int { 767 fake.binaryVersionMutex.RLock() 768 defer fake.binaryVersionMutex.RUnlock() 769 return len(fake.binaryVersionArgsForCall) 770 } 771 772 func (fake *FakeConfig) BinaryVersionCalls(stub func() string) { 773 fake.binaryVersionMutex.Lock() 774 defer fake.binaryVersionMutex.Unlock() 775 fake.BinaryVersionStub = stub 776 } 777 778 func (fake *FakeConfig) BinaryVersionReturns(result1 string) { 779 fake.binaryVersionMutex.Lock() 780 defer fake.binaryVersionMutex.Unlock() 781 fake.BinaryVersionStub = nil 782 fake.binaryVersionReturns = struct { 783 result1 string 784 }{result1} 785 } 786 787 func (fake *FakeConfig) BinaryVersionReturnsOnCall(i int, result1 string) { 788 fake.binaryVersionMutex.Lock() 789 defer fake.binaryVersionMutex.Unlock() 790 fake.BinaryVersionStub = nil 791 if fake.binaryVersionReturnsOnCall == nil { 792 fake.binaryVersionReturnsOnCall = make(map[int]struct { 793 result1 string 794 }) 795 } 796 fake.binaryVersionReturnsOnCall[i] = struct { 797 result1 string 798 }{result1} 799 } 800 801 func (fake *FakeConfig) CFPassword() string { 802 fake.cFPasswordMutex.Lock() 803 ret, specificReturn := fake.cFPasswordReturnsOnCall[len(fake.cFPasswordArgsForCall)] 804 fake.cFPasswordArgsForCall = append(fake.cFPasswordArgsForCall, struct { 805 }{}) 806 fake.recordInvocation("CFPassword", []interface{}{}) 807 fake.cFPasswordMutex.Unlock() 808 if fake.CFPasswordStub != nil { 809 return fake.CFPasswordStub() 810 } 811 if specificReturn { 812 return ret.result1 813 } 814 fakeReturns := fake.cFPasswordReturns 815 return fakeReturns.result1 816 } 817 818 func (fake *FakeConfig) CFPasswordCallCount() int { 819 fake.cFPasswordMutex.RLock() 820 defer fake.cFPasswordMutex.RUnlock() 821 return len(fake.cFPasswordArgsForCall) 822 } 823 824 func (fake *FakeConfig) CFPasswordCalls(stub func() string) { 825 fake.cFPasswordMutex.Lock() 826 defer fake.cFPasswordMutex.Unlock() 827 fake.CFPasswordStub = stub 828 } 829 830 func (fake *FakeConfig) CFPasswordReturns(result1 string) { 831 fake.cFPasswordMutex.Lock() 832 defer fake.cFPasswordMutex.Unlock() 833 fake.CFPasswordStub = nil 834 fake.cFPasswordReturns = struct { 835 result1 string 836 }{result1} 837 } 838 839 func (fake *FakeConfig) CFPasswordReturnsOnCall(i int, result1 string) { 840 fake.cFPasswordMutex.Lock() 841 defer fake.cFPasswordMutex.Unlock() 842 fake.CFPasswordStub = nil 843 if fake.cFPasswordReturnsOnCall == nil { 844 fake.cFPasswordReturnsOnCall = make(map[int]struct { 845 result1 string 846 }) 847 } 848 fake.cFPasswordReturnsOnCall[i] = struct { 849 result1 string 850 }{result1} 851 } 852 853 func (fake *FakeConfig) CFUsername() string { 854 fake.cFUsernameMutex.Lock() 855 ret, specificReturn := fake.cFUsernameReturnsOnCall[len(fake.cFUsernameArgsForCall)] 856 fake.cFUsernameArgsForCall = append(fake.cFUsernameArgsForCall, struct { 857 }{}) 858 fake.recordInvocation("CFUsername", []interface{}{}) 859 fake.cFUsernameMutex.Unlock() 860 if fake.CFUsernameStub != nil { 861 return fake.CFUsernameStub() 862 } 863 if specificReturn { 864 return ret.result1 865 } 866 fakeReturns := fake.cFUsernameReturns 867 return fakeReturns.result1 868 } 869 870 func (fake *FakeConfig) CFUsernameCallCount() int { 871 fake.cFUsernameMutex.RLock() 872 defer fake.cFUsernameMutex.RUnlock() 873 return len(fake.cFUsernameArgsForCall) 874 } 875 876 func (fake *FakeConfig) CFUsernameCalls(stub func() string) { 877 fake.cFUsernameMutex.Lock() 878 defer fake.cFUsernameMutex.Unlock() 879 fake.CFUsernameStub = stub 880 } 881 882 func (fake *FakeConfig) CFUsernameReturns(result1 string) { 883 fake.cFUsernameMutex.Lock() 884 defer fake.cFUsernameMutex.Unlock() 885 fake.CFUsernameStub = nil 886 fake.cFUsernameReturns = struct { 887 result1 string 888 }{result1} 889 } 890 891 func (fake *FakeConfig) CFUsernameReturnsOnCall(i int, result1 string) { 892 fake.cFUsernameMutex.Lock() 893 defer fake.cFUsernameMutex.Unlock() 894 fake.CFUsernameStub = nil 895 if fake.cFUsernameReturnsOnCall == nil { 896 fake.cFUsernameReturnsOnCall = make(map[int]struct { 897 result1 string 898 }) 899 } 900 fake.cFUsernameReturnsOnCall[i] = struct { 901 result1 string 902 }{result1} 903 } 904 905 func (fake *FakeConfig) ColorEnabled() configv3.ColorSetting { 906 fake.colorEnabledMutex.Lock() 907 ret, specificReturn := fake.colorEnabledReturnsOnCall[len(fake.colorEnabledArgsForCall)] 908 fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct { 909 }{}) 910 fake.recordInvocation("ColorEnabled", []interface{}{}) 911 fake.colorEnabledMutex.Unlock() 912 if fake.ColorEnabledStub != nil { 913 return fake.ColorEnabledStub() 914 } 915 if specificReturn { 916 return ret.result1 917 } 918 fakeReturns := fake.colorEnabledReturns 919 return fakeReturns.result1 920 } 921 922 func (fake *FakeConfig) ColorEnabledCallCount() int { 923 fake.colorEnabledMutex.RLock() 924 defer fake.colorEnabledMutex.RUnlock() 925 return len(fake.colorEnabledArgsForCall) 926 } 927 928 func (fake *FakeConfig) ColorEnabledCalls(stub func() configv3.ColorSetting) { 929 fake.colorEnabledMutex.Lock() 930 defer fake.colorEnabledMutex.Unlock() 931 fake.ColorEnabledStub = stub 932 } 933 934 func (fake *FakeConfig) ColorEnabledReturns(result1 configv3.ColorSetting) { 935 fake.colorEnabledMutex.Lock() 936 defer fake.colorEnabledMutex.Unlock() 937 fake.ColorEnabledStub = nil 938 fake.colorEnabledReturns = struct { 939 result1 configv3.ColorSetting 940 }{result1} 941 } 942 943 func (fake *FakeConfig) ColorEnabledReturnsOnCall(i int, result1 configv3.ColorSetting) { 944 fake.colorEnabledMutex.Lock() 945 defer fake.colorEnabledMutex.Unlock() 946 fake.ColorEnabledStub = nil 947 if fake.colorEnabledReturnsOnCall == nil { 948 fake.colorEnabledReturnsOnCall = make(map[int]struct { 949 result1 configv3.ColorSetting 950 }) 951 } 952 fake.colorEnabledReturnsOnCall[i] = struct { 953 result1 configv3.ColorSetting 954 }{result1} 955 } 956 957 func (fake *FakeConfig) CurrentUser() (configv3.User, error) { 958 fake.currentUserMutex.Lock() 959 ret, specificReturn := fake.currentUserReturnsOnCall[len(fake.currentUserArgsForCall)] 960 fake.currentUserArgsForCall = append(fake.currentUserArgsForCall, struct { 961 }{}) 962 fake.recordInvocation("CurrentUser", []interface{}{}) 963 fake.currentUserMutex.Unlock() 964 if fake.CurrentUserStub != nil { 965 return fake.CurrentUserStub() 966 } 967 if specificReturn { 968 return ret.result1, ret.result2 969 } 970 fakeReturns := fake.currentUserReturns 971 return fakeReturns.result1, fakeReturns.result2 972 } 973 974 func (fake *FakeConfig) CurrentUserCallCount() int { 975 fake.currentUserMutex.RLock() 976 defer fake.currentUserMutex.RUnlock() 977 return len(fake.currentUserArgsForCall) 978 } 979 980 func (fake *FakeConfig) CurrentUserCalls(stub func() (configv3.User, error)) { 981 fake.currentUserMutex.Lock() 982 defer fake.currentUserMutex.Unlock() 983 fake.CurrentUserStub = stub 984 } 985 986 func (fake *FakeConfig) CurrentUserReturns(result1 configv3.User, result2 error) { 987 fake.currentUserMutex.Lock() 988 defer fake.currentUserMutex.Unlock() 989 fake.CurrentUserStub = nil 990 fake.currentUserReturns = struct { 991 result1 configv3.User 992 result2 error 993 }{result1, result2} 994 } 995 996 func (fake *FakeConfig) CurrentUserReturnsOnCall(i int, result1 configv3.User, result2 error) { 997 fake.currentUserMutex.Lock() 998 defer fake.currentUserMutex.Unlock() 999 fake.CurrentUserStub = nil 1000 if fake.currentUserReturnsOnCall == nil { 1001 fake.currentUserReturnsOnCall = make(map[int]struct { 1002 result1 configv3.User 1003 result2 error 1004 }) 1005 } 1006 fake.currentUserReturnsOnCall[i] = struct { 1007 result1 configv3.User 1008 result2 error 1009 }{result1, result2} 1010 } 1011 1012 func (fake *FakeConfig) CurrentUserName() (string, error) { 1013 fake.currentUserNameMutex.Lock() 1014 ret, specificReturn := fake.currentUserNameReturnsOnCall[len(fake.currentUserNameArgsForCall)] 1015 fake.currentUserNameArgsForCall = append(fake.currentUserNameArgsForCall, struct { 1016 }{}) 1017 fake.recordInvocation("CurrentUserName", []interface{}{}) 1018 fake.currentUserNameMutex.Unlock() 1019 if fake.CurrentUserNameStub != nil { 1020 return fake.CurrentUserNameStub() 1021 } 1022 if specificReturn { 1023 return ret.result1, ret.result2 1024 } 1025 fakeReturns := fake.currentUserNameReturns 1026 return fakeReturns.result1, fakeReturns.result2 1027 } 1028 1029 func (fake *FakeConfig) CurrentUserNameCallCount() int { 1030 fake.currentUserNameMutex.RLock() 1031 defer fake.currentUserNameMutex.RUnlock() 1032 return len(fake.currentUserNameArgsForCall) 1033 } 1034 1035 func (fake *FakeConfig) CurrentUserNameCalls(stub func() (string, error)) { 1036 fake.currentUserNameMutex.Lock() 1037 defer fake.currentUserNameMutex.Unlock() 1038 fake.CurrentUserNameStub = stub 1039 } 1040 1041 func (fake *FakeConfig) CurrentUserNameReturns(result1 string, result2 error) { 1042 fake.currentUserNameMutex.Lock() 1043 defer fake.currentUserNameMutex.Unlock() 1044 fake.CurrentUserNameStub = nil 1045 fake.currentUserNameReturns = struct { 1046 result1 string 1047 result2 error 1048 }{result1, result2} 1049 } 1050 1051 func (fake *FakeConfig) CurrentUserNameReturnsOnCall(i int, result1 string, result2 error) { 1052 fake.currentUserNameMutex.Lock() 1053 defer fake.currentUserNameMutex.Unlock() 1054 fake.CurrentUserNameStub = nil 1055 if fake.currentUserNameReturnsOnCall == nil { 1056 fake.currentUserNameReturnsOnCall = make(map[int]struct { 1057 result1 string 1058 result2 error 1059 }) 1060 } 1061 fake.currentUserNameReturnsOnCall[i] = struct { 1062 result1 string 1063 result2 error 1064 }{result1, result2} 1065 } 1066 1067 func (fake *FakeConfig) DialTimeout() time.Duration { 1068 fake.dialTimeoutMutex.Lock() 1069 ret, specificReturn := fake.dialTimeoutReturnsOnCall[len(fake.dialTimeoutArgsForCall)] 1070 fake.dialTimeoutArgsForCall = append(fake.dialTimeoutArgsForCall, struct { 1071 }{}) 1072 fake.recordInvocation("DialTimeout", []interface{}{}) 1073 fake.dialTimeoutMutex.Unlock() 1074 if fake.DialTimeoutStub != nil { 1075 return fake.DialTimeoutStub() 1076 } 1077 if specificReturn { 1078 return ret.result1 1079 } 1080 fakeReturns := fake.dialTimeoutReturns 1081 return fakeReturns.result1 1082 } 1083 1084 func (fake *FakeConfig) DialTimeoutCallCount() int { 1085 fake.dialTimeoutMutex.RLock() 1086 defer fake.dialTimeoutMutex.RUnlock() 1087 return len(fake.dialTimeoutArgsForCall) 1088 } 1089 1090 func (fake *FakeConfig) DialTimeoutCalls(stub func() time.Duration) { 1091 fake.dialTimeoutMutex.Lock() 1092 defer fake.dialTimeoutMutex.Unlock() 1093 fake.DialTimeoutStub = stub 1094 } 1095 1096 func (fake *FakeConfig) DialTimeoutReturns(result1 time.Duration) { 1097 fake.dialTimeoutMutex.Lock() 1098 defer fake.dialTimeoutMutex.Unlock() 1099 fake.DialTimeoutStub = nil 1100 fake.dialTimeoutReturns = struct { 1101 result1 time.Duration 1102 }{result1} 1103 } 1104 1105 func (fake *FakeConfig) DialTimeoutReturnsOnCall(i int, result1 time.Duration) { 1106 fake.dialTimeoutMutex.Lock() 1107 defer fake.dialTimeoutMutex.Unlock() 1108 fake.DialTimeoutStub = nil 1109 if fake.dialTimeoutReturnsOnCall == nil { 1110 fake.dialTimeoutReturnsOnCall = make(map[int]struct { 1111 result1 time.Duration 1112 }) 1113 } 1114 fake.dialTimeoutReturnsOnCall[i] = struct { 1115 result1 time.Duration 1116 }{result1} 1117 } 1118 1119 func (fake *FakeConfig) DockerPassword() string { 1120 fake.dockerPasswordMutex.Lock() 1121 ret, specificReturn := fake.dockerPasswordReturnsOnCall[len(fake.dockerPasswordArgsForCall)] 1122 fake.dockerPasswordArgsForCall = append(fake.dockerPasswordArgsForCall, struct { 1123 }{}) 1124 fake.recordInvocation("DockerPassword", []interface{}{}) 1125 fake.dockerPasswordMutex.Unlock() 1126 if fake.DockerPasswordStub != nil { 1127 return fake.DockerPasswordStub() 1128 } 1129 if specificReturn { 1130 return ret.result1 1131 } 1132 fakeReturns := fake.dockerPasswordReturns 1133 return fakeReturns.result1 1134 } 1135 1136 func (fake *FakeConfig) DockerPasswordCallCount() int { 1137 fake.dockerPasswordMutex.RLock() 1138 defer fake.dockerPasswordMutex.RUnlock() 1139 return len(fake.dockerPasswordArgsForCall) 1140 } 1141 1142 func (fake *FakeConfig) DockerPasswordCalls(stub func() string) { 1143 fake.dockerPasswordMutex.Lock() 1144 defer fake.dockerPasswordMutex.Unlock() 1145 fake.DockerPasswordStub = stub 1146 } 1147 1148 func (fake *FakeConfig) DockerPasswordReturns(result1 string) { 1149 fake.dockerPasswordMutex.Lock() 1150 defer fake.dockerPasswordMutex.Unlock() 1151 fake.DockerPasswordStub = nil 1152 fake.dockerPasswordReturns = struct { 1153 result1 string 1154 }{result1} 1155 } 1156 1157 func (fake *FakeConfig) DockerPasswordReturnsOnCall(i int, result1 string) { 1158 fake.dockerPasswordMutex.Lock() 1159 defer fake.dockerPasswordMutex.Unlock() 1160 fake.DockerPasswordStub = nil 1161 if fake.dockerPasswordReturnsOnCall == nil { 1162 fake.dockerPasswordReturnsOnCall = make(map[int]struct { 1163 result1 string 1164 }) 1165 } 1166 fake.dockerPasswordReturnsOnCall[i] = struct { 1167 result1 string 1168 }{result1} 1169 } 1170 1171 func (fake *FakeConfig) Experimental() bool { 1172 fake.experimentalMutex.Lock() 1173 ret, specificReturn := fake.experimentalReturnsOnCall[len(fake.experimentalArgsForCall)] 1174 fake.experimentalArgsForCall = append(fake.experimentalArgsForCall, struct { 1175 }{}) 1176 fake.recordInvocation("Experimental", []interface{}{}) 1177 fake.experimentalMutex.Unlock() 1178 if fake.ExperimentalStub != nil { 1179 return fake.ExperimentalStub() 1180 } 1181 if specificReturn { 1182 return ret.result1 1183 } 1184 fakeReturns := fake.experimentalReturns 1185 return fakeReturns.result1 1186 } 1187 1188 func (fake *FakeConfig) ExperimentalCallCount() int { 1189 fake.experimentalMutex.RLock() 1190 defer fake.experimentalMutex.RUnlock() 1191 return len(fake.experimentalArgsForCall) 1192 } 1193 1194 func (fake *FakeConfig) ExperimentalCalls(stub func() bool) { 1195 fake.experimentalMutex.Lock() 1196 defer fake.experimentalMutex.Unlock() 1197 fake.ExperimentalStub = stub 1198 } 1199 1200 func (fake *FakeConfig) ExperimentalReturns(result1 bool) { 1201 fake.experimentalMutex.Lock() 1202 defer fake.experimentalMutex.Unlock() 1203 fake.ExperimentalStub = nil 1204 fake.experimentalReturns = struct { 1205 result1 bool 1206 }{result1} 1207 } 1208 1209 func (fake *FakeConfig) ExperimentalReturnsOnCall(i int, result1 bool) { 1210 fake.experimentalMutex.Lock() 1211 defer fake.experimentalMutex.Unlock() 1212 fake.ExperimentalStub = nil 1213 if fake.experimentalReturnsOnCall == nil { 1214 fake.experimentalReturnsOnCall = make(map[int]struct { 1215 result1 bool 1216 }) 1217 } 1218 fake.experimentalReturnsOnCall[i] = struct { 1219 result1 bool 1220 }{result1} 1221 } 1222 1223 func (fake *FakeConfig) GetPlugin(arg1 string) (configv3.Plugin, bool) { 1224 fake.getPluginMutex.Lock() 1225 ret, specificReturn := fake.getPluginReturnsOnCall[len(fake.getPluginArgsForCall)] 1226 fake.getPluginArgsForCall = append(fake.getPluginArgsForCall, struct { 1227 arg1 string 1228 }{arg1}) 1229 fake.recordInvocation("GetPlugin", []interface{}{arg1}) 1230 fake.getPluginMutex.Unlock() 1231 if fake.GetPluginStub != nil { 1232 return fake.GetPluginStub(arg1) 1233 } 1234 if specificReturn { 1235 return ret.result1, ret.result2 1236 } 1237 fakeReturns := fake.getPluginReturns 1238 return fakeReturns.result1, fakeReturns.result2 1239 } 1240 1241 func (fake *FakeConfig) GetPluginCallCount() int { 1242 fake.getPluginMutex.RLock() 1243 defer fake.getPluginMutex.RUnlock() 1244 return len(fake.getPluginArgsForCall) 1245 } 1246 1247 func (fake *FakeConfig) GetPluginCalls(stub func(string) (configv3.Plugin, bool)) { 1248 fake.getPluginMutex.Lock() 1249 defer fake.getPluginMutex.Unlock() 1250 fake.GetPluginStub = stub 1251 } 1252 1253 func (fake *FakeConfig) GetPluginArgsForCall(i int) string { 1254 fake.getPluginMutex.RLock() 1255 defer fake.getPluginMutex.RUnlock() 1256 argsForCall := fake.getPluginArgsForCall[i] 1257 return argsForCall.arg1 1258 } 1259 1260 func (fake *FakeConfig) GetPluginReturns(result1 configv3.Plugin, result2 bool) { 1261 fake.getPluginMutex.Lock() 1262 defer fake.getPluginMutex.Unlock() 1263 fake.GetPluginStub = nil 1264 fake.getPluginReturns = struct { 1265 result1 configv3.Plugin 1266 result2 bool 1267 }{result1, result2} 1268 } 1269 1270 func (fake *FakeConfig) GetPluginReturnsOnCall(i int, result1 configv3.Plugin, result2 bool) { 1271 fake.getPluginMutex.Lock() 1272 defer fake.getPluginMutex.Unlock() 1273 fake.GetPluginStub = nil 1274 if fake.getPluginReturnsOnCall == nil { 1275 fake.getPluginReturnsOnCall = make(map[int]struct { 1276 result1 configv3.Plugin 1277 result2 bool 1278 }) 1279 } 1280 fake.getPluginReturnsOnCall[i] = struct { 1281 result1 configv3.Plugin 1282 result2 bool 1283 }{result1, result2} 1284 } 1285 1286 func (fake *FakeConfig) GetPluginCaseInsensitive(arg1 string) (configv3.Plugin, bool) { 1287 fake.getPluginCaseInsensitiveMutex.Lock() 1288 ret, specificReturn := fake.getPluginCaseInsensitiveReturnsOnCall[len(fake.getPluginCaseInsensitiveArgsForCall)] 1289 fake.getPluginCaseInsensitiveArgsForCall = append(fake.getPluginCaseInsensitiveArgsForCall, struct { 1290 arg1 string 1291 }{arg1}) 1292 fake.recordInvocation("GetPluginCaseInsensitive", []interface{}{arg1}) 1293 fake.getPluginCaseInsensitiveMutex.Unlock() 1294 if fake.GetPluginCaseInsensitiveStub != nil { 1295 return fake.GetPluginCaseInsensitiveStub(arg1) 1296 } 1297 if specificReturn { 1298 return ret.result1, ret.result2 1299 } 1300 fakeReturns := fake.getPluginCaseInsensitiveReturns 1301 return fakeReturns.result1, fakeReturns.result2 1302 } 1303 1304 func (fake *FakeConfig) GetPluginCaseInsensitiveCallCount() int { 1305 fake.getPluginCaseInsensitiveMutex.RLock() 1306 defer fake.getPluginCaseInsensitiveMutex.RUnlock() 1307 return len(fake.getPluginCaseInsensitiveArgsForCall) 1308 } 1309 1310 func (fake *FakeConfig) GetPluginCaseInsensitiveCalls(stub func(string) (configv3.Plugin, bool)) { 1311 fake.getPluginCaseInsensitiveMutex.Lock() 1312 defer fake.getPluginCaseInsensitiveMutex.Unlock() 1313 fake.GetPluginCaseInsensitiveStub = stub 1314 } 1315 1316 func (fake *FakeConfig) GetPluginCaseInsensitiveArgsForCall(i int) string { 1317 fake.getPluginCaseInsensitiveMutex.RLock() 1318 defer fake.getPluginCaseInsensitiveMutex.RUnlock() 1319 argsForCall := fake.getPluginCaseInsensitiveArgsForCall[i] 1320 return argsForCall.arg1 1321 } 1322 1323 func (fake *FakeConfig) GetPluginCaseInsensitiveReturns(result1 configv3.Plugin, result2 bool) { 1324 fake.getPluginCaseInsensitiveMutex.Lock() 1325 defer fake.getPluginCaseInsensitiveMutex.Unlock() 1326 fake.GetPluginCaseInsensitiveStub = nil 1327 fake.getPluginCaseInsensitiveReturns = struct { 1328 result1 configv3.Plugin 1329 result2 bool 1330 }{result1, result2} 1331 } 1332 1333 func (fake *FakeConfig) GetPluginCaseInsensitiveReturnsOnCall(i int, result1 configv3.Plugin, result2 bool) { 1334 fake.getPluginCaseInsensitiveMutex.Lock() 1335 defer fake.getPluginCaseInsensitiveMutex.Unlock() 1336 fake.GetPluginCaseInsensitiveStub = nil 1337 if fake.getPluginCaseInsensitiveReturnsOnCall == nil { 1338 fake.getPluginCaseInsensitiveReturnsOnCall = make(map[int]struct { 1339 result1 configv3.Plugin 1340 result2 bool 1341 }) 1342 } 1343 fake.getPluginCaseInsensitiveReturnsOnCall[i] = struct { 1344 result1 configv3.Plugin 1345 result2 bool 1346 }{result1, result2} 1347 } 1348 1349 func (fake *FakeConfig) HasTargetedOrganization() bool { 1350 fake.hasTargetedOrganizationMutex.Lock() 1351 ret, specificReturn := fake.hasTargetedOrganizationReturnsOnCall[len(fake.hasTargetedOrganizationArgsForCall)] 1352 fake.hasTargetedOrganizationArgsForCall = append(fake.hasTargetedOrganizationArgsForCall, struct { 1353 }{}) 1354 fake.recordInvocation("HasTargetedOrganization", []interface{}{}) 1355 fake.hasTargetedOrganizationMutex.Unlock() 1356 if fake.HasTargetedOrganizationStub != nil { 1357 return fake.HasTargetedOrganizationStub() 1358 } 1359 if specificReturn { 1360 return ret.result1 1361 } 1362 fakeReturns := fake.hasTargetedOrganizationReturns 1363 return fakeReturns.result1 1364 } 1365 1366 func (fake *FakeConfig) HasTargetedOrganizationCallCount() int { 1367 fake.hasTargetedOrganizationMutex.RLock() 1368 defer fake.hasTargetedOrganizationMutex.RUnlock() 1369 return len(fake.hasTargetedOrganizationArgsForCall) 1370 } 1371 1372 func (fake *FakeConfig) HasTargetedOrganizationCalls(stub func() bool) { 1373 fake.hasTargetedOrganizationMutex.Lock() 1374 defer fake.hasTargetedOrganizationMutex.Unlock() 1375 fake.HasTargetedOrganizationStub = stub 1376 } 1377 1378 func (fake *FakeConfig) HasTargetedOrganizationReturns(result1 bool) { 1379 fake.hasTargetedOrganizationMutex.Lock() 1380 defer fake.hasTargetedOrganizationMutex.Unlock() 1381 fake.HasTargetedOrganizationStub = nil 1382 fake.hasTargetedOrganizationReturns = struct { 1383 result1 bool 1384 }{result1} 1385 } 1386 1387 func (fake *FakeConfig) HasTargetedOrganizationReturnsOnCall(i int, result1 bool) { 1388 fake.hasTargetedOrganizationMutex.Lock() 1389 defer fake.hasTargetedOrganizationMutex.Unlock() 1390 fake.HasTargetedOrganizationStub = nil 1391 if fake.hasTargetedOrganizationReturnsOnCall == nil { 1392 fake.hasTargetedOrganizationReturnsOnCall = make(map[int]struct { 1393 result1 bool 1394 }) 1395 } 1396 fake.hasTargetedOrganizationReturnsOnCall[i] = struct { 1397 result1 bool 1398 }{result1} 1399 } 1400 1401 func (fake *FakeConfig) HasTargetedSpace() bool { 1402 fake.hasTargetedSpaceMutex.Lock() 1403 ret, specificReturn := fake.hasTargetedSpaceReturnsOnCall[len(fake.hasTargetedSpaceArgsForCall)] 1404 fake.hasTargetedSpaceArgsForCall = append(fake.hasTargetedSpaceArgsForCall, struct { 1405 }{}) 1406 fake.recordInvocation("HasTargetedSpace", []interface{}{}) 1407 fake.hasTargetedSpaceMutex.Unlock() 1408 if fake.HasTargetedSpaceStub != nil { 1409 return fake.HasTargetedSpaceStub() 1410 } 1411 if specificReturn { 1412 return ret.result1 1413 } 1414 fakeReturns := fake.hasTargetedSpaceReturns 1415 return fakeReturns.result1 1416 } 1417 1418 func (fake *FakeConfig) HasTargetedSpaceCallCount() int { 1419 fake.hasTargetedSpaceMutex.RLock() 1420 defer fake.hasTargetedSpaceMutex.RUnlock() 1421 return len(fake.hasTargetedSpaceArgsForCall) 1422 } 1423 1424 func (fake *FakeConfig) HasTargetedSpaceCalls(stub func() bool) { 1425 fake.hasTargetedSpaceMutex.Lock() 1426 defer fake.hasTargetedSpaceMutex.Unlock() 1427 fake.HasTargetedSpaceStub = stub 1428 } 1429 1430 func (fake *FakeConfig) HasTargetedSpaceReturns(result1 bool) { 1431 fake.hasTargetedSpaceMutex.Lock() 1432 defer fake.hasTargetedSpaceMutex.Unlock() 1433 fake.HasTargetedSpaceStub = nil 1434 fake.hasTargetedSpaceReturns = struct { 1435 result1 bool 1436 }{result1} 1437 } 1438 1439 func (fake *FakeConfig) HasTargetedSpaceReturnsOnCall(i int, result1 bool) { 1440 fake.hasTargetedSpaceMutex.Lock() 1441 defer fake.hasTargetedSpaceMutex.Unlock() 1442 fake.HasTargetedSpaceStub = nil 1443 if fake.hasTargetedSpaceReturnsOnCall == nil { 1444 fake.hasTargetedSpaceReturnsOnCall = make(map[int]struct { 1445 result1 bool 1446 }) 1447 } 1448 fake.hasTargetedSpaceReturnsOnCall[i] = struct { 1449 result1 bool 1450 }{result1} 1451 } 1452 1453 func (fake *FakeConfig) Locale() string { 1454 fake.localeMutex.Lock() 1455 ret, specificReturn := fake.localeReturnsOnCall[len(fake.localeArgsForCall)] 1456 fake.localeArgsForCall = append(fake.localeArgsForCall, struct { 1457 }{}) 1458 fake.recordInvocation("Locale", []interface{}{}) 1459 fake.localeMutex.Unlock() 1460 if fake.LocaleStub != nil { 1461 return fake.LocaleStub() 1462 } 1463 if specificReturn { 1464 return ret.result1 1465 } 1466 fakeReturns := fake.localeReturns 1467 return fakeReturns.result1 1468 } 1469 1470 func (fake *FakeConfig) LocaleCallCount() int { 1471 fake.localeMutex.RLock() 1472 defer fake.localeMutex.RUnlock() 1473 return len(fake.localeArgsForCall) 1474 } 1475 1476 func (fake *FakeConfig) LocaleCalls(stub func() string) { 1477 fake.localeMutex.Lock() 1478 defer fake.localeMutex.Unlock() 1479 fake.LocaleStub = stub 1480 } 1481 1482 func (fake *FakeConfig) LocaleReturns(result1 string) { 1483 fake.localeMutex.Lock() 1484 defer fake.localeMutex.Unlock() 1485 fake.LocaleStub = nil 1486 fake.localeReturns = struct { 1487 result1 string 1488 }{result1} 1489 } 1490 1491 func (fake *FakeConfig) LocaleReturnsOnCall(i int, result1 string) { 1492 fake.localeMutex.Lock() 1493 defer fake.localeMutex.Unlock() 1494 fake.LocaleStub = nil 1495 if fake.localeReturnsOnCall == nil { 1496 fake.localeReturnsOnCall = make(map[int]struct { 1497 result1 string 1498 }) 1499 } 1500 fake.localeReturnsOnCall[i] = struct { 1501 result1 string 1502 }{result1} 1503 } 1504 1505 func (fake *FakeConfig) MinCLIVersion() string { 1506 fake.minCLIVersionMutex.Lock() 1507 ret, specificReturn := fake.minCLIVersionReturnsOnCall[len(fake.minCLIVersionArgsForCall)] 1508 fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct { 1509 }{}) 1510 fake.recordInvocation("MinCLIVersion", []interface{}{}) 1511 fake.minCLIVersionMutex.Unlock() 1512 if fake.MinCLIVersionStub != nil { 1513 return fake.MinCLIVersionStub() 1514 } 1515 if specificReturn { 1516 return ret.result1 1517 } 1518 fakeReturns := fake.minCLIVersionReturns 1519 return fakeReturns.result1 1520 } 1521 1522 func (fake *FakeConfig) MinCLIVersionCallCount() int { 1523 fake.minCLIVersionMutex.RLock() 1524 defer fake.minCLIVersionMutex.RUnlock() 1525 return len(fake.minCLIVersionArgsForCall) 1526 } 1527 1528 func (fake *FakeConfig) MinCLIVersionCalls(stub func() string) { 1529 fake.minCLIVersionMutex.Lock() 1530 defer fake.minCLIVersionMutex.Unlock() 1531 fake.MinCLIVersionStub = stub 1532 } 1533 1534 func (fake *FakeConfig) MinCLIVersionReturns(result1 string) { 1535 fake.minCLIVersionMutex.Lock() 1536 defer fake.minCLIVersionMutex.Unlock() 1537 fake.MinCLIVersionStub = nil 1538 fake.minCLIVersionReturns = struct { 1539 result1 string 1540 }{result1} 1541 } 1542 1543 func (fake *FakeConfig) MinCLIVersionReturnsOnCall(i int, result1 string) { 1544 fake.minCLIVersionMutex.Lock() 1545 defer fake.minCLIVersionMutex.Unlock() 1546 fake.MinCLIVersionStub = nil 1547 if fake.minCLIVersionReturnsOnCall == nil { 1548 fake.minCLIVersionReturnsOnCall = make(map[int]struct { 1549 result1 string 1550 }) 1551 } 1552 fake.minCLIVersionReturnsOnCall[i] = struct { 1553 result1 string 1554 }{result1} 1555 } 1556 1557 func (fake *FakeConfig) NOAARequestRetryCount() int { 1558 fake.nOAARequestRetryCountMutex.Lock() 1559 ret, specificReturn := fake.nOAARequestRetryCountReturnsOnCall[len(fake.nOAARequestRetryCountArgsForCall)] 1560 fake.nOAARequestRetryCountArgsForCall = append(fake.nOAARequestRetryCountArgsForCall, struct { 1561 }{}) 1562 fake.recordInvocation("NOAARequestRetryCount", []interface{}{}) 1563 fake.nOAARequestRetryCountMutex.Unlock() 1564 if fake.NOAARequestRetryCountStub != nil { 1565 return fake.NOAARequestRetryCountStub() 1566 } 1567 if specificReturn { 1568 return ret.result1 1569 } 1570 fakeReturns := fake.nOAARequestRetryCountReturns 1571 return fakeReturns.result1 1572 } 1573 1574 func (fake *FakeConfig) NOAARequestRetryCountCallCount() int { 1575 fake.nOAARequestRetryCountMutex.RLock() 1576 defer fake.nOAARequestRetryCountMutex.RUnlock() 1577 return len(fake.nOAARequestRetryCountArgsForCall) 1578 } 1579 1580 func (fake *FakeConfig) NOAARequestRetryCountCalls(stub func() int) { 1581 fake.nOAARequestRetryCountMutex.Lock() 1582 defer fake.nOAARequestRetryCountMutex.Unlock() 1583 fake.NOAARequestRetryCountStub = stub 1584 } 1585 1586 func (fake *FakeConfig) NOAARequestRetryCountReturns(result1 int) { 1587 fake.nOAARequestRetryCountMutex.Lock() 1588 defer fake.nOAARequestRetryCountMutex.Unlock() 1589 fake.NOAARequestRetryCountStub = nil 1590 fake.nOAARequestRetryCountReturns = struct { 1591 result1 int 1592 }{result1} 1593 } 1594 1595 func (fake *FakeConfig) NOAARequestRetryCountReturnsOnCall(i int, result1 int) { 1596 fake.nOAARequestRetryCountMutex.Lock() 1597 defer fake.nOAARequestRetryCountMutex.Unlock() 1598 fake.NOAARequestRetryCountStub = nil 1599 if fake.nOAARequestRetryCountReturnsOnCall == nil { 1600 fake.nOAARequestRetryCountReturnsOnCall = make(map[int]struct { 1601 result1 int 1602 }) 1603 } 1604 fake.nOAARequestRetryCountReturnsOnCall[i] = struct { 1605 result1 int 1606 }{result1} 1607 } 1608 1609 func (fake *FakeConfig) OverallPollingTimeout() time.Duration { 1610 fake.overallPollingTimeoutMutex.Lock() 1611 ret, specificReturn := fake.overallPollingTimeoutReturnsOnCall[len(fake.overallPollingTimeoutArgsForCall)] 1612 fake.overallPollingTimeoutArgsForCall = append(fake.overallPollingTimeoutArgsForCall, struct { 1613 }{}) 1614 fake.recordInvocation("OverallPollingTimeout", []interface{}{}) 1615 fake.overallPollingTimeoutMutex.Unlock() 1616 if fake.OverallPollingTimeoutStub != nil { 1617 return fake.OverallPollingTimeoutStub() 1618 } 1619 if specificReturn { 1620 return ret.result1 1621 } 1622 fakeReturns := fake.overallPollingTimeoutReturns 1623 return fakeReturns.result1 1624 } 1625 1626 func (fake *FakeConfig) OverallPollingTimeoutCallCount() int { 1627 fake.overallPollingTimeoutMutex.RLock() 1628 defer fake.overallPollingTimeoutMutex.RUnlock() 1629 return len(fake.overallPollingTimeoutArgsForCall) 1630 } 1631 1632 func (fake *FakeConfig) OverallPollingTimeoutCalls(stub func() time.Duration) { 1633 fake.overallPollingTimeoutMutex.Lock() 1634 defer fake.overallPollingTimeoutMutex.Unlock() 1635 fake.OverallPollingTimeoutStub = stub 1636 } 1637 1638 func (fake *FakeConfig) OverallPollingTimeoutReturns(result1 time.Duration) { 1639 fake.overallPollingTimeoutMutex.Lock() 1640 defer fake.overallPollingTimeoutMutex.Unlock() 1641 fake.OverallPollingTimeoutStub = nil 1642 fake.overallPollingTimeoutReturns = struct { 1643 result1 time.Duration 1644 }{result1} 1645 } 1646 1647 func (fake *FakeConfig) OverallPollingTimeoutReturnsOnCall(i int, result1 time.Duration) { 1648 fake.overallPollingTimeoutMutex.Lock() 1649 defer fake.overallPollingTimeoutMutex.Unlock() 1650 fake.OverallPollingTimeoutStub = nil 1651 if fake.overallPollingTimeoutReturnsOnCall == nil { 1652 fake.overallPollingTimeoutReturnsOnCall = make(map[int]struct { 1653 result1 time.Duration 1654 }) 1655 } 1656 fake.overallPollingTimeoutReturnsOnCall[i] = struct { 1657 result1 time.Duration 1658 }{result1} 1659 } 1660 1661 func (fake *FakeConfig) PluginHome() string { 1662 fake.pluginHomeMutex.Lock() 1663 ret, specificReturn := fake.pluginHomeReturnsOnCall[len(fake.pluginHomeArgsForCall)] 1664 fake.pluginHomeArgsForCall = append(fake.pluginHomeArgsForCall, struct { 1665 }{}) 1666 fake.recordInvocation("PluginHome", []interface{}{}) 1667 fake.pluginHomeMutex.Unlock() 1668 if fake.PluginHomeStub != nil { 1669 return fake.PluginHomeStub() 1670 } 1671 if specificReturn { 1672 return ret.result1 1673 } 1674 fakeReturns := fake.pluginHomeReturns 1675 return fakeReturns.result1 1676 } 1677 1678 func (fake *FakeConfig) PluginHomeCallCount() int { 1679 fake.pluginHomeMutex.RLock() 1680 defer fake.pluginHomeMutex.RUnlock() 1681 return len(fake.pluginHomeArgsForCall) 1682 } 1683 1684 func (fake *FakeConfig) PluginHomeCalls(stub func() string) { 1685 fake.pluginHomeMutex.Lock() 1686 defer fake.pluginHomeMutex.Unlock() 1687 fake.PluginHomeStub = stub 1688 } 1689 1690 func (fake *FakeConfig) PluginHomeReturns(result1 string) { 1691 fake.pluginHomeMutex.Lock() 1692 defer fake.pluginHomeMutex.Unlock() 1693 fake.PluginHomeStub = nil 1694 fake.pluginHomeReturns = struct { 1695 result1 string 1696 }{result1} 1697 } 1698 1699 func (fake *FakeConfig) PluginHomeReturnsOnCall(i int, result1 string) { 1700 fake.pluginHomeMutex.Lock() 1701 defer fake.pluginHomeMutex.Unlock() 1702 fake.PluginHomeStub = nil 1703 if fake.pluginHomeReturnsOnCall == nil { 1704 fake.pluginHomeReturnsOnCall = make(map[int]struct { 1705 result1 string 1706 }) 1707 } 1708 fake.pluginHomeReturnsOnCall[i] = struct { 1709 result1 string 1710 }{result1} 1711 } 1712 1713 func (fake *FakeConfig) PluginRepositories() []configv3.PluginRepository { 1714 fake.pluginRepositoriesMutex.Lock() 1715 ret, specificReturn := fake.pluginRepositoriesReturnsOnCall[len(fake.pluginRepositoriesArgsForCall)] 1716 fake.pluginRepositoriesArgsForCall = append(fake.pluginRepositoriesArgsForCall, struct { 1717 }{}) 1718 fake.recordInvocation("PluginRepositories", []interface{}{}) 1719 fake.pluginRepositoriesMutex.Unlock() 1720 if fake.PluginRepositoriesStub != nil { 1721 return fake.PluginRepositoriesStub() 1722 } 1723 if specificReturn { 1724 return ret.result1 1725 } 1726 fakeReturns := fake.pluginRepositoriesReturns 1727 return fakeReturns.result1 1728 } 1729 1730 func (fake *FakeConfig) PluginRepositoriesCallCount() int { 1731 fake.pluginRepositoriesMutex.RLock() 1732 defer fake.pluginRepositoriesMutex.RUnlock() 1733 return len(fake.pluginRepositoriesArgsForCall) 1734 } 1735 1736 func (fake *FakeConfig) PluginRepositoriesCalls(stub func() []configv3.PluginRepository) { 1737 fake.pluginRepositoriesMutex.Lock() 1738 defer fake.pluginRepositoriesMutex.Unlock() 1739 fake.PluginRepositoriesStub = stub 1740 } 1741 1742 func (fake *FakeConfig) PluginRepositoriesReturns(result1 []configv3.PluginRepository) { 1743 fake.pluginRepositoriesMutex.Lock() 1744 defer fake.pluginRepositoriesMutex.Unlock() 1745 fake.PluginRepositoriesStub = nil 1746 fake.pluginRepositoriesReturns = struct { 1747 result1 []configv3.PluginRepository 1748 }{result1} 1749 } 1750 1751 func (fake *FakeConfig) PluginRepositoriesReturnsOnCall(i int, result1 []configv3.PluginRepository) { 1752 fake.pluginRepositoriesMutex.Lock() 1753 defer fake.pluginRepositoriesMutex.Unlock() 1754 fake.PluginRepositoriesStub = nil 1755 if fake.pluginRepositoriesReturnsOnCall == nil { 1756 fake.pluginRepositoriesReturnsOnCall = make(map[int]struct { 1757 result1 []configv3.PluginRepository 1758 }) 1759 } 1760 fake.pluginRepositoriesReturnsOnCall[i] = struct { 1761 result1 []configv3.PluginRepository 1762 }{result1} 1763 } 1764 1765 func (fake *FakeConfig) Plugins() []configv3.Plugin { 1766 fake.pluginsMutex.Lock() 1767 ret, specificReturn := fake.pluginsReturnsOnCall[len(fake.pluginsArgsForCall)] 1768 fake.pluginsArgsForCall = append(fake.pluginsArgsForCall, struct { 1769 }{}) 1770 fake.recordInvocation("Plugins", []interface{}{}) 1771 fake.pluginsMutex.Unlock() 1772 if fake.PluginsStub != nil { 1773 return fake.PluginsStub() 1774 } 1775 if specificReturn { 1776 return ret.result1 1777 } 1778 fakeReturns := fake.pluginsReturns 1779 return fakeReturns.result1 1780 } 1781 1782 func (fake *FakeConfig) PluginsCallCount() int { 1783 fake.pluginsMutex.RLock() 1784 defer fake.pluginsMutex.RUnlock() 1785 return len(fake.pluginsArgsForCall) 1786 } 1787 1788 func (fake *FakeConfig) PluginsCalls(stub func() []configv3.Plugin) { 1789 fake.pluginsMutex.Lock() 1790 defer fake.pluginsMutex.Unlock() 1791 fake.PluginsStub = stub 1792 } 1793 1794 func (fake *FakeConfig) PluginsReturns(result1 []configv3.Plugin) { 1795 fake.pluginsMutex.Lock() 1796 defer fake.pluginsMutex.Unlock() 1797 fake.PluginsStub = nil 1798 fake.pluginsReturns = struct { 1799 result1 []configv3.Plugin 1800 }{result1} 1801 } 1802 1803 func (fake *FakeConfig) PluginsReturnsOnCall(i int, result1 []configv3.Plugin) { 1804 fake.pluginsMutex.Lock() 1805 defer fake.pluginsMutex.Unlock() 1806 fake.PluginsStub = nil 1807 if fake.pluginsReturnsOnCall == nil { 1808 fake.pluginsReturnsOnCall = make(map[int]struct { 1809 result1 []configv3.Plugin 1810 }) 1811 } 1812 fake.pluginsReturnsOnCall[i] = struct { 1813 result1 []configv3.Plugin 1814 }{result1} 1815 } 1816 1817 func (fake *FakeConfig) PollingInterval() time.Duration { 1818 fake.pollingIntervalMutex.Lock() 1819 ret, specificReturn := fake.pollingIntervalReturnsOnCall[len(fake.pollingIntervalArgsForCall)] 1820 fake.pollingIntervalArgsForCall = append(fake.pollingIntervalArgsForCall, struct { 1821 }{}) 1822 fake.recordInvocation("PollingInterval", []interface{}{}) 1823 fake.pollingIntervalMutex.Unlock() 1824 if fake.PollingIntervalStub != nil { 1825 return fake.PollingIntervalStub() 1826 } 1827 if specificReturn { 1828 return ret.result1 1829 } 1830 fakeReturns := fake.pollingIntervalReturns 1831 return fakeReturns.result1 1832 } 1833 1834 func (fake *FakeConfig) PollingIntervalCallCount() int { 1835 fake.pollingIntervalMutex.RLock() 1836 defer fake.pollingIntervalMutex.RUnlock() 1837 return len(fake.pollingIntervalArgsForCall) 1838 } 1839 1840 func (fake *FakeConfig) PollingIntervalCalls(stub func() time.Duration) { 1841 fake.pollingIntervalMutex.Lock() 1842 defer fake.pollingIntervalMutex.Unlock() 1843 fake.PollingIntervalStub = stub 1844 } 1845 1846 func (fake *FakeConfig) PollingIntervalReturns(result1 time.Duration) { 1847 fake.pollingIntervalMutex.Lock() 1848 defer fake.pollingIntervalMutex.Unlock() 1849 fake.PollingIntervalStub = nil 1850 fake.pollingIntervalReturns = struct { 1851 result1 time.Duration 1852 }{result1} 1853 } 1854 1855 func (fake *FakeConfig) PollingIntervalReturnsOnCall(i int, result1 time.Duration) { 1856 fake.pollingIntervalMutex.Lock() 1857 defer fake.pollingIntervalMutex.Unlock() 1858 fake.PollingIntervalStub = nil 1859 if fake.pollingIntervalReturnsOnCall == nil { 1860 fake.pollingIntervalReturnsOnCall = make(map[int]struct { 1861 result1 time.Duration 1862 }) 1863 } 1864 fake.pollingIntervalReturnsOnCall[i] = struct { 1865 result1 time.Duration 1866 }{result1} 1867 } 1868 1869 func (fake *FakeConfig) RefreshToken() string { 1870 fake.refreshTokenMutex.Lock() 1871 ret, specificReturn := fake.refreshTokenReturnsOnCall[len(fake.refreshTokenArgsForCall)] 1872 fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct { 1873 }{}) 1874 fake.recordInvocation("RefreshToken", []interface{}{}) 1875 fake.refreshTokenMutex.Unlock() 1876 if fake.RefreshTokenStub != nil { 1877 return fake.RefreshTokenStub() 1878 } 1879 if specificReturn { 1880 return ret.result1 1881 } 1882 fakeReturns := fake.refreshTokenReturns 1883 return fakeReturns.result1 1884 } 1885 1886 func (fake *FakeConfig) RefreshTokenCallCount() int { 1887 fake.refreshTokenMutex.RLock() 1888 defer fake.refreshTokenMutex.RUnlock() 1889 return len(fake.refreshTokenArgsForCall) 1890 } 1891 1892 func (fake *FakeConfig) RefreshTokenCalls(stub func() string) { 1893 fake.refreshTokenMutex.Lock() 1894 defer fake.refreshTokenMutex.Unlock() 1895 fake.RefreshTokenStub = stub 1896 } 1897 1898 func (fake *FakeConfig) RefreshTokenReturns(result1 string) { 1899 fake.refreshTokenMutex.Lock() 1900 defer fake.refreshTokenMutex.Unlock() 1901 fake.RefreshTokenStub = nil 1902 fake.refreshTokenReturns = struct { 1903 result1 string 1904 }{result1} 1905 } 1906 1907 func (fake *FakeConfig) RefreshTokenReturnsOnCall(i int, result1 string) { 1908 fake.refreshTokenMutex.Lock() 1909 defer fake.refreshTokenMutex.Unlock() 1910 fake.RefreshTokenStub = nil 1911 if fake.refreshTokenReturnsOnCall == nil { 1912 fake.refreshTokenReturnsOnCall = make(map[int]struct { 1913 result1 string 1914 }) 1915 } 1916 fake.refreshTokenReturnsOnCall[i] = struct { 1917 result1 string 1918 }{result1} 1919 } 1920 1921 func (fake *FakeConfig) RemovePlugin(arg1 string) { 1922 fake.removePluginMutex.Lock() 1923 fake.removePluginArgsForCall = append(fake.removePluginArgsForCall, struct { 1924 arg1 string 1925 }{arg1}) 1926 fake.recordInvocation("RemovePlugin", []interface{}{arg1}) 1927 fake.removePluginMutex.Unlock() 1928 if fake.RemovePluginStub != nil { 1929 fake.RemovePluginStub(arg1) 1930 } 1931 } 1932 1933 func (fake *FakeConfig) RemovePluginCallCount() int { 1934 fake.removePluginMutex.RLock() 1935 defer fake.removePluginMutex.RUnlock() 1936 return len(fake.removePluginArgsForCall) 1937 } 1938 1939 func (fake *FakeConfig) RemovePluginCalls(stub func(string)) { 1940 fake.removePluginMutex.Lock() 1941 defer fake.removePluginMutex.Unlock() 1942 fake.RemovePluginStub = stub 1943 } 1944 1945 func (fake *FakeConfig) RemovePluginArgsForCall(i int) string { 1946 fake.removePluginMutex.RLock() 1947 defer fake.removePluginMutex.RUnlock() 1948 argsForCall := fake.removePluginArgsForCall[i] 1949 return argsForCall.arg1 1950 } 1951 1952 func (fake *FakeConfig) RequestRetryCount() int { 1953 fake.requestRetryCountMutex.Lock() 1954 ret, specificReturn := fake.requestRetryCountReturnsOnCall[len(fake.requestRetryCountArgsForCall)] 1955 fake.requestRetryCountArgsForCall = append(fake.requestRetryCountArgsForCall, struct { 1956 }{}) 1957 fake.recordInvocation("RequestRetryCount", []interface{}{}) 1958 fake.requestRetryCountMutex.Unlock() 1959 if fake.RequestRetryCountStub != nil { 1960 return fake.RequestRetryCountStub() 1961 } 1962 if specificReturn { 1963 return ret.result1 1964 } 1965 fakeReturns := fake.requestRetryCountReturns 1966 return fakeReturns.result1 1967 } 1968 1969 func (fake *FakeConfig) RequestRetryCountCallCount() int { 1970 fake.requestRetryCountMutex.RLock() 1971 defer fake.requestRetryCountMutex.RUnlock() 1972 return len(fake.requestRetryCountArgsForCall) 1973 } 1974 1975 func (fake *FakeConfig) RequestRetryCountCalls(stub func() int) { 1976 fake.requestRetryCountMutex.Lock() 1977 defer fake.requestRetryCountMutex.Unlock() 1978 fake.RequestRetryCountStub = stub 1979 } 1980 1981 func (fake *FakeConfig) RequestRetryCountReturns(result1 int) { 1982 fake.requestRetryCountMutex.Lock() 1983 defer fake.requestRetryCountMutex.Unlock() 1984 fake.RequestRetryCountStub = nil 1985 fake.requestRetryCountReturns = struct { 1986 result1 int 1987 }{result1} 1988 } 1989 1990 func (fake *FakeConfig) RequestRetryCountReturnsOnCall(i int, result1 int) { 1991 fake.requestRetryCountMutex.Lock() 1992 defer fake.requestRetryCountMutex.Unlock() 1993 fake.RequestRetryCountStub = nil 1994 if fake.requestRetryCountReturnsOnCall == nil { 1995 fake.requestRetryCountReturnsOnCall = make(map[int]struct { 1996 result1 int 1997 }) 1998 } 1999 fake.requestRetryCountReturnsOnCall[i] = struct { 2000 result1 int 2001 }{result1} 2002 } 2003 2004 func (fake *FakeConfig) RoutingEndpoint() string { 2005 fake.routingEndpointMutex.Lock() 2006 ret, specificReturn := fake.routingEndpointReturnsOnCall[len(fake.routingEndpointArgsForCall)] 2007 fake.routingEndpointArgsForCall = append(fake.routingEndpointArgsForCall, struct { 2008 }{}) 2009 fake.recordInvocation("RoutingEndpoint", []interface{}{}) 2010 fake.routingEndpointMutex.Unlock() 2011 if fake.RoutingEndpointStub != nil { 2012 return fake.RoutingEndpointStub() 2013 } 2014 if specificReturn { 2015 return ret.result1 2016 } 2017 fakeReturns := fake.routingEndpointReturns 2018 return fakeReturns.result1 2019 } 2020 2021 func (fake *FakeConfig) RoutingEndpointCallCount() int { 2022 fake.routingEndpointMutex.RLock() 2023 defer fake.routingEndpointMutex.RUnlock() 2024 return len(fake.routingEndpointArgsForCall) 2025 } 2026 2027 func (fake *FakeConfig) RoutingEndpointCalls(stub func() string) { 2028 fake.routingEndpointMutex.Lock() 2029 defer fake.routingEndpointMutex.Unlock() 2030 fake.RoutingEndpointStub = stub 2031 } 2032 2033 func (fake *FakeConfig) RoutingEndpointReturns(result1 string) { 2034 fake.routingEndpointMutex.Lock() 2035 defer fake.routingEndpointMutex.Unlock() 2036 fake.RoutingEndpointStub = nil 2037 fake.routingEndpointReturns = struct { 2038 result1 string 2039 }{result1} 2040 } 2041 2042 func (fake *FakeConfig) RoutingEndpointReturnsOnCall(i int, result1 string) { 2043 fake.routingEndpointMutex.Lock() 2044 defer fake.routingEndpointMutex.Unlock() 2045 fake.RoutingEndpointStub = nil 2046 if fake.routingEndpointReturnsOnCall == nil { 2047 fake.routingEndpointReturnsOnCall = make(map[int]struct { 2048 result1 string 2049 }) 2050 } 2051 fake.routingEndpointReturnsOnCall[i] = struct { 2052 result1 string 2053 }{result1} 2054 } 2055 2056 func (fake *FakeConfig) SSHOAuthClient() string { 2057 fake.sSHOAuthClientMutex.Lock() 2058 ret, specificReturn := fake.sSHOAuthClientReturnsOnCall[len(fake.sSHOAuthClientArgsForCall)] 2059 fake.sSHOAuthClientArgsForCall = append(fake.sSHOAuthClientArgsForCall, struct { 2060 }{}) 2061 fake.recordInvocation("SSHOAuthClient", []interface{}{}) 2062 fake.sSHOAuthClientMutex.Unlock() 2063 if fake.SSHOAuthClientStub != nil { 2064 return fake.SSHOAuthClientStub() 2065 } 2066 if specificReturn { 2067 return ret.result1 2068 } 2069 fakeReturns := fake.sSHOAuthClientReturns 2070 return fakeReturns.result1 2071 } 2072 2073 func (fake *FakeConfig) SSHOAuthClientCallCount() int { 2074 fake.sSHOAuthClientMutex.RLock() 2075 defer fake.sSHOAuthClientMutex.RUnlock() 2076 return len(fake.sSHOAuthClientArgsForCall) 2077 } 2078 2079 func (fake *FakeConfig) SSHOAuthClientCalls(stub func() string) { 2080 fake.sSHOAuthClientMutex.Lock() 2081 defer fake.sSHOAuthClientMutex.Unlock() 2082 fake.SSHOAuthClientStub = stub 2083 } 2084 2085 func (fake *FakeConfig) SSHOAuthClientReturns(result1 string) { 2086 fake.sSHOAuthClientMutex.Lock() 2087 defer fake.sSHOAuthClientMutex.Unlock() 2088 fake.SSHOAuthClientStub = nil 2089 fake.sSHOAuthClientReturns = struct { 2090 result1 string 2091 }{result1} 2092 } 2093 2094 func (fake *FakeConfig) SSHOAuthClientReturnsOnCall(i int, result1 string) { 2095 fake.sSHOAuthClientMutex.Lock() 2096 defer fake.sSHOAuthClientMutex.Unlock() 2097 fake.SSHOAuthClientStub = nil 2098 if fake.sSHOAuthClientReturnsOnCall == nil { 2099 fake.sSHOAuthClientReturnsOnCall = make(map[int]struct { 2100 result1 string 2101 }) 2102 } 2103 fake.sSHOAuthClientReturnsOnCall[i] = struct { 2104 result1 string 2105 }{result1} 2106 } 2107 2108 func (fake *FakeConfig) SetAccessToken(arg1 string) { 2109 fake.setAccessTokenMutex.Lock() 2110 fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct { 2111 arg1 string 2112 }{arg1}) 2113 fake.recordInvocation("SetAccessToken", []interface{}{arg1}) 2114 fake.setAccessTokenMutex.Unlock() 2115 if fake.SetAccessTokenStub != nil { 2116 fake.SetAccessTokenStub(arg1) 2117 } 2118 } 2119 2120 func (fake *FakeConfig) SetAccessTokenCallCount() int { 2121 fake.setAccessTokenMutex.RLock() 2122 defer fake.setAccessTokenMutex.RUnlock() 2123 return len(fake.setAccessTokenArgsForCall) 2124 } 2125 2126 func (fake *FakeConfig) SetAccessTokenCalls(stub func(string)) { 2127 fake.setAccessTokenMutex.Lock() 2128 defer fake.setAccessTokenMutex.Unlock() 2129 fake.SetAccessTokenStub = stub 2130 } 2131 2132 func (fake *FakeConfig) SetAccessTokenArgsForCall(i int) string { 2133 fake.setAccessTokenMutex.RLock() 2134 defer fake.setAccessTokenMutex.RUnlock() 2135 argsForCall := fake.setAccessTokenArgsForCall[i] 2136 return argsForCall.arg1 2137 } 2138 2139 func (fake *FakeConfig) SetOrganizationInformation(arg1 string, arg2 string) { 2140 fake.setOrganizationInformationMutex.Lock() 2141 fake.setOrganizationInformationArgsForCall = append(fake.setOrganizationInformationArgsForCall, struct { 2142 arg1 string 2143 arg2 string 2144 }{arg1, arg2}) 2145 fake.recordInvocation("SetOrganizationInformation", []interface{}{arg1, arg2}) 2146 fake.setOrganizationInformationMutex.Unlock() 2147 if fake.SetOrganizationInformationStub != nil { 2148 fake.SetOrganizationInformationStub(arg1, arg2) 2149 } 2150 } 2151 2152 func (fake *FakeConfig) SetOrganizationInformationCallCount() int { 2153 fake.setOrganizationInformationMutex.RLock() 2154 defer fake.setOrganizationInformationMutex.RUnlock() 2155 return len(fake.setOrganizationInformationArgsForCall) 2156 } 2157 2158 func (fake *FakeConfig) SetOrganizationInformationCalls(stub func(string, string)) { 2159 fake.setOrganizationInformationMutex.Lock() 2160 defer fake.setOrganizationInformationMutex.Unlock() 2161 fake.SetOrganizationInformationStub = stub 2162 } 2163 2164 func (fake *FakeConfig) SetOrganizationInformationArgsForCall(i int) (string, string) { 2165 fake.setOrganizationInformationMutex.RLock() 2166 defer fake.setOrganizationInformationMutex.RUnlock() 2167 argsForCall := fake.setOrganizationInformationArgsForCall[i] 2168 return argsForCall.arg1, argsForCall.arg2 2169 } 2170 2171 func (fake *FakeConfig) SetRefreshToken(arg1 string) { 2172 fake.setRefreshTokenMutex.Lock() 2173 fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct { 2174 arg1 string 2175 }{arg1}) 2176 fake.recordInvocation("SetRefreshToken", []interface{}{arg1}) 2177 fake.setRefreshTokenMutex.Unlock() 2178 if fake.SetRefreshTokenStub != nil { 2179 fake.SetRefreshTokenStub(arg1) 2180 } 2181 } 2182 2183 func (fake *FakeConfig) SetRefreshTokenCallCount() int { 2184 fake.setRefreshTokenMutex.RLock() 2185 defer fake.setRefreshTokenMutex.RUnlock() 2186 return len(fake.setRefreshTokenArgsForCall) 2187 } 2188 2189 func (fake *FakeConfig) SetRefreshTokenCalls(stub func(string)) { 2190 fake.setRefreshTokenMutex.Lock() 2191 defer fake.setRefreshTokenMutex.Unlock() 2192 fake.SetRefreshTokenStub = stub 2193 } 2194 2195 func (fake *FakeConfig) SetRefreshTokenArgsForCall(i int) string { 2196 fake.setRefreshTokenMutex.RLock() 2197 defer fake.setRefreshTokenMutex.RUnlock() 2198 argsForCall := fake.setRefreshTokenArgsForCall[i] 2199 return argsForCall.arg1 2200 } 2201 2202 func (fake *FakeConfig) SetSpaceInformation(arg1 string, arg2 string, arg3 bool) { 2203 fake.setSpaceInformationMutex.Lock() 2204 fake.setSpaceInformationArgsForCall = append(fake.setSpaceInformationArgsForCall, struct { 2205 arg1 string 2206 arg2 string 2207 arg3 bool 2208 }{arg1, arg2, arg3}) 2209 fake.recordInvocation("SetSpaceInformation", []interface{}{arg1, arg2, arg3}) 2210 fake.setSpaceInformationMutex.Unlock() 2211 if fake.SetSpaceInformationStub != nil { 2212 fake.SetSpaceInformationStub(arg1, arg2, arg3) 2213 } 2214 } 2215 2216 func (fake *FakeConfig) SetSpaceInformationCallCount() int { 2217 fake.setSpaceInformationMutex.RLock() 2218 defer fake.setSpaceInformationMutex.RUnlock() 2219 return len(fake.setSpaceInformationArgsForCall) 2220 } 2221 2222 func (fake *FakeConfig) SetSpaceInformationCalls(stub func(string, string, bool)) { 2223 fake.setSpaceInformationMutex.Lock() 2224 defer fake.setSpaceInformationMutex.Unlock() 2225 fake.SetSpaceInformationStub = stub 2226 } 2227 2228 func (fake *FakeConfig) SetSpaceInformationArgsForCall(i int) (string, string, bool) { 2229 fake.setSpaceInformationMutex.RLock() 2230 defer fake.setSpaceInformationMutex.RUnlock() 2231 argsForCall := fake.setSpaceInformationArgsForCall[i] 2232 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 2233 } 2234 2235 func (fake *FakeConfig) SetTargetInformation(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string, arg6 string, arg7 bool) { 2236 fake.setTargetInformationMutex.Lock() 2237 fake.setTargetInformationArgsForCall = append(fake.setTargetInformationArgsForCall, struct { 2238 arg1 string 2239 arg2 string 2240 arg3 string 2241 arg4 string 2242 arg5 string 2243 arg6 string 2244 arg7 bool 2245 }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) 2246 fake.recordInvocation("SetTargetInformation", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) 2247 fake.setTargetInformationMutex.Unlock() 2248 if fake.SetTargetInformationStub != nil { 2249 fake.SetTargetInformationStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) 2250 } 2251 } 2252 2253 func (fake *FakeConfig) SetTargetInformationCallCount() int { 2254 fake.setTargetInformationMutex.RLock() 2255 defer fake.setTargetInformationMutex.RUnlock() 2256 return len(fake.setTargetInformationArgsForCall) 2257 } 2258 2259 func (fake *FakeConfig) SetTargetInformationCalls(stub func(string, string, string, string, string, string, bool)) { 2260 fake.setTargetInformationMutex.Lock() 2261 defer fake.setTargetInformationMutex.Unlock() 2262 fake.SetTargetInformationStub = stub 2263 } 2264 2265 func (fake *FakeConfig) SetTargetInformationArgsForCall(i int) (string, string, string, string, string, string, bool) { 2266 fake.setTargetInformationMutex.RLock() 2267 defer fake.setTargetInformationMutex.RUnlock() 2268 argsForCall := fake.setTargetInformationArgsForCall[i] 2269 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7 2270 } 2271 2272 func (fake *FakeConfig) SetTokenInformation(arg1 string, arg2 string, arg3 string) { 2273 fake.setTokenInformationMutex.Lock() 2274 fake.setTokenInformationArgsForCall = append(fake.setTokenInformationArgsForCall, struct { 2275 arg1 string 2276 arg2 string 2277 arg3 string 2278 }{arg1, arg2, arg3}) 2279 fake.recordInvocation("SetTokenInformation", []interface{}{arg1, arg2, arg3}) 2280 fake.setTokenInformationMutex.Unlock() 2281 if fake.SetTokenInformationStub != nil { 2282 fake.SetTokenInformationStub(arg1, arg2, arg3) 2283 } 2284 } 2285 2286 func (fake *FakeConfig) SetTokenInformationCallCount() int { 2287 fake.setTokenInformationMutex.RLock() 2288 defer fake.setTokenInformationMutex.RUnlock() 2289 return len(fake.setTokenInformationArgsForCall) 2290 } 2291 2292 func (fake *FakeConfig) SetTokenInformationCalls(stub func(string, string, string)) { 2293 fake.setTokenInformationMutex.Lock() 2294 defer fake.setTokenInformationMutex.Unlock() 2295 fake.SetTokenInformationStub = stub 2296 } 2297 2298 func (fake *FakeConfig) SetTokenInformationArgsForCall(i int) (string, string, string) { 2299 fake.setTokenInformationMutex.RLock() 2300 defer fake.setTokenInformationMutex.RUnlock() 2301 argsForCall := fake.setTokenInformationArgsForCall[i] 2302 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 2303 } 2304 2305 func (fake *FakeConfig) SetUAAClientCredentials(arg1 string, arg2 string) { 2306 fake.setUAAClientCredentialsMutex.Lock() 2307 fake.setUAAClientCredentialsArgsForCall = append(fake.setUAAClientCredentialsArgsForCall, struct { 2308 arg1 string 2309 arg2 string 2310 }{arg1, arg2}) 2311 fake.recordInvocation("SetUAAClientCredentials", []interface{}{arg1, arg2}) 2312 fake.setUAAClientCredentialsMutex.Unlock() 2313 if fake.SetUAAClientCredentialsStub != nil { 2314 fake.SetUAAClientCredentialsStub(arg1, arg2) 2315 } 2316 } 2317 2318 func (fake *FakeConfig) SetUAAClientCredentialsCallCount() int { 2319 fake.setUAAClientCredentialsMutex.RLock() 2320 defer fake.setUAAClientCredentialsMutex.RUnlock() 2321 return len(fake.setUAAClientCredentialsArgsForCall) 2322 } 2323 2324 func (fake *FakeConfig) SetUAAClientCredentialsCalls(stub func(string, string)) { 2325 fake.setUAAClientCredentialsMutex.Lock() 2326 defer fake.setUAAClientCredentialsMutex.Unlock() 2327 fake.SetUAAClientCredentialsStub = stub 2328 } 2329 2330 func (fake *FakeConfig) SetUAAClientCredentialsArgsForCall(i int) (string, string) { 2331 fake.setUAAClientCredentialsMutex.RLock() 2332 defer fake.setUAAClientCredentialsMutex.RUnlock() 2333 argsForCall := fake.setUAAClientCredentialsArgsForCall[i] 2334 return argsForCall.arg1, argsForCall.arg2 2335 } 2336 2337 func (fake *FakeConfig) SetUAAEndpoint(arg1 string) { 2338 fake.setUAAEndpointMutex.Lock() 2339 fake.setUAAEndpointArgsForCall = append(fake.setUAAEndpointArgsForCall, struct { 2340 arg1 string 2341 }{arg1}) 2342 fake.recordInvocation("SetUAAEndpoint", []interface{}{arg1}) 2343 fake.setUAAEndpointMutex.Unlock() 2344 if fake.SetUAAEndpointStub != nil { 2345 fake.SetUAAEndpointStub(arg1) 2346 } 2347 } 2348 2349 func (fake *FakeConfig) SetUAAEndpointCallCount() int { 2350 fake.setUAAEndpointMutex.RLock() 2351 defer fake.setUAAEndpointMutex.RUnlock() 2352 return len(fake.setUAAEndpointArgsForCall) 2353 } 2354 2355 func (fake *FakeConfig) SetUAAEndpointCalls(stub func(string)) { 2356 fake.setUAAEndpointMutex.Lock() 2357 defer fake.setUAAEndpointMutex.Unlock() 2358 fake.SetUAAEndpointStub = stub 2359 } 2360 2361 func (fake *FakeConfig) SetUAAEndpointArgsForCall(i int) string { 2362 fake.setUAAEndpointMutex.RLock() 2363 defer fake.setUAAEndpointMutex.RUnlock() 2364 argsForCall := fake.setUAAEndpointArgsForCall[i] 2365 return argsForCall.arg1 2366 } 2367 2368 func (fake *FakeConfig) SetUAAGrantType(arg1 string) { 2369 fake.setUAAGrantTypeMutex.Lock() 2370 fake.setUAAGrantTypeArgsForCall = append(fake.setUAAGrantTypeArgsForCall, struct { 2371 arg1 string 2372 }{arg1}) 2373 fake.recordInvocation("SetUAAGrantType", []interface{}{arg1}) 2374 fake.setUAAGrantTypeMutex.Unlock() 2375 if fake.SetUAAGrantTypeStub != nil { 2376 fake.SetUAAGrantTypeStub(arg1) 2377 } 2378 } 2379 2380 func (fake *FakeConfig) SetUAAGrantTypeCallCount() int { 2381 fake.setUAAGrantTypeMutex.RLock() 2382 defer fake.setUAAGrantTypeMutex.RUnlock() 2383 return len(fake.setUAAGrantTypeArgsForCall) 2384 } 2385 2386 func (fake *FakeConfig) SetUAAGrantTypeCalls(stub func(string)) { 2387 fake.setUAAGrantTypeMutex.Lock() 2388 defer fake.setUAAGrantTypeMutex.Unlock() 2389 fake.SetUAAGrantTypeStub = stub 2390 } 2391 2392 func (fake *FakeConfig) SetUAAGrantTypeArgsForCall(i int) string { 2393 fake.setUAAGrantTypeMutex.RLock() 2394 defer fake.setUAAGrantTypeMutex.RUnlock() 2395 argsForCall := fake.setUAAGrantTypeArgsForCall[i] 2396 return argsForCall.arg1 2397 } 2398 2399 func (fake *FakeConfig) SkipSSLValidation() bool { 2400 fake.skipSSLValidationMutex.Lock() 2401 ret, specificReturn := fake.skipSSLValidationReturnsOnCall[len(fake.skipSSLValidationArgsForCall)] 2402 fake.skipSSLValidationArgsForCall = append(fake.skipSSLValidationArgsForCall, struct { 2403 }{}) 2404 fake.recordInvocation("SkipSSLValidation", []interface{}{}) 2405 fake.skipSSLValidationMutex.Unlock() 2406 if fake.SkipSSLValidationStub != nil { 2407 return fake.SkipSSLValidationStub() 2408 } 2409 if specificReturn { 2410 return ret.result1 2411 } 2412 fakeReturns := fake.skipSSLValidationReturns 2413 return fakeReturns.result1 2414 } 2415 2416 func (fake *FakeConfig) SkipSSLValidationCallCount() int { 2417 fake.skipSSLValidationMutex.RLock() 2418 defer fake.skipSSLValidationMutex.RUnlock() 2419 return len(fake.skipSSLValidationArgsForCall) 2420 } 2421 2422 func (fake *FakeConfig) SkipSSLValidationCalls(stub func() bool) { 2423 fake.skipSSLValidationMutex.Lock() 2424 defer fake.skipSSLValidationMutex.Unlock() 2425 fake.SkipSSLValidationStub = stub 2426 } 2427 2428 func (fake *FakeConfig) SkipSSLValidationReturns(result1 bool) { 2429 fake.skipSSLValidationMutex.Lock() 2430 defer fake.skipSSLValidationMutex.Unlock() 2431 fake.SkipSSLValidationStub = nil 2432 fake.skipSSLValidationReturns = struct { 2433 result1 bool 2434 }{result1} 2435 } 2436 2437 func (fake *FakeConfig) SkipSSLValidationReturnsOnCall(i int, result1 bool) { 2438 fake.skipSSLValidationMutex.Lock() 2439 defer fake.skipSSLValidationMutex.Unlock() 2440 fake.SkipSSLValidationStub = nil 2441 if fake.skipSSLValidationReturnsOnCall == nil { 2442 fake.skipSSLValidationReturnsOnCall = make(map[int]struct { 2443 result1 bool 2444 }) 2445 } 2446 fake.skipSSLValidationReturnsOnCall[i] = struct { 2447 result1 bool 2448 }{result1} 2449 } 2450 2451 func (fake *FakeConfig) StagingTimeout() time.Duration { 2452 fake.stagingTimeoutMutex.Lock() 2453 ret, specificReturn := fake.stagingTimeoutReturnsOnCall[len(fake.stagingTimeoutArgsForCall)] 2454 fake.stagingTimeoutArgsForCall = append(fake.stagingTimeoutArgsForCall, struct { 2455 }{}) 2456 fake.recordInvocation("StagingTimeout", []interface{}{}) 2457 fake.stagingTimeoutMutex.Unlock() 2458 if fake.StagingTimeoutStub != nil { 2459 return fake.StagingTimeoutStub() 2460 } 2461 if specificReturn { 2462 return ret.result1 2463 } 2464 fakeReturns := fake.stagingTimeoutReturns 2465 return fakeReturns.result1 2466 } 2467 2468 func (fake *FakeConfig) StagingTimeoutCallCount() int { 2469 fake.stagingTimeoutMutex.RLock() 2470 defer fake.stagingTimeoutMutex.RUnlock() 2471 return len(fake.stagingTimeoutArgsForCall) 2472 } 2473 2474 func (fake *FakeConfig) StagingTimeoutCalls(stub func() time.Duration) { 2475 fake.stagingTimeoutMutex.Lock() 2476 defer fake.stagingTimeoutMutex.Unlock() 2477 fake.StagingTimeoutStub = stub 2478 } 2479 2480 func (fake *FakeConfig) StagingTimeoutReturns(result1 time.Duration) { 2481 fake.stagingTimeoutMutex.Lock() 2482 defer fake.stagingTimeoutMutex.Unlock() 2483 fake.StagingTimeoutStub = nil 2484 fake.stagingTimeoutReturns = struct { 2485 result1 time.Duration 2486 }{result1} 2487 } 2488 2489 func (fake *FakeConfig) StagingTimeoutReturnsOnCall(i int, result1 time.Duration) { 2490 fake.stagingTimeoutMutex.Lock() 2491 defer fake.stagingTimeoutMutex.Unlock() 2492 fake.StagingTimeoutStub = nil 2493 if fake.stagingTimeoutReturnsOnCall == nil { 2494 fake.stagingTimeoutReturnsOnCall = make(map[int]struct { 2495 result1 time.Duration 2496 }) 2497 } 2498 fake.stagingTimeoutReturnsOnCall[i] = struct { 2499 result1 time.Duration 2500 }{result1} 2501 } 2502 2503 func (fake *FakeConfig) StartupTimeout() time.Duration { 2504 fake.startupTimeoutMutex.Lock() 2505 ret, specificReturn := fake.startupTimeoutReturnsOnCall[len(fake.startupTimeoutArgsForCall)] 2506 fake.startupTimeoutArgsForCall = append(fake.startupTimeoutArgsForCall, struct { 2507 }{}) 2508 fake.recordInvocation("StartupTimeout", []interface{}{}) 2509 fake.startupTimeoutMutex.Unlock() 2510 if fake.StartupTimeoutStub != nil { 2511 return fake.StartupTimeoutStub() 2512 } 2513 if specificReturn { 2514 return ret.result1 2515 } 2516 fakeReturns := fake.startupTimeoutReturns 2517 return fakeReturns.result1 2518 } 2519 2520 func (fake *FakeConfig) StartupTimeoutCallCount() int { 2521 fake.startupTimeoutMutex.RLock() 2522 defer fake.startupTimeoutMutex.RUnlock() 2523 return len(fake.startupTimeoutArgsForCall) 2524 } 2525 2526 func (fake *FakeConfig) StartupTimeoutCalls(stub func() time.Duration) { 2527 fake.startupTimeoutMutex.Lock() 2528 defer fake.startupTimeoutMutex.Unlock() 2529 fake.StartupTimeoutStub = stub 2530 } 2531 2532 func (fake *FakeConfig) StartupTimeoutReturns(result1 time.Duration) { 2533 fake.startupTimeoutMutex.Lock() 2534 defer fake.startupTimeoutMutex.Unlock() 2535 fake.StartupTimeoutStub = nil 2536 fake.startupTimeoutReturns = struct { 2537 result1 time.Duration 2538 }{result1} 2539 } 2540 2541 func (fake *FakeConfig) StartupTimeoutReturnsOnCall(i int, result1 time.Duration) { 2542 fake.startupTimeoutMutex.Lock() 2543 defer fake.startupTimeoutMutex.Unlock() 2544 fake.StartupTimeoutStub = nil 2545 if fake.startupTimeoutReturnsOnCall == nil { 2546 fake.startupTimeoutReturnsOnCall = make(map[int]struct { 2547 result1 time.Duration 2548 }) 2549 } 2550 fake.startupTimeoutReturnsOnCall[i] = struct { 2551 result1 time.Duration 2552 }{result1} 2553 } 2554 2555 func (fake *FakeConfig) Target() string { 2556 fake.targetMutex.Lock() 2557 ret, specificReturn := fake.targetReturnsOnCall[len(fake.targetArgsForCall)] 2558 fake.targetArgsForCall = append(fake.targetArgsForCall, struct { 2559 }{}) 2560 fake.recordInvocation("Target", []interface{}{}) 2561 fake.targetMutex.Unlock() 2562 if fake.TargetStub != nil { 2563 return fake.TargetStub() 2564 } 2565 if specificReturn { 2566 return ret.result1 2567 } 2568 fakeReturns := fake.targetReturns 2569 return fakeReturns.result1 2570 } 2571 2572 func (fake *FakeConfig) TargetCallCount() int { 2573 fake.targetMutex.RLock() 2574 defer fake.targetMutex.RUnlock() 2575 return len(fake.targetArgsForCall) 2576 } 2577 2578 func (fake *FakeConfig) TargetCalls(stub func() string) { 2579 fake.targetMutex.Lock() 2580 defer fake.targetMutex.Unlock() 2581 fake.TargetStub = stub 2582 } 2583 2584 func (fake *FakeConfig) TargetReturns(result1 string) { 2585 fake.targetMutex.Lock() 2586 defer fake.targetMutex.Unlock() 2587 fake.TargetStub = nil 2588 fake.targetReturns = struct { 2589 result1 string 2590 }{result1} 2591 } 2592 2593 func (fake *FakeConfig) TargetReturnsOnCall(i int, result1 string) { 2594 fake.targetMutex.Lock() 2595 defer fake.targetMutex.Unlock() 2596 fake.TargetStub = nil 2597 if fake.targetReturnsOnCall == nil { 2598 fake.targetReturnsOnCall = make(map[int]struct { 2599 result1 string 2600 }) 2601 } 2602 fake.targetReturnsOnCall[i] = struct { 2603 result1 string 2604 }{result1} 2605 } 2606 2607 func (fake *FakeConfig) TargetedOrganization() configv3.Organization { 2608 fake.targetedOrganizationMutex.Lock() 2609 ret, specificReturn := fake.targetedOrganizationReturnsOnCall[len(fake.targetedOrganizationArgsForCall)] 2610 fake.targetedOrganizationArgsForCall = append(fake.targetedOrganizationArgsForCall, struct { 2611 }{}) 2612 fake.recordInvocation("TargetedOrganization", []interface{}{}) 2613 fake.targetedOrganizationMutex.Unlock() 2614 if fake.TargetedOrganizationStub != nil { 2615 return fake.TargetedOrganizationStub() 2616 } 2617 if specificReturn { 2618 return ret.result1 2619 } 2620 fakeReturns := fake.targetedOrganizationReturns 2621 return fakeReturns.result1 2622 } 2623 2624 func (fake *FakeConfig) TargetedOrganizationCallCount() int { 2625 fake.targetedOrganizationMutex.RLock() 2626 defer fake.targetedOrganizationMutex.RUnlock() 2627 return len(fake.targetedOrganizationArgsForCall) 2628 } 2629 2630 func (fake *FakeConfig) TargetedOrganizationCalls(stub func() configv3.Organization) { 2631 fake.targetedOrganizationMutex.Lock() 2632 defer fake.targetedOrganizationMutex.Unlock() 2633 fake.TargetedOrganizationStub = stub 2634 } 2635 2636 func (fake *FakeConfig) TargetedOrganizationReturns(result1 configv3.Organization) { 2637 fake.targetedOrganizationMutex.Lock() 2638 defer fake.targetedOrganizationMutex.Unlock() 2639 fake.TargetedOrganizationStub = nil 2640 fake.targetedOrganizationReturns = struct { 2641 result1 configv3.Organization 2642 }{result1} 2643 } 2644 2645 func (fake *FakeConfig) TargetedOrganizationReturnsOnCall(i int, result1 configv3.Organization) { 2646 fake.targetedOrganizationMutex.Lock() 2647 defer fake.targetedOrganizationMutex.Unlock() 2648 fake.TargetedOrganizationStub = nil 2649 if fake.targetedOrganizationReturnsOnCall == nil { 2650 fake.targetedOrganizationReturnsOnCall = make(map[int]struct { 2651 result1 configv3.Organization 2652 }) 2653 } 2654 fake.targetedOrganizationReturnsOnCall[i] = struct { 2655 result1 configv3.Organization 2656 }{result1} 2657 } 2658 2659 func (fake *FakeConfig) TargetedOrganizationName() string { 2660 fake.targetedOrganizationNameMutex.Lock() 2661 ret, specificReturn := fake.targetedOrganizationNameReturnsOnCall[len(fake.targetedOrganizationNameArgsForCall)] 2662 fake.targetedOrganizationNameArgsForCall = append(fake.targetedOrganizationNameArgsForCall, struct { 2663 }{}) 2664 fake.recordInvocation("TargetedOrganizationName", []interface{}{}) 2665 fake.targetedOrganizationNameMutex.Unlock() 2666 if fake.TargetedOrganizationNameStub != nil { 2667 return fake.TargetedOrganizationNameStub() 2668 } 2669 if specificReturn { 2670 return ret.result1 2671 } 2672 fakeReturns := fake.targetedOrganizationNameReturns 2673 return fakeReturns.result1 2674 } 2675 2676 func (fake *FakeConfig) TargetedOrganizationNameCallCount() int { 2677 fake.targetedOrganizationNameMutex.RLock() 2678 defer fake.targetedOrganizationNameMutex.RUnlock() 2679 return len(fake.targetedOrganizationNameArgsForCall) 2680 } 2681 2682 func (fake *FakeConfig) TargetedOrganizationNameCalls(stub func() string) { 2683 fake.targetedOrganizationNameMutex.Lock() 2684 defer fake.targetedOrganizationNameMutex.Unlock() 2685 fake.TargetedOrganizationNameStub = stub 2686 } 2687 2688 func (fake *FakeConfig) TargetedOrganizationNameReturns(result1 string) { 2689 fake.targetedOrganizationNameMutex.Lock() 2690 defer fake.targetedOrganizationNameMutex.Unlock() 2691 fake.TargetedOrganizationNameStub = nil 2692 fake.targetedOrganizationNameReturns = struct { 2693 result1 string 2694 }{result1} 2695 } 2696 2697 func (fake *FakeConfig) TargetedOrganizationNameReturnsOnCall(i int, result1 string) { 2698 fake.targetedOrganizationNameMutex.Lock() 2699 defer fake.targetedOrganizationNameMutex.Unlock() 2700 fake.TargetedOrganizationNameStub = nil 2701 if fake.targetedOrganizationNameReturnsOnCall == nil { 2702 fake.targetedOrganizationNameReturnsOnCall = make(map[int]struct { 2703 result1 string 2704 }) 2705 } 2706 fake.targetedOrganizationNameReturnsOnCall[i] = struct { 2707 result1 string 2708 }{result1} 2709 } 2710 2711 func (fake *FakeConfig) TargetedSpace() configv3.Space { 2712 fake.targetedSpaceMutex.Lock() 2713 ret, specificReturn := fake.targetedSpaceReturnsOnCall[len(fake.targetedSpaceArgsForCall)] 2714 fake.targetedSpaceArgsForCall = append(fake.targetedSpaceArgsForCall, struct { 2715 }{}) 2716 fake.recordInvocation("TargetedSpace", []interface{}{}) 2717 fake.targetedSpaceMutex.Unlock() 2718 if fake.TargetedSpaceStub != nil { 2719 return fake.TargetedSpaceStub() 2720 } 2721 if specificReturn { 2722 return ret.result1 2723 } 2724 fakeReturns := fake.targetedSpaceReturns 2725 return fakeReturns.result1 2726 } 2727 2728 func (fake *FakeConfig) TargetedSpaceCallCount() int { 2729 fake.targetedSpaceMutex.RLock() 2730 defer fake.targetedSpaceMutex.RUnlock() 2731 return len(fake.targetedSpaceArgsForCall) 2732 } 2733 2734 func (fake *FakeConfig) TargetedSpaceCalls(stub func() configv3.Space) { 2735 fake.targetedSpaceMutex.Lock() 2736 defer fake.targetedSpaceMutex.Unlock() 2737 fake.TargetedSpaceStub = stub 2738 } 2739 2740 func (fake *FakeConfig) TargetedSpaceReturns(result1 configv3.Space) { 2741 fake.targetedSpaceMutex.Lock() 2742 defer fake.targetedSpaceMutex.Unlock() 2743 fake.TargetedSpaceStub = nil 2744 fake.targetedSpaceReturns = struct { 2745 result1 configv3.Space 2746 }{result1} 2747 } 2748 2749 func (fake *FakeConfig) TargetedSpaceReturnsOnCall(i int, result1 configv3.Space) { 2750 fake.targetedSpaceMutex.Lock() 2751 defer fake.targetedSpaceMutex.Unlock() 2752 fake.TargetedSpaceStub = nil 2753 if fake.targetedSpaceReturnsOnCall == nil { 2754 fake.targetedSpaceReturnsOnCall = make(map[int]struct { 2755 result1 configv3.Space 2756 }) 2757 } 2758 fake.targetedSpaceReturnsOnCall[i] = struct { 2759 result1 configv3.Space 2760 }{result1} 2761 } 2762 2763 func (fake *FakeConfig) UAADisableKeepAlives() bool { 2764 fake.uAADisableKeepAlivesMutex.Lock() 2765 ret, specificReturn := fake.uAADisableKeepAlivesReturnsOnCall[len(fake.uAADisableKeepAlivesArgsForCall)] 2766 fake.uAADisableKeepAlivesArgsForCall = append(fake.uAADisableKeepAlivesArgsForCall, struct { 2767 }{}) 2768 fake.recordInvocation("UAADisableKeepAlives", []interface{}{}) 2769 fake.uAADisableKeepAlivesMutex.Unlock() 2770 if fake.UAADisableKeepAlivesStub != nil { 2771 return fake.UAADisableKeepAlivesStub() 2772 } 2773 if specificReturn { 2774 return ret.result1 2775 } 2776 fakeReturns := fake.uAADisableKeepAlivesReturns 2777 return fakeReturns.result1 2778 } 2779 2780 func (fake *FakeConfig) UAADisableKeepAlivesCallCount() int { 2781 fake.uAADisableKeepAlivesMutex.RLock() 2782 defer fake.uAADisableKeepAlivesMutex.RUnlock() 2783 return len(fake.uAADisableKeepAlivesArgsForCall) 2784 } 2785 2786 func (fake *FakeConfig) UAADisableKeepAlivesCalls(stub func() bool) { 2787 fake.uAADisableKeepAlivesMutex.Lock() 2788 defer fake.uAADisableKeepAlivesMutex.Unlock() 2789 fake.UAADisableKeepAlivesStub = stub 2790 } 2791 2792 func (fake *FakeConfig) UAADisableKeepAlivesReturns(result1 bool) { 2793 fake.uAADisableKeepAlivesMutex.Lock() 2794 defer fake.uAADisableKeepAlivesMutex.Unlock() 2795 fake.UAADisableKeepAlivesStub = nil 2796 fake.uAADisableKeepAlivesReturns = struct { 2797 result1 bool 2798 }{result1} 2799 } 2800 2801 func (fake *FakeConfig) UAADisableKeepAlivesReturnsOnCall(i int, result1 bool) { 2802 fake.uAADisableKeepAlivesMutex.Lock() 2803 defer fake.uAADisableKeepAlivesMutex.Unlock() 2804 fake.UAADisableKeepAlivesStub = nil 2805 if fake.uAADisableKeepAlivesReturnsOnCall == nil { 2806 fake.uAADisableKeepAlivesReturnsOnCall = make(map[int]struct { 2807 result1 bool 2808 }) 2809 } 2810 fake.uAADisableKeepAlivesReturnsOnCall[i] = struct { 2811 result1 bool 2812 }{result1} 2813 } 2814 2815 func (fake *FakeConfig) UAAGrantType() string { 2816 fake.uAAGrantTypeMutex.Lock() 2817 ret, specificReturn := fake.uAAGrantTypeReturnsOnCall[len(fake.uAAGrantTypeArgsForCall)] 2818 fake.uAAGrantTypeArgsForCall = append(fake.uAAGrantTypeArgsForCall, struct { 2819 }{}) 2820 fake.recordInvocation("UAAGrantType", []interface{}{}) 2821 fake.uAAGrantTypeMutex.Unlock() 2822 if fake.UAAGrantTypeStub != nil { 2823 return fake.UAAGrantTypeStub() 2824 } 2825 if specificReturn { 2826 return ret.result1 2827 } 2828 fakeReturns := fake.uAAGrantTypeReturns 2829 return fakeReturns.result1 2830 } 2831 2832 func (fake *FakeConfig) UAAGrantTypeCallCount() int { 2833 fake.uAAGrantTypeMutex.RLock() 2834 defer fake.uAAGrantTypeMutex.RUnlock() 2835 return len(fake.uAAGrantTypeArgsForCall) 2836 } 2837 2838 func (fake *FakeConfig) UAAGrantTypeCalls(stub func() string) { 2839 fake.uAAGrantTypeMutex.Lock() 2840 defer fake.uAAGrantTypeMutex.Unlock() 2841 fake.UAAGrantTypeStub = stub 2842 } 2843 2844 func (fake *FakeConfig) UAAGrantTypeReturns(result1 string) { 2845 fake.uAAGrantTypeMutex.Lock() 2846 defer fake.uAAGrantTypeMutex.Unlock() 2847 fake.UAAGrantTypeStub = nil 2848 fake.uAAGrantTypeReturns = struct { 2849 result1 string 2850 }{result1} 2851 } 2852 2853 func (fake *FakeConfig) UAAGrantTypeReturnsOnCall(i int, result1 string) { 2854 fake.uAAGrantTypeMutex.Lock() 2855 defer fake.uAAGrantTypeMutex.Unlock() 2856 fake.UAAGrantTypeStub = nil 2857 if fake.uAAGrantTypeReturnsOnCall == nil { 2858 fake.uAAGrantTypeReturnsOnCall = make(map[int]struct { 2859 result1 string 2860 }) 2861 } 2862 fake.uAAGrantTypeReturnsOnCall[i] = struct { 2863 result1 string 2864 }{result1} 2865 } 2866 2867 func (fake *FakeConfig) UAAOAuthClient() string { 2868 fake.uAAOAuthClientMutex.Lock() 2869 ret, specificReturn := fake.uAAOAuthClientReturnsOnCall[len(fake.uAAOAuthClientArgsForCall)] 2870 fake.uAAOAuthClientArgsForCall = append(fake.uAAOAuthClientArgsForCall, struct { 2871 }{}) 2872 fake.recordInvocation("UAAOAuthClient", []interface{}{}) 2873 fake.uAAOAuthClientMutex.Unlock() 2874 if fake.UAAOAuthClientStub != nil { 2875 return fake.UAAOAuthClientStub() 2876 } 2877 if specificReturn { 2878 return ret.result1 2879 } 2880 fakeReturns := fake.uAAOAuthClientReturns 2881 return fakeReturns.result1 2882 } 2883 2884 func (fake *FakeConfig) UAAOAuthClientCallCount() int { 2885 fake.uAAOAuthClientMutex.RLock() 2886 defer fake.uAAOAuthClientMutex.RUnlock() 2887 return len(fake.uAAOAuthClientArgsForCall) 2888 } 2889 2890 func (fake *FakeConfig) UAAOAuthClientCalls(stub func() string) { 2891 fake.uAAOAuthClientMutex.Lock() 2892 defer fake.uAAOAuthClientMutex.Unlock() 2893 fake.UAAOAuthClientStub = stub 2894 } 2895 2896 func (fake *FakeConfig) UAAOAuthClientReturns(result1 string) { 2897 fake.uAAOAuthClientMutex.Lock() 2898 defer fake.uAAOAuthClientMutex.Unlock() 2899 fake.UAAOAuthClientStub = nil 2900 fake.uAAOAuthClientReturns = struct { 2901 result1 string 2902 }{result1} 2903 } 2904 2905 func (fake *FakeConfig) UAAOAuthClientReturnsOnCall(i int, result1 string) { 2906 fake.uAAOAuthClientMutex.Lock() 2907 defer fake.uAAOAuthClientMutex.Unlock() 2908 fake.UAAOAuthClientStub = nil 2909 if fake.uAAOAuthClientReturnsOnCall == nil { 2910 fake.uAAOAuthClientReturnsOnCall = make(map[int]struct { 2911 result1 string 2912 }) 2913 } 2914 fake.uAAOAuthClientReturnsOnCall[i] = struct { 2915 result1 string 2916 }{result1} 2917 } 2918 2919 func (fake *FakeConfig) UAAOAuthClientSecret() string { 2920 fake.uAAOAuthClientSecretMutex.Lock() 2921 ret, specificReturn := fake.uAAOAuthClientSecretReturnsOnCall[len(fake.uAAOAuthClientSecretArgsForCall)] 2922 fake.uAAOAuthClientSecretArgsForCall = append(fake.uAAOAuthClientSecretArgsForCall, struct { 2923 }{}) 2924 fake.recordInvocation("UAAOAuthClientSecret", []interface{}{}) 2925 fake.uAAOAuthClientSecretMutex.Unlock() 2926 if fake.UAAOAuthClientSecretStub != nil { 2927 return fake.UAAOAuthClientSecretStub() 2928 } 2929 if specificReturn { 2930 return ret.result1 2931 } 2932 fakeReturns := fake.uAAOAuthClientSecretReturns 2933 return fakeReturns.result1 2934 } 2935 2936 func (fake *FakeConfig) UAAOAuthClientSecretCallCount() int { 2937 fake.uAAOAuthClientSecretMutex.RLock() 2938 defer fake.uAAOAuthClientSecretMutex.RUnlock() 2939 return len(fake.uAAOAuthClientSecretArgsForCall) 2940 } 2941 2942 func (fake *FakeConfig) UAAOAuthClientSecretCalls(stub func() string) { 2943 fake.uAAOAuthClientSecretMutex.Lock() 2944 defer fake.uAAOAuthClientSecretMutex.Unlock() 2945 fake.UAAOAuthClientSecretStub = stub 2946 } 2947 2948 func (fake *FakeConfig) UAAOAuthClientSecretReturns(result1 string) { 2949 fake.uAAOAuthClientSecretMutex.Lock() 2950 defer fake.uAAOAuthClientSecretMutex.Unlock() 2951 fake.UAAOAuthClientSecretStub = nil 2952 fake.uAAOAuthClientSecretReturns = struct { 2953 result1 string 2954 }{result1} 2955 } 2956 2957 func (fake *FakeConfig) UAAOAuthClientSecretReturnsOnCall(i int, result1 string) { 2958 fake.uAAOAuthClientSecretMutex.Lock() 2959 defer fake.uAAOAuthClientSecretMutex.Unlock() 2960 fake.UAAOAuthClientSecretStub = nil 2961 if fake.uAAOAuthClientSecretReturnsOnCall == nil { 2962 fake.uAAOAuthClientSecretReturnsOnCall = make(map[int]struct { 2963 result1 string 2964 }) 2965 } 2966 fake.uAAOAuthClientSecretReturnsOnCall[i] = struct { 2967 result1 string 2968 }{result1} 2969 } 2970 2971 func (fake *FakeConfig) UnsetOrganizationAndSpaceInformation() { 2972 fake.unsetOrganizationAndSpaceInformationMutex.Lock() 2973 fake.unsetOrganizationAndSpaceInformationArgsForCall = append(fake.unsetOrganizationAndSpaceInformationArgsForCall, struct { 2974 }{}) 2975 fake.recordInvocation("UnsetOrganizationAndSpaceInformation", []interface{}{}) 2976 fake.unsetOrganizationAndSpaceInformationMutex.Unlock() 2977 if fake.UnsetOrganizationAndSpaceInformationStub != nil { 2978 fake.UnsetOrganizationAndSpaceInformationStub() 2979 } 2980 } 2981 2982 func (fake *FakeConfig) UnsetOrganizationAndSpaceInformationCallCount() int { 2983 fake.unsetOrganizationAndSpaceInformationMutex.RLock() 2984 defer fake.unsetOrganizationAndSpaceInformationMutex.RUnlock() 2985 return len(fake.unsetOrganizationAndSpaceInformationArgsForCall) 2986 } 2987 2988 func (fake *FakeConfig) UnsetOrganizationAndSpaceInformationCalls(stub func()) { 2989 fake.unsetOrganizationAndSpaceInformationMutex.Lock() 2990 defer fake.unsetOrganizationAndSpaceInformationMutex.Unlock() 2991 fake.UnsetOrganizationAndSpaceInformationStub = stub 2992 } 2993 2994 func (fake *FakeConfig) UnsetSpaceInformation() { 2995 fake.unsetSpaceInformationMutex.Lock() 2996 fake.unsetSpaceInformationArgsForCall = append(fake.unsetSpaceInformationArgsForCall, struct { 2997 }{}) 2998 fake.recordInvocation("UnsetSpaceInformation", []interface{}{}) 2999 fake.unsetSpaceInformationMutex.Unlock() 3000 if fake.UnsetSpaceInformationStub != nil { 3001 fake.UnsetSpaceInformationStub() 3002 } 3003 } 3004 3005 func (fake *FakeConfig) UnsetSpaceInformationCallCount() int { 3006 fake.unsetSpaceInformationMutex.RLock() 3007 defer fake.unsetSpaceInformationMutex.RUnlock() 3008 return len(fake.unsetSpaceInformationArgsForCall) 3009 } 3010 3011 func (fake *FakeConfig) UnsetSpaceInformationCalls(stub func()) { 3012 fake.unsetSpaceInformationMutex.Lock() 3013 defer fake.unsetSpaceInformationMutex.Unlock() 3014 fake.UnsetSpaceInformationStub = stub 3015 } 3016 3017 func (fake *FakeConfig) UnsetUserInformation() { 3018 fake.unsetUserInformationMutex.Lock() 3019 fake.unsetUserInformationArgsForCall = append(fake.unsetUserInformationArgsForCall, struct { 3020 }{}) 3021 fake.recordInvocation("UnsetUserInformation", []interface{}{}) 3022 fake.unsetUserInformationMutex.Unlock() 3023 if fake.UnsetUserInformationStub != nil { 3024 fake.UnsetUserInformationStub() 3025 } 3026 } 3027 3028 func (fake *FakeConfig) UnsetUserInformationCallCount() int { 3029 fake.unsetUserInformationMutex.RLock() 3030 defer fake.unsetUserInformationMutex.RUnlock() 3031 return len(fake.unsetUserInformationArgsForCall) 3032 } 3033 3034 func (fake *FakeConfig) UnsetUserInformationCalls(stub func()) { 3035 fake.unsetUserInformationMutex.Lock() 3036 defer fake.unsetUserInformationMutex.Unlock() 3037 fake.UnsetUserInformationStub = stub 3038 } 3039 3040 func (fake *FakeConfig) V7SetSpaceInformation(arg1 string, arg2 string) { 3041 fake.v7SetSpaceInformationMutex.Lock() 3042 fake.v7SetSpaceInformationArgsForCall = append(fake.v7SetSpaceInformationArgsForCall, struct { 3043 arg1 string 3044 arg2 string 3045 }{arg1, arg2}) 3046 fake.recordInvocation("V7SetSpaceInformation", []interface{}{arg1, arg2}) 3047 fake.v7SetSpaceInformationMutex.Unlock() 3048 if fake.V7SetSpaceInformationStub != nil { 3049 fake.V7SetSpaceInformationStub(arg1, arg2) 3050 } 3051 } 3052 3053 func (fake *FakeConfig) V7SetSpaceInformationCallCount() int { 3054 fake.v7SetSpaceInformationMutex.RLock() 3055 defer fake.v7SetSpaceInformationMutex.RUnlock() 3056 return len(fake.v7SetSpaceInformationArgsForCall) 3057 } 3058 3059 func (fake *FakeConfig) V7SetSpaceInformationCalls(stub func(string, string)) { 3060 fake.v7SetSpaceInformationMutex.Lock() 3061 defer fake.v7SetSpaceInformationMutex.Unlock() 3062 fake.V7SetSpaceInformationStub = stub 3063 } 3064 3065 func (fake *FakeConfig) V7SetSpaceInformationArgsForCall(i int) (string, string) { 3066 fake.v7SetSpaceInformationMutex.RLock() 3067 defer fake.v7SetSpaceInformationMutex.RUnlock() 3068 argsForCall := fake.v7SetSpaceInformationArgsForCall[i] 3069 return argsForCall.arg1, argsForCall.arg2 3070 } 3071 3072 func (fake *FakeConfig) Verbose() (bool, []string) { 3073 fake.verboseMutex.Lock() 3074 ret, specificReturn := fake.verboseReturnsOnCall[len(fake.verboseArgsForCall)] 3075 fake.verboseArgsForCall = append(fake.verboseArgsForCall, struct { 3076 }{}) 3077 fake.recordInvocation("Verbose", []interface{}{}) 3078 fake.verboseMutex.Unlock() 3079 if fake.VerboseStub != nil { 3080 return fake.VerboseStub() 3081 } 3082 if specificReturn { 3083 return ret.result1, ret.result2 3084 } 3085 fakeReturns := fake.verboseReturns 3086 return fakeReturns.result1, fakeReturns.result2 3087 } 3088 3089 func (fake *FakeConfig) VerboseCallCount() int { 3090 fake.verboseMutex.RLock() 3091 defer fake.verboseMutex.RUnlock() 3092 return len(fake.verboseArgsForCall) 3093 } 3094 3095 func (fake *FakeConfig) VerboseCalls(stub func() (bool, []string)) { 3096 fake.verboseMutex.Lock() 3097 defer fake.verboseMutex.Unlock() 3098 fake.VerboseStub = stub 3099 } 3100 3101 func (fake *FakeConfig) VerboseReturns(result1 bool, result2 []string) { 3102 fake.verboseMutex.Lock() 3103 defer fake.verboseMutex.Unlock() 3104 fake.VerboseStub = nil 3105 fake.verboseReturns = struct { 3106 result1 bool 3107 result2 []string 3108 }{result1, result2} 3109 } 3110 3111 func (fake *FakeConfig) VerboseReturnsOnCall(i int, result1 bool, result2 []string) { 3112 fake.verboseMutex.Lock() 3113 defer fake.verboseMutex.Unlock() 3114 fake.VerboseStub = nil 3115 if fake.verboseReturnsOnCall == nil { 3116 fake.verboseReturnsOnCall = make(map[int]struct { 3117 result1 bool 3118 result2 []string 3119 }) 3120 } 3121 fake.verboseReturnsOnCall[i] = struct { 3122 result1 bool 3123 result2 []string 3124 }{result1, result2} 3125 } 3126 3127 func (fake *FakeConfig) WritePluginConfig() error { 3128 fake.writePluginConfigMutex.Lock() 3129 ret, specificReturn := fake.writePluginConfigReturnsOnCall[len(fake.writePluginConfigArgsForCall)] 3130 fake.writePluginConfigArgsForCall = append(fake.writePluginConfigArgsForCall, struct { 3131 }{}) 3132 fake.recordInvocation("WritePluginConfig", []interface{}{}) 3133 fake.writePluginConfigMutex.Unlock() 3134 if fake.WritePluginConfigStub != nil { 3135 return fake.WritePluginConfigStub() 3136 } 3137 if specificReturn { 3138 return ret.result1 3139 } 3140 fakeReturns := fake.writePluginConfigReturns 3141 return fakeReturns.result1 3142 } 3143 3144 func (fake *FakeConfig) WritePluginConfigCallCount() int { 3145 fake.writePluginConfigMutex.RLock() 3146 defer fake.writePluginConfigMutex.RUnlock() 3147 return len(fake.writePluginConfigArgsForCall) 3148 } 3149 3150 func (fake *FakeConfig) WritePluginConfigCalls(stub func() error) { 3151 fake.writePluginConfigMutex.Lock() 3152 defer fake.writePluginConfigMutex.Unlock() 3153 fake.WritePluginConfigStub = stub 3154 } 3155 3156 func (fake *FakeConfig) WritePluginConfigReturns(result1 error) { 3157 fake.writePluginConfigMutex.Lock() 3158 defer fake.writePluginConfigMutex.Unlock() 3159 fake.WritePluginConfigStub = nil 3160 fake.writePluginConfigReturns = struct { 3161 result1 error 3162 }{result1} 3163 } 3164 3165 func (fake *FakeConfig) WritePluginConfigReturnsOnCall(i int, result1 error) { 3166 fake.writePluginConfigMutex.Lock() 3167 defer fake.writePluginConfigMutex.Unlock() 3168 fake.WritePluginConfigStub = nil 3169 if fake.writePluginConfigReturnsOnCall == nil { 3170 fake.writePluginConfigReturnsOnCall = make(map[int]struct { 3171 result1 error 3172 }) 3173 } 3174 fake.writePluginConfigReturnsOnCall[i] = struct { 3175 result1 error 3176 }{result1} 3177 } 3178 3179 func (fake *FakeConfig) Invocations() map[string][][]interface{} { 3180 fake.invocationsMutex.RLock() 3181 defer fake.invocationsMutex.RUnlock() 3182 fake.aPIVersionMutex.RLock() 3183 defer fake.aPIVersionMutex.RUnlock() 3184 fake.accessTokenMutex.RLock() 3185 defer fake.accessTokenMutex.RUnlock() 3186 fake.addPluginMutex.RLock() 3187 defer fake.addPluginMutex.RUnlock() 3188 fake.addPluginRepositoryMutex.RLock() 3189 defer fake.addPluginRepositoryMutex.RUnlock() 3190 fake.binaryNameMutex.RLock() 3191 defer fake.binaryNameMutex.RUnlock() 3192 fake.binaryVersionMutex.RLock() 3193 defer fake.binaryVersionMutex.RUnlock() 3194 fake.cFPasswordMutex.RLock() 3195 defer fake.cFPasswordMutex.RUnlock() 3196 fake.cFUsernameMutex.RLock() 3197 defer fake.cFUsernameMutex.RUnlock() 3198 fake.colorEnabledMutex.RLock() 3199 defer fake.colorEnabledMutex.RUnlock() 3200 fake.currentUserMutex.RLock() 3201 defer fake.currentUserMutex.RUnlock() 3202 fake.currentUserNameMutex.RLock() 3203 defer fake.currentUserNameMutex.RUnlock() 3204 fake.dialTimeoutMutex.RLock() 3205 defer fake.dialTimeoutMutex.RUnlock() 3206 fake.dockerPasswordMutex.RLock() 3207 defer fake.dockerPasswordMutex.RUnlock() 3208 fake.experimentalMutex.RLock() 3209 defer fake.experimentalMutex.RUnlock() 3210 fake.getPluginMutex.RLock() 3211 defer fake.getPluginMutex.RUnlock() 3212 fake.getPluginCaseInsensitiveMutex.RLock() 3213 defer fake.getPluginCaseInsensitiveMutex.RUnlock() 3214 fake.hasTargetedOrganizationMutex.RLock() 3215 defer fake.hasTargetedOrganizationMutex.RUnlock() 3216 fake.hasTargetedSpaceMutex.RLock() 3217 defer fake.hasTargetedSpaceMutex.RUnlock() 3218 fake.localeMutex.RLock() 3219 defer fake.localeMutex.RUnlock() 3220 fake.minCLIVersionMutex.RLock() 3221 defer fake.minCLIVersionMutex.RUnlock() 3222 fake.nOAARequestRetryCountMutex.RLock() 3223 defer fake.nOAARequestRetryCountMutex.RUnlock() 3224 fake.overallPollingTimeoutMutex.RLock() 3225 defer fake.overallPollingTimeoutMutex.RUnlock() 3226 fake.pluginHomeMutex.RLock() 3227 defer fake.pluginHomeMutex.RUnlock() 3228 fake.pluginRepositoriesMutex.RLock() 3229 defer fake.pluginRepositoriesMutex.RUnlock() 3230 fake.pluginsMutex.RLock() 3231 defer fake.pluginsMutex.RUnlock() 3232 fake.pollingIntervalMutex.RLock() 3233 defer fake.pollingIntervalMutex.RUnlock() 3234 fake.refreshTokenMutex.RLock() 3235 defer fake.refreshTokenMutex.RUnlock() 3236 fake.removePluginMutex.RLock() 3237 defer fake.removePluginMutex.RUnlock() 3238 fake.requestRetryCountMutex.RLock() 3239 defer fake.requestRetryCountMutex.RUnlock() 3240 fake.routingEndpointMutex.RLock() 3241 defer fake.routingEndpointMutex.RUnlock() 3242 fake.sSHOAuthClientMutex.RLock() 3243 defer fake.sSHOAuthClientMutex.RUnlock() 3244 fake.setAccessTokenMutex.RLock() 3245 defer fake.setAccessTokenMutex.RUnlock() 3246 fake.setOrganizationInformationMutex.RLock() 3247 defer fake.setOrganizationInformationMutex.RUnlock() 3248 fake.setRefreshTokenMutex.RLock() 3249 defer fake.setRefreshTokenMutex.RUnlock() 3250 fake.setSpaceInformationMutex.RLock() 3251 defer fake.setSpaceInformationMutex.RUnlock() 3252 fake.setTargetInformationMutex.RLock() 3253 defer fake.setTargetInformationMutex.RUnlock() 3254 fake.setTokenInformationMutex.RLock() 3255 defer fake.setTokenInformationMutex.RUnlock() 3256 fake.setUAAClientCredentialsMutex.RLock() 3257 defer fake.setUAAClientCredentialsMutex.RUnlock() 3258 fake.setUAAEndpointMutex.RLock() 3259 defer fake.setUAAEndpointMutex.RUnlock() 3260 fake.setUAAGrantTypeMutex.RLock() 3261 defer fake.setUAAGrantTypeMutex.RUnlock() 3262 fake.skipSSLValidationMutex.RLock() 3263 defer fake.skipSSLValidationMutex.RUnlock() 3264 fake.stagingTimeoutMutex.RLock() 3265 defer fake.stagingTimeoutMutex.RUnlock() 3266 fake.startupTimeoutMutex.RLock() 3267 defer fake.startupTimeoutMutex.RUnlock() 3268 fake.targetMutex.RLock() 3269 defer fake.targetMutex.RUnlock() 3270 fake.targetedOrganizationMutex.RLock() 3271 defer fake.targetedOrganizationMutex.RUnlock() 3272 fake.targetedOrganizationNameMutex.RLock() 3273 defer fake.targetedOrganizationNameMutex.RUnlock() 3274 fake.targetedSpaceMutex.RLock() 3275 defer fake.targetedSpaceMutex.RUnlock() 3276 fake.uAADisableKeepAlivesMutex.RLock() 3277 defer fake.uAADisableKeepAlivesMutex.RUnlock() 3278 fake.uAAGrantTypeMutex.RLock() 3279 defer fake.uAAGrantTypeMutex.RUnlock() 3280 fake.uAAOAuthClientMutex.RLock() 3281 defer fake.uAAOAuthClientMutex.RUnlock() 3282 fake.uAAOAuthClientSecretMutex.RLock() 3283 defer fake.uAAOAuthClientSecretMutex.RUnlock() 3284 fake.unsetOrganizationAndSpaceInformationMutex.RLock() 3285 defer fake.unsetOrganizationAndSpaceInformationMutex.RUnlock() 3286 fake.unsetSpaceInformationMutex.RLock() 3287 defer fake.unsetSpaceInformationMutex.RUnlock() 3288 fake.unsetUserInformationMutex.RLock() 3289 defer fake.unsetUserInformationMutex.RUnlock() 3290 fake.v7SetSpaceInformationMutex.RLock() 3291 defer fake.v7SetSpaceInformationMutex.RUnlock() 3292 fake.verboseMutex.RLock() 3293 defer fake.verboseMutex.RUnlock() 3294 fake.writePluginConfigMutex.RLock() 3295 defer fake.writePluginConfigMutex.RUnlock() 3296 copiedInvocations := map[string][][]interface{}{} 3297 for key, value := range fake.invocations { 3298 copiedInvocations[key] = value 3299 } 3300 return copiedInvocations 3301 } 3302 3303 func (fake *FakeConfig) recordInvocation(key string, args []interface{}) { 3304 fake.invocationsMutex.Lock() 3305 defer fake.invocationsMutex.Unlock() 3306 if fake.invocations == nil { 3307 fake.invocations = map[string][][]interface{}{} 3308 } 3309 if fake.invocations[key] == nil { 3310 fake.invocations[key] = [][]interface{}{} 3311 } 3312 fake.invocations[key] = append(fake.invocations[key], args) 3313 } 3314 3315 var _ command.Config = new(FakeConfig)