github.com/dcarley/cf-cli@v6.24.1-0.20170220111324-4225ff346898+incompatible/actor/v2action/v2actionfakes/fake_cloud_controller_client.go

// This file was generated by counterfeiter
package v2actionfakes

import (
	"sync"

	"code.cloudfoundry.org/cli/actor/v2action"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv2"
)

type FakeCloudControllerClient struct {
	DeleteOrganizationStub        func(orgGUID string) (ccv2.Job, ccv2.Warnings, error)
	deleteOrganizationMutex       sync.RWMutex
	deleteOrganizationArgsForCall []struct {
		orgGUID string
	}
	deleteOrganizationReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	DeleteRouteStub        func(routeGUID string) (ccv2.Warnings, error)
	deleteRouteMutex       sync.RWMutex
	deleteRouteArgsForCall []struct {
		routeGUID string
	}
	deleteRouteReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteServiceBindingStub        func(serviceBindingGUID string) (ccv2.Warnings, error)
	deleteServiceBindingMutex       sync.RWMutex
	deleteServiceBindingArgsForCall []struct {
		serviceBindingGUID string
	}
	deleteServiceBindingReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	GetApplicationInstanceStatusesByApplicationStub        func(guid string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error)
	getApplicationInstanceStatusesByApplicationMutex       sync.RWMutex
	getApplicationInstanceStatusesByApplicationArgsForCall []struct {
		guid string
	}
	getApplicationInstanceStatusesByApplicationReturns struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationInstancesByApplicationStub        func(guid string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error)
	getApplicationInstancesByApplicationMutex       sync.RWMutex
	getApplicationInstancesByApplicationArgsForCall []struct {
		guid string
	}
	getApplicationInstancesByApplicationReturns struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationRoutesStub        func(appGUID string, queries []ccv2.Query) ([]ccv2.Route, ccv2.Warnings, error)
	getApplicationRoutesMutex       sync.RWMutex
	getApplicationRoutesArgsForCall []struct {
		appGUID string
		queries []ccv2.Query
	}
	getApplicationRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationStub        func(guid string) (ccv2.Application, ccv2.Warnings, error)
	getApplicationMutex       sync.RWMutex
	getApplicationArgsForCall []struct {
		guid string
	}
	getApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationsStub        func(queries []ccv2.Query) ([]ccv2.Application, ccv2.Warnings, error)
	getApplicationsMutex       sync.RWMutex
	getApplicationsArgsForCall []struct {
		queries []ccv2.Query
	}
	getApplicationsReturns struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetJobStub        func(jobGUID string) (ccv2.Job, ccv2.Warnings, error)
	getJobMutex       sync.RWMutex
	getJobArgsForCall []struct {
		jobGUID string
	}
	getJobReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationsStub        func(queries []ccv2.Query) ([]ccv2.Organization, ccv2.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		queries []ccv2.Query
	}
	getOrganizationsReturns struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	GetPrivateDomainStub        func(domainGUID string) (ccv2.Domain, ccv2.Warnings, error)
	getPrivateDomainMutex       sync.RWMutex
	getPrivateDomainArgsForCall []struct {
		domainGUID string
	}
	getPrivateDomainReturns struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetRouteApplicationsStub        func(routeGUID string, queries []ccv2.Query) ([]ccv2.Application, ccv2.Warnings, error)
	getRouteApplicationsMutex       sync.RWMutex
	getRouteApplicationsArgsForCall []struct {
		routeGUID string
		queries   []ccv2.Query
	}
	getRouteApplicationsReturns struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceBindingsStub        func(queries []ccv2.Query) ([]ccv2.ServiceBinding, ccv2.Warnings, error)
	getServiceBindingsMutex       sync.RWMutex
	getServiceBindingsArgsForCall []struct {
		queries []ccv2.Query
	}
	getServiceBindingsReturns struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstancesStub        func(queries []ccv2.Query) ([]ccv2.ServiceInstance, ccv2.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		queries []ccv2.Query
	}
	getServiceInstancesReturns struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetSharedDomainStub        func(domainGUID string) (ccv2.Domain, ccv2.Warnings, error)
	getSharedDomainMutex       sync.RWMutex
	getSharedDomainArgsForCall []struct {
		domainGUID string
	}
	getSharedDomainReturns struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceRoutesStub        func(spaceGUID string, queries []ccv2.Query) ([]ccv2.Route, ccv2.Warnings, error)
	getSpaceRoutesMutex       sync.RWMutex
	getSpaceRoutesArgsForCall []struct {
		spaceGUID string
		queries   []ccv2.Query
	}
	getSpaceRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceServiceInstancesStub        func(spaceGUID string, includeUserProvidedServices bool, queries []ccv2.Query) ([]ccv2.ServiceInstance, ccv2.Warnings, error)
	getSpaceServiceInstancesMutex       sync.RWMutex
	getSpaceServiceInstancesArgsForCall []struct {
		spaceGUID                   string
		includeUserProvidedServices bool
		queries                     []ccv2.Query
	}
	getSpaceServiceInstancesReturns struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetSpacesStub        func(queries []ccv2.Query) ([]ccv2.Space, ccv2.Warnings, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		queries []ccv2.Query
	}
	getSpacesReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	GetStackStub        func(guid string) (ccv2.Stack, ccv2.Warnings, error)
	getStackMutex       sync.RWMutex
	getStackArgsForCall []struct {
		guid string
	}
	getStackReturns struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	NewUserStub        func(uaaUserID string) (ccv2.User, ccv2.Warnings, error)
	newUserMutex       sync.RWMutex
	newUserArgsForCall []struct {
		uaaUserID string
	}
	newUserReturns struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}
	PollJobStub        func(job ccv2.Job) (ccv2.Warnings, error)
	pollJobMutex       sync.RWMutex
	pollJobArgsForCall []struct {
		job ccv2.Job
	}
	pollJobReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	TargetCFStub        func(settings ccv2.TargetSettings) (ccv2.Warnings, error)
	targetCFMutex       sync.RWMutex
	targetCFArgsForCall []struct {
		settings ccv2.TargetSettings
	}
	targetCFReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateApplicationStub        func(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		app ccv2.Application
	}
	updateApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	APIStub        func() string
	aPIMutex       sync.RWMutex
	aPIArgsForCall []struct{}
	aPIReturns     struct {
		result1 string
	}
	APIVersionStub        func() string
	aPIVersionMutex       sync.RWMutex
	aPIVersionArgsForCall []struct{}
	aPIVersionReturns     struct {
		result1 string
	}
	AuthorizationEndpointStub        func() string
	authorizationEndpointMutex       sync.RWMutex
	authorizationEndpointArgsForCall []struct{}
	authorizationEndpointReturns     struct {
		result1 string
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct{}
	dopplerEndpointReturns     struct {
		result1 string
	}
	MinCLIVersionStub        func() string
	minCLIVersionMutex       sync.RWMutex
	minCLIVersionArgsForCall []struct{}
	minCLIVersionReturns     struct {
		result1 string
	}
	RoutingEndpointStub        func() string
	routingEndpointMutex       sync.RWMutex
	routingEndpointArgsForCall []struct{}
	routingEndpointReturns     struct {
		result1 string
	}
	TokenEndpointStub        func() string
	tokenEndpointMutex       sync.RWMutex
	tokenEndpointArgsForCall []struct{}
	tokenEndpointReturns     struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) DeleteOrganization(orgGUID string) (ccv2.Job, ccv2.Warnings, error) {
	fake.deleteOrganizationMutex.Lock()
	fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, struct {
		orgGUID string
	}{orgGUID})
	fake.recordInvocation("DeleteOrganization", []interface{}{orgGUID})
	fake.deleteOrganizationMutex.Unlock()
	if fake.DeleteOrganizationStub != nil {
		return fake.DeleteOrganizationStub(orgGUID)
	} else {
		return fake.deleteOrganizationReturns.result1, fake.deleteOrganizationReturns.result2, fake.deleteOrganizationReturns.result3
	}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationCallCount() int {
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	return len(fake.deleteOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteOrganizationArgsForCall(i int) string {
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	return fake.deleteOrganizationArgsForCall[i].orgGUID
}

func (fake *FakeCloudControllerClient) DeleteOrganizationReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.DeleteOrganizationStub = nil
	fake.deleteOrganizationReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRoute(routeGUID string) (ccv2.Warnings, error) {
	fake.deleteRouteMutex.Lock()
	fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, struct {
		routeGUID string
	}{routeGUID})
	fake.recordInvocation("DeleteRoute", []interface{}{routeGUID})
	fake.deleteRouteMutex.Unlock()
	if fake.DeleteRouteStub != nil {
		return fake.DeleteRouteStub(routeGUID)
	} else {
		return fake.deleteRouteReturns.result1, fake.deleteRouteReturns.result2
	}
}

func (fake *FakeCloudControllerClient) DeleteRouteCallCount() int {
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	return len(fake.deleteRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteRouteArgsForCall(i int) string {
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	return fake.deleteRouteArgsForCall[i].routeGUID
}

func (fake *FakeCloudControllerClient) DeleteRouteReturns(result1 ccv2.Warnings, result2 error) {
	fake.DeleteRouteStub = nil
	fake.deleteRouteReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceBinding(serviceBindingGUID string) (ccv2.Warnings, error) {
	fake.deleteServiceBindingMutex.Lock()
	fake.deleteServiceBindingArgsForCall = append(fake.deleteServiceBindingArgsForCall, struct {
		serviceBindingGUID string
	}{serviceBindingGUID})
	fake.recordInvocation("DeleteServiceBinding", []interface{}{serviceBindingGUID})
	fake.deleteServiceBindingMutex.Unlock()
	if fake.DeleteServiceBindingStub != nil {
		return fake.DeleteServiceBindingStub(serviceBindingGUID)
	} else {
		return fake.deleteServiceBindingReturns.result1, fake.deleteServiceBindingReturns.result2
	}
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingCallCount() int {
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	return len(fake.deleteServiceBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingArgsForCall(i int) string {
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	return fake.deleteServiceBindingArgsForCall[i].serviceBindingGUID
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingReturns(result1 ccv2.Warnings, result2 error) {
	fake.DeleteServiceBindingStub = nil
	fake.deleteServiceBindingReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) GetApplicationInstanceStatusesByApplication(guid string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error) {
	fake.getApplicationInstanceStatusesByApplicationMutex.Lock()
	fake.getApplicationInstanceStatusesByApplicationArgsForCall = append(fake.getApplicationInstanceStatusesByApplicationArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetApplicationInstanceStatusesByApplication", []interface{}{guid})
	fake.getApplicationInstanceStatusesByApplicationMutex.Unlock()
	if fake.GetApplicationInstanceStatusesByApplicationStub != nil {
		return fake.GetApplicationInstanceStatusesByApplicationStub(guid)
	} else {
		return fake.getApplicationInstanceStatusesByApplicationReturns.result1, fake.getApplicationInstanceStatusesByApplicationReturns.result2, fake.getApplicationInstanceStatusesByApplicationReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetApplicationInstanceStatusesByApplicationCallCount() int {
	fake.getApplicationInstanceStatusesByApplicationMutex.RLock()
	defer fake.getApplicationInstanceStatusesByApplicationMutex.RUnlock()
	return len(fake.getApplicationInstanceStatusesByApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationInstanceStatusesByApplicationArgsForCall(i int) string {
	fake.getApplicationInstanceStatusesByApplicationMutex.RLock()
	defer fake.getApplicationInstanceStatusesByApplicationMutex.RUnlock()
	return fake.getApplicationInstanceStatusesByApplicationArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetApplicationInstanceStatusesByApplicationReturns(result1 map[int]ccv2.ApplicationInstanceStatus, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationInstanceStatusesByApplicationStub = nil
	fake.getApplicationInstanceStatusesByApplicationReturns = struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationInstancesByApplication(guid string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error) {
	fake.getApplicationInstancesByApplicationMutex.Lock()
	fake.getApplicationInstancesByApplicationArgsForCall = append(fake.getApplicationInstancesByApplicationArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetApplicationInstancesByApplication", []interface{}{guid})
	fake.getApplicationInstancesByApplicationMutex.Unlock()
	if fake.GetApplicationInstancesByApplicationStub != nil {
		return fake.GetApplicationInstancesByApplicationStub(guid)
	} else {
		return fake.getApplicationInstancesByApplicationReturns.result1, fake.getApplicationInstancesByApplicationReturns.result2, fake.getApplicationInstancesByApplicationReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetApplicationInstancesByApplicationCallCount() int {
	fake.getApplicationInstancesByApplicationMutex.RLock()
	defer fake.getApplicationInstancesByApplicationMutex.RUnlock()
	return len(fake.getApplicationInstancesByApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationInstancesByApplicationArgsForCall(i int) string {
	fake.getApplicationInstancesByApplicationMutex.RLock()
	defer fake.getApplicationInstancesByApplicationMutex.RUnlock()
	return fake.getApplicationInstancesByApplicationArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetApplicationInstancesByApplicationReturns(result1 map[int]ccv2.ApplicationInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationInstancesByApplicationStub = nil
	fake.getApplicationInstancesByApplicationReturns = struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutes(appGUID string, queries []ccv2.Query) ([]ccv2.Route, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getApplicationRoutesMutex.Lock()
	fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, struct {
		appGUID string
		queries []ccv2.Query
	}{appGUID, queriesCopy})
	fake.recordInvocation("GetApplicationRoutes", []interface{}{appGUID, queriesCopy})
	fake.getApplicationRoutesMutex.Unlock()
	if fake.GetApplicationRoutesStub != nil {
		return fake.GetApplicationRoutesStub(appGUID, queries)
	} else {
		return fake.getApplicationRoutesReturns.result1, fake.getApplicationRoutesReturns.result2, fake.getApplicationRoutesReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesCallCount() int {
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	return len(fake.getApplicationRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesArgsForCall(i int) (string, []ccv2.Query) {
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	return fake.getApplicationRoutesArgsForCall[i].appGUID, fake.getApplicationRoutesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationRoutesStub = nil
	fake.getApplicationRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplication(guid string) (ccv2.Application, ccv2.Warnings, error) {
	fake.getApplicationMutex.Lock()
	fake.getApplicationArgsForCall = append(fake.getApplicationArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetApplication", []interface{}{guid})
	fake.getApplicationMutex.Unlock()
	if fake.GetApplicationStub != nil {
		return fake.GetApplicationStub(guid)
	} else {
		return fake.getApplicationReturns.result1, fake.getApplicationReturns.result2, fake.getApplicationReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetApplicationCallCount() int {
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	return len(fake.getApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationArgsForCall(i int) string {
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	return fake.getApplicationArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationStub = nil
	fake.getApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplications(queries []ccv2.Query) ([]ccv2.Application, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getApplicationsMutex.Lock()
	fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetApplications", []interface{}{queriesCopy})
	fake.getApplicationsMutex.Unlock()
	if fake.GetApplicationsStub != nil {
		return fake.GetApplicationsStub(queries)
	} else {
		return fake.getApplicationsReturns.result1, fake.getApplicationsReturns.result2, fake.getApplicationsReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetApplicationsCallCount() int {
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	return len(fake.getApplicationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationsArgsForCall(i int) []ccv2.Query {
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	return fake.getApplicationsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetApplicationsReturns(result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationsStub = nil
	fake.getApplicationsReturns = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetJob(jobGUID string) (ccv2.Job, ccv2.Warnings, error) {
	fake.getJobMutex.Lock()
	fake.getJobArgsForCall = append(fake.getJobArgsForCall, struct {
		jobGUID string
	}{jobGUID})
	fake.recordInvocation("GetJob", []interface{}{jobGUID})
	fake.getJobMutex.Unlock()
	if fake.GetJobStub != nil {
		return fake.GetJobStub(jobGUID)
	} else {
		return fake.getJobReturns.result1, fake.getJobReturns.result2, fake.getJobReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetJobCallCount() int {
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	return len(fake.getJobArgsForCall)
}

func (fake *FakeCloudControllerClient) GetJobArgsForCall(i int) string {
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	return fake.getJobArgsForCall[i].jobGUID
}

func (fake *FakeCloudControllerClient) GetJobReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.GetJobStub = nil
	fake.getJobReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizations(queries []ccv2.Query) ([]ccv2.Organization, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getOrganizationsMutex.Lock()
	fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetOrganizations", []interface{}{queriesCopy})
	fake.getOrganizationsMutex.Unlock()
	if fake.GetOrganizationsStub != nil {
		return fake.GetOrganizationsStub(queries)
	} else {
		return fake.getOrganizationsReturns.result1, fake.getOrganizationsReturns.result2, fake.getOrganizationsReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetOrganizationsCallCount() int {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	return len(fake.getOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationsArgsForCall(i int) []ccv2.Query {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	return fake.getOrganizationsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetOrganizationsReturns(result1 []ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationsStub = nil
	fake.getOrganizationsReturns = struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPrivateDomain(domainGUID string) (ccv2.Domain, ccv2.Warnings, error) {
	fake.getPrivateDomainMutex.Lock()
	fake.getPrivateDomainArgsForCall = append(fake.getPrivateDomainArgsForCall, struct {
		domainGUID string
	}{domainGUID})
	fake.recordInvocation("GetPrivateDomain", []interface{}{domainGUID})
	fake.getPrivateDomainMutex.Unlock()
	if fake.GetPrivateDomainStub != nil {
		return fake.GetPrivateDomainStub(domainGUID)
	} else {
		return fake.getPrivateDomainReturns.result1, fake.getPrivateDomainReturns.result2, fake.getPrivateDomainReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetPrivateDomainCallCount() int {
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	return len(fake.getPrivateDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPrivateDomainArgsForCall(i int) string {
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	return fake.getPrivateDomainArgsForCall[i].domainGUID
}

func (fake *FakeCloudControllerClient) GetPrivateDomainReturns(result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetPrivateDomainStub = nil
	fake.getPrivateDomainReturns = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRouteApplications(routeGUID string, queries []ccv2.Query) ([]ccv2.Application, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getRouteApplicationsMutex.Lock()
	fake.getRouteApplicationsArgsForCall = append(fake.getRouteApplicationsArgsForCall, struct {
		routeGUID string
		queries   []ccv2.Query
	}{routeGUID, queriesCopy})
	fake.recordInvocation("GetRouteApplications", []interface{}{routeGUID, queriesCopy})
	fake.getRouteApplicationsMutex.Unlock()
	if fake.GetRouteApplicationsStub != nil {
		return fake.GetRouteApplicationsStub(routeGUID, queries)
	} else {
		return fake.getRouteApplicationsReturns.result1, fake.getRouteApplicationsReturns.result2, fake.getRouteApplicationsReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsCallCount() int {
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	return len(fake.getRouteApplicationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsArgsForCall(i int) (string, []ccv2.Query) {
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	return fake.getRouteApplicationsArgsForCall[i].routeGUID, fake.getRouteApplicationsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsReturns(result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetRouteApplicationsStub = nil
	fake.getRouteApplicationsReturns = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBindings(queries []ccv2.Query) ([]ccv2.ServiceBinding, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getServiceBindingsMutex.Lock()
	fake.getServiceBindingsArgsForCall = append(fake.getServiceBindingsArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetServiceBindings", []interface{}{queriesCopy})
	fake.getServiceBindingsMutex.Unlock()
	if fake.GetServiceBindingsStub != nil {
		return fake.GetServiceBindingsStub(queries)
	} else {
		return fake.getServiceBindingsReturns.result1, fake.getServiceBindingsReturns.result2, fake.getServiceBindingsReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetServiceBindingsCallCount() int {
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	return len(fake.getServiceBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceBindingsArgsForCall(i int) []ccv2.Query {
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	return fake.getServiceBindingsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetServiceBindingsReturns(result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceBindingsStub = nil
	fake.getServiceBindingsReturns = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstances(queries []ccv2.Query) ([]ccv2.ServiceInstance, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getServiceInstancesMutex.Lock()
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetServiceInstances", []interface{}{queriesCopy})
	fake.getServiceInstancesMutex.Unlock()
	if fake.GetServiceInstancesStub != nil {
		return fake.GetServiceInstancesStub(queries)
	} else {
		return fake.getServiceInstancesReturns.result1, fake.getServiceInstancesReturns.result2, fake.getServiceInstancesReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetServiceInstancesCallCount() int {
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	return len(fake.getServiceInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstancesArgsForCall(i int) []ccv2.Query {
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	return fake.getServiceInstancesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturns(result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceInstancesStub = nil
	fake.getServiceInstancesReturns = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomain(domainGUID string) (ccv2.Domain, ccv2.Warnings, error) {
	fake.getSharedDomainMutex.Lock()
	fake.getSharedDomainArgsForCall = append(fake.getSharedDomainArgsForCall, struct {
		domainGUID string
	}{domainGUID})
	fake.recordInvocation("GetSharedDomain", []interface{}{domainGUID})
	fake.getSharedDomainMutex.Unlock()
	if fake.GetSharedDomainStub != nil {
		return fake.GetSharedDomainStub(domainGUID)
	} else {
		return fake.getSharedDomainReturns.result1, fake.getSharedDomainReturns.result2, fake.getSharedDomainReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetSharedDomainCallCount() int {
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	return len(fake.getSharedDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSharedDomainArgsForCall(i int) string {
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	return fake.getSharedDomainArgsForCall[i].domainGUID
}

func (fake *FakeCloudControllerClient) GetSharedDomainReturns(result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetSharedDomainStub = nil
	fake.getSharedDomainReturns = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceRoutes(spaceGUID string, queries []ccv2.Query) ([]ccv2.Route, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSpaceRoutesMutex.Lock()
	fake.getSpaceRoutesArgsForCall = append(fake.getSpaceRoutesArgsForCall, struct {
		spaceGUID string
		queries   []ccv2.Query
	}{spaceGUID, queriesCopy})
	fake.recordInvocation("GetSpaceRoutes", []interface{}{spaceGUID, queriesCopy})
	fake.getSpaceRoutesMutex.Unlock()
	if fake.GetSpaceRoutesStub != nil {
		return fake.GetSpaceRoutesStub(spaceGUID, queries)
	} else {
		return fake.getSpaceRoutesReturns.result1, fake.getSpaceRoutesReturns.result2, fake.getSpaceRoutesReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesCallCount() int {
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	return len(fake.getSpaceRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesArgsForCall(i int) (string, []ccv2.Query) {
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	return fake.getSpaceRoutesArgsForCall[i].spaceGUID, fake.getSpaceRoutesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceRoutesStub = nil
	fake.getSpaceRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstances(spaceGUID string, includeUserProvidedServices bool, queries []ccv2.Query) ([]ccv2.ServiceInstance, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSpaceServiceInstancesMutex.Lock()
	fake.getSpaceServiceInstancesArgsForCall = append(fake.getSpaceServiceInstancesArgsForCall, struct {
		spaceGUID                   string
		includeUserProvidedServices bool
		queries                     []ccv2.Query
	}{spaceGUID, includeUserProvidedServices, queriesCopy})
	fake.recordInvocation("GetSpaceServiceInstances", []interface{}{spaceGUID, includeUserProvidedServices, queriesCopy})
	fake.getSpaceServiceInstancesMutex.Unlock()
	if fake.GetSpaceServiceInstancesStub != nil {
		return fake.GetSpaceServiceInstancesStub(spaceGUID, includeUserProvidedServices, queries)
	} else {
		return fake.getSpaceServiceInstancesReturns.result1, fake.getSpaceServiceInstancesReturns.result2, fake.getSpaceServiceInstancesReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesCallCount() int {
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	return len(fake.getSpaceServiceInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesArgsForCall(i int) (string, bool, []ccv2.Query) {
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	return fake.getSpaceServiceInstancesArgsForCall[i].spaceGUID, fake.getSpaceServiceInstancesArgsForCall[i].includeUserProvidedServices, fake.getSpaceServiceInstancesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesReturns(result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceServiceInstancesStub = nil
	fake.getSpaceServiceInstancesReturns = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaces(queries []ccv2.Query) ([]ccv2.Space, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSpacesMutex.Lock()
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetSpaces", []interface{}{queriesCopy})
	fake.getSpacesMutex.Unlock()
	if fake.GetSpacesStub != nil {
		return fake.GetSpacesStub(queries)
	} else {
		return fake.getSpacesReturns.result1, fake.getSpacesReturns.result2, fake.getSpacesReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetSpacesCallCount() int {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	return len(fake.getSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpacesArgsForCall(i int) []ccv2.Query {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	return fake.getSpacesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSpacesReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetSpacesStub = nil
	fake.getSpacesReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStack(guid string) (ccv2.Stack, ccv2.Warnings, error) {
	fake.getStackMutex.Lock()
	fake.getStackArgsForCall = append(fake.getStackArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetStack", []interface{}{guid})
	fake.getStackMutex.Unlock()
	if fake.GetStackStub != nil {
		return fake.GetStackStub(guid)
	} else {
		return fake.getStackReturns.result1, fake.getStackReturns.result2, fake.getStackReturns.result3
	}
}

func (fake *FakeCloudControllerClient) GetStackCallCount() int {
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	return len(fake.getStackArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStackArgsForCall(i int) string {
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	return fake.getStackArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetStackReturns(result1 ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.GetStackStub = nil
	fake.getStackReturns = struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) NewUser(uaaUserID string) (ccv2.User, ccv2.Warnings, error) {
	fake.newUserMutex.Lock()
	fake.newUserArgsForCall = append(fake.newUserArgsForCall, struct {
		uaaUserID string
	}{uaaUserID})
	fake.recordInvocation("NewUser", []interface{}{uaaUserID})
	fake.newUserMutex.Unlock()
	if fake.NewUserStub != nil {
		return fake.NewUserStub(uaaUserID)
	} else {
		return fake.newUserReturns.result1, fake.newUserReturns.result2, fake.newUserReturns.result3
	}
}

func (fake *FakeCloudControllerClient) NewUserCallCount() int {
	fake.newUserMutex.RLock()
	defer fake.newUserMutex.RUnlock()
	return len(fake.newUserArgsForCall)
}

func (fake *FakeCloudControllerClient) NewUserArgsForCall(i int) string {
	fake.newUserMutex.RLock()
	defer fake.newUserMutex.RUnlock()
	return fake.newUserArgsForCall[i].uaaUserID
}

func (fake *FakeCloudControllerClient) NewUserReturns(result1 ccv2.User, result2 ccv2.Warnings, result3 error) {
	fake.NewUserStub = nil
	fake.newUserReturns = struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PollJob(job ccv2.Job) (ccv2.Warnings, error) {
	fake.pollJobMutex.Lock()
	fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, struct {
		job ccv2.Job
	}{job})
	fake.recordInvocation("PollJob", []interface{}{job})
	fake.pollJobMutex.Unlock()
	if fake.PollJobStub != nil {
		return fake.PollJobStub(job)
	} else {
		return fake.pollJobReturns.result1, fake.pollJobReturns.result2
	}
}

func (fake *FakeCloudControllerClient) PollJobCallCount() int {
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	return len(fake.pollJobArgsForCall)
}

func (fake *FakeCloudControllerClient) PollJobArgsForCall(i int) ccv2.Job {
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	return fake.pollJobArgsForCall[i].job
}

func (fake *FakeCloudControllerClient) PollJobReturns(result1 ccv2.Warnings, result2 error) {
	fake.PollJobStub = nil
	fake.pollJobReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) TargetCF(settings ccv2.TargetSettings) (ccv2.Warnings, error) {
	fake.targetCFMutex.Lock()
	fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, struct {
		settings ccv2.TargetSettings
	}{settings})
	fake.recordInvocation("TargetCF", []interface{}{settings})
	fake.targetCFMutex.Unlock()
	if fake.TargetCFStub != nil {
		return fake.TargetCFStub(settings)
	} else {
		return fake.targetCFReturns.result1, fake.targetCFReturns.result2
	}
}

func (fake *FakeCloudControllerClient) TargetCFCallCount() int {
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	return len(fake.targetCFArgsForCall)
}

func (fake *FakeCloudControllerClient) TargetCFArgsForCall(i int) ccv2.TargetSettings {
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	return fake.targetCFArgsForCall[i].settings
}

func (fake *FakeCloudControllerClient) TargetCFReturns(result1 ccv2.Warnings, result2 error) {
	fake.TargetCFStub = nil
	fake.targetCFReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateApplication(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.updateApplicationMutex.Lock()
	fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct {
		app ccv2.Application
	}{app})
	fake.recordInvocation("UpdateApplication", []interface{}{app})
	fake.updateApplicationMutex.Unlock()
	if fake.UpdateApplicationStub != nil {
		return fake.UpdateApplicationStub(app)
	} else {
		return fake.updateApplicationReturns.result1, fake.updateApplicationReturns.result2, fake.updateApplicationReturns.result3
	}
}

func (fake *FakeCloudControllerClient) UpdateApplicationCallCount() int {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	return len(fake.updateApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationArgsForCall(i int) ccv2.Application {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	return fake.updateApplicationArgsForCall[i].app
}

func (fake *FakeCloudControllerClient) UpdateApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.UpdateApplicationStub = nil
	fake.updateApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) API() string {
	fake.aPIMutex.Lock()
	fake.aPIArgsForCall = append(fake.aPIArgsForCall, struct{}{})
	fake.recordInvocation("API", []interface{}{})
	fake.aPIMutex.Unlock()
	if fake.APIStub != nil {
		return fake.APIStub()
	} else {
		return fake.aPIReturns.result1
	}
}

func (fake *FakeCloudControllerClient) APICallCount() int {
	fake.aPIMutex.RLock()
	defer fake.aPIMutex.RUnlock()
	return len(fake.aPIArgsForCall)
}

func (fake *FakeCloudControllerClient) APIReturns(result1 string) {
	fake.APIStub = nil
	fake.aPIReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) APIVersion() string {
	fake.aPIVersionMutex.Lock()
	fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct{}{})
	fake.recordInvocation("APIVersion", []interface{}{})
	fake.aPIVersionMutex.Unlock()
	if fake.APIVersionStub != nil {
		return fake.APIVersionStub()
	} else {
		return fake.aPIVersionReturns.result1
	}
}

func (fake *FakeCloudControllerClient) APIVersionCallCount() int {
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	return len(fake.aPIVersionArgsForCall)
}

func (fake *FakeCloudControllerClient) APIVersionReturns(result1 string) {
	fake.APIVersionStub = nil
	fake.aPIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AuthorizationEndpoint() string {
	fake.authorizationEndpointMutex.Lock()
	fake.authorizationEndpointArgsForCall = append(fake.authorizationEndpointArgsForCall, struct{}{})
	fake.recordInvocation("AuthorizationEndpoint", []interface{}{})
	fake.authorizationEndpointMutex.Unlock()
	if fake.AuthorizationEndpointStub != nil {
		return fake.AuthorizationEndpointStub()
	} else {
		return fake.authorizationEndpointReturns.result1
	}
}

func (fake *FakeCloudControllerClient) AuthorizationEndpointCallCount() int {
	fake.authorizationEndpointMutex.RLock()
	defer fake.authorizationEndpointMutex.RUnlock()
	return len(fake.authorizationEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) AuthorizationEndpointReturns(result1 string) {
	fake.AuthorizationEndpointStub = nil
	fake.authorizationEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) DopplerEndpoint() string {
	fake.dopplerEndpointMutex.Lock()
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct{}{})
	fake.recordInvocation("DopplerEndpoint", []interface{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	} else {
		return fake.dopplerEndpointReturns.result1
	}
}

func (fake *FakeCloudControllerClient) DopplerEndpointCallCount() int {
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	return len(fake.dopplerEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) DopplerEndpointReturns(result1 string) {
	fake.DopplerEndpointStub = nil
	fake.dopplerEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) MinCLIVersion() string {
	fake.minCLIVersionMutex.Lock()
	fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct{}{})
	fake.recordInvocation("MinCLIVersion", []interface{}{})
	fake.minCLIVersionMutex.Unlock()
	if fake.MinCLIVersionStub != nil {
		return fake.MinCLIVersionStub()
	} else {
		return fake.minCLIVersionReturns.result1
	}
}

func (fake *FakeCloudControllerClient) MinCLIVersionCallCount() int {
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	return len(fake.minCLIVersionArgsForCall)
}

func (fake *FakeCloudControllerClient) MinCLIVersionReturns(result1 string) {
	fake.MinCLIVersionStub = nil
	fake.minCLIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) RoutingEndpoint() string {
	fake.routingEndpointMutex.Lock()
	fake.routingEndpointArgsForCall = append(fake.routingEndpointArgsForCall, struct{}{})
	fake.recordInvocation("RoutingEndpoint", []interface{}{})
	fake.routingEndpointMutex.Unlock()
	if fake.RoutingEndpointStub != nil {
		return fake.RoutingEndpointStub()
	} else {
		return fake.routingEndpointReturns.result1
	}
}

func (fake *FakeCloudControllerClient) RoutingEndpointCallCount() int {
	fake.routingEndpointMutex.RLock()
	defer fake.routingEndpointMutex.RUnlock()
	return len(fake.routingEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) RoutingEndpointReturns(result1 string) {
	fake.RoutingEndpointStub = nil
	fake.routingEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) TokenEndpoint() string {
	fake.tokenEndpointMutex.Lock()
	fake.tokenEndpointArgsForCall = append(fake.tokenEndpointArgsForCall, struct{}{})
	fake.recordInvocation("TokenEndpoint", []interface{}{})
	fake.tokenEndpointMutex.Unlock()
	if fake.TokenEndpointStub != nil {
		return fake.TokenEndpointStub()
	} else {
		return fake.tokenEndpointReturns.result1
	}
}

func (fake *FakeCloudControllerClient) TokenEndpointCallCount() int {
	fake.tokenEndpointMutex.RLock()
	defer fake.tokenEndpointMutex.RUnlock()
	return len(fake.tokenEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) TokenEndpointReturns(result1 string) {
	fake.TokenEndpointStub = nil
	fake.tokenEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	fake.getApplicationInstanceStatusesByApplicationMutex.RLock()
	defer fake.getApplicationInstanceStatusesByApplicationMutex.RUnlock()
	fake.getApplicationInstancesByApplicationMutex.RLock()
	defer fake.getApplicationInstancesByApplicationMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	fake.newUserMutex.RLock()
	defer fake.newUserMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.aPIMutex.RLock()
	defer fake.aPIMutex.RUnlock()
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	fake.authorizationEndpointMutex.RLock()
	defer fake.authorizationEndpointMutex.RUnlock()
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	fake.routingEndpointMutex.RLock()
	defer fake.routingEndpointMutex.RUnlock()
	fake.tokenEndpointMutex.RLock()
	defer fake.tokenEndpointMutex.RUnlock()
	return fake.invocations
}

func (fake *FakeCloudControllerClient) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ v2action.CloudControllerClient = new(FakeCloudControllerClient)