fake_cloud_controller_client.go

// Code generated by counterfeiter. DO NOT EDIT.
package v2actionfakes

import (
	"sync"

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

type FakeCloudControllerClient struct {
	AssociateSpaceWithRunningSecurityGroupStub        func(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error)
	associateSpaceWithRunningSecurityGroupMutex       sync.RWMutex
	associateSpaceWithRunningSecurityGroupArgsForCall []struct {
		securityGroupGUID string
		spaceGUID         string
	}
	associateSpaceWithRunningSecurityGroupReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	associateSpaceWithRunningSecurityGroupReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	AssociateSpaceWithStagingSecurityGroupStub        func(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error)
	associateSpaceWithStagingSecurityGroupMutex       sync.RWMutex
	associateSpaceWithStagingSecurityGroupArgsForCall []struct {
		securityGroupGUID string
		spaceGUID         string
	}
	associateSpaceWithStagingSecurityGroupReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	associateSpaceWithStagingSecurityGroupReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	BindRouteToApplicationStub        func(routeGUID string, appGUID string) (ccv2.Route, ccv2.Warnings, error)
	bindRouteToApplicationMutex       sync.RWMutex
	bindRouteToApplicationArgsForCall []struct {
		routeGUID string
		appGUID   string
	}
	bindRouteToApplicationReturns struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	bindRouteToApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	CheckRouteStub        func(route ccv2.Route) (bool, ccv2.Warnings, error)
	checkRouteMutex       sync.RWMutex
	checkRouteArgsForCall []struct {
		route ccv2.Route
	}
	checkRouteReturns struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}
	checkRouteReturnsOnCall map[int]struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}
	CreateApplicationStub        func(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	createApplicationMutex       sync.RWMutex
	createApplicationArgsForCall []struct {
		app ccv2.Application
	}
	createApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	createApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	CreateRouteStub        func(route ccv2.Route, generatePort bool) (ccv2.Route, ccv2.Warnings, error)
	createRouteMutex       sync.RWMutex
	createRouteArgsForCall []struct {
		route        ccv2.Route
		generatePort bool
	}
	createRouteReturns struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	createRouteReturnsOnCall map[int]struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	CreateServiceBindingStub        func(appGUID string, serviceBindingGUID string, parameters map[string]interface{}) (ccv2.ServiceBinding, ccv2.Warnings, error)
	createServiceBindingMutex       sync.RWMutex
	createServiceBindingArgsForCall []struct {
		appGUID            string
		serviceBindingGUID string
		parameters         map[string]interface{}
	}
	createServiceBindingReturns struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	createServiceBindingReturnsOnCall map[int]struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	CreateUserStub        func(uaaUserID string) (ccv2.User, ccv2.Warnings, error)
	createUserMutex       sync.RWMutex
	createUserArgsForCall []struct {
		uaaUserID string
	}
	createUserReturns struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}
	createUserReturnsOnCall map[int]struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}
	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
	}
	deleteOrganizationReturnsOnCall map[int]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
	}
	deleteRouteReturnsOnCall map[int]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
	}
	deleteServiceBindingReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteSpaceStub        func(spaceGUID string) (ccv2.Job, ccv2.Warnings, error)
	deleteSpaceMutex       sync.RWMutex
	deleteSpaceArgsForCall []struct {
		spaceGUID string
	}
	deleteSpaceReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	deleteSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Job
		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
	}
	getApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		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
	}
	getApplicationInstancesByApplicationReturnsOnCall map[int]struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 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
	}
	getApplicationInstanceStatusesByApplicationReturnsOnCall map[int]struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		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
	}
	getApplicationRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		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
	}
	getApplicationsReturnsOnCall map[int]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
	}
	getJobReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationStub        func(guid string) (ccv2.Organization, ccv2.Warnings, error)
	getOrganizationMutex       sync.RWMutex
	getOrganizationArgsForCall []struct {
		guid string
	}
	getOrganizationReturns struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationReturnsOnCall map[int]struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationPrivateDomainsStub        func(orgGUID string, queries []ccv2.Query) ([]ccv2.Domain, ccv2.Warnings, error)
	getOrganizationPrivateDomainsMutex       sync.RWMutex
	getOrganizationPrivateDomainsArgsForCall []struct {
		orgGUID string
		queries []ccv2.Query
	}
	getOrganizationPrivateDomainsReturns struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationPrivateDomainsReturnsOnCall map[int]struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationQuotaStub        func(guid string) (ccv2.OrganizationQuota, ccv2.Warnings, error)
	getOrganizationQuotaMutex       sync.RWMutex
	getOrganizationQuotaArgsForCall []struct {
		guid string
	}
	getOrganizationQuotaReturns struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationQuotaReturnsOnCall map[int]struct {
		result1 ccv2.OrganizationQuota
		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
	}
	getOrganizationsReturnsOnCall map[int]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
	}
	getPrivateDomainReturnsOnCall map[int]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
	}
	getRouteApplicationsReturnsOnCall map[int]struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetRoutesStub        func(queries []ccv2.Query) ([]ccv2.Route, ccv2.Warnings, error)
	getRoutesMutex       sync.RWMutex
	getRoutesArgsForCall []struct {
		queries []ccv2.Query
	}
	getRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	getRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetRunningSpacesBySecurityGroupStub        func(securityGroupGUID string) ([]ccv2.Space, ccv2.Warnings, error)
	getRunningSpacesBySecurityGroupMutex       sync.RWMutex
	getRunningSpacesBySecurityGroupArgsForCall []struct {
		securityGroupGUID string
	}
	getRunningSpacesBySecurityGroupReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	getRunningSpacesBySecurityGroupReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	GetSecurityGroupsStub        func(queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSecurityGroupsMutex       sync.RWMutex
	getSecurityGroupsArgsForCall []struct {
		queries []ccv2.Query
	}
	getSecurityGroupsReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSecurityGroupsReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		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
	}
	getServiceBindingsReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstanceStub        func(serviceInstanceGUID string) (ccv2.ServiceInstance, ccv2.Warnings, error)
	getServiceInstanceMutex       sync.RWMutex
	getServiceInstanceArgsForCall []struct {
		serviceInstanceGUID string
	}
	getServiceInstanceReturns struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstanceReturnsOnCall map[int]struct {
		result1 ccv2.ServiceInstance
		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
	}
	getServiceInstancesReturnsOnCall map[int]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
	}
	getSharedDomainReturnsOnCall map[int]struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetSharedDomainsStub        func() ([]ccv2.Domain, ccv2.Warnings, error)
	getSharedDomainsMutex       sync.RWMutex
	getSharedDomainsArgsForCall []struct{}
	getSharedDomainsReturns     struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getSharedDomainsReturnsOnCall map[int]struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceQuotaStub        func(guid string) (ccv2.SpaceQuota, ccv2.Warnings, error)
	getSpaceQuotaMutex       sync.RWMutex
	getSpaceQuotaArgsForCall []struct {
		guid string
	}
	getSpaceQuotaReturns struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceQuotaReturnsOnCall map[int]struct {
		result1 ccv2.SpaceQuota
		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
	}
	getSpaceRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceRunningSecurityGroupsBySpaceStub        func(spaceGUID string, queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSpaceRunningSecurityGroupsBySpaceMutex       sync.RWMutex
	getSpaceRunningSecurityGroupsBySpaceArgsForCall []struct {
		spaceGUID string
		queries   []ccv2.Query
	}
	getSpaceRunningSecurityGroupsBySpaceReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceRunningSecurityGroupsBySpaceReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		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
	}
	getSpacesReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		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
	}
	getSpaceServiceInstancesReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceStagingSecurityGroupsBySpaceStub        func(spaceGUID string, queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSpaceStagingSecurityGroupsBySpaceMutex       sync.RWMutex
	getSpaceStagingSecurityGroupsBySpaceArgsForCall []struct {
		spaceGUID string
		queries   []ccv2.Query
	}
	getSpaceStagingSecurityGroupsBySpaceReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceStagingSecurityGroupsBySpaceReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		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
	}
	getStackReturnsOnCall map[int]struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	GetStacksStub        func(queries []ccv2.Query) ([]ccv2.Stack, ccv2.Warnings, error)
	getStacksMutex       sync.RWMutex
	getStacksArgsForCall []struct {
		queries []ccv2.Query
	}
	getStacksReturns struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	getStacksReturnsOnCall map[int]struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	GetStagingSpacesBySecurityGroupStub        func(securityGroupGUID string) ([]ccv2.Space, ccv2.Warnings, error)
	getStagingSpacesBySecurityGroupMutex       sync.RWMutex
	getStagingSpacesBySecurityGroupArgsForCall []struct {
		securityGroupGUID string
	}
	getStagingSpacesBySecurityGroupReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	getStagingSpacesBySecurityGroupReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		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
	}
	pollJobReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	RemoveSpaceFromRunningSecurityGroupStub        func(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error)
	removeSpaceFromRunningSecurityGroupMutex       sync.RWMutex
	removeSpaceFromRunningSecurityGroupArgsForCall []struct {
		securityGroupGUID string
		spaceGUID         string
	}
	removeSpaceFromRunningSecurityGroupReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	removeSpaceFromRunningSecurityGroupReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	RemoveSpaceFromStagingSecurityGroupStub        func(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error)
	removeSpaceFromStagingSecurityGroupMutex       sync.RWMutex
	removeSpaceFromStagingSecurityGroupArgsForCall []struct {
		securityGroupGUID string
		spaceGUID         string
	}
	removeSpaceFromStagingSecurityGroupReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	removeSpaceFromStagingSecurityGroupReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	ResourceMatchStub        func(resourcesToMatch []ccv2.Resource) ([]ccv2.Resource, ccv2.Warnings, error)
	resourceMatchMutex       sync.RWMutex
	resourceMatchArgsForCall []struct {
		resourcesToMatch []ccv2.Resource
	}
	resourceMatchReturns struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}
	resourceMatchReturnsOnCall map[int]struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}
	RestageApplicationStub        func(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	restageApplicationMutex       sync.RWMutex
	restageApplicationArgsForCall []struct {
		app ccv2.Application
	}
	restageApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	restageApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	TargetCFStub        func(settings ccv2.TargetSettings) (ccv2.Warnings, error)
	targetCFMutex       sync.RWMutex
	targetCFArgsForCall []struct {
		settings ccv2.TargetSettings
	}
	targetCFReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	targetCFReturnsOnCall map[int]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
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	UploadApplicationPackageStub        func(appGUID string, existingResources []ccv2.Resource, newResources ccv2.Reader, newResourcesLength int64) (ccv2.Job, ccv2.Warnings, error)
	uploadApplicationPackageMutex       sync.RWMutex
	uploadApplicationPackageArgsForCall []struct {
		appGUID            string
		existingResources  []ccv2.Resource
		newResources       ccv2.Reader
		newResourcesLength int64
	}
	uploadApplicationPackageReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	uploadApplicationPackageReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	APIStub        func() string
	aPIMutex       sync.RWMutex
	aPIArgsForCall []struct{}
	aPIReturns     struct {
		result1 string
	}
	aPIReturnsOnCall map[int]struct {
		result1 string
	}
	APIVersionStub        func() string
	aPIVersionMutex       sync.RWMutex
	aPIVersionArgsForCall []struct{}
	aPIVersionReturns     struct {
		result1 string
	}
	aPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	AuthorizationEndpointStub        func() string
	authorizationEndpointMutex       sync.RWMutex
	authorizationEndpointArgsForCall []struct{}
	authorizationEndpointReturns     struct {
		result1 string
	}
	authorizationEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct{}
	dopplerEndpointReturns     struct {
		result1 string
	}
	dopplerEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	MinCLIVersionStub        func() string
	minCLIVersionMutex       sync.RWMutex
	minCLIVersionArgsForCall []struct{}
	minCLIVersionReturns     struct {
		result1 string
	}
	minCLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	RoutingEndpointStub        func() string
	routingEndpointMutex       sync.RWMutex
	routingEndpointArgsForCall []struct{}
	routingEndpointReturns     struct {
		result1 string
	}
	routingEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	TokenEndpointStub        func() string
	tokenEndpointMutex       sync.RWMutex
	tokenEndpointArgsForCall []struct{}
	tokenEndpointReturns     struct {
		result1 string
	}
	tokenEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithRunningSecurityGroup(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error) {
	fake.associateSpaceWithRunningSecurityGroupMutex.Lock()
	ret, specificReturn := fake.associateSpaceWithRunningSecurityGroupReturnsOnCall[len(fake.associateSpaceWithRunningSecurityGroupArgsForCall)]
	fake.associateSpaceWithRunningSecurityGroupArgsForCall = append(fake.associateSpaceWithRunningSecurityGroupArgsForCall, struct {
		securityGroupGUID string
		spaceGUID         string
	}{securityGroupGUID, spaceGUID})
	fake.recordInvocation("AssociateSpaceWithRunningSecurityGroup", []interface{}{securityGroupGUID, spaceGUID})
	fake.associateSpaceWithRunningSecurityGroupMutex.Unlock()
	if fake.AssociateSpaceWithRunningSecurityGroupStub != nil {
		return fake.AssociateSpaceWithRunningSecurityGroupStub(securityGroupGUID, spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.associateSpaceWithRunningSecurityGroupReturns.result1, fake.associateSpaceWithRunningSecurityGroupReturns.result2
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithRunningSecurityGroupCallCount() int {
	fake.associateSpaceWithRunningSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithRunningSecurityGroupMutex.RUnlock()
	return len(fake.associateSpaceWithRunningSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithRunningSecurityGroupArgsForCall(i int) (string, string) {
	fake.associateSpaceWithRunningSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithRunningSecurityGroupMutex.RUnlock()
	return fake.associateSpaceWithRunningSecurityGroupArgsForCall[i].securityGroupGUID, fake.associateSpaceWithRunningSecurityGroupArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithRunningSecurityGroupReturns(result1 ccv2.Warnings, result2 error) {
	fake.AssociateSpaceWithRunningSecurityGroupStub = nil
	fake.associateSpaceWithRunningSecurityGroupReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithRunningSecurityGroupReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.AssociateSpaceWithRunningSecurityGroupStub = nil
	if fake.associateSpaceWithRunningSecurityGroupReturnsOnCall == nil {
		fake.associateSpaceWithRunningSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.associateSpaceWithRunningSecurityGroupReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithStagingSecurityGroup(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error) {
	fake.associateSpaceWithStagingSecurityGroupMutex.Lock()
	ret, specificReturn := fake.associateSpaceWithStagingSecurityGroupReturnsOnCall[len(fake.associateSpaceWithStagingSecurityGroupArgsForCall)]
	fake.associateSpaceWithStagingSecurityGroupArgsForCall = append(fake.associateSpaceWithStagingSecurityGroupArgsForCall, struct {
		securityGroupGUID string
		spaceGUID         string
	}{securityGroupGUID, spaceGUID})
	fake.recordInvocation("AssociateSpaceWithStagingSecurityGroup", []interface{}{securityGroupGUID, spaceGUID})
	fake.associateSpaceWithStagingSecurityGroupMutex.Unlock()
	if fake.AssociateSpaceWithStagingSecurityGroupStub != nil {
		return fake.AssociateSpaceWithStagingSecurityGroupStub(securityGroupGUID, spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.associateSpaceWithStagingSecurityGroupReturns.result1, fake.associateSpaceWithStagingSecurityGroupReturns.result2
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithStagingSecurityGroupCallCount() int {
	fake.associateSpaceWithStagingSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithStagingSecurityGroupMutex.RUnlock()
	return len(fake.associateSpaceWithStagingSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithStagingSecurityGroupArgsForCall(i int) (string, string) {
	fake.associateSpaceWithStagingSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithStagingSecurityGroupMutex.RUnlock()
	return fake.associateSpaceWithStagingSecurityGroupArgsForCall[i].securityGroupGUID, fake.associateSpaceWithStagingSecurityGroupArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithStagingSecurityGroupReturns(result1 ccv2.Warnings, result2 error) {
	fake.AssociateSpaceWithStagingSecurityGroupStub = nil
	fake.associateSpaceWithStagingSecurityGroupReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) AssociateSpaceWithStagingSecurityGroupReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.AssociateSpaceWithStagingSecurityGroupStub = nil
	if fake.associateSpaceWithStagingSecurityGroupReturnsOnCall == nil {
		fake.associateSpaceWithStagingSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.associateSpaceWithStagingSecurityGroupReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) BindRouteToApplication(routeGUID string, appGUID string) (ccv2.Route, ccv2.Warnings, error) {
	fake.bindRouteToApplicationMutex.Lock()
	ret, specificReturn := fake.bindRouteToApplicationReturnsOnCall[len(fake.bindRouteToApplicationArgsForCall)]
	fake.bindRouteToApplicationArgsForCall = append(fake.bindRouteToApplicationArgsForCall, struct {
		routeGUID string
		appGUID   string
	}{routeGUID, appGUID})
	fake.recordInvocation("BindRouteToApplication", []interface{}{routeGUID, appGUID})
	fake.bindRouteToApplicationMutex.Unlock()
	if fake.BindRouteToApplicationStub != nil {
		return fake.BindRouteToApplicationStub(routeGUID, appGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.bindRouteToApplicationReturns.result1, fake.bindRouteToApplicationReturns.result2, fake.bindRouteToApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) BindRouteToApplicationCallCount() int {
	fake.bindRouteToApplicationMutex.RLock()
	defer fake.bindRouteToApplicationMutex.RUnlock()
	return len(fake.bindRouteToApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) BindRouteToApplicationArgsForCall(i int) (string, string) {
	fake.bindRouteToApplicationMutex.RLock()
	defer fake.bindRouteToApplicationMutex.RUnlock()
	return fake.bindRouteToApplicationArgsForCall[i].routeGUID, fake.bindRouteToApplicationArgsForCall[i].appGUID
}

func (fake *FakeCloudControllerClient) BindRouteToApplicationReturns(result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.BindRouteToApplicationStub = nil
	fake.bindRouteToApplicationReturns = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) BindRouteToApplicationReturnsOnCall(i int, result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.BindRouteToApplicationStub = nil
	if fake.bindRouteToApplicationReturnsOnCall == nil {
		fake.bindRouteToApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.bindRouteToApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CheckRoute(route ccv2.Route) (bool, ccv2.Warnings, error) {
	fake.checkRouteMutex.Lock()
	ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)]
	fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct {
		route ccv2.Route
	}{route})
	fake.recordInvocation("CheckRoute", []interface{}{route})
	fake.checkRouteMutex.Unlock()
	if fake.CheckRouteStub != nil {
		return fake.CheckRouteStub(route)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.checkRouteReturns.result1, fake.checkRouteReturns.result2, fake.checkRouteReturns.result3
}

func (fake *FakeCloudControllerClient) CheckRouteCallCount() int {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	return len(fake.checkRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) CheckRouteArgsForCall(i int) ccv2.Route {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	return fake.checkRouteArgsForCall[i].route
}

func (fake *FakeCloudControllerClient) CheckRouteReturns(result1 bool, result2 ccv2.Warnings, result3 error) {
	fake.CheckRouteStub = nil
	fake.checkRouteReturns = struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CheckRouteReturnsOnCall(i int, result1 bool, result2 ccv2.Warnings, result3 error) {
	fake.CheckRouteStub = nil
	if fake.checkRouteReturnsOnCall == nil {
		fake.checkRouteReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.checkRouteReturnsOnCall[i] = struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplication(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.createApplicationMutex.Lock()
	ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)]
	fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, struct {
		app ccv2.Application
	}{app})
	fake.recordInvocation("CreateApplication", []interface{}{app})
	fake.createApplicationMutex.Unlock()
	if fake.CreateApplicationStub != nil {
		return fake.CreateApplicationStub(app)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createApplicationReturns.result1, fake.createApplicationReturns.result2, fake.createApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationCallCount() int {
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	return len(fake.createApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationArgsForCall(i int) ccv2.Application {
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	return fake.createApplicationArgsForCall[i].app
}

func (fake *FakeCloudControllerClient) CreateApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.CreateApplicationStub = nil
	fake.createApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.CreateApplicationStub = nil
	if fake.createApplicationReturnsOnCall == nil {
		fake.createApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRoute(route ccv2.Route, generatePort bool) (ccv2.Route, ccv2.Warnings, error) {
	fake.createRouteMutex.Lock()
	ret, specificReturn := fake.createRouteReturnsOnCall[len(fake.createRouteArgsForCall)]
	fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, struct {
		route        ccv2.Route
		generatePort bool
	}{route, generatePort})
	fake.recordInvocation("CreateRoute", []interface{}{route, generatePort})
	fake.createRouteMutex.Unlock()
	if fake.CreateRouteStub != nil {
		return fake.CreateRouteStub(route, generatePort)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createRouteReturns.result1, fake.createRouteReturns.result2, fake.createRouteReturns.result3
}

func (fake *FakeCloudControllerClient) CreateRouteCallCount() int {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	return len(fake.createRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateRouteArgsForCall(i int) (ccv2.Route, bool) {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	return fake.createRouteArgsForCall[i].route, fake.createRouteArgsForCall[i].generatePort
}

func (fake *FakeCloudControllerClient) CreateRouteReturns(result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.CreateRouteStub = nil
	fake.createRouteReturns = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRouteReturnsOnCall(i int, result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.CreateRouteStub = nil
	if fake.createRouteReturnsOnCall == nil {
		fake.createRouteReturnsOnCall = make(map[int]struct {
			result1 ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createRouteReturnsOnCall[i] = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBinding(appGUID string, serviceBindingGUID string, parameters map[string]interface{}) (ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.createServiceBindingMutex.Lock()
	ret, specificReturn := fake.createServiceBindingReturnsOnCall[len(fake.createServiceBindingArgsForCall)]
	fake.createServiceBindingArgsForCall = append(fake.createServiceBindingArgsForCall, struct {
		appGUID            string
		serviceBindingGUID string
		parameters         map[string]interface{}
	}{appGUID, serviceBindingGUID, parameters})
	fake.recordInvocation("CreateServiceBinding", []interface{}{appGUID, serviceBindingGUID, parameters})
	fake.createServiceBindingMutex.Unlock()
	if fake.CreateServiceBindingStub != nil {
		return fake.CreateServiceBindingStub(appGUID, serviceBindingGUID, parameters)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createServiceBindingReturns.result1, fake.createServiceBindingReturns.result2, fake.createServiceBindingReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceBindingCallCount() int {
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	return len(fake.createServiceBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceBindingArgsForCall(i int) (string, string, map[string]interface{}) {
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	return fake.createServiceBindingArgsForCall[i].appGUID, fake.createServiceBindingArgsForCall[i].serviceBindingGUID, fake.createServiceBindingArgsForCall[i].parameters
}

func (fake *FakeCloudControllerClient) CreateServiceBindingReturns(result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.CreateServiceBindingStub = nil
	fake.createServiceBindingReturns = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBindingReturnsOnCall(i int, result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.CreateServiceBindingStub = nil
	if fake.createServiceBindingReturnsOnCall == nil {
		fake.createServiceBindingReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createServiceBindingReturnsOnCall[i] = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateUser(uaaUserID string) (ccv2.User, ccv2.Warnings, error) {
	fake.createUserMutex.Lock()
	ret, specificReturn := fake.createUserReturnsOnCall[len(fake.createUserArgsForCall)]
	fake.createUserArgsForCall = append(fake.createUserArgsForCall, struct {
		uaaUserID string
	}{uaaUserID})
	fake.recordInvocation("CreateUser", []interface{}{uaaUserID})
	fake.createUserMutex.Unlock()
	if fake.CreateUserStub != nil {
		return fake.CreateUserStub(uaaUserID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createUserReturns.result1, fake.createUserReturns.result2, fake.createUserReturns.result3
}

func (fake *FakeCloudControllerClient) CreateUserCallCount() int {
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	return len(fake.createUserArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateUserArgsForCall(i int) string {
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	return fake.createUserArgsForCall[i].uaaUserID
}

func (fake *FakeCloudControllerClient) CreateUserReturns(result1 ccv2.User, result2 ccv2.Warnings, result3 error) {
	fake.CreateUserStub = nil
	fake.createUserReturns = struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateUserReturnsOnCall(i int, result1 ccv2.User, result2 ccv2.Warnings, result3 error) {
	fake.CreateUserStub = nil
	if fake.createUserReturnsOnCall == nil {
		fake.createUserReturnsOnCall = make(map[int]struct {
			result1 ccv2.User
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createUserReturnsOnCall[i] = struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganization(orgGUID string) (ccv2.Job, ccv2.Warnings, error) {
	fake.deleteOrganizationMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationReturnsOnCall[len(fake.deleteOrganizationArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) DeleteOrganizationReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.DeleteOrganizationStub = nil
	if fake.deleteOrganizationReturnsOnCall == nil {
		fake.deleteOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.deleteOrganizationReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRoute(routeGUID string) (ccv2.Warnings, error) {
	fake.deleteRouteMutex.Lock()
	ret, specificReturn := fake.deleteRouteReturnsOnCall[len(fake.deleteRouteArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) DeleteRouteReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.DeleteRouteStub = nil
	if fake.deleteRouteReturnsOnCall == nil {
		fake.deleteRouteReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteRouteReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceBinding(serviceBindingGUID string) (ccv2.Warnings, error) {
	fake.deleteServiceBindingMutex.Lock()
	ret, specificReturn := fake.deleteServiceBindingReturnsOnCall[len(fake.deleteServiceBindingArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) DeleteServiceBindingReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.DeleteServiceBindingStub = nil
	if fake.deleteServiceBindingReturnsOnCall == nil {
		fake.deleteServiceBindingReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteServiceBindingReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSpace(spaceGUID string) (ccv2.Job, ccv2.Warnings, error) {
	fake.deleteSpaceMutex.Lock()
	ret, specificReturn := fake.deleteSpaceReturnsOnCall[len(fake.deleteSpaceArgsForCall)]
	fake.deleteSpaceArgsForCall = append(fake.deleteSpaceArgsForCall, struct {
		spaceGUID string
	}{spaceGUID})
	fake.recordInvocation("DeleteSpace", []interface{}{spaceGUID})
	fake.deleteSpaceMutex.Unlock()
	if fake.DeleteSpaceStub != nil {
		return fake.DeleteSpaceStub(spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.deleteSpaceReturns.result1, fake.deleteSpaceReturns.result2, fake.deleteSpaceReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteSpaceCallCount() int {
	fake.deleteSpaceMutex.RLock()
	defer fake.deleteSpaceMutex.RUnlock()
	return len(fake.deleteSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSpaceArgsForCall(i int) string {
	fake.deleteSpaceMutex.RLock()
	defer fake.deleteSpaceMutex.RUnlock()
	return fake.deleteSpaceArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) DeleteSpaceReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.DeleteSpaceStub = nil
	fake.deleteSpaceReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSpaceReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.DeleteSpaceStub = nil
	if fake.deleteSpaceReturnsOnCall == nil {
		fake.deleteSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.deleteSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplication(guid string) (ccv2.Application, ccv2.Warnings, error) {
	fake.getApplicationMutex.Lock()
	ret, specificReturn := fake.getApplicationReturnsOnCall[len(fake.getApplicationArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationStub = nil
	if fake.getApplicationReturnsOnCall == nil {
		fake.getApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationInstancesByApplication(guid string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error) {
	fake.getApplicationInstancesByApplicationMutex.Lock()
	ret, specificReturn := fake.getApplicationInstancesByApplicationReturnsOnCall[len(fake.getApplicationInstancesByApplicationArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationInstancesByApplicationReturnsOnCall(i int, result1 map[int]ccv2.ApplicationInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationInstancesByApplicationStub = nil
	if fake.getApplicationInstancesByApplicationReturnsOnCall == nil {
		fake.getApplicationInstancesByApplicationReturnsOnCall = make(map[int]struct {
			result1 map[int]ccv2.ApplicationInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationInstancesByApplicationReturnsOnCall[i] = struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationInstanceStatusesByApplication(guid string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error) {
	fake.getApplicationInstanceStatusesByApplicationMutex.Lock()
	ret, specificReturn := fake.getApplicationInstanceStatusesByApplicationReturnsOnCall[len(fake.getApplicationInstanceStatusesByApplicationArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationInstanceStatusesByApplicationReturnsOnCall(i int, result1 map[int]ccv2.ApplicationInstanceStatus, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationInstanceStatusesByApplicationStub = nil
	if fake.getApplicationInstanceStatusesByApplicationReturnsOnCall == nil {
		fake.getApplicationInstanceStatusesByApplicationReturnsOnCall = make(map[int]struct {
			result1 map[int]ccv2.ApplicationInstanceStatus
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationInstanceStatusesByApplicationReturnsOnCall[i] = struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		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()
	ret, specificReturn := fake.getApplicationRoutesReturnsOnCall[len(fake.getApplicationRoutesArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationRoutesStub = nil
	if fake.getApplicationRoutesReturnsOnCall == nil {
		fake.getApplicationRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		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()
	ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationsReturnsOnCall(i int, result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetApplicationsStub = nil
	if fake.getApplicationsReturnsOnCall == nil {
		fake.getApplicationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationsReturnsOnCall[i] = 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()
	ret, specificReturn := fake.getJobReturnsOnCall[len(fake.getJobArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetJobReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.GetJobStub = nil
	if fake.getJobReturnsOnCall == nil {
		fake.getJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getJobReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganization(guid string) (ccv2.Organization, ccv2.Warnings, error) {
	fake.getOrganizationMutex.Lock()
	ret, specificReturn := fake.getOrganizationReturnsOnCall[len(fake.getOrganizationArgsForCall)]
	fake.getOrganizationArgsForCall = append(fake.getOrganizationArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetOrganization", []interface{}{guid})
	fake.getOrganizationMutex.Unlock()
	if fake.GetOrganizationStub != nil {
		return fake.GetOrganizationStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getOrganizationReturns.result1, fake.getOrganizationReturns.result2, fake.getOrganizationReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationCallCount() int {
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	return len(fake.getOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationArgsForCall(i int) string {
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	return fake.getOrganizationArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetOrganizationReturns(result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationStub = nil
	fake.getOrganizationReturns = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationReturnsOnCall(i int, result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationStub = nil
	if fake.getOrganizationReturnsOnCall == nil {
		fake.getOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Organization
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationReturnsOnCall[i] = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomains(orgGUID string, queries []ccv2.Query) ([]ccv2.Domain, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getOrganizationPrivateDomainsMutex.Lock()
	ret, specificReturn := fake.getOrganizationPrivateDomainsReturnsOnCall[len(fake.getOrganizationPrivateDomainsArgsForCall)]
	fake.getOrganizationPrivateDomainsArgsForCall = append(fake.getOrganizationPrivateDomainsArgsForCall, struct {
		orgGUID string
		queries []ccv2.Query
	}{orgGUID, queriesCopy})
	fake.recordInvocation("GetOrganizationPrivateDomains", []interface{}{orgGUID, queriesCopy})
	fake.getOrganizationPrivateDomainsMutex.Unlock()
	if fake.GetOrganizationPrivateDomainsStub != nil {
		return fake.GetOrganizationPrivateDomainsStub(orgGUID, queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getOrganizationPrivateDomainsReturns.result1, fake.getOrganizationPrivateDomainsReturns.result2, fake.getOrganizationPrivateDomainsReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsCallCount() int {
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	return len(fake.getOrganizationPrivateDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsArgsForCall(i int) (string, []ccv2.Query) {
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	return fake.getOrganizationPrivateDomainsArgsForCall[i].orgGUID, fake.getOrganizationPrivateDomainsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsReturns(result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationPrivateDomainsStub = nil
	fake.getOrganizationPrivateDomainsReturns = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsReturnsOnCall(i int, result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationPrivateDomainsStub = nil
	if fake.getOrganizationPrivateDomainsReturnsOnCall == nil {
		fake.getOrganizationPrivateDomainsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationPrivateDomainsReturnsOnCall[i] = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuota(guid string) (ccv2.OrganizationQuota, ccv2.Warnings, error) {
	fake.getOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.getOrganizationQuotaReturnsOnCall[len(fake.getOrganizationQuotaArgsForCall)]
	fake.getOrganizationQuotaArgsForCall = append(fake.getOrganizationQuotaArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetOrganizationQuota", []interface{}{guid})
	fake.getOrganizationQuotaMutex.Unlock()
	if fake.GetOrganizationQuotaStub != nil {
		return fake.GetOrganizationQuotaStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getOrganizationQuotaReturns.result1, fake.getOrganizationQuotaReturns.result2, fake.getOrganizationQuotaReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaCallCount() int {
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	return len(fake.getOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaArgsForCall(i int) string {
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	return fake.getOrganizationQuotaArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturns(result1 ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationQuotaStub = nil
	fake.getOrganizationQuotaReturns = struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturnsOnCall(i int, result1 ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationQuotaStub = nil
	if fake.getOrganizationQuotaReturnsOnCall == nil {
		fake.getOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv2.OrganizationQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotaReturnsOnCall[i] = struct {
		result1 ccv2.OrganizationQuota
		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()
	ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetOrganizationsReturnsOnCall(i int, result1 []ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.GetOrganizationsStub = nil
	if fake.getOrganizationsReturnsOnCall == nil {
		fake.getOrganizationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Organization
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationsReturnsOnCall[i] = 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()
	ret, specificReturn := fake.getPrivateDomainReturnsOnCall[len(fake.getPrivateDomainArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetPrivateDomainReturnsOnCall(i int, result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetPrivateDomainStub = nil
	if fake.getPrivateDomainReturnsOnCall == nil {
		fake.getPrivateDomainReturnsOnCall = make(map[int]struct {
			result1 ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getPrivateDomainReturnsOnCall[i] = 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()
	ret, specificReturn := fake.getRouteApplicationsReturnsOnCall[len(fake.getRouteApplicationsArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetRouteApplicationsReturnsOnCall(i int, result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.GetRouteApplicationsStub = nil
	if fake.getRouteApplicationsReturnsOnCall == nil {
		fake.getRouteApplicationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getRouteApplicationsReturnsOnCall[i] = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoutes(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.getRoutesMutex.Lock()
	ret, specificReturn := fake.getRoutesReturnsOnCall[len(fake.getRoutesArgsForCall)]
	fake.getRoutesArgsForCall = append(fake.getRoutesArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetRoutes", []interface{}{queriesCopy})
	fake.getRoutesMutex.Unlock()
	if fake.GetRoutesStub != nil {
		return fake.GetRoutesStub(queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getRoutesReturns.result1, fake.getRoutesReturns.result2, fake.getRoutesReturns.result3
}

func (fake *FakeCloudControllerClient) GetRoutesCallCount() int {
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	return len(fake.getRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRoutesArgsForCall(i int) []ccv2.Query {
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	return fake.getRoutesArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetRoutesStub = nil
	fake.getRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetRoutesStub = nil
	if fake.getRoutesReturnsOnCall == nil {
		fake.getRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRunningSpacesBySecurityGroup(securityGroupGUID string) ([]ccv2.Space, ccv2.Warnings, error) {
	fake.getRunningSpacesBySecurityGroupMutex.Lock()
	ret, specificReturn := fake.getRunningSpacesBySecurityGroupReturnsOnCall[len(fake.getRunningSpacesBySecurityGroupArgsForCall)]
	fake.getRunningSpacesBySecurityGroupArgsForCall = append(fake.getRunningSpacesBySecurityGroupArgsForCall, struct {
		securityGroupGUID string
	}{securityGroupGUID})
	fake.recordInvocation("GetRunningSpacesBySecurityGroup", []interface{}{securityGroupGUID})
	fake.getRunningSpacesBySecurityGroupMutex.Unlock()
	if fake.GetRunningSpacesBySecurityGroupStub != nil {
		return fake.GetRunningSpacesBySecurityGroupStub(securityGroupGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getRunningSpacesBySecurityGroupReturns.result1, fake.getRunningSpacesBySecurityGroupReturns.result2, fake.getRunningSpacesBySecurityGroupReturns.result3
}

func (fake *FakeCloudControllerClient) GetRunningSpacesBySecurityGroupCallCount() int {
	fake.getRunningSpacesBySecurityGroupMutex.RLock()
	defer fake.getRunningSpacesBySecurityGroupMutex.RUnlock()
	return len(fake.getRunningSpacesBySecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRunningSpacesBySecurityGroupArgsForCall(i int) string {
	fake.getRunningSpacesBySecurityGroupMutex.RLock()
	defer fake.getRunningSpacesBySecurityGroupMutex.RUnlock()
	return fake.getRunningSpacesBySecurityGroupArgsForCall[i].securityGroupGUID
}

func (fake *FakeCloudControllerClient) GetRunningSpacesBySecurityGroupReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetRunningSpacesBySecurityGroupStub = nil
	fake.getRunningSpacesBySecurityGroupReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRunningSpacesBySecurityGroupReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetRunningSpacesBySecurityGroupStub = nil
	if fake.getRunningSpacesBySecurityGroupReturnsOnCall == nil {
		fake.getRunningSpacesBySecurityGroupReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getRunningSpacesBySecurityGroupReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroups(queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupsReturnsOnCall[len(fake.getSecurityGroupsArgsForCall)]
	fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetSecurityGroups", []interface{}{queriesCopy})
	fake.getSecurityGroupsMutex.Unlock()
	if fake.GetSecurityGroupsStub != nil {
		return fake.GetSecurityGroupsStub(queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getSecurityGroupsReturns.result1, fake.getSecurityGroupsReturns.result2, fake.getSecurityGroupsReturns.result3
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsCallCount() int {
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	return len(fake.getSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsArgsForCall(i int) []ccv2.Query {
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	return fake.getSecurityGroupsArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSecurityGroupsStub = nil
	fake.getSecurityGroupsReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSecurityGroupsStub = nil
	if fake.getSecurityGroupsReturnsOnCall == nil {
		fake.getSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupsReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		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()
	ret, specificReturn := fake.getServiceBindingsReturnsOnCall[len(fake.getServiceBindingsArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetServiceBindingsReturnsOnCall(i int, result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceBindingsStub = nil
	if fake.getServiceBindingsReturnsOnCall == nil {
		fake.getServiceBindingsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceBindingsReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstance(serviceInstanceGUID string) (ccv2.ServiceInstance, ccv2.Warnings, error) {
	fake.getServiceInstanceMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceReturnsOnCall[len(fake.getServiceInstanceArgsForCall)]
	fake.getServiceInstanceArgsForCall = append(fake.getServiceInstanceArgsForCall, struct {
		serviceInstanceGUID string
	}{serviceInstanceGUID})
	fake.recordInvocation("GetServiceInstance", []interface{}{serviceInstanceGUID})
	fake.getServiceInstanceMutex.Unlock()
	if fake.GetServiceInstanceStub != nil {
		return fake.GetServiceInstanceStub(serviceInstanceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getServiceInstanceReturns.result1, fake.getServiceInstanceReturns.result2, fake.getServiceInstanceReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceCallCount() int {
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	return len(fake.getServiceInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceArgsForCall(i int) string {
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	return fake.getServiceInstanceArgsForCall[i].serviceInstanceGUID
}

func (fake *FakeCloudControllerClient) GetServiceInstanceReturns(result1 ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceInstanceStub = nil
	fake.getServiceInstanceReturns = struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceReturnsOnCall(i int, result1 ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceInstanceStub = nil
	if fake.getServiceInstanceReturnsOnCall == nil {
		fake.getServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceReturnsOnCall[i] = struct {
		result1 ccv2.ServiceInstance
		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()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetServiceInstancesReturnsOnCall(i int, result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetServiceInstancesStub = nil
	if fake.getServiceInstancesReturnsOnCall == nil {
		fake.getServiceInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstancesReturnsOnCall[i] = 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()
	ret, specificReturn := fake.getSharedDomainReturnsOnCall[len(fake.getSharedDomainArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetSharedDomainReturnsOnCall(i int, result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetSharedDomainStub = nil
	if fake.getSharedDomainReturnsOnCall == nil {
		fake.getSharedDomainReturnsOnCall = make(map[int]struct {
			result1 ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSharedDomainReturnsOnCall[i] = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomains() ([]ccv2.Domain, ccv2.Warnings, error) {
	fake.getSharedDomainsMutex.Lock()
	ret, specificReturn := fake.getSharedDomainsReturnsOnCall[len(fake.getSharedDomainsArgsForCall)]
	fake.getSharedDomainsArgsForCall = append(fake.getSharedDomainsArgsForCall, struct{}{})
	fake.recordInvocation("GetSharedDomains", []interface{}{})
	fake.getSharedDomainsMutex.Unlock()
	if fake.GetSharedDomainsStub != nil {
		return fake.GetSharedDomainsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getSharedDomainsReturns.result1, fake.getSharedDomainsReturns.result2, fake.getSharedDomainsReturns.result3
}

func (fake *FakeCloudControllerClient) GetSharedDomainsCallCount() int {
	fake.getSharedDomainsMutex.RLock()
	defer fake.getSharedDomainsMutex.RUnlock()
	return len(fake.getSharedDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSharedDomainsReturns(result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetSharedDomainsStub = nil
	fake.getSharedDomainsReturns = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomainsReturnsOnCall(i int, result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.GetSharedDomainsStub = nil
	if fake.getSharedDomainsReturnsOnCall == nil {
		fake.getSharedDomainsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSharedDomainsReturnsOnCall[i] = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuota(guid string) (ccv2.SpaceQuota, ccv2.Warnings, error) {
	fake.getSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotaReturnsOnCall[len(fake.getSpaceQuotaArgsForCall)]
	fake.getSpaceQuotaArgsForCall = append(fake.getSpaceQuotaArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetSpaceQuota", []interface{}{guid})
	fake.getSpaceQuotaMutex.Unlock()
	if fake.GetSpaceQuotaStub != nil {
		return fake.GetSpaceQuotaStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getSpaceQuotaReturns.result1, fake.getSpaceQuotaReturns.result2, fake.getSpaceQuotaReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaCallCount() int {
	fake.getSpaceQuotaMutex.RLock()
	defer fake.getSpaceQuotaMutex.RUnlock()
	return len(fake.getSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaArgsForCall(i int) string {
	fake.getSpaceQuotaMutex.RLock()
	defer fake.getSpaceQuotaMutex.RUnlock()
	return fake.getSpaceQuotaArgsForCall[i].guid
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaReturns(result1 ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceQuotaStub = nil
	fake.getSpaceQuotaReturns = struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaReturnsOnCall(i int, result1 ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceQuotaStub = nil
	if fake.getSpaceQuotaReturnsOnCall == nil {
		fake.getSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv2.SpaceQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotaReturnsOnCall[i] = struct {
		result1 ccv2.SpaceQuota
		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()
	ret, specificReturn := fake.getSpaceRoutesReturnsOnCall[len(fake.getSpaceRoutesArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetSpaceRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceRoutesStub = nil
	if fake.getSpaceRoutesReturnsOnCall == nil {
		fake.getSpaceRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceRunningSecurityGroupsBySpace(spaceGUID string, queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSpaceRunningSecurityGroupsBySpaceMutex.Lock()
	ret, specificReturn := fake.getSpaceRunningSecurityGroupsBySpaceReturnsOnCall[len(fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall)]
	fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall = append(fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall, struct {
		spaceGUID string
		queries   []ccv2.Query
	}{spaceGUID, queriesCopy})
	fake.recordInvocation("GetSpaceRunningSecurityGroupsBySpace", []interface{}{spaceGUID, queriesCopy})
	fake.getSpaceRunningSecurityGroupsBySpaceMutex.Unlock()
	if fake.GetSpaceRunningSecurityGroupsBySpaceStub != nil {
		return fake.GetSpaceRunningSecurityGroupsBySpaceStub(spaceGUID, queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getSpaceRunningSecurityGroupsBySpaceReturns.result1, fake.getSpaceRunningSecurityGroupsBySpaceReturns.result2, fake.getSpaceRunningSecurityGroupsBySpaceReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceRunningSecurityGroupsBySpaceCallCount() int {
	fake.getSpaceRunningSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceRunningSecurityGroupsBySpaceMutex.RUnlock()
	return len(fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceRunningSecurityGroupsBySpaceArgsForCall(i int) (string, []ccv2.Query) {
	fake.getSpaceRunningSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceRunningSecurityGroupsBySpaceMutex.RUnlock()
	return fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall[i].spaceGUID, fake.getSpaceRunningSecurityGroupsBySpaceArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSpaceRunningSecurityGroupsBySpaceReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceRunningSecurityGroupsBySpaceStub = nil
	fake.getSpaceRunningSecurityGroupsBySpaceReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceRunningSecurityGroupsBySpaceReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceRunningSecurityGroupsBySpaceStub = nil
	if fake.getSpaceRunningSecurityGroupsBySpaceReturnsOnCall == nil {
		fake.getSpaceRunningSecurityGroupsBySpaceReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceRunningSecurityGroupsBySpaceReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		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()
	ret, specificReturn := fake.getSpacesReturnsOnCall[len(fake.getSpacesArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetSpacesReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetSpacesStub = nil
	if fake.getSpacesReturnsOnCall == nil {
		fake.getSpacesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpacesReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		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()
	ret, specificReturn := fake.getSpaceServiceInstancesReturnsOnCall[len(fake.getSpaceServiceInstancesArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetSpaceServiceInstancesReturnsOnCall(i int, result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceServiceInstancesStub = nil
	if fake.getSpaceServiceInstancesReturnsOnCall == nil {
		fake.getSpaceServiceInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceServiceInstancesReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsBySpace(spaceGUID string, queries []ccv2.Query) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getSpaceStagingSecurityGroupsBySpaceMutex.Lock()
	ret, specificReturn := fake.getSpaceStagingSecurityGroupsBySpaceReturnsOnCall[len(fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall)]
	fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall = append(fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall, struct {
		spaceGUID string
		queries   []ccv2.Query
	}{spaceGUID, queriesCopy})
	fake.recordInvocation("GetSpaceStagingSecurityGroupsBySpace", []interface{}{spaceGUID, queriesCopy})
	fake.getSpaceStagingSecurityGroupsBySpaceMutex.Unlock()
	if fake.GetSpaceStagingSecurityGroupsBySpaceStub != nil {
		return fake.GetSpaceStagingSecurityGroupsBySpaceStub(spaceGUID, queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getSpaceStagingSecurityGroupsBySpaceReturns.result1, fake.getSpaceStagingSecurityGroupsBySpaceReturns.result2, fake.getSpaceStagingSecurityGroupsBySpaceReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsBySpaceCallCount() int {
	fake.getSpaceStagingSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsBySpaceMutex.RUnlock()
	return len(fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsBySpaceArgsForCall(i int) (string, []ccv2.Query) {
	fake.getSpaceStagingSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsBySpaceMutex.RUnlock()
	return fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall[i].spaceGUID, fake.getSpaceStagingSecurityGroupsBySpaceArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsBySpaceReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceStagingSecurityGroupsBySpaceStub = nil
	fake.getSpaceStagingSecurityGroupsBySpaceReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsBySpaceReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.GetSpaceStagingSecurityGroupsBySpaceStub = nil
	if fake.getSpaceStagingSecurityGroupsBySpaceReturnsOnCall == nil {
		fake.getSpaceStagingSecurityGroupsBySpaceReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceStagingSecurityGroupsBySpaceReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStack(guid string) (ccv2.Stack, ccv2.Warnings, error) {
	fake.getStackMutex.Lock()
	ret, specificReturn := fake.getStackReturnsOnCall[len(fake.getStackArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetStackReturnsOnCall(i int, result1 ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.GetStackStub = nil
	if fake.getStackReturnsOnCall == nil {
		fake.getStackReturnsOnCall = make(map[int]struct {
			result1 ccv2.Stack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getStackReturnsOnCall[i] = struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStacks(queries []ccv2.Query) ([]ccv2.Stack, ccv2.Warnings, error) {
	var queriesCopy []ccv2.Query
	if queries != nil {
		queriesCopy = make([]ccv2.Query, len(queries))
		copy(queriesCopy, queries)
	}
	fake.getStacksMutex.Lock()
	ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)]
	fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct {
		queries []ccv2.Query
	}{queriesCopy})
	fake.recordInvocation("GetStacks", []interface{}{queriesCopy})
	fake.getStacksMutex.Unlock()
	if fake.GetStacksStub != nil {
		return fake.GetStacksStub(queries)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getStacksReturns.result1, fake.getStacksReturns.result2, fake.getStacksReturns.result3
}

func (fake *FakeCloudControllerClient) GetStacksCallCount() int {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	return len(fake.getStacksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStacksArgsForCall(i int) []ccv2.Query {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	return fake.getStacksArgsForCall[i].queries
}

func (fake *FakeCloudControllerClient) GetStacksReturns(result1 []ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.GetStacksStub = nil
	fake.getStacksReturns = struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStacksReturnsOnCall(i int, result1 []ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.GetStacksStub = nil
	if fake.getStacksReturnsOnCall == nil {
		fake.getStacksReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Stack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getStacksReturnsOnCall[i] = struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStagingSpacesBySecurityGroup(securityGroupGUID string) ([]ccv2.Space, ccv2.Warnings, error) {
	fake.getStagingSpacesBySecurityGroupMutex.Lock()
	ret, specificReturn := fake.getStagingSpacesBySecurityGroupReturnsOnCall[len(fake.getStagingSpacesBySecurityGroupArgsForCall)]
	fake.getStagingSpacesBySecurityGroupArgsForCall = append(fake.getStagingSpacesBySecurityGroupArgsForCall, struct {
		securityGroupGUID string
	}{securityGroupGUID})
	fake.recordInvocation("GetStagingSpacesBySecurityGroup", []interface{}{securityGroupGUID})
	fake.getStagingSpacesBySecurityGroupMutex.Unlock()
	if fake.GetStagingSpacesBySecurityGroupStub != nil {
		return fake.GetStagingSpacesBySecurityGroupStub(securityGroupGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getStagingSpacesBySecurityGroupReturns.result1, fake.getStagingSpacesBySecurityGroupReturns.result2, fake.getStagingSpacesBySecurityGroupReturns.result3
}

func (fake *FakeCloudControllerClient) GetStagingSpacesBySecurityGroupCallCount() int {
	fake.getStagingSpacesBySecurityGroupMutex.RLock()
	defer fake.getStagingSpacesBySecurityGroupMutex.RUnlock()
	return len(fake.getStagingSpacesBySecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStagingSpacesBySecurityGroupArgsForCall(i int) string {
	fake.getStagingSpacesBySecurityGroupMutex.RLock()
	defer fake.getStagingSpacesBySecurityGroupMutex.RUnlock()
	return fake.getStagingSpacesBySecurityGroupArgsForCall[i].securityGroupGUID
}

func (fake *FakeCloudControllerClient) GetStagingSpacesBySecurityGroupReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetStagingSpacesBySecurityGroupStub = nil
	fake.getStagingSpacesBySecurityGroupReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStagingSpacesBySecurityGroupReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.GetStagingSpacesBySecurityGroupStub = nil
	if fake.getStagingSpacesBySecurityGroupReturnsOnCall == nil {
		fake.getStagingSpacesBySecurityGroupReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getStagingSpacesBySecurityGroupReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PollJob(job ccv2.Job) (ccv2.Warnings, error) {
	fake.pollJobMutex.Lock()
	ret, specificReturn := fake.pollJobReturnsOnCall[len(fake.pollJobArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) PollJobReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.PollJobStub = nil
	if fake.pollJobReturnsOnCall == nil {
		fake.pollJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.pollJobReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromRunningSecurityGroup(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error) {
	fake.removeSpaceFromRunningSecurityGroupMutex.Lock()
	ret, specificReturn := fake.removeSpaceFromRunningSecurityGroupReturnsOnCall[len(fake.removeSpaceFromRunningSecurityGroupArgsForCall)]
	fake.removeSpaceFromRunningSecurityGroupArgsForCall = append(fake.removeSpaceFromRunningSecurityGroupArgsForCall, struct {
		securityGroupGUID string
		spaceGUID         string
	}{securityGroupGUID, spaceGUID})
	fake.recordInvocation("RemoveSpaceFromRunningSecurityGroup", []interface{}{securityGroupGUID, spaceGUID})
	fake.removeSpaceFromRunningSecurityGroupMutex.Unlock()
	if fake.RemoveSpaceFromRunningSecurityGroupStub != nil {
		return fake.RemoveSpaceFromRunningSecurityGroupStub(securityGroupGUID, spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.removeSpaceFromRunningSecurityGroupReturns.result1, fake.removeSpaceFromRunningSecurityGroupReturns.result2
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromRunningSecurityGroupCallCount() int {
	fake.removeSpaceFromRunningSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromRunningSecurityGroupMutex.RUnlock()
	return len(fake.removeSpaceFromRunningSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromRunningSecurityGroupArgsForCall(i int) (string, string) {
	fake.removeSpaceFromRunningSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromRunningSecurityGroupMutex.RUnlock()
	return fake.removeSpaceFromRunningSecurityGroupArgsForCall[i].securityGroupGUID, fake.removeSpaceFromRunningSecurityGroupArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromRunningSecurityGroupReturns(result1 ccv2.Warnings, result2 error) {
	fake.RemoveSpaceFromRunningSecurityGroupStub = nil
	fake.removeSpaceFromRunningSecurityGroupReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromRunningSecurityGroupReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.RemoveSpaceFromRunningSecurityGroupStub = nil
	if fake.removeSpaceFromRunningSecurityGroupReturnsOnCall == nil {
		fake.removeSpaceFromRunningSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.removeSpaceFromRunningSecurityGroupReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromStagingSecurityGroup(securityGroupGUID string, spaceGUID string) (ccv2.Warnings, error) {
	fake.removeSpaceFromStagingSecurityGroupMutex.Lock()
	ret, specificReturn := fake.removeSpaceFromStagingSecurityGroupReturnsOnCall[len(fake.removeSpaceFromStagingSecurityGroupArgsForCall)]
	fake.removeSpaceFromStagingSecurityGroupArgsForCall = append(fake.removeSpaceFromStagingSecurityGroupArgsForCall, struct {
		securityGroupGUID string
		spaceGUID         string
	}{securityGroupGUID, spaceGUID})
	fake.recordInvocation("RemoveSpaceFromStagingSecurityGroup", []interface{}{securityGroupGUID, spaceGUID})
	fake.removeSpaceFromStagingSecurityGroupMutex.Unlock()
	if fake.RemoveSpaceFromStagingSecurityGroupStub != nil {
		return fake.RemoveSpaceFromStagingSecurityGroupStub(securityGroupGUID, spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.removeSpaceFromStagingSecurityGroupReturns.result1, fake.removeSpaceFromStagingSecurityGroupReturns.result2
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromStagingSecurityGroupCallCount() int {
	fake.removeSpaceFromStagingSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromStagingSecurityGroupMutex.RUnlock()
	return len(fake.removeSpaceFromStagingSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromStagingSecurityGroupArgsForCall(i int) (string, string) {
	fake.removeSpaceFromStagingSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromStagingSecurityGroupMutex.RUnlock()
	return fake.removeSpaceFromStagingSecurityGroupArgsForCall[i].securityGroupGUID, fake.removeSpaceFromStagingSecurityGroupArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromStagingSecurityGroupReturns(result1 ccv2.Warnings, result2 error) {
	fake.RemoveSpaceFromStagingSecurityGroupStub = nil
	fake.removeSpaceFromStagingSecurityGroupReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RemoveSpaceFromStagingSecurityGroupReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.RemoveSpaceFromStagingSecurityGroupStub = nil
	if fake.removeSpaceFromStagingSecurityGroupReturnsOnCall == nil {
		fake.removeSpaceFromStagingSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.removeSpaceFromStagingSecurityGroupReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ResourceMatch(resourcesToMatch []ccv2.Resource) ([]ccv2.Resource, ccv2.Warnings, error) {
	var resourcesToMatchCopy []ccv2.Resource
	if resourcesToMatch != nil {
		resourcesToMatchCopy = make([]ccv2.Resource, len(resourcesToMatch))
		copy(resourcesToMatchCopy, resourcesToMatch)
	}
	fake.resourceMatchMutex.Lock()
	ret, specificReturn := fake.resourceMatchReturnsOnCall[len(fake.resourceMatchArgsForCall)]
	fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, struct {
		resourcesToMatch []ccv2.Resource
	}{resourcesToMatchCopy})
	fake.recordInvocation("ResourceMatch", []interface{}{resourcesToMatchCopy})
	fake.resourceMatchMutex.Unlock()
	if fake.ResourceMatchStub != nil {
		return fake.ResourceMatchStub(resourcesToMatch)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.resourceMatchReturns.result1, fake.resourceMatchReturns.result2, fake.resourceMatchReturns.result3
}

func (fake *FakeCloudControllerClient) ResourceMatchCallCount() int {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	return len(fake.resourceMatchArgsForCall)
}

func (fake *FakeCloudControllerClient) ResourceMatchArgsForCall(i int) []ccv2.Resource {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	return fake.resourceMatchArgsForCall[i].resourcesToMatch
}

func (fake *FakeCloudControllerClient) ResourceMatchReturns(result1 []ccv2.Resource, result2 ccv2.Warnings, result3 error) {
	fake.ResourceMatchStub = nil
	fake.resourceMatchReturns = struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ResourceMatchReturnsOnCall(i int, result1 []ccv2.Resource, result2 ccv2.Warnings, result3 error) {
	fake.ResourceMatchStub = nil
	if fake.resourceMatchReturnsOnCall == nil {
		fake.resourceMatchReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Resource
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.resourceMatchReturnsOnCall[i] = struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) RestageApplication(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.restageApplicationMutex.Lock()
	ret, specificReturn := fake.restageApplicationReturnsOnCall[len(fake.restageApplicationArgsForCall)]
	fake.restageApplicationArgsForCall = append(fake.restageApplicationArgsForCall, struct {
		app ccv2.Application
	}{app})
	fake.recordInvocation("RestageApplication", []interface{}{app})
	fake.restageApplicationMutex.Unlock()
	if fake.RestageApplicationStub != nil {
		return fake.RestageApplicationStub(app)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.restageApplicationReturns.result1, fake.restageApplicationReturns.result2, fake.restageApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) RestageApplicationCallCount() int {
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	return len(fake.restageApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) RestageApplicationArgsForCall(i int) ccv2.Application {
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	return fake.restageApplicationArgsForCall[i].app
}

func (fake *FakeCloudControllerClient) RestageApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.RestageApplicationStub = nil
	fake.restageApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) RestageApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.RestageApplicationStub = nil
	if fake.restageApplicationReturnsOnCall == nil {
		fake.restageApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.restageApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) TargetCF(settings ccv2.TargetSettings) (ccv2.Warnings, error) {
	fake.targetCFMutex.Lock()
	ret, specificReturn := fake.targetCFReturnsOnCall[len(fake.targetCFArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) TargetCFReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.TargetCFStub = nil
	if fake.targetCFReturnsOnCall == nil {
		fake.targetCFReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.targetCFReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateApplication(app ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.updateApplicationMutex.Lock()
	ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)]
	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)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) UpdateApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.UpdateApplicationStub = nil
	if fake.updateApplicationReturnsOnCall == nil {
		fake.updateApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.updateApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadApplicationPackage(appGUID string, existingResources []ccv2.Resource, newResources ccv2.Reader, newResourcesLength int64) (ccv2.Job, ccv2.Warnings, error) {
	var existingResourcesCopy []ccv2.Resource
	if existingResources != nil {
		existingResourcesCopy = make([]ccv2.Resource, len(existingResources))
		copy(existingResourcesCopy, existingResources)
	}
	fake.uploadApplicationPackageMutex.Lock()
	ret, specificReturn := fake.uploadApplicationPackageReturnsOnCall[len(fake.uploadApplicationPackageArgsForCall)]
	fake.uploadApplicationPackageArgsForCall = append(fake.uploadApplicationPackageArgsForCall, struct {
		appGUID            string
		existingResources  []ccv2.Resource
		newResources       ccv2.Reader
		newResourcesLength int64
	}{appGUID, existingResourcesCopy, newResources, newResourcesLength})
	fake.recordInvocation("UploadApplicationPackage", []interface{}{appGUID, existingResourcesCopy, newResources, newResourcesLength})
	fake.uploadApplicationPackageMutex.Unlock()
	if fake.UploadApplicationPackageStub != nil {
		return fake.UploadApplicationPackageStub(appGUID, existingResources, newResources, newResourcesLength)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.uploadApplicationPackageReturns.result1, fake.uploadApplicationPackageReturns.result2, fake.uploadApplicationPackageReturns.result3
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageCallCount() int {
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.RUnlock()
	return len(fake.uploadApplicationPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageArgsForCall(i int) (string, []ccv2.Resource, ccv2.Reader, int64) {
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.RUnlock()
	return fake.uploadApplicationPackageArgsForCall[i].appGUID, fake.uploadApplicationPackageArgsForCall[i].existingResources, fake.uploadApplicationPackageArgsForCall[i].newResources, fake.uploadApplicationPackageArgsForCall[i].newResourcesLength
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.UploadApplicationPackageStub = nil
	fake.uploadApplicationPackageReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.UploadApplicationPackageStub = nil
	if fake.uploadApplicationPackageReturnsOnCall == nil {
		fake.uploadApplicationPackageReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.uploadApplicationPackageReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) API() string {
	fake.aPIMutex.Lock()
	ret, specificReturn := fake.aPIReturnsOnCall[len(fake.aPIArgsForCall)]
	fake.aPIArgsForCall = append(fake.aPIArgsForCall, struct{}{})
	fake.recordInvocation("API", []interface{}{})
	fake.aPIMutex.Unlock()
	if fake.APIStub != nil {
		return fake.APIStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) APIReturnsOnCall(i int, result1 string) {
	fake.APIStub = nil
	if fake.aPIReturnsOnCall == nil {
		fake.aPIReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) APIVersion() string {
	fake.aPIVersionMutex.Lock()
	ret, specificReturn := fake.aPIVersionReturnsOnCall[len(fake.aPIVersionArgsForCall)]
	fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct{}{})
	fake.recordInvocation("APIVersion", []interface{}{})
	fake.aPIVersionMutex.Unlock()
	if fake.APIVersionStub != nil {
		return fake.APIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) APIVersionReturnsOnCall(i int, result1 string) {
	fake.APIVersionStub = nil
	if fake.aPIVersionReturnsOnCall == nil {
		fake.aPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AuthorizationEndpoint() string {
	fake.authorizationEndpointMutex.Lock()
	ret, specificReturn := fake.authorizationEndpointReturnsOnCall[len(fake.authorizationEndpointArgsForCall)]
	fake.authorizationEndpointArgsForCall = append(fake.authorizationEndpointArgsForCall, struct{}{})
	fake.recordInvocation("AuthorizationEndpoint", []interface{}{})
	fake.authorizationEndpointMutex.Unlock()
	if fake.AuthorizationEndpointStub != nil {
		return fake.AuthorizationEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) AuthorizationEndpointReturnsOnCall(i int, result1 string) {
	fake.AuthorizationEndpointStub = nil
	if fake.authorizationEndpointReturnsOnCall == nil {
		fake.authorizationEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.authorizationEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) DopplerEndpoint() string {
	fake.dopplerEndpointMutex.Lock()
	ret, specificReturn := fake.dopplerEndpointReturnsOnCall[len(fake.dopplerEndpointArgsForCall)]
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct{}{})
	fake.recordInvocation("DopplerEndpoint", []interface{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) DopplerEndpointReturnsOnCall(i int, result1 string) {
	fake.DopplerEndpointStub = nil
	if fake.dopplerEndpointReturnsOnCall == nil {
		fake.dopplerEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.dopplerEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) MinCLIVersion() string {
	fake.minCLIVersionMutex.Lock()
	ret, specificReturn := fake.minCLIVersionReturnsOnCall[len(fake.minCLIVersionArgsForCall)]
	fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct{}{})
	fake.recordInvocation("MinCLIVersion", []interface{}{})
	fake.minCLIVersionMutex.Unlock()
	if fake.MinCLIVersionStub != nil {
		return fake.MinCLIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) MinCLIVersionReturnsOnCall(i int, result1 string) {
	fake.MinCLIVersionStub = nil
	if fake.minCLIVersionReturnsOnCall == nil {
		fake.minCLIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.minCLIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) RoutingEndpoint() string {
	fake.routingEndpointMutex.Lock()
	ret, specificReturn := fake.routingEndpointReturnsOnCall[len(fake.routingEndpointArgsForCall)]
	fake.routingEndpointArgsForCall = append(fake.routingEndpointArgsForCall, struct{}{})
	fake.recordInvocation("RoutingEndpoint", []interface{}{})
	fake.routingEndpointMutex.Unlock()
	if fake.RoutingEndpointStub != nil {
		return fake.RoutingEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) RoutingEndpointReturnsOnCall(i int, result1 string) {
	fake.RoutingEndpointStub = nil
	if fake.routingEndpointReturnsOnCall == nil {
		fake.routingEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.routingEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) TokenEndpoint() string {
	fake.tokenEndpointMutex.Lock()
	ret, specificReturn := fake.tokenEndpointReturnsOnCall[len(fake.tokenEndpointArgsForCall)]
	fake.tokenEndpointArgsForCall = append(fake.tokenEndpointArgsForCall, struct{}{})
	fake.recordInvocation("TokenEndpoint", []interface{}{})
	fake.tokenEndpointMutex.Unlock()
	if fake.TokenEndpointStub != nil {
		return fake.TokenEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	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) TokenEndpointReturnsOnCall(i int, result1 string) {
	fake.TokenEndpointStub = nil
	if fake.tokenEndpointReturnsOnCall == nil {
		fake.tokenEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.tokenEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.associateSpaceWithRunningSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithRunningSecurityGroupMutex.RUnlock()
	fake.associateSpaceWithStagingSecurityGroupMutex.RLock()
	defer fake.associateSpaceWithStagingSecurityGroupMutex.RUnlock()
	fake.bindRouteToApplicationMutex.RLock()
	defer fake.bindRouteToApplicationMutex.RUnlock()
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	fake.deleteSpaceMutex.RLock()
	defer fake.deleteSpaceMutex.RUnlock()
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	fake.getApplicationInstancesByApplicationMutex.RLock()
	defer fake.getApplicationInstancesByApplicationMutex.RUnlock()
	fake.getApplicationInstanceStatusesByApplicationMutex.RLock()
	defer fake.getApplicationInstanceStatusesByApplicationMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	fake.getRunningSpacesBySecurityGroupMutex.RLock()
	defer fake.getRunningSpacesBySecurityGroupMutex.RUnlock()
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	fake.getSharedDomainsMutex.RLock()
	defer fake.getSharedDomainsMutex.RUnlock()
	fake.getSpaceQuotaMutex.RLock()
	defer fake.getSpaceQuotaMutex.RUnlock()
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	fake.getSpaceRunningSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceRunningSecurityGroupsBySpaceMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	fake.getSpaceStagingSecurityGroupsBySpaceMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsBySpaceMutex.RUnlock()
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	fake.getStagingSpacesBySecurityGroupMutex.RLock()
	defer fake.getStagingSpacesBySecurityGroupMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.removeSpaceFromRunningSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromRunningSecurityGroupMutex.RUnlock()
	fake.removeSpaceFromStagingSecurityGroupMutex.RLock()
	defer fake.removeSpaceFromStagingSecurityGroupMutex.RUnlock()
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.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()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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)