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

import (
	"io"
	"net/http"
	"sync"

	"code.cloudfoundry.org/cli/actor/v7action"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
	"code.cloudfoundry.org/cli/resources"
	"code.cloudfoundry.org/cli/types"
)

type FakeCloudControllerClient struct {
	ApplyOrganizationQuotaStub        func(string, string) (resources.RelationshipList, ccv3.Warnings, error)
	applyOrganizationQuotaMutex       sync.RWMutex
	applyOrganizationQuotaArgsForCall []struct {
		arg1 string
		arg2 string
	}
	applyOrganizationQuotaReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	applyOrganizationQuotaReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	ApplySpaceQuotaStub        func(string, string) (resources.RelationshipList, ccv3.Warnings, error)
	applySpaceQuotaMutex       sync.RWMutex
	applySpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
	}
	applySpaceQuotaReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	applySpaceQuotaReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	CancelDeploymentStub        func(string) (ccv3.Warnings, error)
	cancelDeploymentMutex       sync.RWMutex
	cancelDeploymentArgsForCall []struct {
		arg1 string
	}
	cancelDeploymentReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	cancelDeploymentReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	CheckRouteStub        func(string, string, string, int) (bool, ccv3.Warnings, error)
	checkRouteMutex       sync.RWMutex
	checkRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}
	checkRouteReturns struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}
	checkRouteReturnsOnCall map[int]struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}
	ContinueDeploymentStub        func(string) (ccv3.Warnings, error)
	continueDeploymentMutex       sync.RWMutex
	continueDeploymentArgsForCall []struct {
		arg1 string
	}
	continueDeploymentReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	continueDeploymentReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	CopyPackageStub        func(string, string) (resources.Package, ccv3.Warnings, error)
	copyPackageMutex       sync.RWMutex
	copyPackageArgsForCall []struct {
		arg1 string
		arg2 string
	}
	copyPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	copyPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationStub        func(resources.Application) (resources.Application, ccv3.Warnings, error)
	createApplicationMutex       sync.RWMutex
	createApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	createApplicationReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationDeploymentStub        func(resources.Deployment) (string, ccv3.Warnings, error)
	createApplicationDeploymentMutex       sync.RWMutex
	createApplicationDeploymentArgsForCall []struct {
		arg1 resources.Deployment
	}
	createApplicationDeploymentReturns struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationDeploymentReturnsOnCall map[int]struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationProcessScaleStub        func(string, resources.Process) (resources.Process, ccv3.Warnings, error)
	createApplicationProcessScaleMutex       sync.RWMutex
	createApplicationProcessScaleArgsForCall []struct {
		arg1 string
		arg2 resources.Process
	}
	createApplicationProcessScaleReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationProcessScaleReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationTaskStub        func(string, resources.Task) (resources.Task, ccv3.Warnings, error)
	createApplicationTaskMutex       sync.RWMutex
	createApplicationTaskArgsForCall []struct {
		arg1 string
		arg2 resources.Task
	}
	createApplicationTaskReturns struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	CreateBuildStub        func(resources.Build) (resources.Build, ccv3.Warnings, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		arg1 resources.Build
	}
	createBuildReturns struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	createBuildReturnsOnCall map[int]struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	CreateBuildpackStub        func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)
	createBuildpackMutex       sync.RWMutex
	createBuildpackArgsForCall []struct {
		arg1 resources.Buildpack
	}
	createBuildpackReturns struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	createBuildpackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	CreateDomainStub        func(resources.Domain) (resources.Domain, ccv3.Warnings, error)
	createDomainMutex       sync.RWMutex
	createDomainArgsForCall []struct {
		arg1 resources.Domain
	}
	createDomainReturns struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	createDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	CreateDropletStub        func(string) (resources.Droplet, ccv3.Warnings, error)
	createDropletMutex       sync.RWMutex
	createDropletArgsForCall []struct {
		arg1 string
	}
	createDropletReturns struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	createDropletReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	CreateIsolationSegmentStub        func(resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error)
	createIsolationSegmentMutex       sync.RWMutex
	createIsolationSegmentArgsForCall []struct {
		arg1 resources.IsolationSegment
	}
	createIsolationSegmentReturns struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	createIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	CreateOrganizationStub        func(string) (resources.Organization, ccv3.Warnings, error)
	createOrganizationMutex       sync.RWMutex
	createOrganizationArgsForCall []struct {
		arg1 string
	}
	createOrganizationReturns struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	createOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	CreateOrganizationQuotaStub        func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error)
	createOrganizationQuotaMutex       sync.RWMutex
	createOrganizationQuotaArgsForCall []struct {
		arg1 resources.OrganizationQuota
	}
	createOrganizationQuotaReturns struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	createOrganizationQuotaReturnsOnCall map[int]struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	CreatePackageStub        func(resources.Package) (resources.Package, ccv3.Warnings, error)
	createPackageMutex       sync.RWMutex
	createPackageArgsForCall []struct {
		arg1 resources.Package
	}
	createPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	createPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	CreateRoleStub        func(resources.Role) (resources.Role, ccv3.Warnings, error)
	createRoleMutex       sync.RWMutex
	createRoleArgsForCall []struct {
		arg1 resources.Role
	}
	createRoleReturns struct {
		result1 resources.Role
		result2 ccv3.Warnings
		result3 error
	}
	createRoleReturnsOnCall map[int]struct {
		result1 resources.Role
		result2 ccv3.Warnings
		result3 error
	}
	CreateRouteStub        func(resources.Route) (resources.Route, ccv3.Warnings, error)
	createRouteMutex       sync.RWMutex
	createRouteArgsForCall []struct {
		arg1 resources.Route
	}
	createRouteReturns struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	createRouteReturnsOnCall map[int]struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	CreateRouteBindingStub        func(resources.RouteBinding) (ccv3.JobURL, ccv3.Warnings, error)
	createRouteBindingMutex       sync.RWMutex
	createRouteBindingArgsForCall []struct {
		arg1 resources.RouteBinding
	}
	createRouteBindingReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	createRouteBindingReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	CreateSecurityGroupStub        func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error)
	createSecurityGroupMutex       sync.RWMutex
	createSecurityGroupArgsForCall []struct {
		arg1 resources.SecurityGroup
	}
	createSecurityGroupReturns struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	createSecurityGroupReturnsOnCall map[int]struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	CreateServiceBrokerStub        func(resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error)
	createServiceBrokerMutex       sync.RWMutex
	createServiceBrokerArgsForCall []struct {
		arg1 resources.ServiceBroker
	}
	createServiceBrokerReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	createServiceBrokerReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	CreateServiceCredentialBindingStub        func(resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error)
	createServiceCredentialBindingMutex       sync.RWMutex
	createServiceCredentialBindingArgsForCall []struct {
		arg1 resources.ServiceCredentialBinding
	}
	createServiceCredentialBindingReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	createServiceCredentialBindingReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	CreateServiceInstanceStub        func(resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error)
	createServiceInstanceMutex       sync.RWMutex
	createServiceInstanceArgsForCall []struct {
		arg1 resources.ServiceInstance
	}
	createServiceInstanceReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	createServiceInstanceReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	CreateSpaceStub        func(resources.Space) (resources.Space, ccv3.Warnings, error)
	createSpaceMutex       sync.RWMutex
	createSpaceArgsForCall []struct {
		arg1 resources.Space
	}
	createSpaceReturns struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	createSpaceReturnsOnCall map[int]struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	CreateSpaceQuotaStub        func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error)
	createSpaceQuotaMutex       sync.RWMutex
	createSpaceQuotaArgsForCall []struct {
		arg1 resources.SpaceQuota
	}
	createSpaceQuotaReturns struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	createSpaceQuotaReturnsOnCall map[int]struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	CreateUserStub        func(string) (resources.User, ccv3.Warnings, error)
	createUserMutex       sync.RWMutex
	createUserArgsForCall []struct {
		arg1 string
	}
	createUserReturns struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}
	createUserReturnsOnCall map[int]struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}
	DeleteApplicationStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteApplicationMutex       sync.RWMutex
	deleteApplicationArgsForCall []struct {
		arg1 string
	}
	deleteApplicationReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteApplicationReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteApplicationProcessInstanceStub        func(string, string, int) (ccv3.Warnings, error)
	deleteApplicationProcessInstanceMutex       sync.RWMutex
	deleteApplicationProcessInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 int
	}
	deleteApplicationProcessInstanceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteApplicationProcessInstanceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteBuildpackStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteBuildpackMutex       sync.RWMutex
	deleteBuildpackArgsForCall []struct {
		arg1 string
	}
	deleteBuildpackReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteBuildpackReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteDomainStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteDomainMutex       sync.RWMutex
	deleteDomainArgsForCall []struct {
		arg1 string
	}
	deleteDomainReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteDomainReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteIsolationSegmentStub        func(string) (ccv3.Warnings, error)
	deleteIsolationSegmentMutex       sync.RWMutex
	deleteIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	deleteIsolationSegmentReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteIsolationSegmentOrganizationStub        func(string, string) (ccv3.Warnings, error)
	deleteIsolationSegmentOrganizationMutex       sync.RWMutex
	deleteIsolationSegmentOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteIsolationSegmentOrganizationReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteIsolationSegmentOrganizationReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteOrganizationStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteOrganizationMutex       sync.RWMutex
	deleteOrganizationArgsForCall []struct {
		arg1 string
	}
	deleteOrganizationReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteOrganizationReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteOrganizationQuotaStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteOrganizationQuotaMutex       sync.RWMutex
	deleteOrganizationQuotaArgsForCall []struct {
		arg1 string
	}
	deleteOrganizationQuotaReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteOrganizationQuotaReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteOrphanedRoutesStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteOrphanedRoutesMutex       sync.RWMutex
	deleteOrphanedRoutesArgsForCall []struct {
		arg1 string
	}
	deleteOrphanedRoutesReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteOrphanedRoutesReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteRoleStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteRoleMutex       sync.RWMutex
	deleteRoleArgsForCall []struct {
		arg1 string
	}
	deleteRoleReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteRoleReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteRouteStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteRouteMutex       sync.RWMutex
	deleteRouteArgsForCall []struct {
		arg1 string
	}
	deleteRouteReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteRouteReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteRouteBindingStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteRouteBindingMutex       sync.RWMutex
	deleteRouteBindingArgsForCall []struct {
		arg1 string
	}
	deleteRouteBindingReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteRouteBindingReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteSecurityGroupStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteSecurityGroupMutex       sync.RWMutex
	deleteSecurityGroupArgsForCall []struct {
		arg1 string
	}
	deleteSecurityGroupReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteSecurityGroupReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteServiceBrokerStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteServiceBrokerMutex       sync.RWMutex
	deleteServiceBrokerArgsForCall []struct {
		arg1 string
	}
	deleteServiceBrokerReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteServiceBrokerReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteServiceCredentialBindingStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteServiceCredentialBindingMutex       sync.RWMutex
	deleteServiceCredentialBindingArgsForCall []struct {
		arg1 string
	}
	deleteServiceCredentialBindingReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteServiceCredentialBindingReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteServiceInstanceStub        func(string, ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error)
	deleteServiceInstanceMutex       sync.RWMutex
	deleteServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	deleteServiceInstanceReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteServiceInstanceReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteServicePlanVisibilityStub        func(string, string) (ccv3.Warnings, error)
	deleteServicePlanVisibilityMutex       sync.RWMutex
	deleteServicePlanVisibilityArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteServicePlanVisibilityReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteServicePlanVisibilityReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteSpaceStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteSpaceMutex       sync.RWMutex
	deleteSpaceArgsForCall []struct {
		arg1 string
	}
	deleteSpaceReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteSpaceReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteSpaceQuotaStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteSpaceQuotaMutex       sync.RWMutex
	deleteSpaceQuotaArgsForCall []struct {
		arg1 string
	}
	deleteSpaceQuotaReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteSpaceQuotaReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteUserStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteUserMutex       sync.RWMutex
	deleteUserArgsForCall []struct {
		arg1 string
	}
	deleteUserReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteUserReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DownloadDropletStub        func(string) ([]byte, ccv3.Warnings, error)
	downloadDropletMutex       sync.RWMutex
	downloadDropletArgsForCall []struct {
		arg1 string
	}
	downloadDropletReturns struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	downloadDropletReturnsOnCall map[int]struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	EntitleIsolationSegmentToOrganizationsStub        func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)
	entitleIsolationSegmentToOrganizationsMutex       sync.RWMutex
	entitleIsolationSegmentToOrganizationsArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	entitleIsolationSegmentToOrganizationsReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	entitleIsolationSegmentToOrganizationsReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	GetAppFeatureStub        func(string, string) (resources.ApplicationFeature, ccv3.Warnings, error)
	getAppFeatureMutex       sync.RWMutex
	getAppFeatureArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getAppFeatureReturns struct {
		result1 resources.ApplicationFeature
		result2 ccv3.Warnings
		result3 error
	}
	getAppFeatureReturnsOnCall map[int]struct {
		result1 resources.ApplicationFeature
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationByNameAndSpaceStub        func(string, string) (resources.Application, ccv3.Warnings, error)
	getApplicationByNameAndSpaceMutex       sync.RWMutex
	getApplicationByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationByNameAndSpaceReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationByNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationDropletCurrentStub        func(string) (resources.Droplet, ccv3.Warnings, error)
	getApplicationDropletCurrentMutex       sync.RWMutex
	getApplicationDropletCurrentArgsForCall []struct {
		arg1 string
	}
	getApplicationDropletCurrentReturns struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationDropletCurrentReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationEnvironmentStub        func(string) (ccv3.Environment, ccv3.Warnings, error)
	getApplicationEnvironmentMutex       sync.RWMutex
	getApplicationEnvironmentArgsForCall []struct {
		arg1 string
	}
	getApplicationEnvironmentReturns struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationEnvironmentReturnsOnCall map[int]struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationManifestStub        func(string) ([]byte, ccv3.Warnings, error)
	getApplicationManifestMutex       sync.RWMutex
	getApplicationManifestArgsForCall []struct {
		arg1 string
	}
	getApplicationManifestReturns struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationManifestReturnsOnCall map[int]struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessByTypeStub        func(string, string) (resources.Process, ccv3.Warnings, error)
	getApplicationProcessByTypeMutex       sync.RWMutex
	getApplicationProcessByTypeArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationProcessByTypeReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessByTypeReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessesStub        func(string) ([]resources.Process, ccv3.Warnings, error)
	getApplicationProcessesMutex       sync.RWMutex
	getApplicationProcessesArgsForCall []struct {
		arg1 string
	}
	getApplicationProcessesReturns struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessesReturnsOnCall map[int]struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationRevisionsStub        func(string, ...ccv3.Query) ([]resources.Revision, ccv3.Warnings, error)
	getApplicationRevisionsMutex       sync.RWMutex
	getApplicationRevisionsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getApplicationRevisionsReturns struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationRevisionsReturnsOnCall map[int]struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationRevisionsDeployedStub        func(string) ([]resources.Revision, ccv3.Warnings, error)
	getApplicationRevisionsDeployedMutex       sync.RWMutex
	getApplicationRevisionsDeployedArgsForCall []struct {
		arg1 string
	}
	getApplicationRevisionsDeployedReturns struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationRevisionsDeployedReturnsOnCall map[int]struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationRoutesStub        func(string) ([]resources.Route, ccv3.Warnings, error)
	getApplicationRoutesMutex       sync.RWMutex
	getApplicationRoutesArgsForCall []struct {
		arg1 string
	}
	getApplicationRoutesReturns struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationRoutesReturnsOnCall map[int]struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationTasksStub        func(string, ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error)
	getApplicationTasksMutex       sync.RWMutex
	getApplicationTasksArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getApplicationTasksReturns struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationTasksReturnsOnCall map[int]struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationsStub        func(...ccv3.Query) ([]resources.Application, ccv3.Warnings, error)
	getApplicationsMutex       sync.RWMutex
	getApplicationsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getApplicationsReturns struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationsReturnsOnCall map[int]struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	GetBuildStub        func(string) (resources.Build, ccv3.Warnings, error)
	getBuildMutex       sync.RWMutex
	getBuildArgsForCall []struct {
		arg1 string
	}
	getBuildReturns struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	getBuildReturnsOnCall map[int]struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	GetBuildpacksStub        func(...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error)
	getBuildpacksMutex       sync.RWMutex
	getBuildpacksArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getBuildpacksReturns struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	getBuildpacksReturnsOnCall map[int]struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	GetDefaultDomainStub        func(string) (resources.Domain, ccv3.Warnings, error)
	getDefaultDomainMutex       sync.RWMutex
	getDefaultDomainArgsForCall []struct {
		arg1 string
	}
	getDefaultDomainReturns struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getDefaultDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetDeploymentStub        func(string) (resources.Deployment, ccv3.Warnings, error)
	getDeploymentMutex       sync.RWMutex
	getDeploymentArgsForCall []struct {
		arg1 string
	}
	getDeploymentReturns struct {
		result1 resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	getDeploymentReturnsOnCall map[int]struct {
		result1 resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	GetDeploymentsStub        func(...ccv3.Query) ([]resources.Deployment, ccv3.Warnings, error)
	getDeploymentsMutex       sync.RWMutex
	getDeploymentsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDeploymentsReturns struct {
		result1 []resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	getDeploymentsReturnsOnCall map[int]struct {
		result1 []resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	GetDomainStub        func(string) (resources.Domain, ccv3.Warnings, error)
	getDomainMutex       sync.RWMutex
	getDomainArgsForCall []struct {
		arg1 string
	}
	getDomainReturns struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetDomainsStub        func(...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)
	getDomainsMutex       sync.RWMutex
	getDomainsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDomainsReturns struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getDomainsReturnsOnCall map[int]struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletStub        func(string) (resources.Droplet, ccv3.Warnings, error)
	getDropletMutex       sync.RWMutex
	getDropletArgsForCall []struct {
		arg1 string
	}
	getDropletReturns struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletsStub        func(...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)
	getDropletsMutex       sync.RWMutex
	getDropletsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDropletsReturns struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletsReturnsOnCall map[int]struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetEnvironmentVariableGroupStub        func(constant.EnvironmentVariableGroupName) (resources.EnvironmentVariables, ccv3.Warnings, error)
	getEnvironmentVariableGroupMutex       sync.RWMutex
	getEnvironmentVariableGroupArgsForCall []struct {
		arg1 constant.EnvironmentVariableGroupName
	}
	getEnvironmentVariableGroupReturns struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	getEnvironmentVariableGroupReturnsOnCall map[int]struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	GetEnvironmentVariablesByURLStub        func(string) (resources.EnvironmentVariables, ccv3.Warnings, error)
	getEnvironmentVariablesByURLMutex       sync.RWMutex
	getEnvironmentVariablesByURLArgsForCall []struct {
		arg1 string
	}
	getEnvironmentVariablesByURLReturns struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	getEnvironmentVariablesByURLReturnsOnCall map[int]struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	GetEventsStub        func(...ccv3.Query) ([]ccv3.Event, ccv3.Warnings, error)
	getEventsMutex       sync.RWMutex
	getEventsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getEventsReturns struct {
		result1 []ccv3.Event
		result2 ccv3.Warnings
		result3 error
	}
	getEventsReturnsOnCall map[int]struct {
		result1 []ccv3.Event
		result2 ccv3.Warnings
		result3 error
	}
	GetFeatureFlagStub        func(string) (resources.FeatureFlag, ccv3.Warnings, error)
	getFeatureFlagMutex       sync.RWMutex
	getFeatureFlagArgsForCall []struct {
		arg1 string
	}
	getFeatureFlagReturns struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	getFeatureFlagReturnsOnCall map[int]struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	GetFeatureFlagsStub        func() ([]resources.FeatureFlag, ccv3.Warnings, error)
	getFeatureFlagsMutex       sync.RWMutex
	getFeatureFlagsArgsForCall []struct {
	}
	getFeatureFlagsReturns struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	getFeatureFlagsReturnsOnCall map[int]struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	GetInfoStub        func() (ccv3.Info, ccv3.Warnings, error)
	getInfoMutex       sync.RWMutex
	getInfoArgsForCall []struct {
	}
	getInfoReturns struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}
	getInfoReturnsOnCall map[int]struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentStub        func(string) (resources.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentMutex       sync.RWMutex
	getIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentReturns struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentOrganizationsStub        func(string) ([]resources.Organization, ccv3.Warnings, error)
	getIsolationSegmentOrganizationsMutex       sync.RWMutex
	getIsolationSegmentOrganizationsArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentOrganizationsReturns struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentOrganizationsReturnsOnCall map[int]struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentsStub        func(...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentsMutex       sync.RWMutex
	getIsolationSegmentsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getIsolationSegmentsReturns struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentsReturnsOnCall map[int]struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	GetNewApplicationProcessesStub        func(string, string) ([]resources.Process, ccv3.Warnings, error)
	getNewApplicationProcessesMutex       sync.RWMutex
	getNewApplicationProcessesArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getNewApplicationProcessesReturns struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getNewApplicationProcessesReturnsOnCall map[int]struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationStub        func(string) (resources.Organization, ccv3.Warnings, error)
	getOrganizationMutex       sync.RWMutex
	getOrganizationArgsForCall []struct {
		arg1 string
	}
	getOrganizationReturns struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationDefaultIsolationSegmentStub        func(string) (resources.Relationship, ccv3.Warnings, error)
	getOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	getOrganizationDefaultIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getOrganizationDefaultIsolationSegmentReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationDomainsStub        func(string, ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)
	getOrganizationDomainsMutex       sync.RWMutex
	getOrganizationDomainsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getOrganizationDomainsReturns struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationDomainsReturnsOnCall map[int]struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationQuotaStub        func(string) (resources.OrganizationQuota, ccv3.Warnings, error)
	getOrganizationQuotaMutex       sync.RWMutex
	getOrganizationQuotaArgsForCall []struct {
		arg1 string
	}
	getOrganizationQuotaReturns struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationQuotaReturnsOnCall map[int]struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationQuotasStub        func(...ccv3.Query) ([]resources.OrganizationQuota, ccv3.Warnings, error)
	getOrganizationQuotasMutex       sync.RWMutex
	getOrganizationQuotasArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getOrganizationQuotasReturns struct {
		result1 []resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationQuotasReturnsOnCall map[int]struct {
		result1 []resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationsStub        func(...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getOrganizationsReturns struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationsReturnsOnCall map[int]struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetPackageStub        func(string) (resources.Package, ccv3.Warnings, error)
	getPackageMutex       sync.RWMutex
	getPackageArgsForCall []struct {
		arg1 string
	}
	getPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	GetPackageDropletsStub        func(string, ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)
	getPackageDropletsMutex       sync.RWMutex
	getPackageDropletsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getPackageDropletsReturns struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getPackageDropletsReturnsOnCall map[int]struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetPackagesStub        func(...ccv3.Query) ([]resources.Package, ccv3.Warnings, error)
	getPackagesMutex       sync.RWMutex
	getPackagesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getPackagesReturns struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackagesReturnsOnCall map[int]struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	GetProcessStub        func(string) (resources.Process, ccv3.Warnings, error)
	getProcessMutex       sync.RWMutex
	getProcessArgsForCall []struct {
		arg1 string
	}
	getProcessReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getProcessReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetProcessInstancesStub        func(string) ([]ccv3.ProcessInstance, ccv3.Warnings, error)
	getProcessInstancesMutex       sync.RWMutex
	getProcessInstancesArgsForCall []struct {
		arg1 string
	}
	getProcessInstancesReturns struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}
	getProcessInstancesReturnsOnCall map[int]struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}
	GetProcessSidecarsStub        func(string) ([]resources.Sidecar, ccv3.Warnings, error)
	getProcessSidecarsMutex       sync.RWMutex
	getProcessSidecarsArgsForCall []struct {
		arg1 string
	}
	getProcessSidecarsReturns struct {
		result1 []resources.Sidecar
		result2 ccv3.Warnings
		result3 error
	}
	getProcessSidecarsReturnsOnCall map[int]struct {
		result1 []resources.Sidecar
		result2 ccv3.Warnings
		result3 error
	}
	GetProcessesStub        func(...ccv3.Query) ([]resources.Process, ccv3.Warnings, error)
	getProcessesMutex       sync.RWMutex
	getProcessesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getProcessesReturns struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getProcessesReturnsOnCall map[int]struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetRolesStub        func(...ccv3.Query) ([]resources.Role, ccv3.IncludedResources, ccv3.Warnings, error)
	getRolesMutex       sync.RWMutex
	getRolesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getRolesReturns struct {
		result1 []resources.Role
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	getRolesReturnsOnCall map[int]struct {
		result1 []resources.Role
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	GetRootStub        func() (ccv3.Root, ccv3.Warnings, error)
	getRootMutex       sync.RWMutex
	getRootArgsForCall []struct {
	}
	getRootReturns struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}
	getRootReturnsOnCall map[int]struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}
	GetRouteBindingsStub        func(...ccv3.Query) ([]resources.RouteBinding, ccv3.IncludedResources, ccv3.Warnings, error)
	getRouteBindingsMutex       sync.RWMutex
	getRouteBindingsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getRouteBindingsReturns struct {
		result1 []resources.RouteBinding
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	getRouteBindingsReturnsOnCall map[int]struct {
		result1 []resources.RouteBinding
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	GetRouteDestinationsStub        func(string) ([]resources.RouteDestination, ccv3.Warnings, error)
	getRouteDestinationsMutex       sync.RWMutex
	getRouteDestinationsArgsForCall []struct {
		arg1 string
	}
	getRouteDestinationsReturns struct {
		result1 []resources.RouteDestination
		result2 ccv3.Warnings
		result3 error
	}
	getRouteDestinationsReturnsOnCall map[int]struct {
		result1 []resources.RouteDestination
		result2 ccv3.Warnings
		result3 error
	}
	GetRoutesStub        func(...ccv3.Query) ([]resources.Route, ccv3.Warnings, error)
	getRoutesMutex       sync.RWMutex
	getRoutesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getRoutesReturns struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	getRoutesReturnsOnCall map[int]struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	GetRunningSecurityGroupsStub        func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)
	getRunningSecurityGroupsMutex       sync.RWMutex
	getRunningSecurityGroupsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getRunningSecurityGroupsReturns struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	getRunningSecurityGroupsReturnsOnCall map[int]struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	GetSSHEnabledStub        func(string) (ccv3.SSHEnabled, ccv3.Warnings, error)
	getSSHEnabledMutex       sync.RWMutex
	getSSHEnabledArgsForCall []struct {
		arg1 string
	}
	getSSHEnabledReturns struct {
		result1 ccv3.SSHEnabled
		result2 ccv3.Warnings
		result3 error
	}
	getSSHEnabledReturnsOnCall map[int]struct {
		result1 ccv3.SSHEnabled
		result2 ccv3.Warnings
		result3 error
	}
	GetSecurityGroupsStub        func(...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)
	getSecurityGroupsMutex       sync.RWMutex
	getSecurityGroupsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getSecurityGroupsReturns struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	getSecurityGroupsReturnsOnCall map[int]struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceBrokersStub        func(...ccv3.Query) ([]resources.ServiceBroker, ccv3.Warnings, error)
	getServiceBrokersMutex       sync.RWMutex
	getServiceBrokersArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceBrokersReturns struct {
		result1 []resources.ServiceBroker
		result2 ccv3.Warnings
		result3 error
	}
	getServiceBrokersReturnsOnCall map[int]struct {
		result1 []resources.ServiceBroker
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceCredentialBindingDetailsStub        func(string) (resources.ServiceCredentialBindingDetails, ccv3.Warnings, error)
	getServiceCredentialBindingDetailsMutex       sync.RWMutex
	getServiceCredentialBindingDetailsArgsForCall []struct {
		arg1 string
	}
	getServiceCredentialBindingDetailsReturns struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 ccv3.Warnings
		result3 error
	}
	getServiceCredentialBindingDetailsReturnsOnCall map[int]struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceCredentialBindingsStub        func(...ccv3.Query) ([]resources.ServiceCredentialBinding, ccv3.Warnings, error)
	getServiceCredentialBindingsMutex       sync.RWMutex
	getServiceCredentialBindingsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceCredentialBindingsReturns struct {
		result1 []resources.ServiceCredentialBinding
		result2 ccv3.Warnings
		result3 error
	}
	getServiceCredentialBindingsReturnsOnCall map[int]struct {
		result1 []resources.ServiceCredentialBinding
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceInstanceByNameAndSpaceStub        func(string, string, ...ccv3.Query) (resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error)
	getServiceInstanceByNameAndSpaceMutex       sync.RWMutex
	getServiceInstanceByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 []ccv3.Query
	}
	getServiceInstanceByNameAndSpaceReturns struct {
		result1 resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	getServiceInstanceByNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	GetServiceInstanceParametersStub        func(string) (types.JSONObject, ccv3.Warnings, error)
	getServiceInstanceParametersMutex       sync.RWMutex
	getServiceInstanceParametersArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceParametersReturns struct {
		result1 types.JSONObject
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstanceParametersReturnsOnCall map[int]struct {
		result1 types.JSONObject
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceInstanceSharedSpacesStub        func(string) ([]ccv3.SpaceWithOrganization, ccv3.Warnings, error)
	getServiceInstanceSharedSpacesMutex       sync.RWMutex
	getServiceInstanceSharedSpacesArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceSharedSpacesReturns struct {
		result1 []ccv3.SpaceWithOrganization
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstanceSharedSpacesReturnsOnCall map[int]struct {
		result1 []ccv3.SpaceWithOrganization
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceInstanceUsageSummaryStub        func(string) ([]resources.ServiceInstanceUsageSummary, ccv3.Warnings, error)
	getServiceInstanceUsageSummaryMutex       sync.RWMutex
	getServiceInstanceUsageSummaryArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceUsageSummaryReturns struct {
		result1 []resources.ServiceInstanceUsageSummary
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstanceUsageSummaryReturnsOnCall map[int]struct {
		result1 []resources.ServiceInstanceUsageSummary
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceInstancesStub        func(...ccv3.Query) ([]resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceInstancesReturns struct {
		result1 []resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	getServiceInstancesReturnsOnCall map[int]struct {
		result1 []resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	GetServiceOfferingByGUIDStub        func(string) (resources.ServiceOffering, ccv3.Warnings, error)
	getServiceOfferingByGUIDMutex       sync.RWMutex
	getServiceOfferingByGUIDArgsForCall []struct {
		arg1 string
	}
	getServiceOfferingByGUIDReturns struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	getServiceOfferingByGUIDReturnsOnCall map[int]struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceOfferingByNameAndBrokerStub        func(string, string) (resources.ServiceOffering, ccv3.Warnings, error)
	getServiceOfferingByNameAndBrokerMutex       sync.RWMutex
	getServiceOfferingByNameAndBrokerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceOfferingByNameAndBrokerReturns struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	getServiceOfferingByNameAndBrokerReturnsOnCall map[int]struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceOfferingsStub        func(...ccv3.Query) ([]resources.ServiceOffering, ccv3.Warnings, error)
	getServiceOfferingsMutex       sync.RWMutex
	getServiceOfferingsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceOfferingsReturns struct {
		result1 []resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	getServiceOfferingsReturnsOnCall map[int]struct {
		result1 []resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}
	GetServicePlanByGUIDStub        func(string) (resources.ServicePlan, ccv3.Warnings, error)
	getServicePlanByGUIDMutex       sync.RWMutex
	getServicePlanByGUIDArgsForCall []struct {
		arg1 string
	}
	getServicePlanByGUIDReturns struct {
		result1 resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}
	getServicePlanByGUIDReturnsOnCall map[int]struct {
		result1 resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}
	GetServicePlanVisibilityStub        func(string) (resources.ServicePlanVisibility, ccv3.Warnings, error)
	getServicePlanVisibilityMutex       sync.RWMutex
	getServicePlanVisibilityArgsForCall []struct {
		arg1 string
	}
	getServicePlanVisibilityReturns struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}
	getServicePlanVisibilityReturnsOnCall map[int]struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}
	GetServicePlansStub        func(...ccv3.Query) ([]resources.ServicePlan, ccv3.Warnings, error)
	getServicePlansMutex       sync.RWMutex
	getServicePlansArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServicePlansReturns struct {
		result1 []resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}
	getServicePlansReturnsOnCall map[int]struct {
		result1 []resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}
	GetServicePlansWithOfferingsStub        func(...ccv3.Query) ([]ccv3.ServiceOfferingWithPlans, ccv3.Warnings, error)
	getServicePlansWithOfferingsMutex       sync.RWMutex
	getServicePlansWithOfferingsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServicePlansWithOfferingsReturns struct {
		result1 []ccv3.ServiceOfferingWithPlans
		result2 ccv3.Warnings
		result3 error
	}
	getServicePlansWithOfferingsReturnsOnCall map[int]struct {
		result1 []ccv3.ServiceOfferingWithPlans
		result2 ccv3.Warnings
		result3 error
	}
	GetServicePlansWithSpaceAndOrganizationStub        func(...ccv3.Query) ([]ccv3.ServicePlanWithSpaceAndOrganization, ccv3.Warnings, error)
	getServicePlansWithSpaceAndOrganizationMutex       sync.RWMutex
	getServicePlansWithSpaceAndOrganizationArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServicePlansWithSpaceAndOrganizationReturns struct {
		result1 []ccv3.ServicePlanWithSpaceAndOrganization
		result2 ccv3.Warnings
		result3 error
	}
	getServicePlansWithSpaceAndOrganizationReturnsOnCall map[int]struct {
		result1 []ccv3.ServicePlanWithSpaceAndOrganization
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceFeatureStub        func(string, string) (bool, ccv3.Warnings, error)
	getSpaceFeatureMutex       sync.RWMutex
	getSpaceFeatureArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceFeatureReturns struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceFeatureReturnsOnCall map[int]struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceIsolationSegmentStub        func(string) (resources.Relationship, ccv3.Warnings, error)
	getSpaceIsolationSegmentMutex       sync.RWMutex
	getSpaceIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getSpaceIsolationSegmentReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceManifestDiffStub        func(string, []byte) (resources.ManifestDiff, ccv3.Warnings, error)
	getSpaceManifestDiffMutex       sync.RWMutex
	getSpaceManifestDiffArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	getSpaceManifestDiffReturns struct {
		result1 resources.ManifestDiff
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceManifestDiffReturnsOnCall map[int]struct {
		result1 resources.ManifestDiff
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceQuotaStub        func(string) (resources.SpaceQuota, ccv3.Warnings, error)
	getSpaceQuotaMutex       sync.RWMutex
	getSpaceQuotaArgsForCall []struct {
		arg1 string
	}
	getSpaceQuotaReturns struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceQuotaReturnsOnCall map[int]struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceQuotasStub        func(...ccv3.Query) ([]resources.SpaceQuota, ccv3.Warnings, error)
	getSpaceQuotasMutex       sync.RWMutex
	getSpaceQuotasArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getSpaceQuotasReturns struct {
		result1 []resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceQuotasReturnsOnCall map[int]struct {
		result1 []resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	GetSpacesStub        func(...ccv3.Query) ([]resources.Space, ccv3.IncludedResources, ccv3.Warnings, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getSpacesReturns struct {
		result1 []resources.Space
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	getSpacesReturnsOnCall map[int]struct {
		result1 []resources.Space
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}
	GetStacksStub        func(...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error)
	getStacksMutex       sync.RWMutex
	getStacksArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getStacksReturns struct {
		result1 []resources.Stack
		result2 ccv3.Warnings
		result3 error
	}
	getStacksReturnsOnCall map[int]struct {
		result1 []resources.Stack
		result2 ccv3.Warnings
		result3 error
	}
	GetStagingSecurityGroupsStub        func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)
	getStagingSecurityGroupsMutex       sync.RWMutex
	getStagingSecurityGroupsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getStagingSecurityGroupsReturns struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	getStagingSecurityGroupsReturnsOnCall map[int]struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	GetTaskStub        func(string) (resources.Task, ccv3.Warnings, error)
	getTaskMutex       sync.RWMutex
	getTaskArgsForCall []struct {
		arg1 string
	}
	getTaskReturns struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	getTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	GetUserStub        func(string) (resources.User, ccv3.Warnings, error)
	getUserMutex       sync.RWMutex
	getUserArgsForCall []struct {
		arg1 string
	}
	getUserReturns struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}
	getUserReturnsOnCall map[int]struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}
	GetUsersStub        func(...ccv3.Query) ([]resources.User, ccv3.Warnings, error)
	getUsersMutex       sync.RWMutex
	getUsersArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getUsersReturns struct {
		result1 []resources.User
		result2 ccv3.Warnings
		result3 error
	}
	getUsersReturnsOnCall map[int]struct {
		result1 []resources.User
		result2 ccv3.Warnings
		result3 error
	}
	MakeRequestSendReceiveRawStub        func(string, string, http.Header, []byte) ([]byte, *http.Response, error)
	makeRequestSendReceiveRawMutex       sync.RWMutex
	makeRequestSendReceiveRawArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 http.Header
		arg4 []byte
	}
	makeRequestSendReceiveRawReturns struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}
	makeRequestSendReceiveRawReturnsOnCall map[int]struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}
	MapRouteStub        func(string, string, string) (ccv3.Warnings, error)
	mapRouteMutex       sync.RWMutex
	mapRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	mapRouteReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	mapRouteReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	MoveRouteStub        func(string, string) (ccv3.Warnings, error)
	moveRouteMutex       sync.RWMutex
	moveRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	moveRouteReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	moveRouteReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	PollJobStub        func(ccv3.JobURL) (ccv3.Warnings, error)
	pollJobMutex       sync.RWMutex
	pollJobArgsForCall []struct {
		arg1 ccv3.JobURL
	}
	pollJobReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	pollJobReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	PollJobForStateStub        func(ccv3.JobURL, constant.JobState) (ccv3.Warnings, error)
	pollJobForStateMutex       sync.RWMutex
	pollJobForStateArgsForCall []struct {
		arg1 ccv3.JobURL
		arg2 constant.JobState
	}
	pollJobForStateReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	pollJobForStateReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	PollJobToEventStreamStub        func(ccv3.JobURL) chan ccv3.PollJobEvent
	pollJobToEventStreamMutex       sync.RWMutex
	pollJobToEventStreamArgsForCall []struct {
		arg1 ccv3.JobURL
	}
	pollJobToEventStreamReturns struct {
		result1 chan ccv3.PollJobEvent
	}
	pollJobToEventStreamReturnsOnCall map[int]struct {
		result1 chan ccv3.PollJobEvent
	}
	PurgeServiceOfferingStub        func(string) (ccv3.Warnings, error)
	purgeServiceOfferingMutex       sync.RWMutex
	purgeServiceOfferingArgsForCall []struct {
		arg1 string
	}
	purgeServiceOfferingReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	purgeServiceOfferingReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	ResourceMatchStub        func([]ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error)
	resourceMatchMutex       sync.RWMutex
	resourceMatchArgsForCall []struct {
		arg1 []ccv3.Resource
	}
	resourceMatchReturns struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}
	resourceMatchReturnsOnCall map[int]struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}
	RootResponseStub        func() (ccv3.Root, ccv3.Warnings, error)
	rootResponseMutex       sync.RWMutex
	rootResponseArgsForCall []struct {
	}
	rootResponseReturns struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}
	rootResponseReturnsOnCall map[int]struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}
	SetApplicationDropletStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	setApplicationDropletMutex       sync.RWMutex
	setApplicationDropletArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setApplicationDropletReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	setApplicationDropletReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	SharePrivateDomainToOrgsStub        func(string, ccv3.SharedOrgs) (ccv3.Warnings, error)
	sharePrivateDomainToOrgsMutex       sync.RWMutex
	sharePrivateDomainToOrgsArgsForCall []struct {
		arg1 string
		arg2 ccv3.SharedOrgs
	}
	sharePrivateDomainToOrgsReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	sharePrivateDomainToOrgsReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	ShareRouteStub        func(string, string) (ccv3.Warnings, error)
	shareRouteMutex       sync.RWMutex
	shareRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	shareRouteReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	shareRouteReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	ShareServiceInstanceToSpacesStub        func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)
	shareServiceInstanceToSpacesMutex       sync.RWMutex
	shareServiceInstanceToSpacesArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	shareServiceInstanceToSpacesReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	shareServiceInstanceToSpacesReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	TargetCFStub        func(ccv3.TargetSettings)
	targetCFMutex       sync.RWMutex
	targetCFArgsForCall []struct {
		arg1 ccv3.TargetSettings
	}
	UnbindSecurityGroupRunningSpaceStub        func(string, string) (ccv3.Warnings, error)
	unbindSecurityGroupRunningSpaceMutex       sync.RWMutex
	unbindSecurityGroupRunningSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unbindSecurityGroupRunningSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unbindSecurityGroupRunningSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnbindSecurityGroupStagingSpaceStub        func(string, string) (ccv3.Warnings, error)
	unbindSecurityGroupStagingSpaceMutex       sync.RWMutex
	unbindSecurityGroupStagingSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unbindSecurityGroupStagingSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unbindSecurityGroupStagingSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnmapRouteStub        func(string, string) (ccv3.Warnings, error)
	unmapRouteMutex       sync.RWMutex
	unmapRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unmapRouteReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unmapRouteReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnsetSpaceQuotaStub        func(string, string) (ccv3.Warnings, error)
	unsetSpaceQuotaMutex       sync.RWMutex
	unsetSpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unsetSpaceQuotaReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unsetSpaceQuotaReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnsharePrivateDomainFromOrgStub        func(string, string) (ccv3.Warnings, error)
	unsharePrivateDomainFromOrgMutex       sync.RWMutex
	unsharePrivateDomainFromOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unsharePrivateDomainFromOrgReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unsharePrivateDomainFromOrgReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnshareRouteStub        func(string, string) (ccv3.Warnings, error)
	unshareRouteMutex       sync.RWMutex
	unshareRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unshareRouteReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unshareRouteReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UnshareServiceInstanceFromSpaceStub        func(string, string) (ccv3.Warnings, error)
	unshareServiceInstanceFromSpaceMutex       sync.RWMutex
	unshareServiceInstanceFromSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unshareServiceInstanceFromSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unshareServiceInstanceFromSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateAppFeatureStub        func(string, bool, string) (ccv3.Warnings, error)
	updateAppFeatureMutex       sync.RWMutex
	updateAppFeatureArgsForCall []struct {
		arg1 string
		arg2 bool
		arg3 string
	}
	updateAppFeatureReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	updateAppFeatureReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateApplicationStub        func(resources.Application) (resources.Application, ccv3.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	updateApplicationReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationApplyManifestStub        func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)
	updateApplicationApplyManifestMutex       sync.RWMutex
	updateApplicationApplyManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	updateApplicationApplyManifestReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationApplyManifestReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationEnvironmentVariablesStub        func(string, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)
	updateApplicationEnvironmentVariablesMutex       sync.RWMutex
	updateApplicationEnvironmentVariablesArgsForCall []struct {
		arg1 string
		arg2 resources.EnvironmentVariables
	}
	updateApplicationEnvironmentVariablesReturns struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationEnvironmentVariablesReturnsOnCall map[int]struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationNameStub        func(string, string) (resources.Application, ccv3.Warnings, error)
	updateApplicationNameMutex       sync.RWMutex
	updateApplicationNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateApplicationNameReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationNameReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationRestartStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationRestartMutex       sync.RWMutex
	updateApplicationRestartArgsForCall []struct {
		arg1 string
	}
	updateApplicationRestartReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationRestartReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationStartStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationStartMutex       sync.RWMutex
	updateApplicationStartArgsForCall []struct {
		arg1 string
	}
	updateApplicationStartReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationStartReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationStopStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationStopMutex       sync.RWMutex
	updateApplicationStopArgsForCall []struct {
		arg1 string
	}
	updateApplicationStopReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationStopReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateBuildpackStub        func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)
	updateBuildpackMutex       sync.RWMutex
	updateBuildpackArgsForCall []struct {
		arg1 resources.Buildpack
	}
	updateBuildpackReturns struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	updateBuildpackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	UpdateDestinationStub        func(string, string, string) (ccv3.Warnings, error)
	updateDestinationMutex       sync.RWMutex
	updateDestinationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	updateDestinationReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	updateDestinationReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateEnvironmentVariableGroupStub        func(constant.EnvironmentVariableGroupName, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)
	updateEnvironmentVariableGroupMutex       sync.RWMutex
	updateEnvironmentVariableGroupArgsForCall []struct {
		arg1 constant.EnvironmentVariableGroupName
		arg2 resources.EnvironmentVariables
	}
	updateEnvironmentVariableGroupReturns struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	updateEnvironmentVariableGroupReturnsOnCall map[int]struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	UpdateFeatureFlagStub        func(resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error)
	updateFeatureFlagMutex       sync.RWMutex
	updateFeatureFlagArgsForCall []struct {
		arg1 resources.FeatureFlag
	}
	updateFeatureFlagReturns struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	updateFeatureFlagReturnsOnCall map[int]struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	UpdateOrganizationStub        func(resources.Organization) (resources.Organization, ccv3.Warnings, error)
	updateOrganizationMutex       sync.RWMutex
	updateOrganizationArgsForCall []struct {
		arg1 resources.Organization
	}
	updateOrganizationReturns struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	updateOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	UpdateOrganizationDefaultIsolationSegmentRelationshipStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	updateOrganizationDefaultIsolationSegmentRelationshipMutex       sync.RWMutex
	updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationDefaultIsolationSegmentRelationshipReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	UpdateOrganizationQuotaStub        func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error)
	updateOrganizationQuotaMutex       sync.RWMutex
	updateOrganizationQuotaArgsForCall []struct {
		arg1 resources.OrganizationQuota
	}
	updateOrganizationQuotaReturns struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	updateOrganizationQuotaReturnsOnCall map[int]struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}
	UpdateProcessStub        func(resources.Process) (resources.Process, ccv3.Warnings, error)
	updateProcessMutex       sync.RWMutex
	updateProcessArgsForCall []struct {
		arg1 resources.Process
	}
	updateProcessReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	updateProcessReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	UpdateResourceMetadataStub        func(string, string, resources.Metadata) (ccv3.JobURL, ccv3.Warnings, error)
	updateResourceMetadataMutex       sync.RWMutex
	updateResourceMetadataArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 resources.Metadata
	}
	updateResourceMetadataReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateResourceMetadataReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateRouteStub        func(string, map[string]*string) (resources.Route, ccv3.Warnings, error)
	updateRouteMutex       sync.RWMutex
	updateRouteArgsForCall []struct {
		arg1 string
		arg2 map[string]*string
	}
	updateRouteReturns struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	updateRouteReturnsOnCall map[int]struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSecurityGroupStub        func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error)
	updateSecurityGroupMutex       sync.RWMutex
	updateSecurityGroupArgsForCall []struct {
		arg1 resources.SecurityGroup
	}
	updateSecurityGroupReturns struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	updateSecurityGroupReturnsOnCall map[int]struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSecurityGroupRunningSpaceStub        func(string, []string) (ccv3.Warnings, error)
	updateSecurityGroupRunningSpaceMutex       sync.RWMutex
	updateSecurityGroupRunningSpaceArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	updateSecurityGroupRunningSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	updateSecurityGroupRunningSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateSecurityGroupStagingSpaceStub        func(string, []string) (ccv3.Warnings, error)
	updateSecurityGroupStagingSpaceMutex       sync.RWMutex
	updateSecurityGroupStagingSpaceArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	updateSecurityGroupStagingSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	updateSecurityGroupStagingSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateServiceBrokerStub        func(string, resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error)
	updateServiceBrokerMutex       sync.RWMutex
	updateServiceBrokerArgsForCall []struct {
		arg1 string
		arg2 resources.ServiceBroker
	}
	updateServiceBrokerReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateServiceBrokerReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateServiceInstanceStub        func(string, resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error)
	updateServiceInstanceMutex       sync.RWMutex
	updateServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 resources.ServiceInstance
	}
	updateServiceInstanceReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateServiceInstanceReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateServicePlanVisibilityStub        func(string, resources.ServicePlanVisibility) (resources.ServicePlanVisibility, ccv3.Warnings, error)
	updateServicePlanVisibilityMutex       sync.RWMutex
	updateServicePlanVisibilityArgsForCall []struct {
		arg1 string
		arg2 resources.ServicePlanVisibility
	}
	updateServicePlanVisibilityReturns struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}
	updateServicePlanVisibilityReturnsOnCall map[int]struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceStub        func(resources.Space) (resources.Space, ccv3.Warnings, error)
	updateSpaceMutex       sync.RWMutex
	updateSpaceArgsForCall []struct {
		arg1 resources.Space
	}
	updateSpaceReturns struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceReturnsOnCall map[int]struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceApplyManifestStub        func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)
	updateSpaceApplyManifestMutex       sync.RWMutex
	updateSpaceApplyManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	updateSpaceApplyManifestReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceApplyManifestReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceFeatureStub        func(string, bool, string) (ccv3.Warnings, error)
	updateSpaceFeatureMutex       sync.RWMutex
	updateSpaceFeatureArgsForCall []struct {
		arg1 string
		arg2 bool
		arg3 string
	}
	updateSpaceFeatureReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	updateSpaceFeatureReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateSpaceIsolationSegmentRelationshipStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	updateSpaceIsolationSegmentRelationshipMutex       sync.RWMutex
	updateSpaceIsolationSegmentRelationshipArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceIsolationSegmentRelationshipReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceIsolationSegmentRelationshipReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceQuotaStub        func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error)
	updateSpaceQuotaMutex       sync.RWMutex
	updateSpaceQuotaArgsForCall []struct {
		arg1 resources.SpaceQuota
	}
	updateSpaceQuotaReturns struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceQuotaReturnsOnCall map[int]struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}
	UpdateTaskCancelStub        func(string) (resources.Task, ccv3.Warnings, error)
	updateTaskCancelMutex       sync.RWMutex
	updateTaskCancelArgsForCall []struct {
		arg1 string
	}
	updateTaskCancelReturns struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	updateTaskCancelReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	UploadBitsPackageStub        func(resources.Package, []ccv3.Resource, io.Reader, int64) (resources.Package, ccv3.Warnings, error)
	uploadBitsPackageMutex       sync.RWMutex
	uploadBitsPackageArgsForCall []struct {
		arg1 resources.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}
	uploadBitsPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadBitsPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	UploadBuildpackStub        func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error)
	uploadBuildpackMutex       sync.RWMutex
	uploadBuildpackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}
	uploadBuildpackReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	uploadBuildpackReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UploadDropletBitsStub        func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error)
	uploadDropletBitsMutex       sync.RWMutex
	uploadDropletBitsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}
	uploadDropletBitsReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	uploadDropletBitsReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UploadPackageStub        func(resources.Package, string) (resources.Package, ccv3.Warnings, error)
	uploadPackageMutex       sync.RWMutex
	uploadPackageArgsForCall []struct {
		arg1 resources.Package
		arg2 string
	}
	uploadPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	WhoAmIStub        func() (resources.K8sUser, ccv3.Warnings, error)
	whoAmIMutex       sync.RWMutex
	whoAmIArgsForCall []struct {
	}
	whoAmIReturns struct {
		result1 resources.K8sUser
		result2 ccv3.Warnings
		result3 error
	}
	whoAmIReturnsOnCall map[int]struct {
		result1 resources.K8sUser
		result2 ccv3.Warnings
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuota(arg1 string, arg2 string) (resources.RelationshipList, ccv3.Warnings, error) {
	fake.applyOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.applyOrganizationQuotaReturnsOnCall[len(fake.applyOrganizationQuotaArgsForCall)]
	fake.applyOrganizationQuotaArgsForCall = append(fake.applyOrganizationQuotaArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ApplyOrganizationQuotaStub
	fakeReturns := fake.applyOrganizationQuotaReturns
	fake.recordInvocation("ApplyOrganizationQuota", []interface{}{arg1, arg2})
	fake.applyOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCallCount() int {
	fake.applyOrganizationQuotaMutex.RLock()
	defer fake.applyOrganizationQuotaMutex.RUnlock()
	return len(fake.applyOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaCalls(stub func(string, string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.applyOrganizationQuotaMutex.Lock()
	defer fake.applyOrganizationQuotaMutex.Unlock()
	fake.ApplyOrganizationQuotaStub = stub
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaArgsForCall(i int) (string, string) {
	fake.applyOrganizationQuotaMutex.RLock()
	defer fake.applyOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.applyOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.applyOrganizationQuotaMutex.Lock()
	defer fake.applyOrganizationQuotaMutex.Unlock()
	fake.ApplyOrganizationQuotaStub = nil
	fake.applyOrganizationQuotaReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ApplyOrganizationQuotaReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.applyOrganizationQuotaMutex.Lock()
	defer fake.applyOrganizationQuotaMutex.Unlock()
	fake.ApplyOrganizationQuotaStub = nil
	if fake.applyOrganizationQuotaReturnsOnCall == nil {
		fake.applyOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.applyOrganizationQuotaReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ApplySpaceQuota(arg1 string, arg2 string) (resources.RelationshipList, ccv3.Warnings, error) {
	fake.applySpaceQuotaMutex.Lock()
	ret, specificReturn := fake.applySpaceQuotaReturnsOnCall[len(fake.applySpaceQuotaArgsForCall)]
	fake.applySpaceQuotaArgsForCall = append(fake.applySpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ApplySpaceQuotaStub
	fakeReturns := fake.applySpaceQuotaReturns
	fake.recordInvocation("ApplySpaceQuota", []interface{}{arg1, arg2})
	fake.applySpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) ApplySpaceQuotaCallCount() int {
	fake.applySpaceQuotaMutex.RLock()
	defer fake.applySpaceQuotaMutex.RUnlock()
	return len(fake.applySpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) ApplySpaceQuotaCalls(stub func(string, string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.applySpaceQuotaMutex.Lock()
	defer fake.applySpaceQuotaMutex.Unlock()
	fake.ApplySpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) ApplySpaceQuotaArgsForCall(i int) (string, string) {
	fake.applySpaceQuotaMutex.RLock()
	defer fake.applySpaceQuotaMutex.RUnlock()
	argsForCall := fake.applySpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) ApplySpaceQuotaReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.applySpaceQuotaMutex.Lock()
	defer fake.applySpaceQuotaMutex.Unlock()
	fake.ApplySpaceQuotaStub = nil
	fake.applySpaceQuotaReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ApplySpaceQuotaReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.applySpaceQuotaMutex.Lock()
	defer fake.applySpaceQuotaMutex.Unlock()
	fake.ApplySpaceQuotaStub = nil
	if fake.applySpaceQuotaReturnsOnCall == nil {
		fake.applySpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.applySpaceQuotaReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CancelDeployment(arg1 string) (ccv3.Warnings, error) {
	fake.cancelDeploymentMutex.Lock()
	ret, specificReturn := fake.cancelDeploymentReturnsOnCall[len(fake.cancelDeploymentArgsForCall)]
	fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CancelDeploymentStub
	fakeReturns := fake.cancelDeploymentReturns
	fake.recordInvocation("CancelDeployment", []interface{}{arg1})
	fake.cancelDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) CancelDeploymentCallCount() int {
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	return len(fake.cancelDeploymentArgsForCall)
}

func (fake *FakeCloudControllerClient) CancelDeploymentCalls(stub func(string) (ccv3.Warnings, error)) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = stub
}

func (fake *FakeCloudControllerClient) CancelDeploymentArgsForCall(i int) string {
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	argsForCall := fake.cancelDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CancelDeploymentReturns(result1 ccv3.Warnings, result2 error) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = nil
	fake.cancelDeploymentReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) CancelDeploymentReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = nil
	if fake.cancelDeploymentReturnsOnCall == nil {
		fake.cancelDeploymentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.cancelDeploymentReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) CheckRoute(arg1 string, arg2 string, arg3 string, arg4 int) (bool, ccv3.Warnings, error) {
	fake.checkRouteMutex.Lock()
	ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)]
	fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}{arg1, arg2, arg3, arg4})
	stub := fake.CheckRouteStub
	fakeReturns := fake.checkRouteReturns
	fake.recordInvocation("CheckRoute", []interface{}{arg1, arg2, arg3, arg4})
	fake.checkRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) CheckRouteCalls(stub func(string, string, string, int) (bool, ccv3.Warnings, error)) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = stub
}

func (fake *FakeCloudControllerClient) CheckRouteArgsForCall(i int) (string, string, string, int) {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	argsForCall := fake.checkRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) CheckRouteReturns(result1 bool, result2 ccv3.Warnings, result3 error) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = nil
	fake.checkRouteReturns = struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) ContinueDeployment(arg1 string) (ccv3.Warnings, error) {
	fake.continueDeploymentMutex.Lock()
	ret, specificReturn := fake.continueDeploymentReturnsOnCall[len(fake.continueDeploymentArgsForCall)]
	fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ContinueDeploymentStub
	fakeReturns := fake.continueDeploymentReturns
	fake.recordInvocation("ContinueDeployment", []interface{}{arg1})
	fake.continueDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) ContinueDeploymentCallCount() int {
	fake.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.RUnlock()
	return len(fake.continueDeploymentArgsForCall)
}

func (fake *FakeCloudControllerClient) ContinueDeploymentCalls(stub func(string) (ccv3.Warnings, error)) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = stub
}

func (fake *FakeCloudControllerClient) ContinueDeploymentArgsForCall(i int) string {
	fake.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.RUnlock()
	argsForCall := fake.continueDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) ContinueDeploymentReturns(result1 ccv3.Warnings, result2 error) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = nil
	fake.continueDeploymentReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ContinueDeploymentReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = nil
	if fake.continueDeploymentReturnsOnCall == nil {
		fake.continueDeploymentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.continueDeploymentReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) CopyPackage(arg1 string, arg2 string) (resources.Package, ccv3.Warnings, error) {
	fake.copyPackageMutex.Lock()
	ret, specificReturn := fake.copyPackageReturnsOnCall[len(fake.copyPackageArgsForCall)]
	fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.CopyPackageStub
	fakeReturns := fake.copyPackageReturns
	fake.recordInvocation("CopyPackage", []interface{}{arg1, arg2})
	fake.copyPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CopyPackageCallCount() int {
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	return len(fake.copyPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) CopyPackageCalls(stub func(string, string) (resources.Package, ccv3.Warnings, error)) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = stub
}

func (fake *FakeCloudControllerClient) CopyPackageArgsForCall(i int) (string, string) {
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	argsForCall := fake.copyPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CopyPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = nil
	fake.copyPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CopyPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = nil
	if fake.copyPackageReturnsOnCall == nil {
		fake.copyPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.copyPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) CreateApplicationCalls(stub func(resources.Application) (resources.Application, ccv3.Warnings, error)) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationArgsForCall(i int) resources.Application {
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	argsForCall := fake.createApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateApplicationReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = nil
	fake.createApplicationReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) CreateApplicationDeployment(arg1 resources.Deployment) (string, ccv3.Warnings, error) {
	fake.createApplicationDeploymentMutex.Lock()
	ret, specificReturn := fake.createApplicationDeploymentReturnsOnCall[len(fake.createApplicationDeploymentArgsForCall)]
	fake.createApplicationDeploymentArgsForCall = append(fake.createApplicationDeploymentArgsForCall, struct {
		arg1 resources.Deployment
	}{arg1})
	stub := fake.CreateApplicationDeploymentStub
	fakeReturns := fake.createApplicationDeploymentReturns
	fake.recordInvocation("CreateApplicationDeployment", []interface{}{arg1})
	fake.createApplicationDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationDeploymentCallCount() int {
	fake.createApplicationDeploymentMutex.RLock()
	defer fake.createApplicationDeploymentMutex.RUnlock()
	return len(fake.createApplicationDeploymentArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationDeploymentCalls(stub func(resources.Deployment) (string, ccv3.Warnings, error)) {
	fake.createApplicationDeploymentMutex.Lock()
	defer fake.createApplicationDeploymentMutex.Unlock()
	fake.CreateApplicationDeploymentStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationDeploymentArgsForCall(i int) resources.Deployment {
	fake.createApplicationDeploymentMutex.RLock()
	defer fake.createApplicationDeploymentMutex.RUnlock()
	argsForCall := fake.createApplicationDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateApplicationDeploymentReturns(result1 string, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationDeploymentMutex.Lock()
	defer fake.createApplicationDeploymentMutex.Unlock()
	fake.CreateApplicationDeploymentStub = nil
	fake.createApplicationDeploymentReturns = struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationDeploymentReturnsOnCall(i int, result1 string, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationDeploymentMutex.Lock()
	defer fake.createApplicationDeploymentMutex.Unlock()
	fake.CreateApplicationDeploymentStub = nil
	if fake.createApplicationDeploymentReturnsOnCall == nil {
		fake.createApplicationDeploymentReturnsOnCall = make(map[int]struct {
			result1 string
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationDeploymentReturnsOnCall[i] = struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScale(arg1 string, arg2 resources.Process) (resources.Process, ccv3.Warnings, error) {
	fake.createApplicationProcessScaleMutex.Lock()
	ret, specificReturn := fake.createApplicationProcessScaleReturnsOnCall[len(fake.createApplicationProcessScaleArgsForCall)]
	fake.createApplicationProcessScaleArgsForCall = append(fake.createApplicationProcessScaleArgsForCall, struct {
		arg1 string
		arg2 resources.Process
	}{arg1, arg2})
	stub := fake.CreateApplicationProcessScaleStub
	fakeReturns := fake.createApplicationProcessScaleReturns
	fake.recordInvocation("CreateApplicationProcessScale", []interface{}{arg1, arg2})
	fake.createApplicationProcessScaleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleCallCount() int {
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	return len(fake.createApplicationProcessScaleArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleCalls(stub func(string, resources.Process) (resources.Process, ccv3.Warnings, error)) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleArgsForCall(i int) (string, resources.Process) {
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	argsForCall := fake.createApplicationProcessScaleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = nil
	fake.createApplicationProcessScaleReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = nil
	if fake.createApplicationProcessScaleReturnsOnCall == nil {
		fake.createApplicationProcessScaleReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationProcessScaleReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationTask(arg1 string, arg2 resources.Task) (resources.Task, ccv3.Warnings, error) {
	fake.createApplicationTaskMutex.Lock()
	ret, specificReturn := fake.createApplicationTaskReturnsOnCall[len(fake.createApplicationTaskArgsForCall)]
	fake.createApplicationTaskArgsForCall = append(fake.createApplicationTaskArgsForCall, struct {
		arg1 string
		arg2 resources.Task
	}{arg1, arg2})
	stub := fake.CreateApplicationTaskStub
	fakeReturns := fake.createApplicationTaskReturns
	fake.recordInvocation("CreateApplicationTask", []interface{}{arg1, arg2})
	fake.createApplicationTaskMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskCallCount() int {
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	return len(fake.createApplicationTaskArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskCalls(stub func(string, resources.Task) (resources.Task, ccv3.Warnings, error)) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskArgsForCall(i int) (string, resources.Task) {
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	argsForCall := fake.createApplicationTaskArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = nil
	fake.createApplicationTaskReturns = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskReturnsOnCall(i int, result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = nil
	if fake.createApplicationTaskReturnsOnCall == nil {
		fake.createApplicationTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuild(arg1 resources.Build) (resources.Build, ccv3.Warnings, error) {
	fake.createBuildMutex.Lock()
	ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)]
	fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct {
		arg1 resources.Build
	}{arg1})
	stub := fake.CreateBuildStub
	fakeReturns := fake.createBuildReturns
	fake.recordInvocation("CreateBuild", []interface{}{arg1})
	fake.createBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateBuildCallCount() int {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	return len(fake.createBuildArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateBuildCalls(stub func(resources.Build) (resources.Build, ccv3.Warnings, error)) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = stub
}

func (fake *FakeCloudControllerClient) CreateBuildArgsForCall(i int) resources.Build {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	argsForCall := fake.createBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	fake.createBuildReturns = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildReturnsOnCall(i int, result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	if fake.createBuildReturnsOnCall == nil {
		fake.createBuildReturnsOnCall = make(map[int]struct {
			result1 resources.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createBuildReturnsOnCall[i] = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) {
	fake.createBuildpackMutex.Lock()
	ret, specificReturn := fake.createBuildpackReturnsOnCall[len(fake.createBuildpackArgsForCall)]
	fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, struct {
		arg1 resources.Buildpack
	}{arg1})
	stub := fake.CreateBuildpackStub
	fakeReturns := fake.createBuildpackReturns
	fake.recordInvocation("CreateBuildpack", []interface{}{arg1})
	fake.createBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateBuildpackCallCount() int {
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	return len(fake.createBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateBuildpackCalls(stub func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) CreateBuildpackArgsForCall(i int) resources.Buildpack {
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	argsForCall := fake.createBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateBuildpackReturns(result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = nil
	fake.createBuildpackReturns = struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildpackReturnsOnCall(i int, result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = nil
	if fake.createBuildpackReturnsOnCall == nil {
		fake.createBuildpackReturnsOnCall = make(map[int]struct {
			result1 resources.Buildpack
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createBuildpackReturnsOnCall[i] = struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateDomain(arg1 resources.Domain) (resources.Domain, ccv3.Warnings, error) {
	fake.createDomainMutex.Lock()
	ret, specificReturn := fake.createDomainReturnsOnCall[len(fake.createDomainArgsForCall)]
	fake.createDomainArgsForCall = append(fake.createDomainArgsForCall, struct {
		arg1 resources.Domain
	}{arg1})
	stub := fake.CreateDomainStub
	fakeReturns := fake.createDomainReturns
	fake.recordInvocation("CreateDomain", []interface{}{arg1})
	fake.createDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateDomainCallCount() int {
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	return len(fake.createDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateDomainCalls(stub func(resources.Domain) (resources.Domain, ccv3.Warnings, error)) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = stub
}

func (fake *FakeCloudControllerClient) CreateDomainArgsForCall(i int) resources.Domain {
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	argsForCall := fake.createDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = nil
	fake.createDomainReturns = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateDomainReturnsOnCall(i int, result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = nil
	if fake.createDomainReturnsOnCall == nil {
		fake.createDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateDroplet(arg1 string) (resources.Droplet, ccv3.Warnings, error) {
	fake.createDropletMutex.Lock()
	ret, specificReturn := fake.createDropletReturnsOnCall[len(fake.createDropletArgsForCall)]
	fake.createDropletArgsForCall = append(fake.createDropletArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CreateDropletStub
	fakeReturns := fake.createDropletReturns
	fake.recordInvocation("CreateDroplet", []interface{}{arg1})
	fake.createDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateDropletCallCount() int {
	fake.createDropletMutex.RLock()
	defer fake.createDropletMutex.RUnlock()
	return len(fake.createDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateDropletCalls(stub func(string) (resources.Droplet, ccv3.Warnings, error)) {
	fake.createDropletMutex.Lock()
	defer fake.createDropletMutex.Unlock()
	fake.CreateDropletStub = stub
}

func (fake *FakeCloudControllerClient) CreateDropletArgsForCall(i int) string {
	fake.createDropletMutex.RLock()
	defer fake.createDropletMutex.RUnlock()
	argsForCall := fake.createDropletArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateDropletReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.createDropletMutex.Lock()
	defer fake.createDropletMutex.Unlock()
	fake.CreateDropletStub = nil
	fake.createDropletReturns = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateDropletReturnsOnCall(i int, result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.createDropletMutex.Lock()
	defer fake.createDropletMutex.Unlock()
	fake.CreateDropletStub = nil
	if fake.createDropletReturnsOnCall == nil {
		fake.createDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createDropletReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateIsolationSegment(arg1 resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error) {
	fake.createIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.createIsolationSegmentReturnsOnCall[len(fake.createIsolationSegmentArgsForCall)]
	fake.createIsolationSegmentArgsForCall = append(fake.createIsolationSegmentArgsForCall, struct {
		arg1 resources.IsolationSegment
	}{arg1})
	stub := fake.CreateIsolationSegmentStub
	fakeReturns := fake.createIsolationSegmentReturns
	fake.recordInvocation("CreateIsolationSegment", []interface{}{arg1})
	fake.createIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentCallCount() int {
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	return len(fake.createIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentCalls(stub func(resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentArgsForCall(i int) resources.IsolationSegment {
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	argsForCall := fake.createIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = nil
	fake.createIsolationSegmentReturns = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturnsOnCall(i int, result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = nil
	if fake.createIsolationSegmentReturnsOnCall == nil {
		fake.createIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganization(arg1 string) (resources.Organization, ccv3.Warnings, error) {
	fake.createOrganizationMutex.Lock()
	ret, specificReturn := fake.createOrganizationReturnsOnCall[len(fake.createOrganizationArgsForCall)]
	fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.CreateOrganizationStub
	fakeReturns := fake.createOrganizationReturns
	fake.recordInvocation("CreateOrganization", []interface{}{arg1})
	fake.createOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateOrganizationCallCount() int {
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	return len(fake.createOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateOrganizationCalls(stub func(string) (resources.Organization, ccv3.Warnings, error)) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) CreateOrganizationArgsForCall(i int) string {
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	argsForCall := fake.createOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = nil
	fake.createOrganizationReturns = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganizationReturnsOnCall(i int, result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = nil
	if fake.createOrganizationReturnsOnCall == nil {
		fake.createOrganizationReturnsOnCall = make(map[int]struct {
			result1 resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createOrganizationReturnsOnCall[i] = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuota(arg1 resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) {
	fake.createOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.createOrganizationQuotaReturnsOnCall[len(fake.createOrganizationQuotaArgsForCall)]
	fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, struct {
		arg1 resources.OrganizationQuota
	}{arg1})
	stub := fake.CreateOrganizationQuotaStub
	fakeReturns := fake.createOrganizationQuotaReturns
	fake.recordInvocation("CreateOrganizationQuota", []interface{}{arg1})
	fake.createOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuotaCallCount() int {
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	return len(fake.createOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuotaCalls(stub func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error)) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = stub
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuotaArgsForCall(i int) resources.OrganizationQuota {
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.createOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = nil
	fake.createOrganizationQuotaReturns = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganizationQuotaReturnsOnCall(i int, result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = nil
	if fake.createOrganizationQuotaReturnsOnCall == nil {
		fake.createOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.OrganizationQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createOrganizationQuotaReturnsOnCall[i] = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreatePackage(arg1 resources.Package) (resources.Package, ccv3.Warnings, error) {
	fake.createPackageMutex.Lock()
	ret, specificReturn := fake.createPackageReturnsOnCall[len(fake.createPackageArgsForCall)]
	fake.createPackageArgsForCall = append(fake.createPackageArgsForCall, struct {
		arg1 resources.Package
	}{arg1})
	stub := fake.CreatePackageStub
	fakeReturns := fake.createPackageReturns
	fake.recordInvocation("CreatePackage", []interface{}{arg1})
	fake.createPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreatePackageCallCount() int {
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	return len(fake.createPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) CreatePackageCalls(stub func(resources.Package) (resources.Package, ccv3.Warnings, error)) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = stub
}

func (fake *FakeCloudControllerClient) CreatePackageArgsForCall(i int) resources.Package {
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	argsForCall := fake.createPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreatePackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = nil
	fake.createPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreatePackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = nil
	if fake.createPackageReturnsOnCall == nil {
		fake.createPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRole(arg1 resources.Role) (resources.Role, ccv3.Warnings, error) {
	fake.createRoleMutex.Lock()
	ret, specificReturn := fake.createRoleReturnsOnCall[len(fake.createRoleArgsForCall)]
	fake.createRoleArgsForCall = append(fake.createRoleArgsForCall, struct {
		arg1 resources.Role
	}{arg1})
	stub := fake.CreateRoleStub
	fakeReturns := fake.createRoleReturns
	fake.recordInvocation("CreateRole", []interface{}{arg1})
	fake.createRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateRoleCallCount() int {
	fake.createRoleMutex.RLock()
	defer fake.createRoleMutex.RUnlock()
	return len(fake.createRoleArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateRoleCalls(stub func(resources.Role) (resources.Role, ccv3.Warnings, error)) {
	fake.createRoleMutex.Lock()
	defer fake.createRoleMutex.Unlock()
	fake.CreateRoleStub = stub
}

func (fake *FakeCloudControllerClient) CreateRoleArgsForCall(i int) resources.Role {
	fake.createRoleMutex.RLock()
	defer fake.createRoleMutex.RUnlock()
	argsForCall := fake.createRoleArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateRoleReturns(result1 resources.Role, result2 ccv3.Warnings, result3 error) {
	fake.createRoleMutex.Lock()
	defer fake.createRoleMutex.Unlock()
	fake.CreateRoleStub = nil
	fake.createRoleReturns = struct {
		result1 resources.Role
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRoleReturnsOnCall(i int, result1 resources.Role, result2 ccv3.Warnings, result3 error) {
	fake.createRoleMutex.Lock()
	defer fake.createRoleMutex.Unlock()
	fake.CreateRoleStub = nil
	if fake.createRoleReturnsOnCall == nil {
		fake.createRoleReturnsOnCall = make(map[int]struct {
			result1 resources.Role
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createRoleReturnsOnCall[i] = struct {
		result1 resources.Role
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) CreateRouteCalls(stub func(resources.Route) (resources.Route, ccv3.Warnings, error)) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = stub
}

func (fake *FakeCloudControllerClient) CreateRouteArgsForCall(i int) resources.Route {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	argsForCall := fake.createRouteArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateRouteReturns(result1 resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = nil
	fake.createRouteReturns = struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) CreateRouteBinding(arg1 resources.RouteBinding) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.createRouteBindingMutex.Lock()
	ret, specificReturn := fake.createRouteBindingReturnsOnCall[len(fake.createRouteBindingArgsForCall)]
	fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, struct {
		arg1 resources.RouteBinding
	}{arg1})
	stub := fake.CreateRouteBindingStub
	fakeReturns := fake.createRouteBindingReturns
	fake.recordInvocation("CreateRouteBinding", []interface{}{arg1})
	fake.createRouteBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateRouteBindingCallCount() int {
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	return len(fake.createRouteBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateRouteBindingCalls(stub func(resources.RouteBinding) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = stub
}

func (fake *FakeCloudControllerClient) CreateRouteBindingArgsForCall(i int) resources.RouteBinding {
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	argsForCall := fake.createRouteBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateRouteBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = nil
	fake.createRouteBindingReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRouteBindingReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = nil
	if fake.createRouteBindingReturnsOnCall == nil {
		fake.createRouteBindingReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createRouteBindingReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSecurityGroup(arg1 resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) {
	fake.createSecurityGroupMutex.Lock()
	ret, specificReturn := fake.createSecurityGroupReturnsOnCall[len(fake.createSecurityGroupArgsForCall)]
	fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, struct {
		arg1 resources.SecurityGroup
	}{arg1})
	stub := fake.CreateSecurityGroupStub
	fakeReturns := fake.createSecurityGroupReturns
	fake.recordInvocation("CreateSecurityGroup", []interface{}{arg1})
	fake.createSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateSecurityGroupCallCount() int {
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	return len(fake.createSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateSecurityGroupCalls(stub func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error)) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = stub
}

func (fake *FakeCloudControllerClient) CreateSecurityGroupArgsForCall(i int) resources.SecurityGroup {
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	argsForCall := fake.createSecurityGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateSecurityGroupReturns(result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = nil
	fake.createSecurityGroupReturns = struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSecurityGroupReturnsOnCall(i int, result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = nil
	if fake.createSecurityGroupReturnsOnCall == nil {
		fake.createSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 resources.SecurityGroup
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createSecurityGroupReturnsOnCall[i] = struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBroker(arg1 resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.createServiceBrokerMutex.Lock()
	ret, specificReturn := fake.createServiceBrokerReturnsOnCall[len(fake.createServiceBrokerArgsForCall)]
	fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, struct {
		arg1 resources.ServiceBroker
	}{arg1})
	stub := fake.CreateServiceBrokerStub
	fakeReturns := fake.createServiceBrokerReturns
	fake.recordInvocation("CreateServiceBroker", []interface{}{arg1})
	fake.createServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerCallCount() int {
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	return len(fake.createServiceBrokerArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerCalls(stub func(resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerArgsForCall(i int) resources.ServiceBroker {
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	argsForCall := fake.createServiceBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = nil
	fake.createServiceBrokerReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = nil
	if fake.createServiceBrokerReturnsOnCall == nil {
		fake.createServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createServiceBrokerReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBinding(arg1 resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.createServiceCredentialBindingMutex.Lock()
	ret, specificReturn := fake.createServiceCredentialBindingReturnsOnCall[len(fake.createServiceCredentialBindingArgsForCall)]
	fake.createServiceCredentialBindingArgsForCall = append(fake.createServiceCredentialBindingArgsForCall, struct {
		arg1 resources.ServiceCredentialBinding
	}{arg1})
	stub := fake.CreateServiceCredentialBindingStub
	fakeReturns := fake.createServiceCredentialBindingReturns
	fake.recordInvocation("CreateServiceCredentialBinding", []interface{}{arg1})
	fake.createServiceCredentialBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingCallCount() int {
	fake.createServiceCredentialBindingMutex.RLock()
	defer fake.createServiceCredentialBindingMutex.RUnlock()
	return len(fake.createServiceCredentialBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingCalls(stub func(resources.ServiceCredentialBinding) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.createServiceCredentialBindingMutex.Lock()
	defer fake.createServiceCredentialBindingMutex.Unlock()
	fake.CreateServiceCredentialBindingStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingArgsForCall(i int) resources.ServiceCredentialBinding {
	fake.createServiceCredentialBindingMutex.RLock()
	defer fake.createServiceCredentialBindingMutex.RUnlock()
	argsForCall := fake.createServiceCredentialBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceCredentialBindingMutex.Lock()
	defer fake.createServiceCredentialBindingMutex.Unlock()
	fake.CreateServiceCredentialBindingStub = nil
	fake.createServiceCredentialBindingReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceCredentialBindingReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceCredentialBindingMutex.Lock()
	defer fake.createServiceCredentialBindingMutex.Unlock()
	fake.CreateServiceCredentialBindingStub = nil
	if fake.createServiceCredentialBindingReturnsOnCall == nil {
		fake.createServiceCredentialBindingReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createServiceCredentialBindingReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceInstance(arg1 resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.createServiceInstanceMutex.Lock()
	ret, specificReturn := fake.createServiceInstanceReturnsOnCall[len(fake.createServiceInstanceArgsForCall)]
	fake.createServiceInstanceArgsForCall = append(fake.createServiceInstanceArgsForCall, struct {
		arg1 resources.ServiceInstance
	}{arg1})
	stub := fake.CreateServiceInstanceStub
	fakeReturns := fake.createServiceInstanceReturns
	fake.recordInvocation("CreateServiceInstance", []interface{}{arg1})
	fake.createServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceInstanceCallCount() int {
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	return len(fake.createServiceInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceInstanceCalls(stub func(resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceInstanceArgsForCall(i int) resources.ServiceInstance {
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	argsForCall := fake.createServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = nil
	fake.createServiceInstanceReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceInstanceReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.createServiceInstanceMutex.Lock()
	defer fake.createServiceInstanceMutex.Unlock()
	fake.CreateServiceInstanceStub = nil
	if fake.createServiceInstanceReturnsOnCall == nil {
		fake.createServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createServiceInstanceReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSpace(arg1 resources.Space) (resources.Space, ccv3.Warnings, error) {
	fake.createSpaceMutex.Lock()
	ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)]
	fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct {
		arg1 resources.Space
	}{arg1})
	stub := fake.CreateSpaceStub
	fakeReturns := fake.createSpaceReturns
	fake.recordInvocation("CreateSpace", []interface{}{arg1})
	fake.createSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateSpaceCallCount() int {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	return len(fake.createSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateSpaceCalls(stub func(resources.Space) (resources.Space, ccv3.Warnings, error)) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = stub
}

func (fake *FakeCloudControllerClient) CreateSpaceArgsForCall(i int) resources.Space {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	argsForCall := fake.createSpaceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateSpaceReturns(result1 resources.Space, result2 ccv3.Warnings, result3 error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = nil
	fake.createSpaceReturns = struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSpaceReturnsOnCall(i int, result1 resources.Space, result2 ccv3.Warnings, result3 error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = nil
	if fake.createSpaceReturnsOnCall == nil {
		fake.createSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Space
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createSpaceReturnsOnCall[i] = struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSpaceQuota(arg1 resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) {
	fake.createSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.createSpaceQuotaReturnsOnCall[len(fake.createSpaceQuotaArgsForCall)]
	fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, struct {
		arg1 resources.SpaceQuota
	}{arg1})
	stub := fake.CreateSpaceQuotaStub
	fakeReturns := fake.createSpaceQuotaReturns
	fake.recordInvocation("CreateSpaceQuota", []interface{}{arg1})
	fake.createSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateSpaceQuotaCallCount() int {
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	return len(fake.createSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateSpaceQuotaCalls(stub func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error)) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) CreateSpaceQuotaArgsForCall(i int) resources.SpaceQuota {
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	argsForCall := fake.createSpaceQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = nil
	fake.createSpaceQuotaReturns = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSpaceQuotaReturnsOnCall(i int, result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = nil
	if fake.createSpaceQuotaReturnsOnCall == nil {
		fake.createSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.SpaceQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createSpaceQuotaReturnsOnCall[i] = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) CreateUserCalls(stub func(string) (resources.User, ccv3.Warnings, error)) {
	fake.createUserMutex.Lock()
	defer fake.createUserMutex.Unlock()
	fake.CreateUserStub = stub
}

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

func (fake *FakeCloudControllerClient) CreateUserReturns(result1 resources.User, result2 ccv3.Warnings, result3 error) {
	fake.createUserMutex.Lock()
	defer fake.createUserMutex.Unlock()
	fake.CreateUserStub = nil
	fake.createUserReturns = struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) DeleteApplication(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteApplicationMutex.Lock()
	ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)]
	fake.deleteApplicationArgsForCall = append(fake.deleteApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteApplicationStub
	fakeReturns := fake.deleteApplicationReturns
	fake.recordInvocation("DeleteApplication", []interface{}{arg1})
	fake.deleteApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteApplicationCallCount() int {
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	return len(fake.deleteApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteApplicationCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = stub
}

func (fake *FakeCloudControllerClient) DeleteApplicationArgsForCall(i int) string {
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	argsForCall := fake.deleteApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteApplicationReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = nil
	fake.deleteApplicationReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteApplicationReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = nil
	if fake.deleteApplicationReturnsOnCall == nil {
		fake.deleteApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteApplicationReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstance(arg1 string, arg2 string, arg3 int) (ccv3.Warnings, error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	ret, specificReturn := fake.deleteApplicationProcessInstanceReturnsOnCall[len(fake.deleteApplicationProcessInstanceArgsForCall)]
	fake.deleteApplicationProcessInstanceArgsForCall = append(fake.deleteApplicationProcessInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 int
	}{arg1, arg2, arg3})
	stub := fake.DeleteApplicationProcessInstanceStub
	fakeReturns := fake.deleteApplicationProcessInstanceReturns
	fake.recordInvocation("DeleteApplicationProcessInstance", []interface{}{arg1, arg2, arg3})
	fake.deleteApplicationProcessInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceCallCount() int {
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	return len(fake.deleteApplicationProcessInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceCalls(stub func(string, string, int) (ccv3.Warnings, error)) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = stub
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceArgsForCall(i int) (string, string, int) {
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	argsForCall := fake.deleteApplicationProcessInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = nil
	fake.deleteApplicationProcessInstanceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = nil
	if fake.deleteApplicationProcessInstanceReturnsOnCall == nil {
		fake.deleteApplicationProcessInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteApplicationProcessInstanceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteBuildpack(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteBuildpackMutex.Lock()
	ret, specificReturn := fake.deleteBuildpackReturnsOnCall[len(fake.deleteBuildpackArgsForCall)]
	fake.deleteBuildpackArgsForCall = append(fake.deleteBuildpackArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteBuildpackStub
	fakeReturns := fake.deleteBuildpackReturns
	fake.recordInvocation("DeleteBuildpack", []interface{}{arg1})
	fake.deleteBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteBuildpackCallCount() int {
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	return len(fake.deleteBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteBuildpackCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) DeleteBuildpackArgsForCall(i int) string {
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	argsForCall := fake.deleteBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteBuildpackReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = nil
	fake.deleteBuildpackReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteBuildpackReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = nil
	if fake.deleteBuildpackReturnsOnCall == nil {
		fake.deleteBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteBuildpackReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteDomain(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteDomainMutex.Lock()
	ret, specificReturn := fake.deleteDomainReturnsOnCall[len(fake.deleteDomainArgsForCall)]
	fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteDomainStub
	fakeReturns := fake.deleteDomainReturns
	fake.recordInvocation("DeleteDomain", []interface{}{arg1})
	fake.deleteDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteDomainCallCount() int {
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	return len(fake.deleteDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteDomainCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = stub
}

func (fake *FakeCloudControllerClient) DeleteDomainArgsForCall(i int) string {
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	argsForCall := fake.deleteDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteDomainReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = nil
	fake.deleteDomainReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteDomainReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = nil
	if fake.deleteDomainReturnsOnCall == nil {
		fake.deleteDomainReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteDomainReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegment(arg1 string) (ccv3.Warnings, error) {
	fake.deleteIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentReturnsOnCall[len(fake.deleteIsolationSegmentArgsForCall)]
	fake.deleteIsolationSegmentArgsForCall = append(fake.deleteIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteIsolationSegmentStub
	fakeReturns := fake.deleteIsolationSegmentReturns
	fake.recordInvocation("DeleteIsolationSegment", []interface{}{arg1})
	fake.deleteIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentCallCount() int {
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	return len(fake.deleteIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentCalls(stub func(string) (ccv3.Warnings, error)) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentArgsForCall(i int) string {
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	argsForCall := fake.deleteIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = nil
	fake.deleteIsolationSegmentReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = nil
	if fake.deleteIsolationSegmentReturnsOnCall == nil {
		fake.deleteIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganization(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentOrganizationReturnsOnCall[len(fake.deleteIsolationSegmentOrganizationArgsForCall)]
	fake.deleteIsolationSegmentOrganizationArgsForCall = append(fake.deleteIsolationSegmentOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteIsolationSegmentOrganizationStub
	fakeReturns := fake.deleteIsolationSegmentOrganizationReturns
	fake.recordInvocation("DeleteIsolationSegmentOrganization", []interface{}{arg1, arg2})
	fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationCallCount() int {
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	return len(fake.deleteIsolationSegmentOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationArgsForCall(i int) (string, string) {
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	argsForCall := fake.deleteIsolationSegmentOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = nil
	fake.deleteIsolationSegmentOrganizationReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = nil
	if fake.deleteIsolationSegmentOrganizationReturnsOnCall == nil {
		fake.deleteIsolationSegmentOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentOrganizationReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteOrganization(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteOrganizationMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationReturnsOnCall[len(fake.deleteOrganizationArgsForCall)]
	fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteOrganizationStub
	fakeReturns := fake.deleteOrganizationReturns
	fake.recordInvocation("DeleteOrganization", []interface{}{arg1})
	fake.deleteOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) DeleteOrganizationCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteOrganizationReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = nil
	fake.deleteOrganizationReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = nil
	if fake.deleteOrganizationReturnsOnCall == nil {
		fake.deleteOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteOrganizationReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuota(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationQuotaReturnsOnCall[len(fake.deleteOrganizationQuotaArgsForCall)]
	fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteOrganizationQuotaStub
	fakeReturns := fake.deleteOrganizationQuotaReturns
	fake.recordInvocation("DeleteOrganizationQuota", []interface{}{arg1})
	fake.deleteOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaCallCount() int {
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	return len(fake.deleteOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = stub
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaArgsForCall(i int) string {
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.deleteOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = nil
	fake.deleteOrganizationQuotaReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationQuotaReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = nil
	if fake.deleteOrganizationQuotaReturnsOnCall == nil {
		fake.deleteOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteOrganizationQuotaReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutes(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	ret, specificReturn := fake.deleteOrphanedRoutesReturnsOnCall[len(fake.deleteOrphanedRoutesArgsForCall)]
	fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteOrphanedRoutesStub
	fakeReturns := fake.deleteOrphanedRoutesReturns
	fake.recordInvocation("DeleteOrphanedRoutes", []interface{}{arg1})
	fake.deleteOrphanedRoutesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesCallCount() int {
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	return len(fake.deleteOrphanedRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = stub
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesArgsForCall(i int) string {
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	argsForCall := fake.deleteOrphanedRoutesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = nil
	fake.deleteOrphanedRoutesReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrphanedRoutesReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = nil
	if fake.deleteOrphanedRoutesReturnsOnCall == nil {
		fake.deleteOrphanedRoutesReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteOrphanedRoutesReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRole(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteRoleMutex.Lock()
	ret, specificReturn := fake.deleteRoleReturnsOnCall[len(fake.deleteRoleArgsForCall)]
	fake.deleteRoleArgsForCall = append(fake.deleteRoleArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteRoleStub
	fakeReturns := fake.deleteRoleReturns
	fake.recordInvocation("DeleteRole", []interface{}{arg1})
	fake.deleteRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteRoleCallCount() int {
	fake.deleteRoleMutex.RLock()
	defer fake.deleteRoleMutex.RUnlock()
	return len(fake.deleteRoleArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteRoleCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteRoleMutex.Lock()
	defer fake.deleteRoleMutex.Unlock()
	fake.DeleteRoleStub = stub
}

func (fake *FakeCloudControllerClient) DeleteRoleArgsForCall(i int) string {
	fake.deleteRoleMutex.RLock()
	defer fake.deleteRoleMutex.RUnlock()
	argsForCall := fake.deleteRoleArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteRoleReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRoleMutex.Lock()
	defer fake.deleteRoleMutex.Unlock()
	fake.DeleteRoleStub = nil
	fake.deleteRoleReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRoleReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRoleMutex.Lock()
	defer fake.deleteRoleMutex.Unlock()
	fake.DeleteRoleStub = nil
	if fake.deleteRoleReturnsOnCall == nil {
		fake.deleteRoleReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteRoleReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRoute(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteRouteMutex.Lock()
	ret, specificReturn := fake.deleteRouteReturnsOnCall[len(fake.deleteRouteArgsForCall)]
	fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteRouteStub
	fakeReturns := fake.deleteRouteReturns
	fake.recordInvocation("DeleteRoute", []interface{}{arg1})
	fake.deleteRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) DeleteRouteCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteRouteReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = nil
	fake.deleteRouteReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRouteReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = nil
	if fake.deleteRouteReturnsOnCall == nil {
		fake.deleteRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteRouteReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRouteBinding(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteRouteBindingMutex.Lock()
	ret, specificReturn := fake.deleteRouteBindingReturnsOnCall[len(fake.deleteRouteBindingArgsForCall)]
	fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteRouteBindingStub
	fakeReturns := fake.deleteRouteBindingReturns
	fake.recordInvocation("DeleteRouteBinding", []interface{}{arg1})
	fake.deleteRouteBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteRouteBindingCallCount() int {
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	return len(fake.deleteRouteBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteRouteBindingCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = stub
}

func (fake *FakeCloudControllerClient) DeleteRouteBindingArgsForCall(i int) string {
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	argsForCall := fake.deleteRouteBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteRouteBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = nil
	fake.deleteRouteBindingReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRouteBindingReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = nil
	if fake.deleteRouteBindingReturnsOnCall == nil {
		fake.deleteRouteBindingReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteRouteBindingReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroup(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteSecurityGroupMutex.Lock()
	ret, specificReturn := fake.deleteSecurityGroupReturnsOnCall[len(fake.deleteSecurityGroupArgsForCall)]
	fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteSecurityGroupStub
	fakeReturns := fake.deleteSecurityGroupReturns
	fake.recordInvocation("DeleteSecurityGroup", []interface{}{arg1})
	fake.deleteSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupCallCount() int {
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	return len(fake.deleteSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = stub
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupArgsForCall(i int) string {
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	argsForCall := fake.deleteSecurityGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = nil
	fake.deleteSecurityGroupReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = nil
	if fake.deleteSecurityGroupReturnsOnCall == nil {
		fake.deleteSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteSecurityGroupReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceBroker(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteServiceBrokerMutex.Lock()
	ret, specificReturn := fake.deleteServiceBrokerReturnsOnCall[len(fake.deleteServiceBrokerArgsForCall)]
	fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteServiceBrokerStub
	fakeReturns := fake.deleteServiceBrokerReturns
	fake.recordInvocation("DeleteServiceBroker", []interface{}{arg1})
	fake.deleteServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteServiceBrokerCallCount() int {
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	return len(fake.deleteServiceBrokerArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceBrokerCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServiceBrokerArgsForCall(i int) string {
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	argsForCall := fake.deleteServiceBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = nil
	fake.deleteServiceBrokerReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceBrokerReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = nil
	if fake.deleteServiceBrokerReturnsOnCall == nil {
		fake.deleteServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteServiceBrokerReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBinding(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteServiceCredentialBindingMutex.Lock()
	ret, specificReturn := fake.deleteServiceCredentialBindingReturnsOnCall[len(fake.deleteServiceCredentialBindingArgsForCall)]
	fake.deleteServiceCredentialBindingArgsForCall = append(fake.deleteServiceCredentialBindingArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteServiceCredentialBindingStub
	fakeReturns := fake.deleteServiceCredentialBindingReturns
	fake.recordInvocation("DeleteServiceCredentialBinding", []interface{}{arg1})
	fake.deleteServiceCredentialBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingCallCount() int {
	fake.deleteServiceCredentialBindingMutex.RLock()
	defer fake.deleteServiceCredentialBindingMutex.RUnlock()
	return len(fake.deleteServiceCredentialBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteServiceCredentialBindingMutex.Lock()
	defer fake.deleteServiceCredentialBindingMutex.Unlock()
	fake.DeleteServiceCredentialBindingStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingArgsForCall(i int) string {
	fake.deleteServiceCredentialBindingMutex.RLock()
	defer fake.deleteServiceCredentialBindingMutex.RUnlock()
	argsForCall := fake.deleteServiceCredentialBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceCredentialBindingMutex.Lock()
	defer fake.deleteServiceCredentialBindingMutex.Unlock()
	fake.DeleteServiceCredentialBindingStub = nil
	fake.deleteServiceCredentialBindingReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceCredentialBindingReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceCredentialBindingMutex.Lock()
	defer fake.deleteServiceCredentialBindingMutex.Unlock()
	fake.DeleteServiceCredentialBindingStub = nil
	if fake.deleteServiceCredentialBindingReturnsOnCall == nil {
		fake.deleteServiceCredentialBindingReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteServiceCredentialBindingReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceInstance(arg1 string, arg2 ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteServiceInstanceMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceReturnsOnCall[len(fake.deleteServiceInstanceArgsForCall)]
	fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.DeleteServiceInstanceStub
	fakeReturns := fake.deleteServiceInstanceReturns
	fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2})
	fake.deleteServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceCallCount() int {
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	return len(fake.deleteServiceInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceCalls(stub func(string, ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceArgsForCall(i int) (string, []ccv3.Query) {
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	argsForCall := fake.deleteServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = nil
	fake.deleteServiceInstanceReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = nil
	if fake.deleteServiceInstanceReturnsOnCall == nil {
		fake.deleteServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteServiceInstanceReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibility(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	ret, specificReturn := fake.deleteServicePlanVisibilityReturnsOnCall[len(fake.deleteServicePlanVisibilityArgsForCall)]
	fake.deleteServicePlanVisibilityArgsForCall = append(fake.deleteServicePlanVisibilityArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteServicePlanVisibilityStub
	fakeReturns := fake.deleteServicePlanVisibilityReturns
	fake.recordInvocation("DeleteServicePlanVisibility", []interface{}{arg1, arg2})
	fake.deleteServicePlanVisibilityMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityCallCount() int {
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	return len(fake.deleteServicePlanVisibilityArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityArgsForCall(i int) (string, string) {
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	argsForCall := fake.deleteServicePlanVisibilityArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = nil
	fake.deleteServicePlanVisibilityReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = nil
	if fake.deleteServicePlanVisibilityReturnsOnCall == nil {
		fake.deleteServicePlanVisibilityReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteServicePlanVisibilityReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

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

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

func (fake *FakeCloudControllerClient) DeleteSpaceCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteSpaceMutex.Lock()
	defer fake.deleteSpaceMutex.Unlock()
	fake.DeleteSpaceStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteSpaceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSpaceMutex.Lock()
	defer fake.deleteSpaceMutex.Unlock()
	fake.DeleteSpaceStub = nil
	fake.deleteSpaceReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSpaceReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSpaceMutex.Lock()
	defer fake.deleteSpaceMutex.Unlock()
	fake.DeleteSpaceStub = nil
	if fake.deleteSpaceReturnsOnCall == nil {
		fake.deleteSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteSpaceReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuota(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.deleteSpaceQuotaReturnsOnCall[len(fake.deleteSpaceQuotaArgsForCall)]
	fake.deleteSpaceQuotaArgsForCall = append(fake.deleteSpaceQuotaArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteSpaceQuotaStub
	fakeReturns := fake.deleteSpaceQuotaReturns
	fake.recordInvocation("DeleteSpaceQuota", []interface{}{arg1})
	fake.deleteSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuotaCallCount() int {
	fake.deleteSpaceQuotaMutex.RLock()
	defer fake.deleteSpaceQuotaMutex.RUnlock()
	return len(fake.deleteSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuotaCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteSpaceQuotaMutex.Lock()
	defer fake.deleteSpaceQuotaMutex.Unlock()
	fake.DeleteSpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuotaArgsForCall(i int) string {
	fake.deleteSpaceQuotaMutex.RLock()
	defer fake.deleteSpaceQuotaMutex.RUnlock()
	argsForCall := fake.deleteSpaceQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuotaReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSpaceQuotaMutex.Lock()
	defer fake.deleteSpaceQuotaMutex.Unlock()
	fake.DeleteSpaceQuotaStub = nil
	fake.deleteSpaceQuotaReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSpaceQuotaReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteSpaceQuotaMutex.Lock()
	defer fake.deleteSpaceQuotaMutex.Unlock()
	fake.DeleteSpaceQuotaStub = nil
	if fake.deleteSpaceQuotaReturnsOnCall == nil {
		fake.deleteSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteSpaceQuotaReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteUser(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteUserMutex.Lock()
	ret, specificReturn := fake.deleteUserReturnsOnCall[len(fake.deleteUserArgsForCall)]
	fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteUserStub
	fakeReturns := fake.deleteUserReturns
	fake.recordInvocation("DeleteUser", []interface{}{arg1})
	fake.deleteUserMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteUserCallCount() int {
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	return len(fake.deleteUserArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteUserCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = stub
}

func (fake *FakeCloudControllerClient) DeleteUserArgsForCall(i int) string {
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	argsForCall := fake.deleteUserArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteUserReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = nil
	fake.deleteUserReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteUserReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = nil
	if fake.deleteUserReturnsOnCall == nil {
		fake.deleteUserReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteUserReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DownloadDroplet(arg1 string) ([]byte, ccv3.Warnings, error) {
	fake.downloadDropletMutex.Lock()
	ret, specificReturn := fake.downloadDropletReturnsOnCall[len(fake.downloadDropletArgsForCall)]
	fake.downloadDropletArgsForCall = append(fake.downloadDropletArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DownloadDropletStub
	fakeReturns := fake.downloadDropletReturns
	fake.recordInvocation("DownloadDroplet", []interface{}{arg1})
	fake.downloadDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DownloadDropletCallCount() int {
	fake.downloadDropletMutex.RLock()
	defer fake.downloadDropletMutex.RUnlock()
	return len(fake.downloadDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) DownloadDropletCalls(stub func(string) ([]byte, ccv3.Warnings, error)) {
	fake.downloadDropletMutex.Lock()
	defer fake.downloadDropletMutex.Unlock()
	fake.DownloadDropletStub = stub
}

func (fake *FakeCloudControllerClient) DownloadDropletArgsForCall(i int) string {
	fake.downloadDropletMutex.RLock()
	defer fake.downloadDropletMutex.RUnlock()
	argsForCall := fake.downloadDropletArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DownloadDropletReturns(result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.downloadDropletMutex.Lock()
	defer fake.downloadDropletMutex.Unlock()
	fake.DownloadDropletStub = nil
	fake.downloadDropletReturns = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DownloadDropletReturnsOnCall(i int, result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.downloadDropletMutex.Lock()
	defer fake.downloadDropletMutex.Unlock()
	fake.DownloadDropletStub = nil
	if fake.downloadDropletReturnsOnCall == nil {
		fake.downloadDropletReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.downloadDropletReturnsOnCall[i] = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizations(arg1 string, arg2 []string) (resources.RelationshipList, ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	ret, specificReturn := fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)]
	fake.entitleIsolationSegmentToOrganizationsArgsForCall = append(fake.entitleIsolationSegmentToOrganizationsArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.EntitleIsolationSegmentToOrganizationsStub
	fakeReturns := fake.entitleIsolationSegmentToOrganizationsReturns
	fake.recordInvocation("EntitleIsolationSegmentToOrganizations", []interface{}{arg1, arg2Copy})
	fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsCallCount() int {
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	return len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsCalls(stub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = stub
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsArgsForCall(i int) (string, []string) {
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	argsForCall := fake.entitleIsolationSegmentToOrganizationsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = nil
	fake.entitleIsolationSegmentToOrganizationsReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = nil
	if fake.entitleIsolationSegmentToOrganizationsReturnsOnCall == nil {
		fake.entitleIsolationSegmentToOrganizationsReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, ccv3.Warnings, error) {
	fake.getAppFeatureMutex.Lock()
	ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)]
	fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetAppFeatureStub
	fakeReturns := fake.getAppFeatureReturns
	fake.recordInvocation("GetAppFeature", []interface{}{arg1, arg2})
	fake.getAppFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetAppFeatureCallCount() int {
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	return len(fake.getAppFeatureArgsForCall)
}

func (fake *FakeCloudControllerClient) GetAppFeatureCalls(stub func(string, string) (resources.ApplicationFeature, ccv3.Warnings, error)) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = stub
}

func (fake *FakeCloudControllerClient) GetAppFeatureArgsForCall(i int) (string, string) {
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	argsForCall := fake.getAppFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetAppFeatureReturns(result1 resources.ApplicationFeature, result2 ccv3.Warnings, result3 error) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = nil
	fake.getAppFeatureReturns = struct {
		result1 resources.ApplicationFeature
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetAppFeatureReturnsOnCall(i int, result1 resources.ApplicationFeature, result2 ccv3.Warnings, result3 error) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = nil
	if fake.getAppFeatureReturnsOnCall == nil {
		fake.getAppFeatureReturnsOnCall = make(map[int]struct {
			result1 resources.ApplicationFeature
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getAppFeatureReturnsOnCall[i] = struct {
		result1 resources.ApplicationFeature
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpace(arg1 string, arg2 string) (resources.Application, ccv3.Warnings, error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getApplicationByNameAndSpaceReturnsOnCall[len(fake.getApplicationByNameAndSpaceArgsForCall)]
	fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetApplicationByNameAndSpaceStub
	fakeReturns := fake.getApplicationByNameAndSpaceReturns
	fake.recordInvocation("GetApplicationByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceCallCount() int {
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	return len(fake.getApplicationByNameAndSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceCalls(stub func(string, string) (resources.Application, ccv3.Warnings, error)) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getApplicationByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = nil
	fake.getApplicationByNameAndSpaceReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationByNameAndSpaceReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = nil
	if fake.getApplicationByNameAndSpaceReturnsOnCall == nil {
		fake.getApplicationByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationByNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrent(arg1 string) (resources.Droplet, ccv3.Warnings, error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	ret, specificReturn := fake.getApplicationDropletCurrentReturnsOnCall[len(fake.getApplicationDropletCurrentArgsForCall)]
	fake.getApplicationDropletCurrentArgsForCall = append(fake.getApplicationDropletCurrentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationDropletCurrentStub
	fakeReturns := fake.getApplicationDropletCurrentReturns
	fake.recordInvocation("GetApplicationDropletCurrent", []interface{}{arg1})
	fake.getApplicationDropletCurrentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentCallCount() int {
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	return len(fake.getApplicationDropletCurrentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentCalls(stub func(string) (resources.Droplet, ccv3.Warnings, error)) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentArgsForCall(i int) string {
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	argsForCall := fake.getApplicationDropletCurrentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = nil
	fake.getApplicationDropletCurrentReturns = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturnsOnCall(i int, result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = nil
	if fake.getApplicationDropletCurrentReturnsOnCall == nil {
		fake.getApplicationDropletCurrentReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationDropletCurrentReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironment(arg1 string) (ccv3.Environment, ccv3.Warnings, error) {
	fake.getApplicationEnvironmentMutex.Lock()
	ret, specificReturn := fake.getApplicationEnvironmentReturnsOnCall[len(fake.getApplicationEnvironmentArgsForCall)]
	fake.getApplicationEnvironmentArgsForCall = append(fake.getApplicationEnvironmentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationEnvironmentStub
	fakeReturns := fake.getApplicationEnvironmentReturns
	fake.recordInvocation("GetApplicationEnvironment", []interface{}{arg1})
	fake.getApplicationEnvironmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentCallCount() int {
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	return len(fake.getApplicationEnvironmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentCalls(stub func(string) (ccv3.Environment, ccv3.Warnings, error)) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentArgsForCall(i int) string {
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	argsForCall := fake.getApplicationEnvironmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturns(result1 ccv3.Environment, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = nil
	fake.getApplicationEnvironmentReturns = struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturnsOnCall(i int, result1 ccv3.Environment, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = nil
	if fake.getApplicationEnvironmentReturnsOnCall == nil {
		fake.getApplicationEnvironmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Environment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationEnvironmentReturnsOnCall[i] = struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationManifest(arg1 string) ([]byte, ccv3.Warnings, error) {
	fake.getApplicationManifestMutex.Lock()
	ret, specificReturn := fake.getApplicationManifestReturnsOnCall[len(fake.getApplicationManifestArgsForCall)]
	fake.getApplicationManifestArgsForCall = append(fake.getApplicationManifestArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationManifestStub
	fakeReturns := fake.getApplicationManifestReturns
	fake.recordInvocation("GetApplicationManifest", []interface{}{arg1})
	fake.getApplicationManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationManifestCallCount() int {
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	return len(fake.getApplicationManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationManifestCalls(stub func(string) ([]byte, ccv3.Warnings, error)) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationManifestArgsForCall(i int) string {
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	argsForCall := fake.getApplicationManifestArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationManifestReturns(result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = nil
	fake.getApplicationManifestReturns = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationManifestReturnsOnCall(i int, result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = nil
	if fake.getApplicationManifestReturnsOnCall == nil {
		fake.getApplicationManifestReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationManifestReturnsOnCall[i] = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByType(arg1 string, arg2 string) (resources.Process, ccv3.Warnings, error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessByTypeReturnsOnCall[len(fake.getApplicationProcessByTypeArgsForCall)]
	fake.getApplicationProcessByTypeArgsForCall = append(fake.getApplicationProcessByTypeArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetApplicationProcessByTypeStub
	fakeReturns := fake.getApplicationProcessByTypeReturns
	fake.recordInvocation("GetApplicationProcessByType", []interface{}{arg1, arg2})
	fake.getApplicationProcessByTypeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeCallCount() int {
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	return len(fake.getApplicationProcessByTypeArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeCalls(stub func(string, string) (resources.Process, ccv3.Warnings, error)) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeArgsForCall(i int) (string, string) {
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	argsForCall := fake.getApplicationProcessByTypeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = nil
	fake.getApplicationProcessByTypeReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = nil
	if fake.getApplicationProcessByTypeReturnsOnCall == nil {
		fake.getApplicationProcessByTypeReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessByTypeReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcesses(arg1 string) ([]resources.Process, ccv3.Warnings, error) {
	fake.getApplicationProcessesMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessesReturnsOnCall[len(fake.getApplicationProcessesArgsForCall)]
	fake.getApplicationProcessesArgsForCall = append(fake.getApplicationProcessesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationProcessesStub
	fakeReturns := fake.getApplicationProcessesReturns
	fake.recordInvocation("GetApplicationProcesses", []interface{}{arg1})
	fake.getApplicationProcessesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesCallCount() int {
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	return len(fake.getApplicationProcessesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesCalls(stub func(string) ([]resources.Process, ccv3.Warnings, error)) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesArgsForCall(i int) string {
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	argsForCall := fake.getApplicationProcessesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = nil
	fake.getApplicationProcessesReturns = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturnsOnCall(i int, result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = nil
	if fake.getApplicationProcessesReturnsOnCall == nil {
		fake.getApplicationProcessesReturnsOnCall = make(map[int]struct {
			result1 []resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessesReturnsOnCall[i] = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRevisions(arg1 string, arg2 ...ccv3.Query) ([]resources.Revision, ccv3.Warnings, error) {
	fake.getApplicationRevisionsMutex.Lock()
	ret, specificReturn := fake.getApplicationRevisionsReturnsOnCall[len(fake.getApplicationRevisionsArgsForCall)]
	fake.getApplicationRevisionsArgsForCall = append(fake.getApplicationRevisionsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetApplicationRevisionsStub
	fakeReturns := fake.getApplicationRevisionsReturns
	fake.recordInvocation("GetApplicationRevisions", []interface{}{arg1, arg2})
	fake.getApplicationRevisionsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsCallCount() int {
	fake.getApplicationRevisionsMutex.RLock()
	defer fake.getApplicationRevisionsMutex.RUnlock()
	return len(fake.getApplicationRevisionsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsCalls(stub func(string, ...ccv3.Query) ([]resources.Revision, ccv3.Warnings, error)) {
	fake.getApplicationRevisionsMutex.Lock()
	defer fake.getApplicationRevisionsMutex.Unlock()
	fake.GetApplicationRevisionsStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getApplicationRevisionsMutex.RLock()
	defer fake.getApplicationRevisionsMutex.RUnlock()
	argsForCall := fake.getApplicationRevisionsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsReturns(result1 []resources.Revision, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRevisionsMutex.Lock()
	defer fake.getApplicationRevisionsMutex.Unlock()
	fake.GetApplicationRevisionsStub = nil
	fake.getApplicationRevisionsReturns = struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsReturnsOnCall(i int, result1 []resources.Revision, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRevisionsMutex.Lock()
	defer fake.getApplicationRevisionsMutex.Unlock()
	fake.GetApplicationRevisionsStub = nil
	if fake.getApplicationRevisionsReturnsOnCall == nil {
		fake.getApplicationRevisionsReturnsOnCall = make(map[int]struct {
			result1 []resources.Revision
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationRevisionsReturnsOnCall[i] = struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployed(arg1 string) ([]resources.Revision, ccv3.Warnings, error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	ret, specificReturn := fake.getApplicationRevisionsDeployedReturnsOnCall[len(fake.getApplicationRevisionsDeployedArgsForCall)]
	fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationRevisionsDeployedStub
	fakeReturns := fake.getApplicationRevisionsDeployedReturns
	fake.recordInvocation("GetApplicationRevisionsDeployed", []interface{}{arg1})
	fake.getApplicationRevisionsDeployedMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedCallCount() int {
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	return len(fake.getApplicationRevisionsDeployedArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedCalls(stub func(string) ([]resources.Revision, ccv3.Warnings, error)) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedArgsForCall(i int) string {
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	argsForCall := fake.getApplicationRevisionsDeployedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedReturns(result1 []resources.Revision, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = nil
	fake.getApplicationRevisionsDeployedReturns = struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRevisionsDeployedReturnsOnCall(i int, result1 []resources.Revision, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = nil
	if fake.getApplicationRevisionsDeployedReturnsOnCall == nil {
		fake.getApplicationRevisionsDeployedReturnsOnCall = make(map[int]struct {
			result1 []resources.Revision
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationRevisionsDeployedReturnsOnCall[i] = struct {
		result1 []resources.Revision
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutes(arg1 string) ([]resources.Route, ccv3.Warnings, error) {
	fake.getApplicationRoutesMutex.Lock()
	ret, specificReturn := fake.getApplicationRoutesReturnsOnCall[len(fake.getApplicationRoutesArgsForCall)]
	fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetApplicationRoutesStub
	fakeReturns := fake.getApplicationRoutesReturns
	fake.recordInvocation("GetApplicationRoutes", []interface{}{arg1})
	fake.getApplicationRoutesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetApplicationRoutesCalls(stub func(string) ([]resources.Route, ccv3.Warnings, error)) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesArgsForCall(i int) string {
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	argsForCall := fake.getApplicationRoutesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesReturns(result1 []resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = nil
	fake.getApplicationRoutesReturns = struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesReturnsOnCall(i int, result1 []resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = nil
	if fake.getApplicationRoutesReturnsOnCall == nil {
		fake.getApplicationRoutesReturnsOnCall = make(map[int]struct {
			result1 []resources.Route
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationRoutesReturnsOnCall[i] = struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasks(arg1 string, arg2 ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error) {
	fake.getApplicationTasksMutex.Lock()
	ret, specificReturn := fake.getApplicationTasksReturnsOnCall[len(fake.getApplicationTasksArgsForCall)]
	fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetApplicationTasksStub
	fakeReturns := fake.getApplicationTasksReturns
	fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2})
	fake.getApplicationTasksMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationTasksCallCount() int {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	return len(fake.getApplicationTasksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationTasksCalls(stub func(string, ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error)) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationTasksArgsForCall(i int) (string, []ccv3.Query) {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	argsForCall := fake.getApplicationTasksArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturns(result1 []resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = nil
	fake.getApplicationTasksReturns = struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturnsOnCall(i int, result1 []resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = nil
	if fake.getApplicationTasksReturnsOnCall == nil {
		fake.getApplicationTasksReturnsOnCall = make(map[int]struct {
			result1 []resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationTasksReturnsOnCall[i] = struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplications(arg1 ...ccv3.Query) ([]resources.Application, ccv3.Warnings, error) {
	fake.getApplicationsMutex.Lock()
	ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)]
	fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetApplicationsStub
	fakeReturns := fake.getApplicationsReturns
	fake.recordInvocation("GetApplications", []interface{}{arg1})
	fake.getApplicationsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetApplicationsCalls(stub func(...ccv3.Query) ([]resources.Application, ccv3.Warnings, error)) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationsArgsForCall(i int) []ccv3.Query {
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	argsForCall := fake.getApplicationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationsReturns(result1 []resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = nil
	fake.getApplicationsReturns = struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationsReturnsOnCall(i int, result1 []resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = nil
	if fake.getApplicationsReturnsOnCall == nil {
		fake.getApplicationsReturnsOnCall = make(map[int]struct {
			result1 []resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationsReturnsOnCall[i] = struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuild(arg1 string) (resources.Build, ccv3.Warnings, error) {
	fake.getBuildMutex.Lock()
	ret, specificReturn := fake.getBuildReturnsOnCall[len(fake.getBuildArgsForCall)]
	fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetBuildStub
	fakeReturns := fake.getBuildReturns
	fake.recordInvocation("GetBuild", []interface{}{arg1})
	fake.getBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetBuildCallCount() int {
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	return len(fake.getBuildArgsForCall)
}

func (fake *FakeCloudControllerClient) GetBuildCalls(stub func(string) (resources.Build, ccv3.Warnings, error)) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = stub
}

func (fake *FakeCloudControllerClient) GetBuildArgsForCall(i int) string {
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	argsForCall := fake.getBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = nil
	fake.getBuildReturns = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildReturnsOnCall(i int, result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = nil
	if fake.getBuildReturnsOnCall == nil {
		fake.getBuildReturnsOnCall = make(map[int]struct {
			result1 resources.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getBuildReturnsOnCall[i] = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildpacks(arg1 ...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error) {
	fake.getBuildpacksMutex.Lock()
	ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)]
	fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetBuildpacksStub
	fakeReturns := fake.getBuildpacksReturns
	fake.recordInvocation("GetBuildpacks", []interface{}{arg1})
	fake.getBuildpacksMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetBuildpacksCallCount() int {
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	return len(fake.getBuildpacksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetBuildpacksCalls(stub func(...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error)) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = stub
}

func (fake *FakeCloudControllerClient) GetBuildpacksArgsForCall(i int) []ccv3.Query {
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	argsForCall := fake.getBuildpacksArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetBuildpacksReturns(result1 []resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = nil
	fake.getBuildpacksReturns = struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildpacksReturnsOnCall(i int, result1 []resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = nil
	if fake.getBuildpacksReturnsOnCall == nil {
		fake.getBuildpacksReturnsOnCall = make(map[int]struct {
			result1 []resources.Buildpack
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getBuildpacksReturnsOnCall[i] = struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDefaultDomain(arg1 string) (resources.Domain, ccv3.Warnings, error) {
	fake.getDefaultDomainMutex.Lock()
	ret, specificReturn := fake.getDefaultDomainReturnsOnCall[len(fake.getDefaultDomainArgsForCall)]
	fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetDefaultDomainStub
	fakeReturns := fake.getDefaultDomainReturns
	fake.recordInvocation("GetDefaultDomain", []interface{}{arg1})
	fake.getDefaultDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDefaultDomainCallCount() int {
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	return len(fake.getDefaultDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDefaultDomainCalls(stub func(string) (resources.Domain, ccv3.Warnings, error)) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = stub
}

func (fake *FakeCloudControllerClient) GetDefaultDomainArgsForCall(i int) string {
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	argsForCall := fake.getDefaultDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDefaultDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = nil
	fake.getDefaultDomainReturns = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDefaultDomainReturnsOnCall(i int, result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = nil
	if fake.getDefaultDomainReturnsOnCall == nil {
		fake.getDefaultDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDefaultDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDeployment(arg1 string) (resources.Deployment, ccv3.Warnings, error) {
	fake.getDeploymentMutex.Lock()
	ret, specificReturn := fake.getDeploymentReturnsOnCall[len(fake.getDeploymentArgsForCall)]
	fake.getDeploymentArgsForCall = append(fake.getDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetDeploymentStub
	fakeReturns := fake.getDeploymentReturns
	fake.recordInvocation("GetDeployment", []interface{}{arg1})
	fake.getDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDeploymentCallCount() int {
	fake.getDeploymentMutex.RLock()
	defer fake.getDeploymentMutex.RUnlock()
	return len(fake.getDeploymentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDeploymentCalls(stub func(string) (resources.Deployment, ccv3.Warnings, error)) {
	fake.getDeploymentMutex.Lock()
	defer fake.getDeploymentMutex.Unlock()
	fake.GetDeploymentStub = stub
}

func (fake *FakeCloudControllerClient) GetDeploymentArgsForCall(i int) string {
	fake.getDeploymentMutex.RLock()
	defer fake.getDeploymentMutex.RUnlock()
	argsForCall := fake.getDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDeploymentReturns(result1 resources.Deployment, result2 ccv3.Warnings, result3 error) {
	fake.getDeploymentMutex.Lock()
	defer fake.getDeploymentMutex.Unlock()
	fake.GetDeploymentStub = nil
	fake.getDeploymentReturns = struct {
		result1 resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDeploymentReturnsOnCall(i int, result1 resources.Deployment, result2 ccv3.Warnings, result3 error) {
	fake.getDeploymentMutex.Lock()
	defer fake.getDeploymentMutex.Unlock()
	fake.GetDeploymentStub = nil
	if fake.getDeploymentReturnsOnCall == nil {
		fake.getDeploymentReturnsOnCall = make(map[int]struct {
			result1 resources.Deployment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDeploymentReturnsOnCall[i] = struct {
		result1 resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDeployments(arg1 ...ccv3.Query) ([]resources.Deployment, ccv3.Warnings, error) {
	fake.getDeploymentsMutex.Lock()
	ret, specificReturn := fake.getDeploymentsReturnsOnCall[len(fake.getDeploymentsArgsForCall)]
	fake.getDeploymentsArgsForCall = append(fake.getDeploymentsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetDeploymentsStub
	fakeReturns := fake.getDeploymentsReturns
	fake.recordInvocation("GetDeployments", []interface{}{arg1})
	fake.getDeploymentsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDeploymentsCallCount() int {
	fake.getDeploymentsMutex.RLock()
	defer fake.getDeploymentsMutex.RUnlock()
	return len(fake.getDeploymentsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDeploymentsCalls(stub func(...ccv3.Query) ([]resources.Deployment, ccv3.Warnings, error)) {
	fake.getDeploymentsMutex.Lock()
	defer fake.getDeploymentsMutex.Unlock()
	fake.GetDeploymentsStub = stub
}

func (fake *FakeCloudControllerClient) GetDeploymentsArgsForCall(i int) []ccv3.Query {
	fake.getDeploymentsMutex.RLock()
	defer fake.getDeploymentsMutex.RUnlock()
	argsForCall := fake.getDeploymentsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDeploymentsReturns(result1 []resources.Deployment, result2 ccv3.Warnings, result3 error) {
	fake.getDeploymentsMutex.Lock()
	defer fake.getDeploymentsMutex.Unlock()
	fake.GetDeploymentsStub = nil
	fake.getDeploymentsReturns = struct {
		result1 []resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDeploymentsReturnsOnCall(i int, result1 []resources.Deployment, result2 ccv3.Warnings, result3 error) {
	fake.getDeploymentsMutex.Lock()
	defer fake.getDeploymentsMutex.Unlock()
	fake.GetDeploymentsStub = nil
	if fake.getDeploymentsReturnsOnCall == nil {
		fake.getDeploymentsReturnsOnCall = make(map[int]struct {
			result1 []resources.Deployment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDeploymentsReturnsOnCall[i] = struct {
		result1 []resources.Deployment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDomain(arg1 string) (resources.Domain, ccv3.Warnings, error) {
	fake.getDomainMutex.Lock()
	ret, specificReturn := fake.getDomainReturnsOnCall[len(fake.getDomainArgsForCall)]
	fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetDomainStub
	fakeReturns := fake.getDomainReturns
	fake.recordInvocation("GetDomain", []interface{}{arg1})
	fake.getDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDomainCallCount() int {
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	return len(fake.getDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDomainCalls(stub func(string) (resources.Domain, ccv3.Warnings, error)) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = stub
}

func (fake *FakeCloudControllerClient) GetDomainArgsForCall(i int) string {
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	argsForCall := fake.getDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = nil
	fake.getDomainReturns = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDomainReturnsOnCall(i int, result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = nil
	if fake.getDomainReturnsOnCall == nil {
		fake.getDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDomains(arg1 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) {
	fake.getDomainsMutex.Lock()
	ret, specificReturn := fake.getDomainsReturnsOnCall[len(fake.getDomainsArgsForCall)]
	fake.getDomainsArgsForCall = append(fake.getDomainsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetDomainsStub
	fakeReturns := fake.getDomainsReturns
	fake.recordInvocation("GetDomains", []interface{}{arg1})
	fake.getDomainsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDomainsCallCount() int {
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	return len(fake.getDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDomainsCalls(stub func(...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetDomainsArgsForCall(i int) []ccv3.Query {
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	argsForCall := fake.getDomainsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = nil
	fake.getDomainsReturns = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDomainsReturnsOnCall(i int, result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = nil
	if fake.getDomainsReturnsOnCall == nil {
		fake.getDomainsReturnsOnCall = make(map[int]struct {
			result1 []resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDomainsReturnsOnCall[i] = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDroplet(arg1 string) (resources.Droplet, ccv3.Warnings, error) {
	fake.getDropletMutex.Lock()
	ret, specificReturn := fake.getDropletReturnsOnCall[len(fake.getDropletArgsForCall)]
	fake.getDropletArgsForCall = append(fake.getDropletArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetDropletStub
	fakeReturns := fake.getDropletReturns
	fake.recordInvocation("GetDroplet", []interface{}{arg1})
	fake.getDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDropletCallCount() int {
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	return len(fake.getDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDropletCalls(stub func(string) (resources.Droplet, ccv3.Warnings, error)) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = stub
}

func (fake *FakeCloudControllerClient) GetDropletArgsForCall(i int) string {
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	argsForCall := fake.getDropletArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDropletReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = nil
	fake.getDropletReturns = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDropletReturnsOnCall(i int, result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = nil
	if fake.getDropletReturnsOnCall == nil {
		fake.getDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDropletReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDroplets(arg1 ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) {
	fake.getDropletsMutex.Lock()
	ret, specificReturn := fake.getDropletsReturnsOnCall[len(fake.getDropletsArgsForCall)]
	fake.getDropletsArgsForCall = append(fake.getDropletsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetDropletsStub
	fakeReturns := fake.getDropletsReturns
	fake.recordInvocation("GetDroplets", []interface{}{arg1})
	fake.getDropletsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDropletsCallCount() int {
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	return len(fake.getDropletsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDropletsCalls(stub func(...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = stub
}

func (fake *FakeCloudControllerClient) GetDropletsArgsForCall(i int) []ccv3.Query {
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	argsForCall := fake.getDropletsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDropletsReturns(result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = nil
	fake.getDropletsReturns = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDropletsReturnsOnCall(i int, result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = nil
	if fake.getDropletsReturnsOnCall == nil {
		fake.getDropletsReturnsOnCall = make(map[int]struct {
			result1 []resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDropletsReturnsOnCall[i] = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroup(arg1 constant.EnvironmentVariableGroupName) (resources.EnvironmentVariables, ccv3.Warnings, error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	ret, specificReturn := fake.getEnvironmentVariableGroupReturnsOnCall[len(fake.getEnvironmentVariableGroupArgsForCall)]
	fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, struct {
		arg1 constant.EnvironmentVariableGroupName
	}{arg1})
	stub := fake.GetEnvironmentVariableGroupStub
	fakeReturns := fake.getEnvironmentVariableGroupReturns
	fake.recordInvocation("GetEnvironmentVariableGroup", []interface{}{arg1})
	fake.getEnvironmentVariableGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupCallCount() int {
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	return len(fake.getEnvironmentVariableGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupCalls(stub func(constant.EnvironmentVariableGroupName) (resources.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = stub
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupArgsForCall(i int) constant.EnvironmentVariableGroupName {
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	argsForCall := fake.getEnvironmentVariableGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = nil
	fake.getEnvironmentVariableGroupReturns = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariableGroupReturnsOnCall(i int, result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = nil
	if fake.getEnvironmentVariableGroupReturnsOnCall == nil {
		fake.getEnvironmentVariableGroupReturnsOnCall = make(map[int]struct {
			result1 resources.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getEnvironmentVariableGroupReturnsOnCall[i] = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURL(arg1 string) (resources.EnvironmentVariables, ccv3.Warnings, error) {
	fake.getEnvironmentVariablesByURLMutex.Lock()
	ret, specificReturn := fake.getEnvironmentVariablesByURLReturnsOnCall[len(fake.getEnvironmentVariablesByURLArgsForCall)]
	fake.getEnvironmentVariablesByURLArgsForCall = append(fake.getEnvironmentVariablesByURLArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetEnvironmentVariablesByURLStub
	fakeReturns := fake.getEnvironmentVariablesByURLReturns
	fake.recordInvocation("GetEnvironmentVariablesByURL", []interface{}{arg1})
	fake.getEnvironmentVariablesByURLMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLCallCount() int {
	fake.getEnvironmentVariablesByURLMutex.RLock()
	defer fake.getEnvironmentVariablesByURLMutex.RUnlock()
	return len(fake.getEnvironmentVariablesByURLArgsForCall)
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLCalls(stub func(string) (resources.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.getEnvironmentVariablesByURLMutex.Lock()
	defer fake.getEnvironmentVariablesByURLMutex.Unlock()
	fake.GetEnvironmentVariablesByURLStub = stub
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLArgsForCall(i int) string {
	fake.getEnvironmentVariablesByURLMutex.RLock()
	defer fake.getEnvironmentVariablesByURLMutex.RUnlock()
	argsForCall := fake.getEnvironmentVariablesByURLArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.getEnvironmentVariablesByURLMutex.Lock()
	defer fake.getEnvironmentVariablesByURLMutex.Unlock()
	fake.GetEnvironmentVariablesByURLStub = nil
	fake.getEnvironmentVariablesByURLReturns = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEnvironmentVariablesByURLReturnsOnCall(i int, result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.getEnvironmentVariablesByURLMutex.Lock()
	defer fake.getEnvironmentVariablesByURLMutex.Unlock()
	fake.GetEnvironmentVariablesByURLStub = nil
	if fake.getEnvironmentVariablesByURLReturnsOnCall == nil {
		fake.getEnvironmentVariablesByURLReturnsOnCall = make(map[int]struct {
			result1 resources.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getEnvironmentVariablesByURLReturnsOnCall[i] = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEvents(arg1 ...ccv3.Query) ([]ccv3.Event, ccv3.Warnings, error) {
	fake.getEventsMutex.Lock()
	ret, specificReturn := fake.getEventsReturnsOnCall[len(fake.getEventsArgsForCall)]
	fake.getEventsArgsForCall = append(fake.getEventsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetEventsStub
	fakeReturns := fake.getEventsReturns
	fake.recordInvocation("GetEvents", []interface{}{arg1})
	fake.getEventsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetEventsCallCount() int {
	fake.getEventsMutex.RLock()
	defer fake.getEventsMutex.RUnlock()
	return len(fake.getEventsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetEventsCalls(stub func(...ccv3.Query) ([]ccv3.Event, ccv3.Warnings, error)) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = stub
}

func (fake *FakeCloudControllerClient) GetEventsArgsForCall(i int) []ccv3.Query {
	fake.getEventsMutex.RLock()
	defer fake.getEventsMutex.RUnlock()
	argsForCall := fake.getEventsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetEventsReturns(result1 []ccv3.Event, result2 ccv3.Warnings, result3 error) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = nil
	fake.getEventsReturns = struct {
		result1 []ccv3.Event
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetEventsReturnsOnCall(i int, result1 []ccv3.Event, result2 ccv3.Warnings, result3 error) {
	fake.getEventsMutex.Lock()
	defer fake.getEventsMutex.Unlock()
	fake.GetEventsStub = nil
	if fake.getEventsReturnsOnCall == nil {
		fake.getEventsReturnsOnCall = make(map[int]struct {
			result1 []ccv3.Event
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getEventsReturnsOnCall[i] = struct {
		result1 []ccv3.Event
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlag(arg1 string) (resources.FeatureFlag, ccv3.Warnings, error) {
	fake.getFeatureFlagMutex.Lock()
	ret, specificReturn := fake.getFeatureFlagReturnsOnCall[len(fake.getFeatureFlagArgsForCall)]
	fake.getFeatureFlagArgsForCall = append(fake.getFeatureFlagArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetFeatureFlagStub
	fakeReturns := fake.getFeatureFlagReturns
	fake.recordInvocation("GetFeatureFlag", []interface{}{arg1})
	fake.getFeatureFlagMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetFeatureFlagCallCount() int {
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	return len(fake.getFeatureFlagArgsForCall)
}

func (fake *FakeCloudControllerClient) GetFeatureFlagCalls(stub func(string) (resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = stub
}

func (fake *FakeCloudControllerClient) GetFeatureFlagArgsForCall(i int) string {
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	argsForCall := fake.getFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = nil
	fake.getFeatureFlagReturns = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlagReturnsOnCall(i int, result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = nil
	if fake.getFeatureFlagReturnsOnCall == nil {
		fake.getFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagReturnsOnCall[i] = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlags() ([]resources.FeatureFlag, ccv3.Warnings, error) {
	fake.getFeatureFlagsMutex.Lock()
	ret, specificReturn := fake.getFeatureFlagsReturnsOnCall[len(fake.getFeatureFlagsArgsForCall)]
	fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct {
	}{})
	stub := fake.GetFeatureFlagsStub
	fakeReturns := fake.getFeatureFlagsReturns
	fake.recordInvocation("GetFeatureFlags", []interface{}{})
	fake.getFeatureFlagsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsCallCount() int {
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	return len(fake.getFeatureFlagsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsCalls(stub func() ([]resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = stub
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsReturns(result1 []resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = nil
	fake.getFeatureFlagsReturns = struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsReturnsOnCall(i int, result1 []resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = nil
	if fake.getFeatureFlagsReturnsOnCall == nil {
		fake.getFeatureFlagsReturnsOnCall = make(map[int]struct {
			result1 []resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagsReturnsOnCall[i] = struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetInfo() (ccv3.Info, ccv3.Warnings, error) {
	fake.getInfoMutex.Lock()
	ret, specificReturn := fake.getInfoReturnsOnCall[len(fake.getInfoArgsForCall)]
	fake.getInfoArgsForCall = append(fake.getInfoArgsForCall, struct {
	}{})
	stub := fake.GetInfoStub
	fakeReturns := fake.getInfoReturns
	fake.recordInvocation("GetInfo", []interface{}{})
	fake.getInfoMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetInfoCallCount() int {
	fake.getInfoMutex.RLock()
	defer fake.getInfoMutex.RUnlock()
	return len(fake.getInfoArgsForCall)
}

func (fake *FakeCloudControllerClient) GetInfoCalls(stub func() (ccv3.Info, ccv3.Warnings, error)) {
	fake.getInfoMutex.Lock()
	defer fake.getInfoMutex.Unlock()
	fake.GetInfoStub = stub
}

func (fake *FakeCloudControllerClient) GetInfoReturns(result1 ccv3.Info, result2 ccv3.Warnings, result3 error) {
	fake.getInfoMutex.Lock()
	defer fake.getInfoMutex.Unlock()
	fake.GetInfoStub = nil
	fake.getInfoReturns = struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetInfoReturnsOnCall(i int, result1 ccv3.Info, result2 ccv3.Warnings, result3 error) {
	fake.getInfoMutex.Lock()
	defer fake.getInfoMutex.Unlock()
	fake.GetInfoStub = nil
	if fake.getInfoReturnsOnCall == nil {
		fake.getInfoReturnsOnCall = make(map[int]struct {
			result1 ccv3.Info
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getInfoReturnsOnCall[i] = struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegment(arg1 string) (resources.IsolationSegment, ccv3.Warnings, error) {
	fake.getIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentReturnsOnCall[len(fake.getIsolationSegmentArgsForCall)]
	fake.getIsolationSegmentArgsForCall = append(fake.getIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetIsolationSegmentStub
	fakeReturns := fake.getIsolationSegmentReturns
	fake.recordInvocation("GetIsolationSegment", []interface{}{arg1})
	fake.getIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentCallCount() int {
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	return len(fake.getIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentCalls(stub func(string) (resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentArgsForCall(i int) string {
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = nil
	fake.getIsolationSegmentReturns = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturnsOnCall(i int, result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = nil
	if fake.getIsolationSegmentReturnsOnCall == nil {
		fake.getIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizations(arg1 string) ([]resources.Organization, ccv3.Warnings, error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentOrganizationsReturnsOnCall[len(fake.getIsolationSegmentOrganizationsArgsForCall)]
	fake.getIsolationSegmentOrganizationsArgsForCall = append(fake.getIsolationSegmentOrganizationsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetIsolationSegmentOrganizationsStub
	fakeReturns := fake.getIsolationSegmentOrganizationsReturns
	fake.recordInvocation("GetIsolationSegmentOrganizations", []interface{}{arg1})
	fake.getIsolationSegmentOrganizationsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsCallCount() int {
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	return len(fake.getIsolationSegmentOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsCalls(stub func(string) ([]resources.Organization, ccv3.Warnings, error)) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsArgsForCall(i int) string {
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentOrganizationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturns(result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = nil
	fake.getIsolationSegmentOrganizationsReturns = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturnsOnCall(i int, result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = nil
	if fake.getIsolationSegmentOrganizationsReturnsOnCall == nil {
		fake.getIsolationSegmentOrganizationsReturnsOnCall = make(map[int]struct {
			result1 []resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentOrganizationsReturnsOnCall[i] = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegments(arg1 ...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error) {
	fake.getIsolationSegmentsMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentsReturnsOnCall[len(fake.getIsolationSegmentsArgsForCall)]
	fake.getIsolationSegmentsArgsForCall = append(fake.getIsolationSegmentsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetIsolationSegmentsStub
	fakeReturns := fake.getIsolationSegmentsReturns
	fake.recordInvocation("GetIsolationSegments", []interface{}{arg1})
	fake.getIsolationSegmentsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsCallCount() int {
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	return len(fake.getIsolationSegmentsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsCalls(stub func(...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsArgsForCall(i int) []ccv3.Query {
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturns(result1 []resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = nil
	fake.getIsolationSegmentsReturns = struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturnsOnCall(i int, result1 []resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = nil
	if fake.getIsolationSegmentsReturnsOnCall == nil {
		fake.getIsolationSegmentsReturnsOnCall = make(map[int]struct {
			result1 []resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentsReturnsOnCall[i] = struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcesses(arg1 string, arg2 string) ([]resources.Process, ccv3.Warnings, error) {
	fake.getNewApplicationProcessesMutex.Lock()
	ret, specificReturn := fake.getNewApplicationProcessesReturnsOnCall[len(fake.getNewApplicationProcessesArgsForCall)]
	fake.getNewApplicationProcessesArgsForCall = append(fake.getNewApplicationProcessesArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetNewApplicationProcessesStub
	fakeReturns := fake.getNewApplicationProcessesReturns
	fake.recordInvocation("GetNewApplicationProcesses", []interface{}{arg1, arg2})
	fake.getNewApplicationProcessesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcessesCallCount() int {
	fake.getNewApplicationProcessesMutex.RLock()
	defer fake.getNewApplicationProcessesMutex.RUnlock()
	return len(fake.getNewApplicationProcessesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcessesCalls(stub func(string, string) ([]resources.Process, ccv3.Warnings, error)) {
	fake.getNewApplicationProcessesMutex.Lock()
	defer fake.getNewApplicationProcessesMutex.Unlock()
	fake.GetNewApplicationProcessesStub = stub
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcessesArgsForCall(i int) (string, string) {
	fake.getNewApplicationProcessesMutex.RLock()
	defer fake.getNewApplicationProcessesMutex.RUnlock()
	argsForCall := fake.getNewApplicationProcessesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getNewApplicationProcessesMutex.Lock()
	defer fake.getNewApplicationProcessesMutex.Unlock()
	fake.GetNewApplicationProcessesStub = nil
	fake.getNewApplicationProcessesReturns = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetNewApplicationProcessesReturnsOnCall(i int, result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getNewApplicationProcessesMutex.Lock()
	defer fake.getNewApplicationProcessesMutex.Unlock()
	fake.GetNewApplicationProcessesStub = nil
	if fake.getNewApplicationProcessesReturnsOnCall == nil {
		fake.getNewApplicationProcessesReturnsOnCall = make(map[int]struct {
			result1 []resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getNewApplicationProcessesReturnsOnCall[i] = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) GetOrganizationCalls(stub func(string) (resources.Organization, ccv3.Warnings, error)) {
	fake.getOrganizationMutex.Lock()
	defer fake.getOrganizationMutex.Unlock()
	fake.GetOrganizationStub = stub
}

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

func (fake *FakeCloudControllerClient) GetOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationMutex.Lock()
	defer fake.getOrganizationMutex.Unlock()
	fake.GetOrganizationStub = nil
	fake.getOrganizationReturns = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.getOrganizationDefaultIsolationSegmentArgsForCall = append(fake.getOrganizationDefaultIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetOrganizationDefaultIsolationSegmentStub
	fakeReturns := fake.getOrganizationDefaultIsolationSegmentReturns
	fake.recordInvocation("GetOrganizationDefaultIsolationSegment", []interface{}{arg1})
	fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentCallCount() int {
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentCalls(stub func(string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentArgsForCall(i int) string {
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getOrganizationDefaultIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = nil
	fake.getOrganizationDefaultIsolationSegmentReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = nil
	if fake.getOrganizationDefaultIsolationSegmentReturnsOnCall == nil {
		fake.getOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDomains(arg1 string, arg2 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) {
	fake.getOrganizationDomainsMutex.Lock()
	ret, specificReturn := fake.getOrganizationDomainsReturnsOnCall[len(fake.getOrganizationDomainsArgsForCall)]
	fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetOrganizationDomainsStub
	fakeReturns := fake.getOrganizationDomainsReturns
	fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2})
	fake.getOrganizationDomainsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsCallCount() int {
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	return len(fake.getOrganizationDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsCalls(stub func(string, ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	argsForCall := fake.getOrganizationDomainsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = nil
	fake.getOrganizationDomainsReturns = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturnsOnCall(i int, result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = nil
	if fake.getOrganizationDomainsReturnsOnCall == nil {
		fake.getOrganizationDomainsReturnsOnCall = make(map[int]struct {
			result1 []resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationDomainsReturnsOnCall[i] = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) GetOrganizationQuotaCalls(stub func(string) (resources.OrganizationQuota, ccv3.Warnings, error)) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = stub
}

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

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = nil
	fake.getOrganizationQuotaReturns = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturnsOnCall(i int, result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = nil
	if fake.getOrganizationQuotaReturnsOnCall == nil {
		fake.getOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.OrganizationQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotaReturnsOnCall[i] = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotas(arg1 ...ccv3.Query) ([]resources.OrganizationQuota, ccv3.Warnings, error) {
	fake.getOrganizationQuotasMutex.Lock()
	ret, specificReturn := fake.getOrganizationQuotasReturnsOnCall[len(fake.getOrganizationQuotasArgsForCall)]
	fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetOrganizationQuotasStub
	fakeReturns := fake.getOrganizationQuotasReturns
	fake.recordInvocation("GetOrganizationQuotas", []interface{}{arg1})
	fake.getOrganizationQuotasMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasCallCount() int {
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	return len(fake.getOrganizationQuotasArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasCalls(stub func(...ccv3.Query) ([]resources.OrganizationQuota, ccv3.Warnings, error)) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasArgsForCall(i int) []ccv3.Query {
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	argsForCall := fake.getOrganizationQuotasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturns(result1 []resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = nil
	fake.getOrganizationQuotasReturns = struct {
		result1 []resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturnsOnCall(i int, result1 []resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = nil
	if fake.getOrganizationQuotasReturnsOnCall == nil {
		fake.getOrganizationQuotasReturnsOnCall = make(map[int]struct {
			result1 []resources.OrganizationQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotasReturnsOnCall[i] = struct {
		result1 []resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizations(arg1 ...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error) {
	fake.getOrganizationsMutex.Lock()
	ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)]
	fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetOrganizationsStub
	fakeReturns := fake.getOrganizationsReturns
	fake.recordInvocation("GetOrganizations", []interface{}{arg1})
	fake.getOrganizationsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetOrganizationsCalls(stub func(...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error)) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationsArgsForCall(i int) []ccv3.Query {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	argsForCall := fake.getOrganizationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationsReturns(result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = nil
	fake.getOrganizationsReturns = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationsReturnsOnCall(i int, result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = nil
	if fake.getOrganizationsReturnsOnCall == nil {
		fake.getOrganizationsReturnsOnCall = make(map[int]struct {
			result1 []resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationsReturnsOnCall[i] = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackage(arg1 string) (resources.Package, ccv3.Warnings, error) {
	fake.getPackageMutex.Lock()
	ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)]
	fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetPackageStub
	fakeReturns := fake.getPackageReturns
	fake.recordInvocation("GetPackage", []interface{}{arg1})
	fake.getPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPackageCallCount() int {
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	return len(fake.getPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPackageCalls(stub func(string) (resources.Package, ccv3.Warnings, error)) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = stub
}

func (fake *FakeCloudControllerClient) GetPackageArgsForCall(i int) string {
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	argsForCall := fake.getPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = nil
	fake.getPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = nil
	if fake.getPackageReturnsOnCall == nil {
		fake.getPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackageDroplets(arg1 string, arg2 ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) {
	fake.getPackageDropletsMutex.Lock()
	ret, specificReturn := fake.getPackageDropletsReturnsOnCall[len(fake.getPackageDropletsArgsForCall)]
	fake.getPackageDropletsArgsForCall = append(fake.getPackageDropletsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetPackageDropletsStub
	fakeReturns := fake.getPackageDropletsReturns
	fake.recordInvocation("GetPackageDroplets", []interface{}{arg1, arg2})
	fake.getPackageDropletsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPackageDropletsCallCount() int {
	fake.getPackageDropletsMutex.RLock()
	defer fake.getPackageDropletsMutex.RUnlock()
	return len(fake.getPackageDropletsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPackageDropletsCalls(stub func(string, ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)) {
	fake.getPackageDropletsMutex.Lock()
	defer fake.getPackageDropletsMutex.Unlock()
	fake.GetPackageDropletsStub = stub
}

func (fake *FakeCloudControllerClient) GetPackageDropletsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getPackageDropletsMutex.RLock()
	defer fake.getPackageDropletsMutex.RUnlock()
	argsForCall := fake.getPackageDropletsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetPackageDropletsReturns(result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getPackageDropletsMutex.Lock()
	defer fake.getPackageDropletsMutex.Unlock()
	fake.GetPackageDropletsStub = nil
	fake.getPackageDropletsReturns = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackageDropletsReturnsOnCall(i int, result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getPackageDropletsMutex.Lock()
	defer fake.getPackageDropletsMutex.Unlock()
	fake.GetPackageDropletsStub = nil
	if fake.getPackageDropletsReturnsOnCall == nil {
		fake.getPackageDropletsReturnsOnCall = make(map[int]struct {
			result1 []resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackageDropletsReturnsOnCall[i] = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackages(arg1 ...ccv3.Query) ([]resources.Package, ccv3.Warnings, error) {
	fake.getPackagesMutex.Lock()
	ret, specificReturn := fake.getPackagesReturnsOnCall[len(fake.getPackagesArgsForCall)]
	fake.getPackagesArgsForCall = append(fake.getPackagesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetPackagesStub
	fakeReturns := fake.getPackagesReturns
	fake.recordInvocation("GetPackages", []interface{}{arg1})
	fake.getPackagesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPackagesCallCount() int {
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	return len(fake.getPackagesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPackagesCalls(stub func(...ccv3.Query) ([]resources.Package, ccv3.Warnings, error)) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = stub
}

func (fake *FakeCloudControllerClient) GetPackagesArgsForCall(i int) []ccv3.Query {
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	argsForCall := fake.getPackagesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetPackagesReturns(result1 []resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = nil
	fake.getPackagesReturns = struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackagesReturnsOnCall(i int, result1 []resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = nil
	if fake.getPackagesReturnsOnCall == nil {
		fake.getPackagesReturnsOnCall = make(map[int]struct {
			result1 []resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackagesReturnsOnCall[i] = struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcess(arg1 string) (resources.Process, ccv3.Warnings, error) {
	fake.getProcessMutex.Lock()
	ret, specificReturn := fake.getProcessReturnsOnCall[len(fake.getProcessArgsForCall)]
	fake.getProcessArgsForCall = append(fake.getProcessArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProcessStub
	fakeReturns := fake.getProcessReturns
	fake.recordInvocation("GetProcess", []interface{}{arg1})
	fake.getProcessMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetProcessCallCount() int {
	fake.getProcessMutex.RLock()
	defer fake.getProcessMutex.RUnlock()
	return len(fake.getProcessArgsForCall)
}

func (fake *FakeCloudControllerClient) GetProcessCalls(stub func(string) (resources.Process, ccv3.Warnings, error)) {
	fake.getProcessMutex.Lock()
	defer fake.getProcessMutex.Unlock()
	fake.GetProcessStub = stub
}

func (fake *FakeCloudControllerClient) GetProcessArgsForCall(i int) string {
	fake.getProcessMutex.RLock()
	defer fake.getProcessMutex.RUnlock()
	argsForCall := fake.getProcessArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetProcessReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getProcessMutex.Lock()
	defer fake.getProcessMutex.Unlock()
	fake.GetProcessStub = nil
	fake.getProcessReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getProcessMutex.Lock()
	defer fake.getProcessMutex.Unlock()
	fake.GetProcessStub = nil
	if fake.getProcessReturnsOnCall == nil {
		fake.getProcessReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getProcessReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessInstances(arg1 string) ([]ccv3.ProcessInstance, ccv3.Warnings, error) {
	fake.getProcessInstancesMutex.Lock()
	ret, specificReturn := fake.getProcessInstancesReturnsOnCall[len(fake.getProcessInstancesArgsForCall)]
	fake.getProcessInstancesArgsForCall = append(fake.getProcessInstancesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProcessInstancesStub
	fakeReturns := fake.getProcessInstancesReturns
	fake.recordInvocation("GetProcessInstances", []interface{}{arg1})
	fake.getProcessInstancesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetProcessInstancesCallCount() int {
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	return len(fake.getProcessInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetProcessInstancesCalls(stub func(string) ([]ccv3.ProcessInstance, ccv3.Warnings, error)) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetProcessInstancesArgsForCall(i int) string {
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	argsForCall := fake.getProcessInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetProcessInstancesReturns(result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = nil
	fake.getProcessInstancesReturns = struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessInstancesReturnsOnCall(i int, result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = nil
	if fake.getProcessInstancesReturnsOnCall == nil {
		fake.getProcessInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv3.ProcessInstance
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getProcessInstancesReturnsOnCall[i] = struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessSidecars(arg1 string) ([]resources.Sidecar, ccv3.Warnings, error) {
	fake.getProcessSidecarsMutex.Lock()
	ret, specificReturn := fake.getProcessSidecarsReturnsOnCall[len(fake.getProcessSidecarsArgsForCall)]
	fake.getProcessSidecarsArgsForCall = append(fake.getProcessSidecarsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProcessSidecarsStub
	fakeReturns := fake.getProcessSidecarsReturns
	fake.recordInvocation("GetProcessSidecars", []interface{}{arg1})
	fake.getProcessSidecarsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetProcessSidecarsCallCount() int {
	fake.getProcessSidecarsMutex.RLock()
	defer fake.getProcessSidecarsMutex.RUnlock()
	return len(fake.getProcessSidecarsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetProcessSidecarsCalls(stub func(string) ([]resources.Sidecar, ccv3.Warnings, error)) {
	fake.getProcessSidecarsMutex.Lock()
	defer fake.getProcessSidecarsMutex.Unlock()
	fake.GetProcessSidecarsStub = stub
}

func (fake *FakeCloudControllerClient) GetProcessSidecarsArgsForCall(i int) string {
	fake.getProcessSidecarsMutex.RLock()
	defer fake.getProcessSidecarsMutex.RUnlock()
	argsForCall := fake.getProcessSidecarsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetProcessSidecarsReturns(result1 []resources.Sidecar, result2 ccv3.Warnings, result3 error) {
	fake.getProcessSidecarsMutex.Lock()
	defer fake.getProcessSidecarsMutex.Unlock()
	fake.GetProcessSidecarsStub = nil
	fake.getProcessSidecarsReturns = struct {
		result1 []resources.Sidecar
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessSidecarsReturnsOnCall(i int, result1 []resources.Sidecar, result2 ccv3.Warnings, result3 error) {
	fake.getProcessSidecarsMutex.Lock()
	defer fake.getProcessSidecarsMutex.Unlock()
	fake.GetProcessSidecarsStub = nil
	if fake.getProcessSidecarsReturnsOnCall == nil {
		fake.getProcessSidecarsReturnsOnCall = make(map[int]struct {
			result1 []resources.Sidecar
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getProcessSidecarsReturnsOnCall[i] = struct {
		result1 []resources.Sidecar
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcesses(arg1 ...ccv3.Query) ([]resources.Process, ccv3.Warnings, error) {
	fake.getProcessesMutex.Lock()
	ret, specificReturn := fake.getProcessesReturnsOnCall[len(fake.getProcessesArgsForCall)]
	fake.getProcessesArgsForCall = append(fake.getProcessesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetProcessesStub
	fakeReturns := fake.getProcessesReturns
	fake.recordInvocation("GetProcesses", []interface{}{arg1})
	fake.getProcessesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetProcessesCallCount() int {
	fake.getProcessesMutex.RLock()
	defer fake.getProcessesMutex.RUnlock()
	return len(fake.getProcessesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetProcessesCalls(stub func(...ccv3.Query) ([]resources.Process, ccv3.Warnings, error)) {
	fake.getProcessesMutex.Lock()
	defer fake.getProcessesMutex.Unlock()
	fake.GetProcessesStub = stub
}

func (fake *FakeCloudControllerClient) GetProcessesArgsForCall(i int) []ccv3.Query {
	fake.getProcessesMutex.RLock()
	defer fake.getProcessesMutex.RUnlock()
	argsForCall := fake.getProcessesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getProcessesMutex.Lock()
	defer fake.getProcessesMutex.Unlock()
	fake.GetProcessesStub = nil
	fake.getProcessesReturns = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessesReturnsOnCall(i int, result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getProcessesMutex.Lock()
	defer fake.getProcessesMutex.Unlock()
	fake.GetProcessesStub = nil
	if fake.getProcessesReturnsOnCall == nil {
		fake.getProcessesReturnsOnCall = make(map[int]struct {
			result1 []resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getProcessesReturnsOnCall[i] = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoles(arg1 ...ccv3.Query) ([]resources.Role, ccv3.IncludedResources, ccv3.Warnings, error) {
	fake.getRolesMutex.Lock()
	ret, specificReturn := fake.getRolesReturnsOnCall[len(fake.getRolesArgsForCall)]
	fake.getRolesArgsForCall = append(fake.getRolesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetRolesStub
	fakeReturns := fake.getRolesReturns
	fake.recordInvocation("GetRoles", []interface{}{arg1})
	fake.getRolesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeCloudControllerClient) GetRolesCallCount() int {
	fake.getRolesMutex.RLock()
	defer fake.getRolesMutex.RUnlock()
	return len(fake.getRolesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRolesCalls(stub func(...ccv3.Query) ([]resources.Role, ccv3.IncludedResources, ccv3.Warnings, error)) {
	fake.getRolesMutex.Lock()
	defer fake.getRolesMutex.Unlock()
	fake.GetRolesStub = stub
}

func (fake *FakeCloudControllerClient) GetRolesArgsForCall(i int) []ccv3.Query {
	fake.getRolesMutex.RLock()
	defer fake.getRolesMutex.RUnlock()
	argsForCall := fake.getRolesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetRolesReturns(result1 []resources.Role, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getRolesMutex.Lock()
	defer fake.getRolesMutex.Unlock()
	fake.GetRolesStub = nil
	fake.getRolesReturns = struct {
		result1 []resources.Role
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetRolesReturnsOnCall(i int, result1 []resources.Role, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getRolesMutex.Lock()
	defer fake.getRolesMutex.Unlock()
	fake.GetRolesStub = nil
	if fake.getRolesReturnsOnCall == nil {
		fake.getRolesReturnsOnCall = make(map[int]struct {
			result1 []resources.Role
			result2 ccv3.IncludedResources
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getRolesReturnsOnCall[i] = struct {
		result1 []resources.Role
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetRoot() (ccv3.Root, ccv3.Warnings, error) {
	fake.getRootMutex.Lock()
	ret, specificReturn := fake.getRootReturnsOnCall[len(fake.getRootArgsForCall)]
	fake.getRootArgsForCall = append(fake.getRootArgsForCall, struct {
	}{})
	stub := fake.GetRootStub
	fakeReturns := fake.getRootReturns
	fake.recordInvocation("GetRoot", []interface{}{})
	fake.getRootMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetRootCallCount() int {
	fake.getRootMutex.RLock()
	defer fake.getRootMutex.RUnlock()
	return len(fake.getRootArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRootCalls(stub func() (ccv3.Root, ccv3.Warnings, error)) {
	fake.getRootMutex.Lock()
	defer fake.getRootMutex.Unlock()
	fake.GetRootStub = stub
}

func (fake *FakeCloudControllerClient) GetRootReturns(result1 ccv3.Root, result2 ccv3.Warnings, result3 error) {
	fake.getRootMutex.Lock()
	defer fake.getRootMutex.Unlock()
	fake.GetRootStub = nil
	fake.getRootReturns = struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRootReturnsOnCall(i int, result1 ccv3.Root, result2 ccv3.Warnings, result3 error) {
	fake.getRootMutex.Lock()
	defer fake.getRootMutex.Unlock()
	fake.GetRootStub = nil
	if fake.getRootReturnsOnCall == nil {
		fake.getRootReturnsOnCall = make(map[int]struct {
			result1 ccv3.Root
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getRootReturnsOnCall[i] = struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRouteBindings(arg1 ...ccv3.Query) ([]resources.RouteBinding, ccv3.IncludedResources, ccv3.Warnings, error) {
	fake.getRouteBindingsMutex.Lock()
	ret, specificReturn := fake.getRouteBindingsReturnsOnCall[len(fake.getRouteBindingsArgsForCall)]
	fake.getRouteBindingsArgsForCall = append(fake.getRouteBindingsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetRouteBindingsStub
	fakeReturns := fake.getRouteBindingsReturns
	fake.recordInvocation("GetRouteBindings", []interface{}{arg1})
	fake.getRouteBindingsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeCloudControllerClient) GetRouteBindingsCallCount() int {
	fake.getRouteBindingsMutex.RLock()
	defer fake.getRouteBindingsMutex.RUnlock()
	return len(fake.getRouteBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRouteBindingsCalls(stub func(...ccv3.Query) ([]resources.RouteBinding, ccv3.IncludedResources, ccv3.Warnings, error)) {
	fake.getRouteBindingsMutex.Lock()
	defer fake.getRouteBindingsMutex.Unlock()
	fake.GetRouteBindingsStub = stub
}

func (fake *FakeCloudControllerClient) GetRouteBindingsArgsForCall(i int) []ccv3.Query {
	fake.getRouteBindingsMutex.RLock()
	defer fake.getRouteBindingsMutex.RUnlock()
	argsForCall := fake.getRouteBindingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetRouteBindingsReturns(result1 []resources.RouteBinding, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getRouteBindingsMutex.Lock()
	defer fake.getRouteBindingsMutex.Unlock()
	fake.GetRouteBindingsStub = nil
	fake.getRouteBindingsReturns = struct {
		result1 []resources.RouteBinding
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetRouteBindingsReturnsOnCall(i int, result1 []resources.RouteBinding, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getRouteBindingsMutex.Lock()
	defer fake.getRouteBindingsMutex.Unlock()
	fake.GetRouteBindingsStub = nil
	if fake.getRouteBindingsReturnsOnCall == nil {
		fake.getRouteBindingsReturnsOnCall = make(map[int]struct {
			result1 []resources.RouteBinding
			result2 ccv3.IncludedResources
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getRouteBindingsReturnsOnCall[i] = struct {
		result1 []resources.RouteBinding
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetRouteDestinations(arg1 string) ([]resources.RouteDestination, ccv3.Warnings, error) {
	fake.getRouteDestinationsMutex.Lock()
	ret, specificReturn := fake.getRouteDestinationsReturnsOnCall[len(fake.getRouteDestinationsArgsForCall)]
	fake.getRouteDestinationsArgsForCall = append(fake.getRouteDestinationsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetRouteDestinationsStub
	fakeReturns := fake.getRouteDestinationsReturns
	fake.recordInvocation("GetRouteDestinations", []interface{}{arg1})
	fake.getRouteDestinationsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetRouteDestinationsCallCount() int {
	fake.getRouteDestinationsMutex.RLock()
	defer fake.getRouteDestinationsMutex.RUnlock()
	return len(fake.getRouteDestinationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRouteDestinationsCalls(stub func(string) ([]resources.RouteDestination, ccv3.Warnings, error)) {
	fake.getRouteDestinationsMutex.Lock()
	defer fake.getRouteDestinationsMutex.Unlock()
	fake.GetRouteDestinationsStub = stub
}

func (fake *FakeCloudControllerClient) GetRouteDestinationsArgsForCall(i int) string {
	fake.getRouteDestinationsMutex.RLock()
	defer fake.getRouteDestinationsMutex.RUnlock()
	argsForCall := fake.getRouteDestinationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetRouteDestinationsReturns(result1 []resources.RouteDestination, result2 ccv3.Warnings, result3 error) {
	fake.getRouteDestinationsMutex.Lock()
	defer fake.getRouteDestinationsMutex.Unlock()
	fake.GetRouteDestinationsStub = nil
	fake.getRouteDestinationsReturns = struct {
		result1 []resources.RouteDestination
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRouteDestinationsReturnsOnCall(i int, result1 []resources.RouteDestination, result2 ccv3.Warnings, result3 error) {
	fake.getRouteDestinationsMutex.Lock()
	defer fake.getRouteDestinationsMutex.Unlock()
	fake.GetRouteDestinationsStub = nil
	if fake.getRouteDestinationsReturnsOnCall == nil {
		fake.getRouteDestinationsReturnsOnCall = make(map[int]struct {
			result1 []resources.RouteDestination
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getRouteDestinationsReturnsOnCall[i] = struct {
		result1 []resources.RouteDestination
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoutes(arg1 ...ccv3.Query) ([]resources.Route, ccv3.Warnings, error) {
	fake.getRoutesMutex.Lock()
	ret, specificReturn := fake.getRoutesReturnsOnCall[len(fake.getRoutesArgsForCall)]
	fake.getRoutesArgsForCall = append(fake.getRoutesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetRoutesStub
	fakeReturns := fake.getRoutesReturns
	fake.recordInvocation("GetRoutes", []interface{}{arg1})
	fake.getRoutesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetRoutesCalls(stub func(...ccv3.Query) ([]resources.Route, ccv3.Warnings, error)) {
	fake.getRoutesMutex.Lock()
	defer fake.getRoutesMutex.Unlock()
	fake.GetRoutesStub = stub
}

func (fake *FakeCloudControllerClient) GetRoutesArgsForCall(i int) []ccv3.Query {
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	argsForCall := fake.getRoutesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetRoutesReturns(result1 []resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.getRoutesMutex.Lock()
	defer fake.getRoutesMutex.Unlock()
	fake.GetRoutesStub = nil
	fake.getRoutesReturns = struct {
		result1 []resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetRunningSecurityGroups(arg1 string, arg2 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) {
	fake.getRunningSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getRunningSecurityGroupsReturnsOnCall[len(fake.getRunningSecurityGroupsArgsForCall)]
	fake.getRunningSecurityGroupsArgsForCall = append(fake.getRunningSecurityGroupsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetRunningSecurityGroupsStub
	fakeReturns := fake.getRunningSecurityGroupsReturns
	fake.recordInvocation("GetRunningSecurityGroups", []interface{}{arg1, arg2})
	fake.getRunningSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsCallCount() int {
	fake.getRunningSecurityGroupsMutex.RLock()
	defer fake.getRunningSecurityGroupsMutex.RUnlock()
	return len(fake.getRunningSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsCalls(stub func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)) {
	fake.getRunningSecurityGroupsMutex.Lock()
	defer fake.getRunningSecurityGroupsMutex.Unlock()
	fake.GetRunningSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getRunningSecurityGroupsMutex.RLock()
	defer fake.getRunningSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getRunningSecurityGroupsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getRunningSecurityGroupsMutex.Lock()
	defer fake.getRunningSecurityGroupsMutex.Unlock()
	fake.GetRunningSecurityGroupsStub = nil
	fake.getRunningSecurityGroupsReturns = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRunningSecurityGroupsReturnsOnCall(i int, result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getRunningSecurityGroupsMutex.Lock()
	defer fake.getRunningSecurityGroupsMutex.Unlock()
	fake.GetRunningSecurityGroupsStub = nil
	if fake.getRunningSecurityGroupsReturnsOnCall == nil {
		fake.getRunningSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []resources.SecurityGroup
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getRunningSecurityGroupsReturnsOnCall[i] = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSSHEnabled(arg1 string) (ccv3.SSHEnabled, ccv3.Warnings, error) {
	fake.getSSHEnabledMutex.Lock()
	ret, specificReturn := fake.getSSHEnabledReturnsOnCall[len(fake.getSSHEnabledArgsForCall)]
	fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetSSHEnabledStub
	fakeReturns := fake.getSSHEnabledReturns
	fake.recordInvocation("GetSSHEnabled", []interface{}{arg1})
	fake.getSSHEnabledMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSSHEnabledCallCount() int {
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	return len(fake.getSSHEnabledArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSSHEnabledCalls(stub func(string) (ccv3.SSHEnabled, ccv3.Warnings, error)) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = stub
}

func (fake *FakeCloudControllerClient) GetSSHEnabledArgsForCall(i int) string {
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	argsForCall := fake.getSSHEnabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSSHEnabledReturns(result1 ccv3.SSHEnabled, result2 ccv3.Warnings, result3 error) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = nil
	fake.getSSHEnabledReturns = struct {
		result1 ccv3.SSHEnabled
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSSHEnabledReturnsOnCall(i int, result1 ccv3.SSHEnabled, result2 ccv3.Warnings, result3 error) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = nil
	if fake.getSSHEnabledReturnsOnCall == nil {
		fake.getSSHEnabledReturnsOnCall = make(map[int]struct {
			result1 ccv3.SSHEnabled
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSSHEnabledReturnsOnCall[i] = struct {
		result1 ccv3.SSHEnabled
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroups(arg1 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) {
	fake.getSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupsReturnsOnCall[len(fake.getSecurityGroupsArgsForCall)]
	fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetSecurityGroupsStub
	fakeReturns := fake.getSecurityGroupsReturns
	fake.recordInvocation("GetSecurityGroups", []interface{}{arg1})
	fake.getSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetSecurityGroupsCalls(stub func(...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsArgsForCall(i int) []ccv3.Query {
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getSecurityGroupsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = nil
	fake.getSecurityGroupsReturns = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturnsOnCall(i int, result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = nil
	if fake.getSecurityGroupsReturnsOnCall == nil {
		fake.getSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []resources.SecurityGroup
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupsReturnsOnCall[i] = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBrokers(arg1 ...ccv3.Query) ([]resources.ServiceBroker, ccv3.Warnings, error) {
	fake.getServiceBrokersMutex.Lock()
	ret, specificReturn := fake.getServiceBrokersReturnsOnCall[len(fake.getServiceBrokersArgsForCall)]
	fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServiceBrokersStub
	fakeReturns := fake.getServiceBrokersReturns
	fake.recordInvocation("GetServiceBrokers", []interface{}{arg1})
	fake.getServiceBrokersMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceBrokersCallCount() int {
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	return len(fake.getServiceBrokersArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceBrokersCalls(stub func(...ccv3.Query) ([]resources.ServiceBroker, ccv3.Warnings, error)) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceBrokersArgsForCall(i int) []ccv3.Query {
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	argsForCall := fake.getServiceBrokersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceBrokersReturns(result1 []resources.ServiceBroker, result2 ccv3.Warnings, result3 error) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = nil
	fake.getServiceBrokersReturns = struct {
		result1 []resources.ServiceBroker
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBrokersReturnsOnCall(i int, result1 []resources.ServiceBroker, result2 ccv3.Warnings, result3 error) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = nil
	if fake.getServiceBrokersReturnsOnCall == nil {
		fake.getServiceBrokersReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceBroker
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceBrokersReturnsOnCall[i] = struct {
		result1 []resources.ServiceBroker
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetails(arg1 string) (resources.ServiceCredentialBindingDetails, ccv3.Warnings, error) {
	fake.getServiceCredentialBindingDetailsMutex.Lock()
	ret, specificReturn := fake.getServiceCredentialBindingDetailsReturnsOnCall[len(fake.getServiceCredentialBindingDetailsArgsForCall)]
	fake.getServiceCredentialBindingDetailsArgsForCall = append(fake.getServiceCredentialBindingDetailsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceCredentialBindingDetailsStub
	fakeReturns := fake.getServiceCredentialBindingDetailsReturns
	fake.recordInvocation("GetServiceCredentialBindingDetails", []interface{}{arg1})
	fake.getServiceCredentialBindingDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsCallCount() int {
	fake.getServiceCredentialBindingDetailsMutex.RLock()
	defer fake.getServiceCredentialBindingDetailsMutex.RUnlock()
	return len(fake.getServiceCredentialBindingDetailsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsCalls(stub func(string) (resources.ServiceCredentialBindingDetails, ccv3.Warnings, error)) {
	fake.getServiceCredentialBindingDetailsMutex.Lock()
	defer fake.getServiceCredentialBindingDetailsMutex.Unlock()
	fake.GetServiceCredentialBindingDetailsStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsArgsForCall(i int) string {
	fake.getServiceCredentialBindingDetailsMutex.RLock()
	defer fake.getServiceCredentialBindingDetailsMutex.RUnlock()
	argsForCall := fake.getServiceCredentialBindingDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsReturns(result1 resources.ServiceCredentialBindingDetails, result2 ccv3.Warnings, result3 error) {
	fake.getServiceCredentialBindingDetailsMutex.Lock()
	defer fake.getServiceCredentialBindingDetailsMutex.Unlock()
	fake.GetServiceCredentialBindingDetailsStub = nil
	fake.getServiceCredentialBindingDetailsReturns = struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingDetailsReturnsOnCall(i int, result1 resources.ServiceCredentialBindingDetails, result2 ccv3.Warnings, result3 error) {
	fake.getServiceCredentialBindingDetailsMutex.Lock()
	defer fake.getServiceCredentialBindingDetailsMutex.Unlock()
	fake.GetServiceCredentialBindingDetailsStub = nil
	if fake.getServiceCredentialBindingDetailsReturnsOnCall == nil {
		fake.getServiceCredentialBindingDetailsReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceCredentialBindingDetails
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceCredentialBindingDetailsReturnsOnCall[i] = struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindings(arg1 ...ccv3.Query) ([]resources.ServiceCredentialBinding, ccv3.Warnings, error) {
	fake.getServiceCredentialBindingsMutex.Lock()
	ret, specificReturn := fake.getServiceCredentialBindingsReturnsOnCall[len(fake.getServiceCredentialBindingsArgsForCall)]
	fake.getServiceCredentialBindingsArgsForCall = append(fake.getServiceCredentialBindingsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServiceCredentialBindingsStub
	fakeReturns := fake.getServiceCredentialBindingsReturns
	fake.recordInvocation("GetServiceCredentialBindings", []interface{}{arg1})
	fake.getServiceCredentialBindingsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsCallCount() int {
	fake.getServiceCredentialBindingsMutex.RLock()
	defer fake.getServiceCredentialBindingsMutex.RUnlock()
	return len(fake.getServiceCredentialBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsCalls(stub func(...ccv3.Query) ([]resources.ServiceCredentialBinding, ccv3.Warnings, error)) {
	fake.getServiceCredentialBindingsMutex.Lock()
	defer fake.getServiceCredentialBindingsMutex.Unlock()
	fake.GetServiceCredentialBindingsStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsArgsForCall(i int) []ccv3.Query {
	fake.getServiceCredentialBindingsMutex.RLock()
	defer fake.getServiceCredentialBindingsMutex.RUnlock()
	argsForCall := fake.getServiceCredentialBindingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsReturns(result1 []resources.ServiceCredentialBinding, result2 ccv3.Warnings, result3 error) {
	fake.getServiceCredentialBindingsMutex.Lock()
	defer fake.getServiceCredentialBindingsMutex.Unlock()
	fake.GetServiceCredentialBindingsStub = nil
	fake.getServiceCredentialBindingsReturns = struct {
		result1 []resources.ServiceCredentialBinding
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceCredentialBindingsReturnsOnCall(i int, result1 []resources.ServiceCredentialBinding, result2 ccv3.Warnings, result3 error) {
	fake.getServiceCredentialBindingsMutex.Lock()
	defer fake.getServiceCredentialBindingsMutex.Unlock()
	fake.GetServiceCredentialBindingsStub = nil
	if fake.getServiceCredentialBindingsReturnsOnCall == nil {
		fake.getServiceCredentialBindingsReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceCredentialBinding
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceCredentialBindingsReturnsOnCall[i] = struct {
		result1 []resources.ServiceCredentialBinding
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpace(arg1 string, arg2 string, arg3 ...ccv3.Query) (resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceByNameAndSpaceReturnsOnCall[len(fake.getServiceInstanceByNameAndSpaceArgsForCall)]
	fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 []ccv3.Query
	}{arg1, arg2, arg3})
	stub := fake.GetServiceInstanceByNameAndSpaceStub
	fakeReturns := fake.getServiceInstanceByNameAndSpaceReturns
	fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceCallCount() int {
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	return len(fake.getServiceInstanceByNameAndSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceCalls(stub func(string, string, ...ccv3.Query) (resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error)) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceArgsForCall(i int) (string, string, []ccv3.Query) {
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getServiceInstanceByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceReturns(result1 resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = nil
	fake.getServiceInstanceByNameAndSpaceReturns = struct {
		result1 resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceByNameAndSpaceReturnsOnCall(i int, result1 resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = nil
	if fake.getServiceInstanceByNameAndSpaceReturnsOnCall == nil {
		fake.getServiceInstanceByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceInstance
			result2 ccv3.IncludedResources
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getServiceInstanceByNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParameters(arg1 string) (types.JSONObject, ccv3.Warnings, error) {
	fake.getServiceInstanceParametersMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceParametersReturnsOnCall[len(fake.getServiceInstanceParametersArgsForCall)]
	fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceInstanceParametersStub
	fakeReturns := fake.getServiceInstanceParametersReturns
	fake.recordInvocation("GetServiceInstanceParameters", []interface{}{arg1})
	fake.getServiceInstanceParametersMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParametersCallCount() int {
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	return len(fake.getServiceInstanceParametersArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParametersCalls(stub func(string) (types.JSONObject, ccv3.Warnings, error)) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParametersArgsForCall(i int) string {
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	argsForCall := fake.getServiceInstanceParametersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParametersReturns(result1 types.JSONObject, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = nil
	fake.getServiceInstanceParametersReturns = struct {
		result1 types.JSONObject
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceParametersReturnsOnCall(i int, result1 types.JSONObject, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = nil
	if fake.getServiceInstanceParametersReturnsOnCall == nil {
		fake.getServiceInstanceParametersReturnsOnCall = make(map[int]struct {
			result1 types.JSONObject
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceParametersReturnsOnCall[i] = struct {
		result1 types.JSONObject
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpaces(arg1 string) ([]ccv3.SpaceWithOrganization, ccv3.Warnings, error) {
	fake.getServiceInstanceSharedSpacesMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceSharedSpacesReturnsOnCall[len(fake.getServiceInstanceSharedSpacesArgsForCall)]
	fake.getServiceInstanceSharedSpacesArgsForCall = append(fake.getServiceInstanceSharedSpacesArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceInstanceSharedSpacesStub
	fakeReturns := fake.getServiceInstanceSharedSpacesReturns
	fake.recordInvocation("GetServiceInstanceSharedSpaces", []interface{}{arg1})
	fake.getServiceInstanceSharedSpacesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesCallCount() int {
	fake.getServiceInstanceSharedSpacesMutex.RLock()
	defer fake.getServiceInstanceSharedSpacesMutex.RUnlock()
	return len(fake.getServiceInstanceSharedSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesCalls(stub func(string) ([]ccv3.SpaceWithOrganization, ccv3.Warnings, error)) {
	fake.getServiceInstanceSharedSpacesMutex.Lock()
	defer fake.getServiceInstanceSharedSpacesMutex.Unlock()
	fake.GetServiceInstanceSharedSpacesStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesArgsForCall(i int) string {
	fake.getServiceInstanceSharedSpacesMutex.RLock()
	defer fake.getServiceInstanceSharedSpacesMutex.RUnlock()
	argsForCall := fake.getServiceInstanceSharedSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesReturns(result1 []ccv3.SpaceWithOrganization, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceSharedSpacesMutex.Lock()
	defer fake.getServiceInstanceSharedSpacesMutex.Unlock()
	fake.GetServiceInstanceSharedSpacesStub = nil
	fake.getServiceInstanceSharedSpacesReturns = struct {
		result1 []ccv3.SpaceWithOrganization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedSpacesReturnsOnCall(i int, result1 []ccv3.SpaceWithOrganization, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceSharedSpacesMutex.Lock()
	defer fake.getServiceInstanceSharedSpacesMutex.Unlock()
	fake.GetServiceInstanceSharedSpacesStub = nil
	if fake.getServiceInstanceSharedSpacesReturnsOnCall == nil {
		fake.getServiceInstanceSharedSpacesReturnsOnCall = make(map[int]struct {
			result1 []ccv3.SpaceWithOrganization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceSharedSpacesReturnsOnCall[i] = struct {
		result1 []ccv3.SpaceWithOrganization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummary(arg1 string) ([]resources.ServiceInstanceUsageSummary, ccv3.Warnings, error) {
	fake.getServiceInstanceUsageSummaryMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceUsageSummaryReturnsOnCall[len(fake.getServiceInstanceUsageSummaryArgsForCall)]
	fake.getServiceInstanceUsageSummaryArgsForCall = append(fake.getServiceInstanceUsageSummaryArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceInstanceUsageSummaryStub
	fakeReturns := fake.getServiceInstanceUsageSummaryReturns
	fake.recordInvocation("GetServiceInstanceUsageSummary", []interface{}{arg1})
	fake.getServiceInstanceUsageSummaryMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryCallCount() int {
	fake.getServiceInstanceUsageSummaryMutex.RLock()
	defer fake.getServiceInstanceUsageSummaryMutex.RUnlock()
	return len(fake.getServiceInstanceUsageSummaryArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryCalls(stub func(string) ([]resources.ServiceInstanceUsageSummary, ccv3.Warnings, error)) {
	fake.getServiceInstanceUsageSummaryMutex.Lock()
	defer fake.getServiceInstanceUsageSummaryMutex.Unlock()
	fake.GetServiceInstanceUsageSummaryStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryArgsForCall(i int) string {
	fake.getServiceInstanceUsageSummaryMutex.RLock()
	defer fake.getServiceInstanceUsageSummaryMutex.RUnlock()
	argsForCall := fake.getServiceInstanceUsageSummaryArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryReturns(result1 []resources.ServiceInstanceUsageSummary, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceUsageSummaryMutex.Lock()
	defer fake.getServiceInstanceUsageSummaryMutex.Unlock()
	fake.GetServiceInstanceUsageSummaryStub = nil
	fake.getServiceInstanceUsageSummaryReturns = struct {
		result1 []resources.ServiceInstanceUsageSummary
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceUsageSummaryReturnsOnCall(i int, result1 []resources.ServiceInstanceUsageSummary, result2 ccv3.Warnings, result3 error) {
	fake.getServiceInstanceUsageSummaryMutex.Lock()
	defer fake.getServiceInstanceUsageSummaryMutex.Unlock()
	fake.GetServiceInstanceUsageSummaryStub = nil
	if fake.getServiceInstanceUsageSummaryReturnsOnCall == nil {
		fake.getServiceInstanceUsageSummaryReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceInstanceUsageSummary
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceUsageSummaryReturnsOnCall[i] = struct {
		result1 []resources.ServiceInstanceUsageSummary
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstances(arg1 ...ccv3.Query) ([]resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error) {
	fake.getServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServiceInstancesStub
	fakeReturns := fake.getServiceInstancesReturns
	fake.recordInvocation("GetServiceInstances", []interface{}{arg1})
	fake.getServiceInstancesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

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

func (fake *FakeCloudControllerClient) GetServiceInstancesCalls(stub func(...ccv3.Query) ([]resources.ServiceInstance, ccv3.IncludedResources, ccv3.Warnings, error)) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstancesArgsForCall(i int) []ccv3.Query {
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	argsForCall := fake.getServiceInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturns(result1 []resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = nil
	fake.getServiceInstancesReturns = struct {
		result1 []resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturnsOnCall(i int, result1 []resources.ServiceInstance, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = nil
	if fake.getServiceInstancesReturnsOnCall == nil {
		fake.getServiceInstancesReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceInstance
			result2 ccv3.IncludedResources
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getServiceInstancesReturnsOnCall[i] = struct {
		result1 []resources.ServiceInstance
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUID(arg1 string) (resources.ServiceOffering, ccv3.Warnings, error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingByGUIDReturnsOnCall[len(fake.getServiceOfferingByGUIDArgsForCall)]
	fake.getServiceOfferingByGUIDArgsForCall = append(fake.getServiceOfferingByGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceOfferingByGUIDStub
	fakeReturns := fake.getServiceOfferingByGUIDReturns
	fake.recordInvocation("GetServiceOfferingByGUID", []interface{}{arg1})
	fake.getServiceOfferingByGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDCallCount() int {
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	return len(fake.getServiceOfferingByGUIDArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDCalls(stub func(string) (resources.ServiceOffering, ccv3.Warnings, error)) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDArgsForCall(i int) string {
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	argsForCall := fake.getServiceOfferingByGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDReturns(result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = nil
	fake.getServiceOfferingByGUIDReturns = struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByGUIDReturnsOnCall(i int, result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingByGUIDMutex.Lock()
	defer fake.getServiceOfferingByGUIDMutex.Unlock()
	fake.GetServiceOfferingByGUIDStub = nil
	if fake.getServiceOfferingByGUIDReturnsOnCall == nil {
		fake.getServiceOfferingByGUIDReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceOffering
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceOfferingByGUIDReturnsOnCall[i] = struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBroker(arg1 string, arg2 string) (resources.ServiceOffering, ccv3.Warnings, error) {
	fake.getServiceOfferingByNameAndBrokerMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingByNameAndBrokerReturnsOnCall[len(fake.getServiceOfferingByNameAndBrokerArgsForCall)]
	fake.getServiceOfferingByNameAndBrokerArgsForCall = append(fake.getServiceOfferingByNameAndBrokerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetServiceOfferingByNameAndBrokerStub
	fakeReturns := fake.getServiceOfferingByNameAndBrokerReturns
	fake.recordInvocation("GetServiceOfferingByNameAndBroker", []interface{}{arg1, arg2})
	fake.getServiceOfferingByNameAndBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerCallCount() int {
	fake.getServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.RUnlock()
	return len(fake.getServiceOfferingByNameAndBrokerArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerCalls(stub func(string, string) (resources.ServiceOffering, ccv3.Warnings, error)) {
	fake.getServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.GetServiceOfferingByNameAndBrokerStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerArgsForCall(i int) (string, string) {
	fake.getServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.RUnlock()
	argsForCall := fake.getServiceOfferingByNameAndBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerReturns(result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.GetServiceOfferingByNameAndBrokerStub = nil
	fake.getServiceOfferingByNameAndBrokerReturns = struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceOfferingByNameAndBrokerReturnsOnCall(i int, result1 resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.GetServiceOfferingByNameAndBrokerStub = nil
	if fake.getServiceOfferingByNameAndBrokerReturnsOnCall == nil {
		fake.getServiceOfferingByNameAndBrokerReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceOffering
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceOfferingByNameAndBrokerReturnsOnCall[i] = struct {
		result1 resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceOfferings(arg1 ...ccv3.Query) ([]resources.ServiceOffering, ccv3.Warnings, error) {
	fake.getServiceOfferingsMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingsReturnsOnCall[len(fake.getServiceOfferingsArgsForCall)]
	fake.getServiceOfferingsArgsForCall = append(fake.getServiceOfferingsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServiceOfferingsStub
	fakeReturns := fake.getServiceOfferingsReturns
	fake.recordInvocation("GetServiceOfferings", []interface{}{arg1})
	fake.getServiceOfferingsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceOfferingsCallCount() int {
	fake.getServiceOfferingsMutex.RLock()
	defer fake.getServiceOfferingsMutex.RUnlock()
	return len(fake.getServiceOfferingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceOfferingsCalls(stub func(...ccv3.Query) ([]resources.ServiceOffering, ccv3.Warnings, error)) {
	fake.getServiceOfferingsMutex.Lock()
	defer fake.getServiceOfferingsMutex.Unlock()
	fake.GetServiceOfferingsStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceOfferingsArgsForCall(i int) []ccv3.Query {
	fake.getServiceOfferingsMutex.RLock()
	defer fake.getServiceOfferingsMutex.RUnlock()
	argsForCall := fake.getServiceOfferingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceOfferingsReturns(result1 []resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingsMutex.Lock()
	defer fake.getServiceOfferingsMutex.Unlock()
	fake.GetServiceOfferingsStub = nil
	fake.getServiceOfferingsReturns = struct {
		result1 []resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceOfferingsReturnsOnCall(i int, result1 []resources.ServiceOffering, result2 ccv3.Warnings, result3 error) {
	fake.getServiceOfferingsMutex.Lock()
	defer fake.getServiceOfferingsMutex.Unlock()
	fake.GetServiceOfferingsStub = nil
	if fake.getServiceOfferingsReturnsOnCall == nil {
		fake.getServiceOfferingsReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceOffering
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServiceOfferingsReturnsOnCall[i] = struct {
		result1 []resources.ServiceOffering
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUID(arg1 string) (resources.ServicePlan, ccv3.Warnings, error) {
	fake.getServicePlanByGUIDMutex.Lock()
	ret, specificReturn := fake.getServicePlanByGUIDReturnsOnCall[len(fake.getServicePlanByGUIDArgsForCall)]
	fake.getServicePlanByGUIDArgsForCall = append(fake.getServicePlanByGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServicePlanByGUIDStub
	fakeReturns := fake.getServicePlanByGUIDReturns
	fake.recordInvocation("GetServicePlanByGUID", []interface{}{arg1})
	fake.getServicePlanByGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUIDCallCount() int {
	fake.getServicePlanByGUIDMutex.RLock()
	defer fake.getServicePlanByGUIDMutex.RUnlock()
	return len(fake.getServicePlanByGUIDArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUIDCalls(stub func(string) (resources.ServicePlan, ccv3.Warnings, error)) {
	fake.getServicePlanByGUIDMutex.Lock()
	defer fake.getServicePlanByGUIDMutex.Unlock()
	fake.GetServicePlanByGUIDStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUIDArgsForCall(i int) string {
	fake.getServicePlanByGUIDMutex.RLock()
	defer fake.getServicePlanByGUIDMutex.RUnlock()
	argsForCall := fake.getServicePlanByGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUIDReturns(result1 resources.ServicePlan, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlanByGUIDMutex.Lock()
	defer fake.getServicePlanByGUIDMutex.Unlock()
	fake.GetServicePlanByGUIDStub = nil
	fake.getServicePlanByGUIDReturns = struct {
		result1 resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanByGUIDReturnsOnCall(i int, result1 resources.ServicePlan, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlanByGUIDMutex.Lock()
	defer fake.getServicePlanByGUIDMutex.Unlock()
	fake.GetServicePlanByGUIDStub = nil
	if fake.getServicePlanByGUIDReturnsOnCall == nil {
		fake.getServicePlanByGUIDReturnsOnCall = make(map[int]struct {
			result1 resources.ServicePlan
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServicePlanByGUIDReturnsOnCall[i] = struct {
		result1 resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibility(arg1 string) (resources.ServicePlanVisibility, ccv3.Warnings, error) {
	fake.getServicePlanVisibilityMutex.Lock()
	ret, specificReturn := fake.getServicePlanVisibilityReturnsOnCall[len(fake.getServicePlanVisibilityArgsForCall)]
	fake.getServicePlanVisibilityArgsForCall = append(fake.getServicePlanVisibilityArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServicePlanVisibilityStub
	fakeReturns := fake.getServicePlanVisibilityReturns
	fake.recordInvocation("GetServicePlanVisibility", []interface{}{arg1})
	fake.getServicePlanVisibilityMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilityCallCount() int {
	fake.getServicePlanVisibilityMutex.RLock()
	defer fake.getServicePlanVisibilityMutex.RUnlock()
	return len(fake.getServicePlanVisibilityArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilityCalls(stub func(string) (resources.ServicePlanVisibility, ccv3.Warnings, error)) {
	fake.getServicePlanVisibilityMutex.Lock()
	defer fake.getServicePlanVisibilityMutex.Unlock()
	fake.GetServicePlanVisibilityStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilityArgsForCall(i int) string {
	fake.getServicePlanVisibilityMutex.RLock()
	defer fake.getServicePlanVisibilityMutex.RUnlock()
	argsForCall := fake.getServicePlanVisibilityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilityReturns(result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlanVisibilityMutex.Lock()
	defer fake.getServicePlanVisibilityMutex.Unlock()
	fake.GetServicePlanVisibilityStub = nil
	fake.getServicePlanVisibilityReturns = struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilityReturnsOnCall(i int, result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlanVisibilityMutex.Lock()
	defer fake.getServicePlanVisibilityMutex.Unlock()
	fake.GetServicePlanVisibilityStub = nil
	if fake.getServicePlanVisibilityReturnsOnCall == nil {
		fake.getServicePlanVisibilityReturnsOnCall = make(map[int]struct {
			result1 resources.ServicePlanVisibility
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServicePlanVisibilityReturnsOnCall[i] = struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlans(arg1 ...ccv3.Query) ([]resources.ServicePlan, ccv3.Warnings, error) {
	fake.getServicePlansMutex.Lock()
	ret, specificReturn := fake.getServicePlansReturnsOnCall[len(fake.getServicePlansArgsForCall)]
	fake.getServicePlansArgsForCall = append(fake.getServicePlansArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServicePlansStub
	fakeReturns := fake.getServicePlansReturns
	fake.recordInvocation("GetServicePlans", []interface{}{arg1})
	fake.getServicePlansMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlansCallCount() int {
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	return len(fake.getServicePlansArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlansCalls(stub func(...ccv3.Query) ([]resources.ServicePlan, ccv3.Warnings, error)) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlansArgsForCall(i int) []ccv3.Query {
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	argsForCall := fake.getServicePlansArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlansReturns(result1 []resources.ServicePlan, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = nil
	fake.getServicePlansReturns = struct {
		result1 []resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansReturnsOnCall(i int, result1 []resources.ServicePlan, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = nil
	if fake.getServicePlansReturnsOnCall == nil {
		fake.getServicePlansReturnsOnCall = make(map[int]struct {
			result1 []resources.ServicePlan
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServicePlansReturnsOnCall[i] = struct {
		result1 []resources.ServicePlan
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferings(arg1 ...ccv3.Query) ([]ccv3.ServiceOfferingWithPlans, ccv3.Warnings, error) {
	fake.getServicePlansWithOfferingsMutex.Lock()
	ret, specificReturn := fake.getServicePlansWithOfferingsReturnsOnCall[len(fake.getServicePlansWithOfferingsArgsForCall)]
	fake.getServicePlansWithOfferingsArgsForCall = append(fake.getServicePlansWithOfferingsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServicePlansWithOfferingsStub
	fakeReturns := fake.getServicePlansWithOfferingsReturns
	fake.recordInvocation("GetServicePlansWithOfferings", []interface{}{arg1})
	fake.getServicePlansWithOfferingsMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsCallCount() int {
	fake.getServicePlansWithOfferingsMutex.RLock()
	defer fake.getServicePlansWithOfferingsMutex.RUnlock()
	return len(fake.getServicePlansWithOfferingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsCalls(stub func(...ccv3.Query) ([]ccv3.ServiceOfferingWithPlans, ccv3.Warnings, error)) {
	fake.getServicePlansWithOfferingsMutex.Lock()
	defer fake.getServicePlansWithOfferingsMutex.Unlock()
	fake.GetServicePlansWithOfferingsStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsArgsForCall(i int) []ccv3.Query {
	fake.getServicePlansWithOfferingsMutex.RLock()
	defer fake.getServicePlansWithOfferingsMutex.RUnlock()
	argsForCall := fake.getServicePlansWithOfferingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsReturns(result1 []ccv3.ServiceOfferingWithPlans, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansWithOfferingsMutex.Lock()
	defer fake.getServicePlansWithOfferingsMutex.Unlock()
	fake.GetServicePlansWithOfferingsStub = nil
	fake.getServicePlansWithOfferingsReturns = struct {
		result1 []ccv3.ServiceOfferingWithPlans
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansWithOfferingsReturnsOnCall(i int, result1 []ccv3.ServiceOfferingWithPlans, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansWithOfferingsMutex.Lock()
	defer fake.getServicePlansWithOfferingsMutex.Unlock()
	fake.GetServicePlansWithOfferingsStub = nil
	if fake.getServicePlansWithOfferingsReturnsOnCall == nil {
		fake.getServicePlansWithOfferingsReturnsOnCall = make(map[int]struct {
			result1 []ccv3.ServiceOfferingWithPlans
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServicePlansWithOfferingsReturnsOnCall[i] = struct {
		result1 []ccv3.ServiceOfferingWithPlans
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganization(arg1 ...ccv3.Query) ([]ccv3.ServicePlanWithSpaceAndOrganization, ccv3.Warnings, error) {
	fake.getServicePlansWithSpaceAndOrganizationMutex.Lock()
	ret, specificReturn := fake.getServicePlansWithSpaceAndOrganizationReturnsOnCall[len(fake.getServicePlansWithSpaceAndOrganizationArgsForCall)]
	fake.getServicePlansWithSpaceAndOrganizationArgsForCall = append(fake.getServicePlansWithSpaceAndOrganizationArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetServicePlansWithSpaceAndOrganizationStub
	fakeReturns := fake.getServicePlansWithSpaceAndOrganizationReturns
	fake.recordInvocation("GetServicePlansWithSpaceAndOrganization", []interface{}{arg1})
	fake.getServicePlansWithSpaceAndOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationCallCount() int {
	fake.getServicePlansWithSpaceAndOrganizationMutex.RLock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.RUnlock()
	return len(fake.getServicePlansWithSpaceAndOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationCalls(stub func(...ccv3.Query) ([]ccv3.ServicePlanWithSpaceAndOrganization, ccv3.Warnings, error)) {
	fake.getServicePlansWithSpaceAndOrganizationMutex.Lock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.Unlock()
	fake.GetServicePlansWithSpaceAndOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationArgsForCall(i int) []ccv3.Query {
	fake.getServicePlansWithSpaceAndOrganizationMutex.RLock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.RUnlock()
	argsForCall := fake.getServicePlansWithSpaceAndOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationReturns(result1 []ccv3.ServicePlanWithSpaceAndOrganization, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansWithSpaceAndOrganizationMutex.Lock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.Unlock()
	fake.GetServicePlansWithSpaceAndOrganizationStub = nil
	fake.getServicePlansWithSpaceAndOrganizationReturns = struct {
		result1 []ccv3.ServicePlanWithSpaceAndOrganization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansWithSpaceAndOrganizationReturnsOnCall(i int, result1 []ccv3.ServicePlanWithSpaceAndOrganization, result2 ccv3.Warnings, result3 error) {
	fake.getServicePlansWithSpaceAndOrganizationMutex.Lock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.Unlock()
	fake.GetServicePlansWithSpaceAndOrganizationStub = nil
	if fake.getServicePlansWithSpaceAndOrganizationReturnsOnCall == nil {
		fake.getServicePlansWithSpaceAndOrganizationReturnsOnCall = make(map[int]struct {
			result1 []ccv3.ServicePlanWithSpaceAndOrganization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getServicePlansWithSpaceAndOrganizationReturnsOnCall[i] = struct {
		result1 []ccv3.ServicePlanWithSpaceAndOrganization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceFeature(arg1 string, arg2 string) (bool, ccv3.Warnings, error) {
	fake.getSpaceFeatureMutex.Lock()
	ret, specificReturn := fake.getSpaceFeatureReturnsOnCall[len(fake.getSpaceFeatureArgsForCall)]
	fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetSpaceFeatureStub
	fakeReturns := fake.getSpaceFeatureReturns
	fake.recordInvocation("GetSpaceFeature", []interface{}{arg1, arg2})
	fake.getSpaceFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceFeatureCallCount() int {
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	return len(fake.getSpaceFeatureArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceFeatureCalls(stub func(string, string) (bool, ccv3.Warnings, error)) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceFeatureArgsForCall(i int) (string, string) {
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	argsForCall := fake.getSpaceFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceFeatureReturns(result1 bool, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = nil
	fake.getSpaceFeatureReturns = struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceFeatureReturnsOnCall(i int, result1 bool, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = nil
	if fake.getSpaceFeatureReturnsOnCall == nil {
		fake.getSpaceFeatureReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceFeatureReturnsOnCall[i] = struct {
		result1 bool
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getSpaceIsolationSegmentReturnsOnCall[len(fake.getSpaceIsolationSegmentArgsForCall)]
	fake.getSpaceIsolationSegmentArgsForCall = append(fake.getSpaceIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetSpaceIsolationSegmentStub
	fakeReturns := fake.getSpaceIsolationSegmentReturns
	fake.recordInvocation("GetSpaceIsolationSegment", []interface{}{arg1})
	fake.getSpaceIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentCallCount() int {
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	return len(fake.getSpaceIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentCalls(stub func(string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentArgsForCall(i int) string {
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getSpaceIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = nil
	fake.getSpaceIsolationSegmentReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = nil
	if fake.getSpaceIsolationSegmentReturnsOnCall == nil {
		fake.getSpaceIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiff(arg1 string, arg2 []byte) (resources.ManifestDiff, ccv3.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.getSpaceManifestDiffMutex.Lock()
	ret, specificReturn := fake.getSpaceManifestDiffReturnsOnCall[len(fake.getSpaceManifestDiffArgsForCall)]
	fake.getSpaceManifestDiffArgsForCall = append(fake.getSpaceManifestDiffArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	stub := fake.GetSpaceManifestDiffStub
	fakeReturns := fake.getSpaceManifestDiffReturns
	fake.recordInvocation("GetSpaceManifestDiff", []interface{}{arg1, arg2Copy})
	fake.getSpaceManifestDiffMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiffCallCount() int {
	fake.getSpaceManifestDiffMutex.RLock()
	defer fake.getSpaceManifestDiffMutex.RUnlock()
	return len(fake.getSpaceManifestDiffArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiffCalls(stub func(string, []byte) (resources.ManifestDiff, ccv3.Warnings, error)) {
	fake.getSpaceManifestDiffMutex.Lock()
	defer fake.getSpaceManifestDiffMutex.Unlock()
	fake.GetSpaceManifestDiffStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiffArgsForCall(i int) (string, []byte) {
	fake.getSpaceManifestDiffMutex.RLock()
	defer fake.getSpaceManifestDiffMutex.RUnlock()
	argsForCall := fake.getSpaceManifestDiffArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiffReturns(result1 resources.ManifestDiff, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceManifestDiffMutex.Lock()
	defer fake.getSpaceManifestDiffMutex.Unlock()
	fake.GetSpaceManifestDiffStub = nil
	fake.getSpaceManifestDiffReturns = struct {
		result1 resources.ManifestDiff
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceManifestDiffReturnsOnCall(i int, result1 resources.ManifestDiff, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceManifestDiffMutex.Lock()
	defer fake.getSpaceManifestDiffMutex.Unlock()
	fake.GetSpaceManifestDiffStub = nil
	if fake.getSpaceManifestDiffReturnsOnCall == nil {
		fake.getSpaceManifestDiffReturnsOnCall = make(map[int]struct {
			result1 resources.ManifestDiff
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceManifestDiffReturnsOnCall[i] = struct {
		result1 resources.ManifestDiff
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) GetSpaceQuotaCalls(stub func(string) (resources.SpaceQuota, ccv3.Warnings, error)) {
	fake.getSpaceQuotaMutex.Lock()
	defer fake.getSpaceQuotaMutex.Unlock()
	fake.GetSpaceQuotaStub = stub
}

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

func (fake *FakeCloudControllerClient) GetSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceQuotaMutex.Lock()
	defer fake.getSpaceQuotaMutex.Unlock()
	fake.GetSpaceQuotaStub = nil
	fake.getSpaceQuotaReturns = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaReturnsOnCall(i int, result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceQuotaMutex.Lock()
	defer fake.getSpaceQuotaMutex.Unlock()
	fake.GetSpaceQuotaStub = nil
	if fake.getSpaceQuotaReturnsOnCall == nil {
		fake.getSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.SpaceQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotaReturnsOnCall[i] = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotas(arg1 ...ccv3.Query) ([]resources.SpaceQuota, ccv3.Warnings, error) {
	fake.getSpaceQuotasMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotasReturnsOnCall[len(fake.getSpaceQuotasArgsForCall)]
	fake.getSpaceQuotasArgsForCall = append(fake.getSpaceQuotasArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetSpaceQuotasStub
	fakeReturns := fake.getSpaceQuotasReturns
	fake.recordInvocation("GetSpaceQuotas", []interface{}{arg1})
	fake.getSpaceQuotasMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasCallCount() int {
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	return len(fake.getSpaceQuotasArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasCalls(stub func(...ccv3.Query) ([]resources.SpaceQuota, ccv3.Warnings, error)) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasArgsForCall(i int) []ccv3.Query {
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	argsForCall := fake.getSpaceQuotasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasReturns(result1 []resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = nil
	fake.getSpaceQuotasReturns = struct {
		result1 []resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasReturnsOnCall(i int, result1 []resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = nil
	if fake.getSpaceQuotasReturnsOnCall == nil {
		fake.getSpaceQuotasReturnsOnCall = make(map[int]struct {
			result1 []resources.SpaceQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotasReturnsOnCall[i] = struct {
		result1 []resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaces(arg1 ...ccv3.Query) ([]resources.Space, ccv3.IncludedResources, ccv3.Warnings, error) {
	fake.getSpacesMutex.Lock()
	ret, specificReturn := fake.getSpacesReturnsOnCall[len(fake.getSpacesArgsForCall)]
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetSpacesStub
	fakeReturns := fake.getSpacesReturns
	fake.recordInvocation("GetSpaces", []interface{}{arg1})
	fake.getSpacesMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

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

func (fake *FakeCloudControllerClient) GetSpacesCalls(stub func(...ccv3.Query) ([]resources.Space, ccv3.IncludedResources, ccv3.Warnings, error)) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = stub
}

func (fake *FakeCloudControllerClient) GetSpacesArgsForCall(i int) []ccv3.Query {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	argsForCall := fake.getSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpacesReturns(result1 []resources.Space, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = nil
	fake.getSpacesReturns = struct {
		result1 []resources.Space
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetSpacesReturnsOnCall(i int, result1 []resources.Space, result2 ccv3.IncludedResources, result3 ccv3.Warnings, result4 error) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = nil
	if fake.getSpacesReturnsOnCall == nil {
		fake.getSpacesReturnsOnCall = make(map[int]struct {
			result1 []resources.Space
			result2 ccv3.IncludedResources
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getSpacesReturnsOnCall[i] = struct {
		result1 []resources.Space
		result2 ccv3.IncludedResources
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeCloudControllerClient) GetStacks(arg1 ...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error) {
	fake.getStacksMutex.Lock()
	ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)]
	fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetStacksStub
	fakeReturns := fake.getStacksReturns
	fake.recordInvocation("GetStacks", []interface{}{arg1})
	fake.getStacksMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) GetStacksCalls(stub func(...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error)) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = stub
}

func (fake *FakeCloudControllerClient) GetStacksArgsForCall(i int) []ccv3.Query {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	argsForCall := fake.getStacksArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetStacksReturns(result1 []resources.Stack, result2 ccv3.Warnings, result3 error) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = nil
	fake.getStacksReturns = struct {
		result1 []resources.Stack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetStagingSecurityGroups(arg1 string, arg2 ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error) {
	fake.getStagingSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getStagingSecurityGroupsReturnsOnCall[len(fake.getStagingSecurityGroupsArgsForCall)]
	fake.getStagingSecurityGroupsArgsForCall = append(fake.getStagingSecurityGroupsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	stub := fake.GetStagingSecurityGroupsStub
	fakeReturns := fake.getStagingSecurityGroupsReturns
	fake.recordInvocation("GetStagingSecurityGroups", []interface{}{arg1, arg2})
	fake.getStagingSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsCallCount() int {
	fake.getStagingSecurityGroupsMutex.RLock()
	defer fake.getStagingSecurityGroupsMutex.RUnlock()
	return len(fake.getStagingSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsCalls(stub func(string, ...ccv3.Query) ([]resources.SecurityGroup, ccv3.Warnings, error)) {
	fake.getStagingSecurityGroupsMutex.Lock()
	defer fake.getStagingSecurityGroupsMutex.Unlock()
	fake.GetStagingSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getStagingSecurityGroupsMutex.RLock()
	defer fake.getStagingSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getStagingSecurityGroupsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getStagingSecurityGroupsMutex.Lock()
	defer fake.getStagingSecurityGroupsMutex.Unlock()
	fake.GetStagingSecurityGroupsStub = nil
	fake.getStagingSecurityGroupsReturns = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStagingSecurityGroupsReturnsOnCall(i int, result1 []resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.getStagingSecurityGroupsMutex.Lock()
	defer fake.getStagingSecurityGroupsMutex.Unlock()
	fake.GetStagingSecurityGroupsStub = nil
	if fake.getStagingSecurityGroupsReturnsOnCall == nil {
		fake.getStagingSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []resources.SecurityGroup
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getStagingSecurityGroupsReturnsOnCall[i] = struct {
		result1 []resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetTask(arg1 string) (resources.Task, ccv3.Warnings, error) {
	fake.getTaskMutex.Lock()
	ret, specificReturn := fake.getTaskReturnsOnCall[len(fake.getTaskArgsForCall)]
	fake.getTaskArgsForCall = append(fake.getTaskArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetTaskStub
	fakeReturns := fake.getTaskReturns
	fake.recordInvocation("GetTask", []interface{}{arg1})
	fake.getTaskMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetTaskCallCount() int {
	fake.getTaskMutex.RLock()
	defer fake.getTaskMutex.RUnlock()
	return len(fake.getTaskArgsForCall)
}

func (fake *FakeCloudControllerClient) GetTaskCalls(stub func(string) (resources.Task, ccv3.Warnings, error)) {
	fake.getTaskMutex.Lock()
	defer fake.getTaskMutex.Unlock()
	fake.GetTaskStub = stub
}

func (fake *FakeCloudControllerClient) GetTaskArgsForCall(i int) string {
	fake.getTaskMutex.RLock()
	defer fake.getTaskMutex.RUnlock()
	argsForCall := fake.getTaskArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetTaskReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getTaskMutex.Lock()
	defer fake.getTaskMutex.Unlock()
	fake.GetTaskStub = nil
	fake.getTaskReturns = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetTaskReturnsOnCall(i int, result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getTaskMutex.Lock()
	defer fake.getTaskMutex.Unlock()
	fake.GetTaskStub = nil
	if fake.getTaskReturnsOnCall == nil {
		fake.getTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUser(arg1 string) (resources.User, ccv3.Warnings, error) {
	fake.getUserMutex.Lock()
	ret, specificReturn := fake.getUserReturnsOnCall[len(fake.getUserArgsForCall)]
	fake.getUserArgsForCall = append(fake.getUserArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetUserStub
	fakeReturns := fake.getUserReturns
	fake.recordInvocation("GetUser", []interface{}{arg1})
	fake.getUserMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetUserCallCount() int {
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	return len(fake.getUserArgsForCall)
}

func (fake *FakeCloudControllerClient) GetUserCalls(stub func(string) (resources.User, ccv3.Warnings, error)) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = stub
}

func (fake *FakeCloudControllerClient) GetUserArgsForCall(i int) string {
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	argsForCall := fake.getUserArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetUserReturns(result1 resources.User, result2 ccv3.Warnings, result3 error) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = nil
	fake.getUserReturns = struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUserReturnsOnCall(i int, result1 resources.User, result2 ccv3.Warnings, result3 error) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = nil
	if fake.getUserReturnsOnCall == nil {
		fake.getUserReturnsOnCall = make(map[int]struct {
			result1 resources.User
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getUserReturnsOnCall[i] = struct {
		result1 resources.User
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUsers(arg1 ...ccv3.Query) ([]resources.User, ccv3.Warnings, error) {
	fake.getUsersMutex.Lock()
	ret, specificReturn := fake.getUsersReturnsOnCall[len(fake.getUsersArgsForCall)]
	fake.getUsersArgsForCall = append(fake.getUsersArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	stub := fake.GetUsersStub
	fakeReturns := fake.getUsersReturns
	fake.recordInvocation("GetUsers", []interface{}{arg1})
	fake.getUsersMutex.Unlock()
	if stub != nil {
		return stub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetUsersCallCount() int {
	fake.getUsersMutex.RLock()
	defer fake.getUsersMutex.RUnlock()
	return len(fake.getUsersArgsForCall)
}

func (fake *FakeCloudControllerClient) GetUsersCalls(stub func(...ccv3.Query) ([]resources.User, ccv3.Warnings, error)) {
	fake.getUsersMutex.Lock()
	defer fake.getUsersMutex.Unlock()
	fake.GetUsersStub = stub
}

func (fake *FakeCloudControllerClient) GetUsersArgsForCall(i int) []ccv3.Query {
	fake.getUsersMutex.RLock()
	defer fake.getUsersMutex.RUnlock()
	argsForCall := fake.getUsersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetUsersReturns(result1 []resources.User, result2 ccv3.Warnings, result3 error) {
	fake.getUsersMutex.Lock()
	defer fake.getUsersMutex.Unlock()
	fake.GetUsersStub = nil
	fake.getUsersReturns = struct {
		result1 []resources.User
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUsersReturnsOnCall(i int, result1 []resources.User, result2 ccv3.Warnings, result3 error) {
	fake.getUsersMutex.Lock()
	defer fake.getUsersMutex.Unlock()
	fake.GetUsersStub = nil
	if fake.getUsersReturnsOnCall == nil {
		fake.getUsersReturnsOnCall = make(map[int]struct {
			result1 []resources.User
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getUsersReturnsOnCall[i] = struct {
		result1 []resources.User
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRaw(arg1 string, arg2 string, arg3 http.Header, arg4 []byte) ([]byte, *http.Response, error) {
	var arg4Copy []byte
	if arg4 != nil {
		arg4Copy = make([]byte, len(arg4))
		copy(arg4Copy, arg4)
	}
	fake.makeRequestSendReceiveRawMutex.Lock()
	ret, specificReturn := fake.makeRequestSendReceiveRawReturnsOnCall[len(fake.makeRequestSendReceiveRawArgsForCall)]
	fake.makeRequestSendReceiveRawArgsForCall = append(fake.makeRequestSendReceiveRawArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 http.Header
		arg4 []byte
	}{arg1, arg2, arg3, arg4Copy})
	stub := fake.MakeRequestSendReceiveRawStub
	fakeReturns := fake.makeRequestSendReceiveRawReturns
	fake.recordInvocation("MakeRequestSendReceiveRaw", []interface{}{arg1, arg2, arg3, arg4Copy})
	fake.makeRequestSendReceiveRawMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawCallCount() int {
	fake.makeRequestSendReceiveRawMutex.RLock()
	defer fake.makeRequestSendReceiveRawMutex.RUnlock()
	return len(fake.makeRequestSendReceiveRawArgsForCall)
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawCalls(stub func(string, string, http.Header, []byte) ([]byte, *http.Response, error)) {
	fake.makeRequestSendReceiveRawMutex.Lock()
	defer fake.makeRequestSendReceiveRawMutex.Unlock()
	fake.MakeRequestSendReceiveRawStub = stub
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawArgsForCall(i int) (string, string, http.Header, []byte) {
	fake.makeRequestSendReceiveRawMutex.RLock()
	defer fake.makeRequestSendReceiveRawMutex.RUnlock()
	argsForCall := fake.makeRequestSendReceiveRawArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawReturns(result1 []byte, result2 *http.Response, result3 error) {
	fake.makeRequestSendReceiveRawMutex.Lock()
	defer fake.makeRequestSendReceiveRawMutex.Unlock()
	fake.MakeRequestSendReceiveRawStub = nil
	fake.makeRequestSendReceiveRawReturns = struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) MakeRequestSendReceiveRawReturnsOnCall(i int, result1 []byte, result2 *http.Response, result3 error) {
	fake.makeRequestSendReceiveRawMutex.Lock()
	defer fake.makeRequestSendReceiveRawMutex.Unlock()
	fake.MakeRequestSendReceiveRawStub = nil
	if fake.makeRequestSendReceiveRawReturnsOnCall == nil {
		fake.makeRequestSendReceiveRawReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 *http.Response
			result3 error
		})
	}
	fake.makeRequestSendReceiveRawReturnsOnCall[i] = struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) MapRoute(arg1 string, arg2 string, arg3 string) (ccv3.Warnings, error) {
	fake.mapRouteMutex.Lock()
	ret, specificReturn := fake.mapRouteReturnsOnCall[len(fake.mapRouteArgsForCall)]
	fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.MapRouteStub
	fakeReturns := fake.mapRouteReturns
	fake.recordInvocation("MapRoute", []interface{}{arg1, arg2, arg3})
	fake.mapRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) MapRouteCallCount() int {
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	return len(fake.mapRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) MapRouteCalls(stub func(string, string, string) (ccv3.Warnings, error)) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = stub
}

func (fake *FakeCloudControllerClient) MapRouteArgsForCall(i int) (string, string, string) {
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	argsForCall := fake.mapRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) MapRouteReturns(result1 ccv3.Warnings, result2 error) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = nil
	fake.mapRouteReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) MapRouteReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = nil
	if fake.mapRouteReturnsOnCall == nil {
		fake.mapRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.mapRouteReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) MoveRoute(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.moveRouteMutex.Lock()
	ret, specificReturn := fake.moveRouteReturnsOnCall[len(fake.moveRouteArgsForCall)]
	fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.MoveRouteStub
	fakeReturns := fake.moveRouteReturns
	fake.recordInvocation("MoveRoute", []interface{}{arg1, arg2})
	fake.moveRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) MoveRouteCallCount() int {
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	return len(fake.moveRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) MoveRouteCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = stub
}

func (fake *FakeCloudControllerClient) MoveRouteArgsForCall(i int) (string, string) {
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	argsForCall := fake.moveRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) MoveRouteReturns(result1 ccv3.Warnings, result2 error) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = nil
	fake.moveRouteReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) MoveRouteReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = nil
	if fake.moveRouteReturnsOnCall == nil {
		fake.moveRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.moveRouteReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJob(arg1 ccv3.JobURL) (ccv3.Warnings, error) {
	fake.pollJobMutex.Lock()
	ret, specificReturn := fake.pollJobReturnsOnCall[len(fake.pollJobArgsForCall)]
	fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, struct {
		arg1 ccv3.JobURL
	}{arg1})
	stub := fake.PollJobStub
	fakeReturns := fake.pollJobReturns
	fake.recordInvocation("PollJob", []interface{}{arg1})
	fake.pollJobMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

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

func (fake *FakeCloudControllerClient) PollJobCalls(stub func(ccv3.JobURL) (ccv3.Warnings, error)) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = stub
}

func (fake *FakeCloudControllerClient) PollJobArgsForCall(i int) ccv3.JobURL {
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	argsForCall := fake.pollJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) PollJobReturns(result1 ccv3.Warnings, result2 error) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = nil
	fake.pollJobReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJobReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = nil
	if fake.pollJobReturnsOnCall == nil {
		fake.pollJobReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.pollJobReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJobForState(arg1 ccv3.JobURL, arg2 constant.JobState) (ccv3.Warnings, error) {
	fake.pollJobForStateMutex.Lock()
	ret, specificReturn := fake.pollJobForStateReturnsOnCall[len(fake.pollJobForStateArgsForCall)]
	fake.pollJobForStateArgsForCall = append(fake.pollJobForStateArgsForCall, struct {
		arg1 ccv3.JobURL
		arg2 constant.JobState
	}{arg1, arg2})
	stub := fake.PollJobForStateStub
	fakeReturns := fake.pollJobForStateReturns
	fake.recordInvocation("PollJobForState", []interface{}{arg1, arg2})
	fake.pollJobForStateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) PollJobForStateCallCount() int {
	fake.pollJobForStateMutex.RLock()
	defer fake.pollJobForStateMutex.RUnlock()
	return len(fake.pollJobForStateArgsForCall)
}

func (fake *FakeCloudControllerClient) PollJobForStateCalls(stub func(ccv3.JobURL, constant.JobState) (ccv3.Warnings, error)) {
	fake.pollJobForStateMutex.Lock()
	defer fake.pollJobForStateMutex.Unlock()
	fake.PollJobForStateStub = stub
}

func (fake *FakeCloudControllerClient) PollJobForStateArgsForCall(i int) (ccv3.JobURL, constant.JobState) {
	fake.pollJobForStateMutex.RLock()
	defer fake.pollJobForStateMutex.RUnlock()
	argsForCall := fake.pollJobForStateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) PollJobForStateReturns(result1 ccv3.Warnings, result2 error) {
	fake.pollJobForStateMutex.Lock()
	defer fake.pollJobForStateMutex.Unlock()
	fake.PollJobForStateStub = nil
	fake.pollJobForStateReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJobForStateReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.pollJobForStateMutex.Lock()
	defer fake.pollJobForStateMutex.Unlock()
	fake.PollJobForStateStub = nil
	if fake.pollJobForStateReturnsOnCall == nil {
		fake.pollJobForStateReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.pollJobForStateReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJobToEventStream(arg1 ccv3.JobURL) chan ccv3.PollJobEvent {
	fake.pollJobToEventStreamMutex.Lock()
	ret, specificReturn := fake.pollJobToEventStreamReturnsOnCall[len(fake.pollJobToEventStreamArgsForCall)]
	fake.pollJobToEventStreamArgsForCall = append(fake.pollJobToEventStreamArgsForCall, struct {
		arg1 ccv3.JobURL
	}{arg1})
	stub := fake.PollJobToEventStreamStub
	fakeReturns := fake.pollJobToEventStreamReturns
	fake.recordInvocation("PollJobToEventStream", []interface{}{arg1})
	fake.pollJobToEventStreamMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) PollJobToEventStreamCallCount() int {
	fake.pollJobToEventStreamMutex.RLock()
	defer fake.pollJobToEventStreamMutex.RUnlock()
	return len(fake.pollJobToEventStreamArgsForCall)
}

func (fake *FakeCloudControllerClient) PollJobToEventStreamCalls(stub func(ccv3.JobURL) chan ccv3.PollJobEvent) {
	fake.pollJobToEventStreamMutex.Lock()
	defer fake.pollJobToEventStreamMutex.Unlock()
	fake.PollJobToEventStreamStub = stub
}

func (fake *FakeCloudControllerClient) PollJobToEventStreamArgsForCall(i int) ccv3.JobURL {
	fake.pollJobToEventStreamMutex.RLock()
	defer fake.pollJobToEventStreamMutex.RUnlock()
	argsForCall := fake.pollJobToEventStreamArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) PollJobToEventStreamReturns(result1 chan ccv3.PollJobEvent) {
	fake.pollJobToEventStreamMutex.Lock()
	defer fake.pollJobToEventStreamMutex.Unlock()
	fake.PollJobToEventStreamStub = nil
	fake.pollJobToEventStreamReturns = struct {
		result1 chan ccv3.PollJobEvent
	}{result1}
}

func (fake *FakeCloudControllerClient) PollJobToEventStreamReturnsOnCall(i int, result1 chan ccv3.PollJobEvent) {
	fake.pollJobToEventStreamMutex.Lock()
	defer fake.pollJobToEventStreamMutex.Unlock()
	fake.PollJobToEventStreamStub = nil
	if fake.pollJobToEventStreamReturnsOnCall == nil {
		fake.pollJobToEventStreamReturnsOnCall = make(map[int]struct {
			result1 chan ccv3.PollJobEvent
		})
	}
	fake.pollJobToEventStreamReturnsOnCall[i] = struct {
		result1 chan ccv3.PollJobEvent
	}{result1}
}

func (fake *FakeCloudControllerClient) PurgeServiceOffering(arg1 string) (ccv3.Warnings, error) {
	fake.purgeServiceOfferingMutex.Lock()
	ret, specificReturn := fake.purgeServiceOfferingReturnsOnCall[len(fake.purgeServiceOfferingArgsForCall)]
	fake.purgeServiceOfferingArgsForCall = append(fake.purgeServiceOfferingArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.PurgeServiceOfferingStub
	fakeReturns := fake.purgeServiceOfferingReturns
	fake.recordInvocation("PurgeServiceOffering", []interface{}{arg1})
	fake.purgeServiceOfferingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) PurgeServiceOfferingCallCount() int {
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	return len(fake.purgeServiceOfferingArgsForCall)
}

func (fake *FakeCloudControllerClient) PurgeServiceOfferingCalls(stub func(string) (ccv3.Warnings, error)) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = stub
}

func (fake *FakeCloudControllerClient) PurgeServiceOfferingArgsForCall(i int) string {
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	argsForCall := fake.purgeServiceOfferingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) PurgeServiceOfferingReturns(result1 ccv3.Warnings, result2 error) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = nil
	fake.purgeServiceOfferingReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PurgeServiceOfferingReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.purgeServiceOfferingMutex.Lock()
	defer fake.purgeServiceOfferingMutex.Unlock()
	fake.PurgeServiceOfferingStub = nil
	if fake.purgeServiceOfferingReturnsOnCall == nil {
		fake.purgeServiceOfferingReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.purgeServiceOfferingReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

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

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

func (fake *FakeCloudControllerClient) ResourceMatchCalls(stub func([]ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error)) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = stub
}

func (fake *FakeCloudControllerClient) ResourceMatchArgsForCall(i int) []ccv3.Resource {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	argsForCall := fake.resourceMatchArgsForCall[i]
	return argsForCall.arg1
}

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

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

func (fake *FakeCloudControllerClient) RootResponse() (ccv3.Root, ccv3.Warnings, error) {
	fake.rootResponseMutex.Lock()
	ret, specificReturn := fake.rootResponseReturnsOnCall[len(fake.rootResponseArgsForCall)]
	fake.rootResponseArgsForCall = append(fake.rootResponseArgsForCall, struct {
	}{})
	stub := fake.RootResponseStub
	fakeReturns := fake.rootResponseReturns
	fake.recordInvocation("RootResponse", []interface{}{})
	fake.rootResponseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) RootResponseCallCount() int {
	fake.rootResponseMutex.RLock()
	defer fake.rootResponseMutex.RUnlock()
	return len(fake.rootResponseArgsForCall)
}

func (fake *FakeCloudControllerClient) RootResponseCalls(stub func() (ccv3.Root, ccv3.Warnings, error)) {
	fake.rootResponseMutex.Lock()
	defer fake.rootResponseMutex.Unlock()
	fake.RootResponseStub = stub
}

func (fake *FakeCloudControllerClient) RootResponseReturns(result1 ccv3.Root, result2 ccv3.Warnings, result3 error) {
	fake.rootResponseMutex.Lock()
	defer fake.rootResponseMutex.Unlock()
	fake.RootResponseStub = nil
	fake.rootResponseReturns = struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) RootResponseReturnsOnCall(i int, result1 ccv3.Root, result2 ccv3.Warnings, result3 error) {
	fake.rootResponseMutex.Lock()
	defer fake.rootResponseMutex.Unlock()
	fake.RootResponseStub = nil
	if fake.rootResponseReturnsOnCall == nil {
		fake.rootResponseReturnsOnCall = make(map[int]struct {
			result1 ccv3.Root
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.rootResponseReturnsOnCall[i] = struct {
		result1 ccv3.Root
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SetApplicationDroplet(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.setApplicationDropletMutex.Lock()
	ret, specificReturn := fake.setApplicationDropletReturnsOnCall[len(fake.setApplicationDropletArgsForCall)]
	fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.SetApplicationDropletStub
	fakeReturns := fake.setApplicationDropletReturns
	fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2})
	fake.setApplicationDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) SetApplicationDropletCallCount() int {
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	return len(fake.setApplicationDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) SetApplicationDropletCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = stub
}

func (fake *FakeCloudControllerClient) SetApplicationDropletArgsForCall(i int) (string, string) {
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	argsForCall := fake.setApplicationDropletArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) SetApplicationDropletReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = nil
	fake.setApplicationDropletReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SetApplicationDropletReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = nil
	if fake.setApplicationDropletReturnsOnCall == nil {
		fake.setApplicationDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.setApplicationDropletReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgs(arg1 string, arg2 ccv3.SharedOrgs) (ccv3.Warnings, error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	ret, specificReturn := fake.sharePrivateDomainToOrgsReturnsOnCall[len(fake.sharePrivateDomainToOrgsArgsForCall)]
	fake.sharePrivateDomainToOrgsArgsForCall = append(fake.sharePrivateDomainToOrgsArgsForCall, struct {
		arg1 string
		arg2 ccv3.SharedOrgs
	}{arg1, arg2})
	stub := fake.SharePrivateDomainToOrgsStub
	fakeReturns := fake.sharePrivateDomainToOrgsReturns
	fake.recordInvocation("SharePrivateDomainToOrgs", []interface{}{arg1, arg2})
	fake.sharePrivateDomainToOrgsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsCallCount() int {
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	return len(fake.sharePrivateDomainToOrgsArgsForCall)
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsCalls(stub func(string, ccv3.SharedOrgs) (ccv3.Warnings, error)) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = stub
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsArgsForCall(i int) (string, ccv3.SharedOrgs) {
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	argsForCall := fake.sharePrivateDomainToOrgsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturns(result1 ccv3.Warnings, result2 error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = nil
	fake.sharePrivateDomainToOrgsReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = nil
	if fake.sharePrivateDomainToOrgsReturnsOnCall == nil {
		fake.sharePrivateDomainToOrgsReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.sharePrivateDomainToOrgsReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ShareRoute(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.shareRouteMutex.Lock()
	ret, specificReturn := fake.shareRouteReturnsOnCall[len(fake.shareRouteArgsForCall)]
	fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ShareRouteStub
	fakeReturns := fake.shareRouteReturns
	fake.recordInvocation("ShareRoute", []interface{}{arg1, arg2})
	fake.shareRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) ShareRouteCallCount() int {
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	return len(fake.shareRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) ShareRouteCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = stub
}

func (fake *FakeCloudControllerClient) ShareRouteArgsForCall(i int) (string, string) {
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	argsForCall := fake.shareRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) ShareRouteReturns(result1 ccv3.Warnings, result2 error) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = nil
	fake.shareRouteReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ShareRouteReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = nil
	if fake.shareRouteReturnsOnCall == nil {
		fake.shareRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.shareRouteReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpaces(arg1 string, arg2 []string) (resources.RelationshipList, ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.shareServiceInstanceToSpacesMutex.Lock()
	ret, specificReturn := fake.shareServiceInstanceToSpacesReturnsOnCall[len(fake.shareServiceInstanceToSpacesArgsForCall)]
	fake.shareServiceInstanceToSpacesArgsForCall = append(fake.shareServiceInstanceToSpacesArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.ShareServiceInstanceToSpacesStub
	fakeReturns := fake.shareServiceInstanceToSpacesReturns
	fake.recordInvocation("ShareServiceInstanceToSpaces", []interface{}{arg1, arg2Copy})
	fake.shareServiceInstanceToSpacesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesCallCount() int {
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	return len(fake.shareServiceInstanceToSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesCalls(stub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = stub
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesArgsForCall(i int) (string, []string) {
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	argsForCall := fake.shareServiceInstanceToSpacesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = nil
	fake.shareServiceInstanceToSpacesReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = nil
	if fake.shareServiceInstanceToSpacesReturnsOnCall == nil {
		fake.shareServiceInstanceToSpacesReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.shareServiceInstanceToSpacesReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) TargetCF(arg1 ccv3.TargetSettings) {
	fake.targetCFMutex.Lock()
	fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, struct {
		arg1 ccv3.TargetSettings
	}{arg1})
	stub := fake.TargetCFStub
	fake.recordInvocation("TargetCF", []interface{}{arg1})
	fake.targetCFMutex.Unlock()
	if stub != nil {
		fake.TargetCFStub(arg1)
	}
}

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

func (fake *FakeCloudControllerClient) TargetCFCalls(stub func(ccv3.TargetSettings)) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = stub
}

func (fake *FakeCloudControllerClient) TargetCFArgsForCall(i int) ccv3.TargetSettings {
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	argsForCall := fake.targetCFArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpace(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unbindSecurityGroupRunningSpaceMutex.Lock()
	ret, specificReturn := fake.unbindSecurityGroupRunningSpaceReturnsOnCall[len(fake.unbindSecurityGroupRunningSpaceArgsForCall)]
	fake.unbindSecurityGroupRunningSpaceArgsForCall = append(fake.unbindSecurityGroupRunningSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnbindSecurityGroupRunningSpaceStub
	fakeReturns := fake.unbindSecurityGroupRunningSpaceReturns
	fake.recordInvocation("UnbindSecurityGroupRunningSpace", []interface{}{arg1, arg2})
	fake.unbindSecurityGroupRunningSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceCallCount() int {
	fake.unbindSecurityGroupRunningSpaceMutex.RLock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.RUnlock()
	return len(fake.unbindSecurityGroupRunningSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unbindSecurityGroupRunningSpaceMutex.Lock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.Unlock()
	fake.UnbindSecurityGroupRunningSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceArgsForCall(i int) (string, string) {
	fake.unbindSecurityGroupRunningSpaceMutex.RLock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.RUnlock()
	argsForCall := fake.unbindSecurityGroupRunningSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.unbindSecurityGroupRunningSpaceMutex.Lock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.Unlock()
	fake.UnbindSecurityGroupRunningSpaceStub = nil
	fake.unbindSecurityGroupRunningSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupRunningSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unbindSecurityGroupRunningSpaceMutex.Lock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.Unlock()
	fake.UnbindSecurityGroupRunningSpaceStub = nil
	if fake.unbindSecurityGroupRunningSpaceReturnsOnCall == nil {
		fake.unbindSecurityGroupRunningSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unbindSecurityGroupRunningSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpace(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unbindSecurityGroupStagingSpaceMutex.Lock()
	ret, specificReturn := fake.unbindSecurityGroupStagingSpaceReturnsOnCall[len(fake.unbindSecurityGroupStagingSpaceArgsForCall)]
	fake.unbindSecurityGroupStagingSpaceArgsForCall = append(fake.unbindSecurityGroupStagingSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnbindSecurityGroupStagingSpaceStub
	fakeReturns := fake.unbindSecurityGroupStagingSpaceReturns
	fake.recordInvocation("UnbindSecurityGroupStagingSpace", []interface{}{arg1, arg2})
	fake.unbindSecurityGroupStagingSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceCallCount() int {
	fake.unbindSecurityGroupStagingSpaceMutex.RLock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.RUnlock()
	return len(fake.unbindSecurityGroupStagingSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unbindSecurityGroupStagingSpaceMutex.Lock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.Unlock()
	fake.UnbindSecurityGroupStagingSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceArgsForCall(i int) (string, string) {
	fake.unbindSecurityGroupStagingSpaceMutex.RLock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.RUnlock()
	argsForCall := fake.unbindSecurityGroupStagingSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.unbindSecurityGroupStagingSpaceMutex.Lock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.Unlock()
	fake.UnbindSecurityGroupStagingSpaceStub = nil
	fake.unbindSecurityGroupStagingSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnbindSecurityGroupStagingSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unbindSecurityGroupStagingSpaceMutex.Lock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.Unlock()
	fake.UnbindSecurityGroupStagingSpaceStub = nil
	if fake.unbindSecurityGroupStagingSpaceReturnsOnCall == nil {
		fake.unbindSecurityGroupStagingSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unbindSecurityGroupStagingSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnmapRoute(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unmapRouteMutex.Lock()
	ret, specificReturn := fake.unmapRouteReturnsOnCall[len(fake.unmapRouteArgsForCall)]
	fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnmapRouteStub
	fakeReturns := fake.unmapRouteReturns
	fake.recordInvocation("UnmapRoute", []interface{}{arg1, arg2})
	fake.unmapRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnmapRouteCallCount() int {
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	return len(fake.unmapRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) UnmapRouteCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = stub
}

func (fake *FakeCloudControllerClient) UnmapRouteArgsForCall(i int) (string, string) {
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	argsForCall := fake.unmapRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnmapRouteReturns(result1 ccv3.Warnings, result2 error) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = nil
	fake.unmapRouteReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnmapRouteReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = nil
	if fake.unmapRouteReturnsOnCall == nil {
		fake.unmapRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unmapRouteReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuota(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unsetSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.unsetSpaceQuotaReturnsOnCall[len(fake.unsetSpaceQuotaArgsForCall)]
	fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnsetSpaceQuotaStub
	fakeReturns := fake.unsetSpaceQuotaReturns
	fake.recordInvocation("UnsetSpaceQuota", []interface{}{arg1, arg2})
	fake.unsetSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuotaCallCount() int {
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	return len(fake.unsetSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuotaCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuotaArgsForCall(i int) (string, string) {
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	argsForCall := fake.unsetSpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuotaReturns(result1 ccv3.Warnings, result2 error) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = nil
	fake.unsetSpaceQuotaReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnsetSpaceQuotaReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = nil
	if fake.unsetSpaceQuotaReturnsOnCall == nil {
		fake.unsetSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unsetSpaceQuotaReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrg(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	ret, specificReturn := fake.unsharePrivateDomainFromOrgReturnsOnCall[len(fake.unsharePrivateDomainFromOrgArgsForCall)]
	fake.unsharePrivateDomainFromOrgArgsForCall = append(fake.unsharePrivateDomainFromOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnsharePrivateDomainFromOrgStub
	fakeReturns := fake.unsharePrivateDomainFromOrgReturns
	fake.recordInvocation("UnsharePrivateDomainFromOrg", []interface{}{arg1, arg2})
	fake.unsharePrivateDomainFromOrgMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgCallCount() int {
	fake.unsharePrivateDomainFromOrgMutex.RLock()
	defer fake.unsharePrivateDomainFromOrgMutex.RUnlock()
	return len(fake.unsharePrivateDomainFromOrgArgsForCall)
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = stub
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgArgsForCall(i int) (string, string) {
	fake.unsharePrivateDomainFromOrgMutex.RLock()
	defer fake.unsharePrivateDomainFromOrgMutex.RUnlock()
	argsForCall := fake.unsharePrivateDomainFromOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturns(result1 ccv3.Warnings, result2 error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = nil
	fake.unsharePrivateDomainFromOrgReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = nil
	if fake.unsharePrivateDomainFromOrgReturnsOnCall == nil {
		fake.unsharePrivateDomainFromOrgReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unsharePrivateDomainFromOrgReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnshareRoute(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unshareRouteMutex.Lock()
	ret, specificReturn := fake.unshareRouteReturnsOnCall[len(fake.unshareRouteArgsForCall)]
	fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnshareRouteStub
	fakeReturns := fake.unshareRouteReturns
	fake.recordInvocation("UnshareRoute", []interface{}{arg1, arg2})
	fake.unshareRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnshareRouteCallCount() int {
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	return len(fake.unshareRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) UnshareRouteCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = stub
}

func (fake *FakeCloudControllerClient) UnshareRouteArgsForCall(i int) (string, string) {
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	argsForCall := fake.unshareRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnshareRouteReturns(result1 ccv3.Warnings, result2 error) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = nil
	fake.unshareRouteReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnshareRouteReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = nil
	if fake.unshareRouteReturnsOnCall == nil {
		fake.unshareRouteReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unshareRouteReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpace(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unshareServiceInstanceFromSpaceMutex.Lock()
	ret, specificReturn := fake.unshareServiceInstanceFromSpaceReturnsOnCall[len(fake.unshareServiceInstanceFromSpaceArgsForCall)]
	fake.unshareServiceInstanceFromSpaceArgsForCall = append(fake.unshareServiceInstanceFromSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UnshareServiceInstanceFromSpaceStub
	fakeReturns := fake.unshareServiceInstanceFromSpaceReturns
	fake.recordInvocation("UnshareServiceInstanceFromSpace", []interface{}{arg1, arg2})
	fake.unshareServiceInstanceFromSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceCallCount() int {
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	return len(fake.unshareServiceInstanceFromSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unshareServiceInstanceFromSpaceMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceArgsForCall(i int) (string, string) {
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	argsForCall := fake.unshareServiceInstanceFromSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.unshareServiceInstanceFromSpaceMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceStub = nil
	fake.unshareServiceInstanceFromSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unshareServiceInstanceFromSpaceMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceStub = nil
	if fake.unshareServiceInstanceFromSpaceReturnsOnCall == nil {
		fake.unshareServiceInstanceFromSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unshareServiceInstanceFromSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateAppFeature(arg1 string, arg2 bool, arg3 string) (ccv3.Warnings, error) {
	fake.updateAppFeatureMutex.Lock()
	ret, specificReturn := fake.updateAppFeatureReturnsOnCall[len(fake.updateAppFeatureArgsForCall)]
	fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, struct {
		arg1 string
		arg2 bool
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateAppFeatureStub
	fakeReturns := fake.updateAppFeatureReturns
	fake.recordInvocation("UpdateAppFeature", []interface{}{arg1, arg2, arg3})
	fake.updateAppFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateAppFeatureCallCount() int {
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	return len(fake.updateAppFeatureArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateAppFeatureCalls(stub func(string, bool, string) (ccv3.Warnings, error)) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = stub
}

func (fake *FakeCloudControllerClient) UpdateAppFeatureArgsForCall(i int) (string, bool, string) {
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	argsForCall := fake.updateAppFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UpdateAppFeatureReturns(result1 ccv3.Warnings, result2 error) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = nil
	fake.updateAppFeatureReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateAppFeatureReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = nil
	if fake.updateAppFeatureReturnsOnCall == nil {
		fake.updateAppFeatureReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.updateAppFeatureReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationMutex.Lock()
	ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)]
	fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct {
		arg1 resources.Application
	}{arg1})
	stub := fake.UpdateApplicationStub
	fakeReturns := fake.updateApplicationReturns
	fake.recordInvocation("UpdateApplication", []interface{}{arg1})
	fake.updateApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) UpdateApplicationCalls(stub func(resources.Application) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationArgsForCall(i int) resources.Application {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	argsForCall := fake.updateApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = nil
	fake.updateApplicationReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = nil
	if fake.updateApplicationReturnsOnCall == nil {
		fake.updateApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifest(arg1 string, arg2 []byte) (ccv3.JobURL, ccv3.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateApplicationApplyManifestMutex.Lock()
	ret, specificReturn := fake.updateApplicationApplyManifestReturnsOnCall[len(fake.updateApplicationApplyManifestArgsForCall)]
	fake.updateApplicationApplyManifestArgsForCall = append(fake.updateApplicationApplyManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	stub := fake.UpdateApplicationApplyManifestStub
	fakeReturns := fake.updateApplicationApplyManifestReturns
	fake.recordInvocation("UpdateApplicationApplyManifest", []interface{}{arg1, arg2Copy})
	fake.updateApplicationApplyManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestCallCount() int {
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	return len(fake.updateApplicationApplyManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestCalls(stub func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestArgsForCall(i int) (string, []byte) {
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	argsForCall := fake.updateApplicationApplyManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = nil
	fake.updateApplicationApplyManifestReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = nil
	if fake.updateApplicationApplyManifestReturnsOnCall == nil {
		fake.updateApplicationApplyManifestReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationApplyManifestReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariables(arg1 string, arg2 resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	ret, specificReturn := fake.updateApplicationEnvironmentVariablesReturnsOnCall[len(fake.updateApplicationEnvironmentVariablesArgsForCall)]
	fake.updateApplicationEnvironmentVariablesArgsForCall = append(fake.updateApplicationEnvironmentVariablesArgsForCall, struct {
		arg1 string
		arg2 resources.EnvironmentVariables
	}{arg1, arg2})
	stub := fake.UpdateApplicationEnvironmentVariablesStub
	fakeReturns := fake.updateApplicationEnvironmentVariablesReturns
	fake.recordInvocation("UpdateApplicationEnvironmentVariables", []interface{}{arg1, arg2})
	fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesCallCount() int {
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	return len(fake.updateApplicationEnvironmentVariablesArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesCalls(stub func(string, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesArgsForCall(i int) (string, resources.EnvironmentVariables) {
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	argsForCall := fake.updateApplicationEnvironmentVariablesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = nil
	fake.updateApplicationEnvironmentVariablesReturns = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturnsOnCall(i int, result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = nil
	if fake.updateApplicationEnvironmentVariablesReturnsOnCall == nil {
		fake.updateApplicationEnvironmentVariablesReturnsOnCall = make(map[int]struct {
			result1 resources.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationEnvironmentVariablesReturnsOnCall[i] = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationName(arg1 string, arg2 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationNameMutex.Lock()
	ret, specificReturn := fake.updateApplicationNameReturnsOnCall[len(fake.updateApplicationNameArgsForCall)]
	fake.updateApplicationNameArgsForCall = append(fake.updateApplicationNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateApplicationNameStub
	fakeReturns := fake.updateApplicationNameReturns
	fake.recordInvocation("UpdateApplicationName", []interface{}{arg1, arg2})
	fake.updateApplicationNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationNameCallCount() int {
	fake.updateApplicationNameMutex.RLock()
	defer fake.updateApplicationNameMutex.RUnlock()
	return len(fake.updateApplicationNameArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationNameCalls(stub func(string, string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationNameMutex.Lock()
	defer fake.updateApplicationNameMutex.Unlock()
	fake.UpdateApplicationNameStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationNameArgsForCall(i int) (string, string) {
	fake.updateApplicationNameMutex.RLock()
	defer fake.updateApplicationNameMutex.RUnlock()
	argsForCall := fake.updateApplicationNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationNameReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationNameMutex.Lock()
	defer fake.updateApplicationNameMutex.Unlock()
	fake.UpdateApplicationNameStub = nil
	fake.updateApplicationNameReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationNameReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationNameMutex.Lock()
	defer fake.updateApplicationNameMutex.Unlock()
	fake.UpdateApplicationNameStub = nil
	if fake.updateApplicationNameReturnsOnCall == nil {
		fake.updateApplicationNameReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationNameReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestart(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationRestartMutex.Lock()
	ret, specificReturn := fake.updateApplicationRestartReturnsOnCall[len(fake.updateApplicationRestartArgsForCall)]
	fake.updateApplicationRestartArgsForCall = append(fake.updateApplicationRestartArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UpdateApplicationRestartStub
	fakeReturns := fake.updateApplicationRestartReturns
	fake.recordInvocation("UpdateApplicationRestart", []interface{}{arg1})
	fake.updateApplicationRestartMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartCallCount() int {
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	return len(fake.updateApplicationRestartArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartArgsForCall(i int) string {
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	argsForCall := fake.updateApplicationRestartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = nil
	fake.updateApplicationRestartReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = nil
	if fake.updateApplicationRestartReturnsOnCall == nil {
		fake.updateApplicationRestartReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationRestartReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStart(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationStartMutex.Lock()
	ret, specificReturn := fake.updateApplicationStartReturnsOnCall[len(fake.updateApplicationStartArgsForCall)]
	fake.updateApplicationStartArgsForCall = append(fake.updateApplicationStartArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UpdateApplicationStartStub
	fakeReturns := fake.updateApplicationStartReturns
	fake.recordInvocation("UpdateApplicationStart", []interface{}{arg1})
	fake.updateApplicationStartMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartCallCount() int {
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	return len(fake.updateApplicationStartArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartArgsForCall(i int) string {
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	argsForCall := fake.updateApplicationStartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = nil
	fake.updateApplicationStartReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = nil
	if fake.updateApplicationStartReturnsOnCall == nil {
		fake.updateApplicationStartReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationStartReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStop(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationStopMutex.Lock()
	ret, specificReturn := fake.updateApplicationStopReturnsOnCall[len(fake.updateApplicationStopArgsForCall)]
	fake.updateApplicationStopArgsForCall = append(fake.updateApplicationStopArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UpdateApplicationStopStub
	fakeReturns := fake.updateApplicationStopReturns
	fake.recordInvocation("UpdateApplicationStop", []interface{}{arg1})
	fake.updateApplicationStopMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopCallCount() int {
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	return len(fake.updateApplicationStopArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopArgsForCall(i int) string {
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	argsForCall := fake.updateApplicationStopArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = nil
	fake.updateApplicationStopReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = nil
	if fake.updateApplicationStopReturnsOnCall == nil {
		fake.updateApplicationStopReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationStopReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) {
	fake.updateBuildpackMutex.Lock()
	ret, specificReturn := fake.updateBuildpackReturnsOnCall[len(fake.updateBuildpackArgsForCall)]
	fake.updateBuildpackArgsForCall = append(fake.updateBuildpackArgsForCall, struct {
		arg1 resources.Buildpack
	}{arg1})
	stub := fake.UpdateBuildpackStub
	fakeReturns := fake.updateBuildpackReturns
	fake.recordInvocation("UpdateBuildpack", []interface{}{arg1})
	fake.updateBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateBuildpackCallCount() int {
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	return len(fake.updateBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateBuildpackCalls(stub func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) UpdateBuildpackArgsForCall(i int) resources.Buildpack {
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	argsForCall := fake.updateBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateBuildpackReturns(result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = nil
	fake.updateBuildpackReturns = struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateBuildpackReturnsOnCall(i int, result1 resources.Buildpack, result2 ccv3.Warnings, result3 error) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = nil
	if fake.updateBuildpackReturnsOnCall == nil {
		fake.updateBuildpackReturnsOnCall = make(map[int]struct {
			result1 resources.Buildpack
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateBuildpackReturnsOnCall[i] = struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateDestination(arg1 string, arg2 string, arg3 string) (ccv3.Warnings, error) {
	fake.updateDestinationMutex.Lock()
	ret, specificReturn := fake.updateDestinationReturnsOnCall[len(fake.updateDestinationArgsForCall)]
	fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateDestinationStub
	fakeReturns := fake.updateDestinationReturns
	fake.recordInvocation("UpdateDestination", []interface{}{arg1, arg2, arg3})
	fake.updateDestinationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateDestinationCallCount() int {
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	return len(fake.updateDestinationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateDestinationCalls(stub func(string, string, string) (ccv3.Warnings, error)) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateDestinationArgsForCall(i int) (string, string, string) {
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	argsForCall := fake.updateDestinationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UpdateDestinationReturns(result1 ccv3.Warnings, result2 error) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = nil
	fake.updateDestinationReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateDestinationReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = nil
	if fake.updateDestinationReturnsOnCall == nil {
		fake.updateDestinationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.updateDestinationReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroup(arg1 constant.EnvironmentVariableGroupName, arg2 resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) {
	fake.updateEnvironmentVariableGroupMutex.Lock()
	ret, specificReturn := fake.updateEnvironmentVariableGroupReturnsOnCall[len(fake.updateEnvironmentVariableGroupArgsForCall)]
	fake.updateEnvironmentVariableGroupArgsForCall = append(fake.updateEnvironmentVariableGroupArgsForCall, struct {
		arg1 constant.EnvironmentVariableGroupName
		arg2 resources.EnvironmentVariables
	}{arg1, arg2})
	stub := fake.UpdateEnvironmentVariableGroupStub
	fakeReturns := fake.updateEnvironmentVariableGroupReturns
	fake.recordInvocation("UpdateEnvironmentVariableGroup", []interface{}{arg1, arg2})
	fake.updateEnvironmentVariableGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupCallCount() int {
	fake.updateEnvironmentVariableGroupMutex.RLock()
	defer fake.updateEnvironmentVariableGroupMutex.RUnlock()
	return len(fake.updateEnvironmentVariableGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupCalls(stub func(constant.EnvironmentVariableGroupName, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.updateEnvironmentVariableGroupMutex.Lock()
	defer fake.updateEnvironmentVariableGroupMutex.Unlock()
	fake.UpdateEnvironmentVariableGroupStub = stub
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupArgsForCall(i int) (constant.EnvironmentVariableGroupName, resources.EnvironmentVariables) {
	fake.updateEnvironmentVariableGroupMutex.RLock()
	defer fake.updateEnvironmentVariableGroupMutex.RUnlock()
	argsForCall := fake.updateEnvironmentVariableGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateEnvironmentVariableGroupMutex.Lock()
	defer fake.updateEnvironmentVariableGroupMutex.Unlock()
	fake.UpdateEnvironmentVariableGroupStub = nil
	fake.updateEnvironmentVariableGroupReturns = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateEnvironmentVariableGroupReturnsOnCall(i int, result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateEnvironmentVariableGroupMutex.Lock()
	defer fake.updateEnvironmentVariableGroupMutex.Unlock()
	fake.UpdateEnvironmentVariableGroupStub = nil
	if fake.updateEnvironmentVariableGroupReturnsOnCall == nil {
		fake.updateEnvironmentVariableGroupReturnsOnCall = make(map[int]struct {
			result1 resources.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateEnvironmentVariableGroupReturnsOnCall[i] = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlag(arg1 resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error) {
	fake.updateFeatureFlagMutex.Lock()
	ret, specificReturn := fake.updateFeatureFlagReturnsOnCall[len(fake.updateFeatureFlagArgsForCall)]
	fake.updateFeatureFlagArgsForCall = append(fake.updateFeatureFlagArgsForCall, struct {
		arg1 resources.FeatureFlag
	}{arg1})
	stub := fake.UpdateFeatureFlagStub
	fakeReturns := fake.updateFeatureFlagReturns
	fake.recordInvocation("UpdateFeatureFlag", []interface{}{arg1})
	fake.updateFeatureFlagMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagCallCount() int {
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	return len(fake.updateFeatureFlagArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagCalls(stub func(resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = stub
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagArgsForCall(i int) resources.FeatureFlag {
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	argsForCall := fake.updateFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = nil
	fake.updateFeatureFlagReturns = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturnsOnCall(i int, result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = nil
	if fake.updateFeatureFlagReturnsOnCall == nil {
		fake.updateFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateFeatureFlagReturnsOnCall[i] = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganization(arg1 resources.Organization) (resources.Organization, ccv3.Warnings, error) {
	fake.updateOrganizationMutex.Lock()
	ret, specificReturn := fake.updateOrganizationReturnsOnCall[len(fake.updateOrganizationArgsForCall)]
	fake.updateOrganizationArgsForCall = append(fake.updateOrganizationArgsForCall, struct {
		arg1 resources.Organization
	}{arg1})
	stub := fake.UpdateOrganizationStub
	fakeReturns := fake.updateOrganizationReturns
	fake.recordInvocation("UpdateOrganization", []interface{}{arg1})
	fake.updateOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateOrganizationCallCount() int {
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	return len(fake.updateOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationCalls(stub func(resources.Organization) (resources.Organization, ccv3.Warnings, error)) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationArgsForCall(i int) resources.Organization {
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	argsForCall := fake.updateOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = nil
	fake.updateOrganizationReturns = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationReturnsOnCall(i int, result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = nil
	if fake.updateOrganizationReturnsOnCall == nil {
		fake.updateOrganizationReturnsOnCall = make(map[int]struct {
			result1 resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateOrganizationReturnsOnCall[i] = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	ret, specificReturn := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall[len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)]
	fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall = append(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub
	fakeReturns := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns
	fake.recordInvocation("UpdateOrganizationDefaultIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipCallCount() int {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	return len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipArgsForCall(i int) (string, string) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	argsForCall := fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = nil
	fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = nil
	if fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall == nil {
		fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuota(arg1 resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error) {
	fake.updateOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.updateOrganizationQuotaReturnsOnCall[len(fake.updateOrganizationQuotaArgsForCall)]
	fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, struct {
		arg1 resources.OrganizationQuota
	}{arg1})
	stub := fake.UpdateOrganizationQuotaStub
	fakeReturns := fake.updateOrganizationQuotaReturns
	fake.recordInvocation("UpdateOrganizationQuota", []interface{}{arg1})
	fake.updateOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaCallCount() int {
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	return len(fake.updateOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaCalls(stub func(resources.OrganizationQuota) (resources.OrganizationQuota, ccv3.Warnings, error)) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaArgsForCall(i int) resources.OrganizationQuota {
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.updateOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaReturns(result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = nil
	fake.updateOrganizationQuotaReturns = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationQuotaReturnsOnCall(i int, result1 resources.OrganizationQuota, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = nil
	if fake.updateOrganizationQuotaReturnsOnCall == nil {
		fake.updateOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.OrganizationQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateOrganizationQuotaReturnsOnCall[i] = struct {
		result1 resources.OrganizationQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateProcess(arg1 resources.Process) (resources.Process, ccv3.Warnings, error) {
	fake.updateProcessMutex.Lock()
	ret, specificReturn := fake.updateProcessReturnsOnCall[len(fake.updateProcessArgsForCall)]
	fake.updateProcessArgsForCall = append(fake.updateProcessArgsForCall, struct {
		arg1 resources.Process
	}{arg1})
	stub := fake.UpdateProcessStub
	fakeReturns := fake.updateProcessReturns
	fake.recordInvocation("UpdateProcess", []interface{}{arg1})
	fake.updateProcessMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateProcessCallCount() int {
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	return len(fake.updateProcessArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateProcessCalls(stub func(resources.Process) (resources.Process, ccv3.Warnings, error)) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = stub
}

func (fake *FakeCloudControllerClient) UpdateProcessArgsForCall(i int) resources.Process {
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	argsForCall := fake.updateProcessArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateProcessReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = nil
	fake.updateProcessReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateProcessReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = nil
	if fake.updateProcessReturnsOnCall == nil {
		fake.updateProcessReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateProcessReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadata(arg1 string, arg2 string, arg3 resources.Metadata) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.updateResourceMetadataMutex.Lock()
	ret, specificReturn := fake.updateResourceMetadataReturnsOnCall[len(fake.updateResourceMetadataArgsForCall)]
	fake.updateResourceMetadataArgsForCall = append(fake.updateResourceMetadataArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 resources.Metadata
	}{arg1, arg2, arg3})
	stub := fake.UpdateResourceMetadataStub
	fakeReturns := fake.updateResourceMetadataReturns
	fake.recordInvocation("UpdateResourceMetadata", []interface{}{arg1, arg2, arg3})
	fake.updateResourceMetadataMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadataCallCount() int {
	fake.updateResourceMetadataMutex.RLock()
	defer fake.updateResourceMetadataMutex.RUnlock()
	return len(fake.updateResourceMetadataArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadataCalls(stub func(string, string, resources.Metadata) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateResourceMetadataMutex.Lock()
	defer fake.updateResourceMetadataMutex.Unlock()
	fake.UpdateResourceMetadataStub = stub
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadataArgsForCall(i int) (string, string, resources.Metadata) {
	fake.updateResourceMetadataMutex.RLock()
	defer fake.updateResourceMetadataMutex.RUnlock()
	argsForCall := fake.updateResourceMetadataArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadataReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateResourceMetadataMutex.Lock()
	defer fake.updateResourceMetadataMutex.Unlock()
	fake.UpdateResourceMetadataStub = nil
	fake.updateResourceMetadataReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateResourceMetadataReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateResourceMetadataMutex.Lock()
	defer fake.updateResourceMetadataMutex.Unlock()
	fake.UpdateResourceMetadataStub = nil
	if fake.updateResourceMetadataReturnsOnCall == nil {
		fake.updateResourceMetadataReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateResourceMetadataReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateRoute(arg1 string, arg2 map[string]*string) (resources.Route, ccv3.Warnings, error) {
	fake.updateRouteMutex.Lock()
	ret, specificReturn := fake.updateRouteReturnsOnCall[len(fake.updateRouteArgsForCall)]
	fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, struct {
		arg1 string
		arg2 map[string]*string
	}{arg1, arg2})
	stub := fake.UpdateRouteStub
	fakeReturns := fake.updateRouteReturns
	fake.recordInvocation("UpdateRoute", []interface{}{arg1, arg2})
	fake.updateRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateRouteCallCount() int {
	fake.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.RUnlock()
	return len(fake.updateRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateRouteCalls(stub func(string, map[string]*string) (resources.Route, ccv3.Warnings, error)) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = stub
}

func (fake *FakeCloudControllerClient) UpdateRouteArgsForCall(i int) (string, map[string]*string) {
	fake.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.RUnlock()
	argsForCall := fake.updateRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateRouteReturns(result1 resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = nil
	fake.updateRouteReturns = struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateRouteReturnsOnCall(i int, result1 resources.Route, result2 ccv3.Warnings, result3 error) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = nil
	if fake.updateRouteReturnsOnCall == nil {
		fake.updateRouteReturnsOnCall = make(map[int]struct {
			result1 resources.Route
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateRouteReturnsOnCall[i] = struct {
		result1 resources.Route
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroup(arg1 resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error) {
	fake.updateSecurityGroupMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupReturnsOnCall[len(fake.updateSecurityGroupArgsForCall)]
	fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, struct {
		arg1 resources.SecurityGroup
	}{arg1})
	stub := fake.UpdateSecurityGroupStub
	fakeReturns := fake.updateSecurityGroupReturns
	fake.recordInvocation("UpdateSecurityGroup", []interface{}{arg1})
	fake.updateSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupCallCount() int {
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	return len(fake.updateSecurityGroupArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupCalls(stub func(resources.SecurityGroup) (resources.SecurityGroup, ccv3.Warnings, error)) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupArgsForCall(i int) resources.SecurityGroup {
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupReturns(result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = nil
	fake.updateSecurityGroupReturns = struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupReturnsOnCall(i int, result1 resources.SecurityGroup, result2 ccv3.Warnings, result3 error) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = nil
	if fake.updateSecurityGroupReturnsOnCall == nil {
		fake.updateSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 resources.SecurityGroup
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSecurityGroupReturnsOnCall[i] = struct {
		result1 resources.SecurityGroup
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpace(arg1 string, arg2 []string) (ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateSecurityGroupRunningSpaceMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupRunningSpaceReturnsOnCall[len(fake.updateSecurityGroupRunningSpaceArgsForCall)]
	fake.updateSecurityGroupRunningSpaceArgsForCall = append(fake.updateSecurityGroupRunningSpaceArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.UpdateSecurityGroupRunningSpaceStub
	fakeReturns := fake.updateSecurityGroupRunningSpaceReturns
	fake.recordInvocation("UpdateSecurityGroupRunningSpace", []interface{}{arg1, arg2Copy})
	fake.updateSecurityGroupRunningSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceCallCount() int {
	fake.updateSecurityGroupRunningSpaceMutex.RLock()
	defer fake.updateSecurityGroupRunningSpaceMutex.RUnlock()
	return len(fake.updateSecurityGroupRunningSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceCalls(stub func(string, []string) (ccv3.Warnings, error)) {
	fake.updateSecurityGroupRunningSpaceMutex.Lock()
	defer fake.updateSecurityGroupRunningSpaceMutex.Unlock()
	fake.UpdateSecurityGroupRunningSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceArgsForCall(i int) (string, []string) {
	fake.updateSecurityGroupRunningSpaceMutex.RLock()
	defer fake.updateSecurityGroupRunningSpaceMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupRunningSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.updateSecurityGroupRunningSpaceMutex.Lock()
	defer fake.updateSecurityGroupRunningSpaceMutex.Unlock()
	fake.UpdateSecurityGroupRunningSpaceStub = nil
	fake.updateSecurityGroupRunningSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupRunningSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.updateSecurityGroupRunningSpaceMutex.Lock()
	defer fake.updateSecurityGroupRunningSpaceMutex.Unlock()
	fake.UpdateSecurityGroupRunningSpaceStub = nil
	if fake.updateSecurityGroupRunningSpaceReturnsOnCall == nil {
		fake.updateSecurityGroupRunningSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupRunningSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpace(arg1 string, arg2 []string) (ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupStagingSpaceReturnsOnCall[len(fake.updateSecurityGroupStagingSpaceArgsForCall)]
	fake.updateSecurityGroupStagingSpaceArgsForCall = append(fake.updateSecurityGroupStagingSpaceArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	stub := fake.UpdateSecurityGroupStagingSpaceStub
	fakeReturns := fake.updateSecurityGroupStagingSpaceReturns
	fake.recordInvocation("UpdateSecurityGroupStagingSpace", []interface{}{arg1, arg2Copy})
	fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceCallCount() int {
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	return len(fake.updateSecurityGroupStagingSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceCalls(stub func(string, []string) (ccv3.Warnings, error)) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceArgsForCall(i int) (string, []string) {
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupStagingSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = nil
	fake.updateSecurityGroupStagingSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = nil
	if fake.updateSecurityGroupStagingSpaceReturnsOnCall == nil {
		fake.updateSecurityGroupStagingSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupStagingSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateServiceBroker(arg1 string, arg2 resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.updateServiceBrokerMutex.Lock()
	ret, specificReturn := fake.updateServiceBrokerReturnsOnCall[len(fake.updateServiceBrokerArgsForCall)]
	fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, struct {
		arg1 string
		arg2 resources.ServiceBroker
	}{arg1, arg2})
	stub := fake.UpdateServiceBrokerStub
	fakeReturns := fake.updateServiceBrokerReturns
	fake.recordInvocation("UpdateServiceBroker", []interface{}{arg1, arg2})
	fake.updateServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateServiceBrokerCallCount() int {
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	return len(fake.updateServiceBrokerArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateServiceBrokerCalls(stub func(string, resources.ServiceBroker) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = stub
}

func (fake *FakeCloudControllerClient) UpdateServiceBrokerArgsForCall(i int) (string, resources.ServiceBroker) {
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	argsForCall := fake.updateServiceBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateServiceBrokerReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = nil
	fake.updateServiceBrokerReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateServiceBrokerReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = nil
	if fake.updateServiceBrokerReturnsOnCall == nil {
		fake.updateServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateServiceBrokerReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateServiceInstance(arg1 string, arg2 resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.updateServiceInstanceMutex.Lock()
	ret, specificReturn := fake.updateServiceInstanceReturnsOnCall[len(fake.updateServiceInstanceArgsForCall)]
	fake.updateServiceInstanceArgsForCall = append(fake.updateServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 resources.ServiceInstance
	}{arg1, arg2})
	stub := fake.UpdateServiceInstanceStub
	fakeReturns := fake.updateServiceInstanceReturns
	fake.recordInvocation("UpdateServiceInstance", []interface{}{arg1, arg2})
	fake.updateServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateServiceInstanceCallCount() int {
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	return len(fake.updateServiceInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateServiceInstanceCalls(stub func(string, resources.ServiceInstance) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateServiceInstanceArgsForCall(i int) (string, resources.ServiceInstance) {
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	argsForCall := fake.updateServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateServiceInstanceReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = nil
	fake.updateServiceInstanceReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateServiceInstanceReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateServiceInstanceMutex.Lock()
	defer fake.updateServiceInstanceMutex.Unlock()
	fake.UpdateServiceInstanceStub = nil
	if fake.updateServiceInstanceReturnsOnCall == nil {
		fake.updateServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateServiceInstanceReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibility(arg1 string, arg2 resources.ServicePlanVisibility) (resources.ServicePlanVisibility, ccv3.Warnings, error) {
	fake.updateServicePlanVisibilityMutex.Lock()
	ret, specificReturn := fake.updateServicePlanVisibilityReturnsOnCall[len(fake.updateServicePlanVisibilityArgsForCall)]
	fake.updateServicePlanVisibilityArgsForCall = append(fake.updateServicePlanVisibilityArgsForCall, struct {
		arg1 string
		arg2 resources.ServicePlanVisibility
	}{arg1, arg2})
	stub := fake.UpdateServicePlanVisibilityStub
	fakeReturns := fake.updateServicePlanVisibilityReturns
	fake.recordInvocation("UpdateServicePlanVisibility", []interface{}{arg1, arg2})
	fake.updateServicePlanVisibilityMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityCallCount() int {
	fake.updateServicePlanVisibilityMutex.RLock()
	defer fake.updateServicePlanVisibilityMutex.RUnlock()
	return len(fake.updateServicePlanVisibilityArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityCalls(stub func(string, resources.ServicePlanVisibility) (resources.ServicePlanVisibility, ccv3.Warnings, error)) {
	fake.updateServicePlanVisibilityMutex.Lock()
	defer fake.updateServicePlanVisibilityMutex.Unlock()
	fake.UpdateServicePlanVisibilityStub = stub
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityArgsForCall(i int) (string, resources.ServicePlanVisibility) {
	fake.updateServicePlanVisibilityMutex.RLock()
	defer fake.updateServicePlanVisibilityMutex.RUnlock()
	argsForCall := fake.updateServicePlanVisibilityArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityReturns(result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) {
	fake.updateServicePlanVisibilityMutex.Lock()
	defer fake.updateServicePlanVisibilityMutex.Unlock()
	fake.UpdateServicePlanVisibilityStub = nil
	fake.updateServicePlanVisibilityReturns = struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateServicePlanVisibilityReturnsOnCall(i int, result1 resources.ServicePlanVisibility, result2 ccv3.Warnings, result3 error) {
	fake.updateServicePlanVisibilityMutex.Lock()
	defer fake.updateServicePlanVisibilityMutex.Unlock()
	fake.UpdateServicePlanVisibilityStub = nil
	if fake.updateServicePlanVisibilityReturnsOnCall == nil {
		fake.updateServicePlanVisibilityReturnsOnCall = make(map[int]struct {
			result1 resources.ServicePlanVisibility
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateServicePlanVisibilityReturnsOnCall[i] = struct {
		result1 resources.ServicePlanVisibility
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpace(arg1 resources.Space) (resources.Space, ccv3.Warnings, error) {
	fake.updateSpaceMutex.Lock()
	ret, specificReturn := fake.updateSpaceReturnsOnCall[len(fake.updateSpaceArgsForCall)]
	fake.updateSpaceArgsForCall = append(fake.updateSpaceArgsForCall, struct {
		arg1 resources.Space
	}{arg1})
	stub := fake.UpdateSpaceStub
	fakeReturns := fake.updateSpaceReturns
	fake.recordInvocation("UpdateSpace", []interface{}{arg1})
	fake.updateSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceCallCount() int {
	fake.updateSpaceMutex.RLock()
	defer fake.updateSpaceMutex.RUnlock()
	return len(fake.updateSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceCalls(stub func(resources.Space) (resources.Space, ccv3.Warnings, error)) {
	fake.updateSpaceMutex.Lock()
	defer fake.updateSpaceMutex.Unlock()
	fake.UpdateSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceArgsForCall(i int) resources.Space {
	fake.updateSpaceMutex.RLock()
	defer fake.updateSpaceMutex.RUnlock()
	argsForCall := fake.updateSpaceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateSpaceReturns(result1 resources.Space, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceMutex.Lock()
	defer fake.updateSpaceMutex.Unlock()
	fake.UpdateSpaceStub = nil
	fake.updateSpaceReturns = struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceReturnsOnCall(i int, result1 resources.Space, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceMutex.Lock()
	defer fake.updateSpaceMutex.Unlock()
	fake.UpdateSpaceStub = nil
	if fake.updateSpaceReturnsOnCall == nil {
		fake.updateSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Space
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceReturnsOnCall[i] = struct {
		result1 resources.Space
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifest(arg1 string, arg2 []byte) (ccv3.JobURL, ccv3.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateSpaceApplyManifestMutex.Lock()
	ret, specificReturn := fake.updateSpaceApplyManifestReturnsOnCall[len(fake.updateSpaceApplyManifestArgsForCall)]
	fake.updateSpaceApplyManifestArgsForCall = append(fake.updateSpaceApplyManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	stub := fake.UpdateSpaceApplyManifestStub
	fakeReturns := fake.updateSpaceApplyManifestReturns
	fake.recordInvocation("UpdateSpaceApplyManifest", []interface{}{arg1, arg2Copy})
	fake.updateSpaceApplyManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestCallCount() int {
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	return len(fake.updateSpaceApplyManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestCalls(stub func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestArgsForCall(i int) (string, []byte) {
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	argsForCall := fake.updateSpaceApplyManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = nil
	fake.updateSpaceApplyManifestReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = nil
	if fake.updateSpaceApplyManifestReturnsOnCall == nil {
		fake.updateSpaceApplyManifestReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceApplyManifestReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeature(arg1 string, arg2 bool, arg3 string) (ccv3.Warnings, error) {
	fake.updateSpaceFeatureMutex.Lock()
	ret, specificReturn := fake.updateSpaceFeatureReturnsOnCall[len(fake.updateSpaceFeatureArgsForCall)]
	fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, struct {
		arg1 string
		arg2 bool
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.UpdateSpaceFeatureStub
	fakeReturns := fake.updateSpaceFeatureReturns
	fake.recordInvocation("UpdateSpaceFeature", []interface{}{arg1, arg2, arg3})
	fake.updateSpaceFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeatureCallCount() int {
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	return len(fake.updateSpaceFeatureArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeatureCalls(stub func(string, bool, string) (ccv3.Warnings, error)) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeatureArgsForCall(i int) (string, bool, string) {
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	argsForCall := fake.updateSpaceFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeatureReturns(result1 ccv3.Warnings, result2 error) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = nil
	fake.updateSpaceFeatureReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceFeatureReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = nil
	if fake.updateSpaceFeatureReturnsOnCall == nil {
		fake.updateSpaceFeatureReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.updateSpaceFeatureReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	ret, specificReturn := fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall[len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)]
	fake.updateSpaceIsolationSegmentRelationshipArgsForCall = append(fake.updateSpaceIsolationSegmentRelationshipArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.UpdateSpaceIsolationSegmentRelationshipStub
	fakeReturns := fake.updateSpaceIsolationSegmentRelationshipReturns
	fake.recordInvocation("UpdateSpaceIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipCallCount() int {
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	return len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipArgsForCall(i int) (string, string) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	argsForCall := fake.updateSpaceIsolationSegmentRelationshipArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = nil
	fake.updateSpaceIsolationSegmentRelationshipReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = nil
	if fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall == nil {
		fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuota(arg1 resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error) {
	fake.updateSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.updateSpaceQuotaReturnsOnCall[len(fake.updateSpaceQuotaArgsForCall)]
	fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, struct {
		arg1 resources.SpaceQuota
	}{arg1})
	stub := fake.UpdateSpaceQuotaStub
	fakeReturns := fake.updateSpaceQuotaReturns
	fake.recordInvocation("UpdateSpaceQuota", []interface{}{arg1})
	fake.updateSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuotaCallCount() int {
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	return len(fake.updateSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuotaCalls(stub func(resources.SpaceQuota) (resources.SpaceQuota, ccv3.Warnings, error)) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuotaArgsForCall(i int) resources.SpaceQuota {
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	argsForCall := fake.updateSpaceQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuotaReturns(result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = nil
	fake.updateSpaceQuotaReturns = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceQuotaReturnsOnCall(i int, result1 resources.SpaceQuota, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = nil
	if fake.updateSpaceQuotaReturnsOnCall == nil {
		fake.updateSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 resources.SpaceQuota
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceQuotaReturnsOnCall[i] = struct {
		result1 resources.SpaceQuota
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskCancel(arg1 string) (resources.Task, ccv3.Warnings, error) {
	fake.updateTaskCancelMutex.Lock()
	ret, specificReturn := fake.updateTaskCancelReturnsOnCall[len(fake.updateTaskCancelArgsForCall)]
	fake.updateTaskCancelArgsForCall = append(fake.updateTaskCancelArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.UpdateTaskCancelStub
	fakeReturns := fake.updateTaskCancelReturns
	fake.recordInvocation("UpdateTaskCancel", []interface{}{arg1})
	fake.updateTaskCancelMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelCallCount() int {
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	return len(fake.updateTaskCancelArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelCalls(stub func(string) (resources.Task, ccv3.Warnings, error)) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = stub
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelArgsForCall(i int) string {
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	argsForCall := fake.updateTaskCancelArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = nil
	fake.updateTaskCancelReturns = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelReturnsOnCall(i int, result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = nil
	if fake.updateTaskCancelReturnsOnCall == nil {
		fake.updateTaskCancelReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateTaskCancelReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackage(arg1 resources.Package, arg2 []ccv3.Resource, arg3 io.Reader, arg4 int64) (resources.Package, ccv3.Warnings, error) {
	var arg2Copy []ccv3.Resource
	if arg2 != nil {
		arg2Copy = make([]ccv3.Resource, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.uploadBitsPackageMutex.Lock()
	ret, specificReturn := fake.uploadBitsPackageReturnsOnCall[len(fake.uploadBitsPackageArgsForCall)]
	fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, struct {
		arg1 resources.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2Copy, arg3, arg4})
	stub := fake.UploadBitsPackageStub
	fakeReturns := fake.uploadBitsPackageReturns
	fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4})
	fake.uploadBitsPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadBitsPackageCallCount() int {
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	return len(fake.uploadBitsPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadBitsPackageCalls(stub func(resources.Package, []ccv3.Resource, io.Reader, int64) (resources.Package, ccv3.Warnings, error)) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadBitsPackageArgsForCall(i int) (resources.Package, []ccv3.Resource, io.Reader, int64) {
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	argsForCall := fake.uploadBitsPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadBitsPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	fake.uploadBitsPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	if fake.uploadBitsPackageReturnsOnCall == nil {
		fake.uploadBitsPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadBitsPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBuildpack(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.uploadBuildpackMutex.Lock()
	ret, specificReturn := fake.uploadBuildpackReturnsOnCall[len(fake.uploadBuildpackArgsForCall)]
	fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2, arg3, arg4})
	stub := fake.UploadBuildpackStub
	fakeReturns := fake.uploadBuildpackReturns
	fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3, arg4})
	fake.uploadBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadBuildpackCallCount() int {
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	return len(fake.uploadBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadBuildpackCalls(stub func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) UploadBuildpackArgsForCall(i int) (string, string, io.Reader, int64) {
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	argsForCall := fake.uploadBuildpackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadBuildpackReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	fake.uploadBuildpackReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBuildpackReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	if fake.uploadBuildpackReturnsOnCall == nil {
		fake.uploadBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadBuildpackReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadDropletBits(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.uploadDropletBitsMutex.Lock()
	ret, specificReturn := fake.uploadDropletBitsReturnsOnCall[len(fake.uploadDropletBitsArgsForCall)]
	fake.uploadDropletBitsArgsForCall = append(fake.uploadDropletBitsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2, arg3, arg4})
	stub := fake.UploadDropletBitsStub
	fakeReturns := fake.uploadDropletBitsReturns
	fake.recordInvocation("UploadDropletBits", []interface{}{arg1, arg2, arg3, arg4})
	fake.uploadDropletBitsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadDropletBitsCallCount() int {
	fake.uploadDropletBitsMutex.RLock()
	defer fake.uploadDropletBitsMutex.RUnlock()
	return len(fake.uploadDropletBitsArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadDropletBitsCalls(stub func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.uploadDropletBitsMutex.Lock()
	defer fake.uploadDropletBitsMutex.Unlock()
	fake.UploadDropletBitsStub = stub
}

func (fake *FakeCloudControllerClient) UploadDropletBitsArgsForCall(i int) (string, string, io.Reader, int64) {
	fake.uploadDropletBitsMutex.RLock()
	defer fake.uploadDropletBitsMutex.RUnlock()
	argsForCall := fake.uploadDropletBitsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadDropletBitsReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.uploadDropletBitsMutex.Lock()
	defer fake.uploadDropletBitsMutex.Unlock()
	fake.UploadDropletBitsStub = nil
	fake.uploadDropletBitsReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadDropletBitsReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.uploadDropletBitsMutex.Lock()
	defer fake.uploadDropletBitsMutex.Unlock()
	fake.UploadDropletBitsStub = nil
	if fake.uploadDropletBitsReturnsOnCall == nil {
		fake.uploadDropletBitsReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadDropletBitsReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadPackage(arg1 resources.Package, arg2 string) (resources.Package, ccv3.Warnings, error) {
	fake.uploadPackageMutex.Lock()
	ret, specificReturn := fake.uploadPackageReturnsOnCall[len(fake.uploadPackageArgsForCall)]
	fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, struct {
		arg1 resources.Package
		arg2 string
	}{arg1, arg2})
	stub := fake.UploadPackageStub
	fakeReturns := fake.uploadPackageReturns
	fake.recordInvocation("UploadPackage", []interface{}{arg1, arg2})
	fake.uploadPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadPackageCallCount() int {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	return len(fake.uploadPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadPackageCalls(stub func(resources.Package, string) (resources.Package, ccv3.Warnings, error)) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadPackageArgsForCall(i int) (resources.Package, string) {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	argsForCall := fake.uploadPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UploadPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = nil
	fake.uploadPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = nil
	if fake.uploadPackageReturnsOnCall == nil {
		fake.uploadPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) WhoAmI() (resources.K8sUser, ccv3.Warnings, error) {
	fake.whoAmIMutex.Lock()
	ret, specificReturn := fake.whoAmIReturnsOnCall[len(fake.whoAmIArgsForCall)]
	fake.whoAmIArgsForCall = append(fake.whoAmIArgsForCall, struct {
	}{})
	stub := fake.WhoAmIStub
	fakeReturns := fake.whoAmIReturns
	fake.recordInvocation("WhoAmI", []interface{}{})
	fake.whoAmIMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) WhoAmICallCount() int {
	fake.whoAmIMutex.RLock()
	defer fake.whoAmIMutex.RUnlock()
	return len(fake.whoAmIArgsForCall)
}

func (fake *FakeCloudControllerClient) WhoAmICalls(stub func() (resources.K8sUser, ccv3.Warnings, error)) {
	fake.whoAmIMutex.Lock()
	defer fake.whoAmIMutex.Unlock()
	fake.WhoAmIStub = stub
}

func (fake *FakeCloudControllerClient) WhoAmIReturns(result1 resources.K8sUser, result2 ccv3.Warnings, result3 error) {
	fake.whoAmIMutex.Lock()
	defer fake.whoAmIMutex.Unlock()
	fake.WhoAmIStub = nil
	fake.whoAmIReturns = struct {
		result1 resources.K8sUser
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) WhoAmIReturnsOnCall(i int, result1 resources.K8sUser, result2 ccv3.Warnings, result3 error) {
	fake.whoAmIMutex.Lock()
	defer fake.whoAmIMutex.Unlock()
	fake.WhoAmIStub = nil
	if fake.whoAmIReturnsOnCall == nil {
		fake.whoAmIReturnsOnCall = make(map[int]struct {
			result1 resources.K8sUser
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.whoAmIReturnsOnCall[i] = struct {
		result1 resources.K8sUser
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.applyOrganizationQuotaMutex.RLock()
	defer fake.applyOrganizationQuotaMutex.RUnlock()
	fake.applySpaceQuotaMutex.RLock()
	defer fake.applySpaceQuotaMutex.RUnlock()
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	fake.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.RUnlock()
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	fake.createApplicationDeploymentMutex.RLock()
	defer fake.createApplicationDeploymentMutex.RUnlock()
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	fake.createDropletMutex.RLock()
	defer fake.createDropletMutex.RUnlock()
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	fake.createRoleMutex.RLock()
	defer fake.createRoleMutex.RUnlock()
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	fake.createServiceCredentialBindingMutex.RLock()
	defer fake.createServiceCredentialBindingMutex.RUnlock()
	fake.createServiceInstanceMutex.RLock()
	defer fake.createServiceInstanceMutex.RUnlock()
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	fake.deleteRoleMutex.RLock()
	defer fake.deleteRoleMutex.RUnlock()
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	fake.deleteServiceCredentialBindingMutex.RLock()
	defer fake.deleteServiceCredentialBindingMutex.RUnlock()
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	fake.deleteSpaceMutex.RLock()
	defer fake.deleteSpaceMutex.RUnlock()
	fake.deleteSpaceQuotaMutex.RLock()
	defer fake.deleteSpaceQuotaMutex.RUnlock()
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	fake.downloadDropletMutex.RLock()
	defer fake.downloadDropletMutex.RUnlock()
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	fake.getApplicationRevisionsMutex.RLock()
	defer fake.getApplicationRevisionsMutex.RUnlock()
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	fake.getDeploymentMutex.RLock()
	defer fake.getDeploymentMutex.RUnlock()
	fake.getDeploymentsMutex.RLock()
	defer fake.getDeploymentsMutex.RUnlock()
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	fake.getEnvironmentVariablesByURLMutex.RLock()
	defer fake.getEnvironmentVariablesByURLMutex.RUnlock()
	fake.getEventsMutex.RLock()
	defer fake.getEventsMutex.RUnlock()
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	fake.getInfoMutex.RLock()
	defer fake.getInfoMutex.RUnlock()
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	fake.getNewApplicationProcessesMutex.RLock()
	defer fake.getNewApplicationProcessesMutex.RUnlock()
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	fake.getPackageDropletsMutex.RLock()
	defer fake.getPackageDropletsMutex.RUnlock()
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	fake.getProcessMutex.RLock()
	defer fake.getProcessMutex.RUnlock()
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	fake.getProcessSidecarsMutex.RLock()
	defer fake.getProcessSidecarsMutex.RUnlock()
	fake.getProcessesMutex.RLock()
	defer fake.getProcessesMutex.RUnlock()
	fake.getRolesMutex.RLock()
	defer fake.getRolesMutex.RUnlock()
	fake.getRootMutex.RLock()
	defer fake.getRootMutex.RUnlock()
	fake.getRouteBindingsMutex.RLock()
	defer fake.getRouteBindingsMutex.RUnlock()
	fake.getRouteDestinationsMutex.RLock()
	defer fake.getRouteDestinationsMutex.RUnlock()
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	fake.getRunningSecurityGroupsMutex.RLock()
	defer fake.getRunningSecurityGroupsMutex.RUnlock()
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	fake.getServiceCredentialBindingDetailsMutex.RLock()
	defer fake.getServiceCredentialBindingDetailsMutex.RUnlock()
	fake.getServiceCredentialBindingsMutex.RLock()
	defer fake.getServiceCredentialBindingsMutex.RUnlock()
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	fake.getServiceInstanceSharedSpacesMutex.RLock()
	defer fake.getServiceInstanceSharedSpacesMutex.RUnlock()
	fake.getServiceInstanceUsageSummaryMutex.RLock()
	defer fake.getServiceInstanceUsageSummaryMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getServiceOfferingByGUIDMutex.RLock()
	defer fake.getServiceOfferingByGUIDMutex.RUnlock()
	fake.getServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.getServiceOfferingByNameAndBrokerMutex.RUnlock()
	fake.getServiceOfferingsMutex.RLock()
	defer fake.getServiceOfferingsMutex.RUnlock()
	fake.getServicePlanByGUIDMutex.RLock()
	defer fake.getServicePlanByGUIDMutex.RUnlock()
	fake.getServicePlanVisibilityMutex.RLock()
	defer fake.getServicePlanVisibilityMutex.RUnlock()
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	fake.getServicePlansWithOfferingsMutex.RLock()
	defer fake.getServicePlansWithOfferingsMutex.RUnlock()
	fake.getServicePlansWithSpaceAndOrganizationMutex.RLock()
	defer fake.getServicePlansWithSpaceAndOrganizationMutex.RUnlock()
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	fake.getSpaceManifestDiffMutex.RLock()
	defer fake.getSpaceManifestDiffMutex.RUnlock()
	fake.getSpaceQuotaMutex.RLock()
	defer fake.getSpaceQuotaMutex.RUnlock()
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	fake.getStagingSecurityGroupsMutex.RLock()
	defer fake.getStagingSecurityGroupsMutex.RUnlock()
	fake.getTaskMutex.RLock()
	defer fake.getTaskMutex.RUnlock()
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	fake.getUsersMutex.RLock()
	defer fake.getUsersMutex.RUnlock()
	fake.makeRequestSendReceiveRawMutex.RLock()
	defer fake.makeRequestSendReceiveRawMutex.RUnlock()
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.pollJobForStateMutex.RLock()
	defer fake.pollJobForStateMutex.RUnlock()
	fake.pollJobToEventStreamMutex.RLock()
	defer fake.pollJobToEventStreamMutex.RUnlock()
	fake.purgeServiceOfferingMutex.RLock()
	defer fake.purgeServiceOfferingMutex.RUnlock()
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	fake.rootResponseMutex.RLock()
	defer fake.rootResponseMutex.RUnlock()
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	fake.unbindSecurityGroupRunningSpaceMutex.RLock()
	defer fake.unbindSecurityGroupRunningSpaceMutex.RUnlock()
	fake.unbindSecurityGroupStagingSpaceMutex.RLock()
	defer fake.unbindSecurityGroupStagingSpaceMutex.RUnlock()
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	fake.unsharePrivateDomainFromOrgMutex.RLock()
	defer fake.unsharePrivateDomainFromOrgMutex.RUnlock()
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	fake.updateApplicationNameMutex.RLock()
	defer fake.updateApplicationNameMutex.RUnlock()
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	fake.updateEnvironmentVariableGroupMutex.RLock()
	defer fake.updateEnvironmentVariableGroupMutex.RUnlock()
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	fake.updateResourceMetadataMutex.RLock()
	defer fake.updateResourceMetadataMutex.RUnlock()
	fake.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.RUnlock()
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	fake.updateSecurityGroupRunningSpaceMutex.RLock()
	defer fake.updateSecurityGroupRunningSpaceMutex.RUnlock()
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	fake.updateServiceInstanceMutex.RLock()
	defer fake.updateServiceInstanceMutex.RUnlock()
	fake.updateServicePlanVisibilityMutex.RLock()
	defer fake.updateServicePlanVisibilityMutex.RUnlock()
	fake.updateSpaceMutex.RLock()
	defer fake.updateSpaceMutex.RUnlock()
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	fake.uploadDropletBitsMutex.RLock()
	defer fake.uploadDropletBitsMutex.RUnlock()
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	fake.whoAmIMutex.RLock()
	defer fake.whoAmIMutex.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 _ v7action.CloudControllerClient = new(FakeCloudControllerClient)
