fake_cloud_controller_client.go

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

import (
	"io"
	"sync"

	"code.cloudfoundry.org/cli/actor/v3action"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
	"code.cloudfoundry.org/cli/resources"
)

type FakeCloudControllerClient struct {
	AppSSHEndpointStub        func() string
	appSSHEndpointMutex       sync.RWMutex
	appSSHEndpointArgsForCall []struct {
	}
	appSSHEndpointReturns struct {
		result1 string
	}
	appSSHEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	AppSSHHostKeyFingerprintStub        func() string
	appSSHHostKeyFingerprintMutex       sync.RWMutex
	appSSHHostKeyFingerprintArgsForCall []struct {
	}
	appSSHHostKeyFingerprintReturns struct {
		result1 string
	}
	appSSHHostKeyFingerprintReturnsOnCall map[int]struct {
		result1 string
	}
	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
	}
	CloudControllerAPIVersionStub        func() string
	cloudControllerAPIVersionMutex       sync.RWMutex
	cloudControllerAPIVersionArgsForCall []struct {
	}
	cloudControllerAPIVersionReturns struct {
		result1 string
	}
	cloudControllerAPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	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(string, string) (string, ccv3.Warnings, error)
	createApplicationDeploymentMutex       sync.RWMutex
	createApplicationDeploymentArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createApplicationDeploymentReturns struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationDeploymentReturnsOnCall map[int]struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationProcessScaleStub        func(string, ccv3.Process) (ccv3.Process, ccv3.Warnings, error)
	createApplicationProcessScaleMutex       sync.RWMutex
	createApplicationProcessScaleArgsForCall []struct {
		arg1 string
		arg2 ccv3.Process
	}
	createApplicationProcessScaleReturns struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationProcessScaleReturnsOnCall map[int]struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationTaskStub        func(string, ccv3.Task) (ccv3.Task, ccv3.Warnings, error)
	createApplicationTaskMutex       sync.RWMutex
	createApplicationTaskArgsForCall []struct {
		arg1 string
		arg2 ccv3.Task
	}
	createApplicationTaskReturns struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationTaskReturnsOnCall map[int]struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	CreateBuildStub        func(ccv3.Build) (ccv3.Build, ccv3.Warnings, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		arg1 ccv3.Build
	}
	createBuildReturns struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	createBuildReturnsOnCall map[int]struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	CreateIsolationSegmentStub        func(ccv3.IsolationSegment) (ccv3.IsolationSegment, ccv3.Warnings, error)
	createIsolationSegmentMutex       sync.RWMutex
	createIsolationSegmentArgsForCall []struct {
		arg1 ccv3.IsolationSegment
	}
	createIsolationSegmentReturns struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	createIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	CreatePackageStub        func(ccv3.Package) (ccv3.Package, ccv3.Warnings, error)
	createPackageMutex       sync.RWMutex
	createPackageArgsForCall []struct {
		arg1 ccv3.Package
	}
	createPackageReturns struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	createPackageReturnsOnCall map[int]struct {
		result1 ccv3.Package
		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
	}
	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
	}
	DeleteServiceInstanceRelationshipsSharedSpaceStub        func(string, string) (ccv3.Warnings, error)
	deleteServiceInstanceRelationshipsSharedSpaceMutex       sync.RWMutex
	deleteServiceInstanceRelationshipsSharedSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 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
	}
	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
	}
	GetApplicationProcessByTypeStub        func(string, string) (ccv3.Process, ccv3.Warnings, error)
	getApplicationProcessByTypeMutex       sync.RWMutex
	getApplicationProcessByTypeArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationProcessByTypeReturns struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessByTypeReturnsOnCall map[int]struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessesStub        func(string) ([]ccv3.Process, ccv3.Warnings, error)
	getApplicationProcessesMutex       sync.RWMutex
	getApplicationProcessesArgsForCall []struct {
		arg1 string
	}
	getApplicationProcessesReturns struct {
		result1 []ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessesReturnsOnCall map[int]struct {
		result1 []ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationTasksStub        func(string, ...ccv3.Query) ([]ccv3.Task, ccv3.Warnings, error)
	getApplicationTasksMutex       sync.RWMutex
	getApplicationTasksArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getApplicationTasksReturns struct {
		result1 []ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationTasksReturnsOnCall map[int]struct {
		result1 []ccv3.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) (ccv3.Build, ccv3.Warnings, error)
	getBuildMutex       sync.RWMutex
	getBuildArgsForCall []struct {
		arg1 string
	}
	getBuildReturns struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	getBuildReturnsOnCall map[int]struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	GetDeploymentStub        func(string) (ccv3.Deployment, ccv3.Warnings, error)
	getDeploymentMutex       sync.RWMutex
	getDeploymentArgsForCall []struct {
		arg1 string
	}
	getDeploymentReturns struct {
		result1 ccv3.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	getDeploymentReturnsOnCall map[int]struct {
		result1 ccv3.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	GetDeploymentsStub        func(...ccv3.Query) ([]ccv3.Deployment, ccv3.Warnings, error)
	getDeploymentsMutex       sync.RWMutex
	getDeploymentsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDeploymentsReturns struct {
		result1 []ccv3.Deployment
		result2 ccv3.Warnings
		result3 error
	}
	getDeploymentsReturnsOnCall map[int]struct {
		result1 []ccv3.Deployment
		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
	}
	GetInfoStub        func() (ccv3.Info, ccv3.ResourceLinks, ccv3.Warnings, error)
	getInfoMutex       sync.RWMutex
	getInfoArgsForCall []struct {
	}
	getInfoReturns struct {
		result1 ccv3.Info
		result2 ccv3.ResourceLinks
		result3 ccv3.Warnings
		result4 error
	}
	getInfoReturnsOnCall map[int]struct {
		result1 ccv3.Info
		result2 ccv3.ResourceLinks
		result3 ccv3.Warnings
		result4 error
	}
	GetIsolationSegmentStub        func(string) (ccv3.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentMutex       sync.RWMutex
	getIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentReturns struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.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) ([]ccv3.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentsMutex       sync.RWMutex
	getIsolationSegmentsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getIsolationSegmentsReturns struct {
		result1 []ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentsReturnsOnCall map[int]struct {
		result1 []ccv3.IsolationSegment
		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
	}
	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) (ccv3.Package, ccv3.Warnings, error)
	getPackageMutex       sync.RWMutex
	getPackageArgsForCall []struct {
		arg1 string
	}
	getPackageReturns struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackageReturnsOnCall map[int]struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	GetPackagesStub        func(...ccv3.Query) ([]ccv3.Package, ccv3.Warnings, error)
	getPackagesMutex       sync.RWMutex
	getPackagesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getPackagesReturns struct {
		result1 []ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackagesReturnsOnCall map[int]struct {
		result1 []ccv3.Package
		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
	}
	GetServiceInstancesStub        func(...ccv3.Query) ([]resources.ServiceInstance, ccv3.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceInstancesReturns struct {
		result1 []resources.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstancesReturnsOnCall map[int]struct {
		result1 []resources.ServiceInstance
		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
	}
	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
	}
	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
	}
	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
	}
	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) (ccv3.Info, ccv3.Warnings, error)
	targetCFMutex       sync.RWMutex
	targetCFArgsForCall []struct {
		arg1 ccv3.TargetSettings
	}
	targetCFReturns struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}
	targetCFReturnsOnCall map[int]struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 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, ccv3.EnvironmentVariables) (ccv3.EnvironmentVariables, ccv3.Warnings, error)
	updateApplicationEnvironmentVariablesMutex       sync.RWMutex
	updateApplicationEnvironmentVariablesArgsForCall []struct {
		arg1 string
		arg2 ccv3.EnvironmentVariables
	}
	updateApplicationEnvironmentVariablesReturns struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationEnvironmentVariablesReturnsOnCall map[int]struct {
		result1 ccv3.EnvironmentVariables
		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
	}
	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
	}
	UpdateProcessStub        func(ccv3.Process) (ccv3.Process, ccv3.Warnings, error)
	updateProcessMutex       sync.RWMutex
	updateProcessArgsForCall []struct {
		arg1 ccv3.Process
	}
	updateProcessReturns struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	updateProcessReturnsOnCall map[int]struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 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
	}
	UpdateTaskCancelStub        func(string) (ccv3.Task, ccv3.Warnings, error)
	updateTaskCancelMutex       sync.RWMutex
	updateTaskCancelArgsForCall []struct {
		arg1 string
	}
	updateTaskCancelReturns struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	updateTaskCancelReturnsOnCall map[int]struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	UploadBitsPackageStub        func(ccv3.Package, []ccv3.Resource, io.Reader, int64) (ccv3.Package, ccv3.Warnings, error)
	uploadBitsPackageMutex       sync.RWMutex
	uploadBitsPackageArgsForCall []struct {
		arg1 ccv3.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}
	uploadBitsPackageReturns struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadBitsPackageReturnsOnCall map[int]struct {
		result1 ccv3.Package
		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(ccv3.Package, string) (ccv3.Package, ccv3.Warnings, error)
	uploadPackageMutex       sync.RWMutex
	uploadPackageArgsForCall []struct {
		arg1 ccv3.Package
		arg2 string
	}
	uploadPackageReturns struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadPackageReturnsOnCall map[int]struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) AppSSHEndpoint() string {
	fake.appSSHEndpointMutex.Lock()
	ret, specificReturn := fake.appSSHEndpointReturnsOnCall[len(fake.appSSHEndpointArgsForCall)]
	fake.appSSHEndpointArgsForCall = append(fake.appSSHEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("AppSSHEndpoint", []interface{}{})
	fake.appSSHEndpointMutex.Unlock()
	if fake.AppSSHEndpointStub != nil {
		return fake.AppSSHEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.appSSHEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) AppSSHEndpointCallCount() int {
	fake.appSSHEndpointMutex.RLock()
	defer fake.appSSHEndpointMutex.RUnlock()
	return len(fake.appSSHEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) AppSSHEndpointCalls(stub func() string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = stub
}

func (fake *FakeCloudControllerClient) AppSSHEndpointReturns(result1 string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = nil
	fake.appSSHEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHEndpointReturnsOnCall(i int, result1 string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = nil
	if fake.appSSHEndpointReturnsOnCall == nil {
		fake.appSSHEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.appSSHEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprint() string {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	ret, specificReturn := fake.appSSHHostKeyFingerprintReturnsOnCall[len(fake.appSSHHostKeyFingerprintArgsForCall)]
	fake.appSSHHostKeyFingerprintArgsForCall = append(fake.appSSHHostKeyFingerprintArgsForCall, struct {
	}{})
	fake.recordInvocation("AppSSHHostKeyFingerprint", []interface{}{})
	fake.appSSHHostKeyFingerprintMutex.Unlock()
	if fake.AppSSHHostKeyFingerprintStub != nil {
		return fake.AppSSHHostKeyFingerprintStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.appSSHHostKeyFingerprintReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintCallCount() int {
	fake.appSSHHostKeyFingerprintMutex.RLock()
	defer fake.appSSHHostKeyFingerprintMutex.RUnlock()
	return len(fake.appSSHHostKeyFingerprintArgsForCall)
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintCalls(stub func() string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = stub
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintReturns(result1 string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = nil
	fake.appSSHHostKeyFingerprintReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintReturnsOnCall(i int, result1 string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = nil
	if fake.appSSHHostKeyFingerprintReturnsOnCall == nil {
		fake.appSSHHostKeyFingerprintReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.appSSHHostKeyFingerprintReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

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})
	fake.recordInvocation("CancelDeployment", []interface{}{arg1})
	fake.cancelDeploymentMutex.Unlock()
	if fake.CancelDeploymentStub != nil {
		return fake.CancelDeploymentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.cancelDeploymentReturns
	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) CloudControllerAPIVersion() string {
	fake.cloudControllerAPIVersionMutex.Lock()
	ret, specificReturn := fake.cloudControllerAPIVersionReturnsOnCall[len(fake.cloudControllerAPIVersionArgsForCall)]
	fake.cloudControllerAPIVersionArgsForCall = append(fake.cloudControllerAPIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("CloudControllerAPIVersion", []interface{}{})
	fake.cloudControllerAPIVersionMutex.Unlock()
	if fake.CloudControllerAPIVersionStub != nil {
		return fake.CloudControllerAPIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.cloudControllerAPIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionCallCount() int {
	fake.cloudControllerAPIVersionMutex.RLock()
	defer fake.cloudControllerAPIVersionMutex.RUnlock()
	return len(fake.cloudControllerAPIVersionArgsForCall)
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionCalls(stub func() string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = stub
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionReturns(result1 string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = nil
	fake.cloudControllerAPIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionReturnsOnCall(i int, result1 string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = nil
	if fake.cloudControllerAPIVersionReturnsOnCall == nil {
		fake.cloudControllerAPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cloudControllerAPIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

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})
	fake.recordInvocation("CreateApplication", []interface{}{arg1})
	fake.createApplicationMutex.Unlock()
	if fake.CreateApplicationStub != nil {
		return fake.CreateApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationReturns
	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 string, arg2 string) (string, ccv3.Warnings, error) {
	fake.createApplicationDeploymentMutex.Lock()
	ret, specificReturn := fake.createApplicationDeploymentReturnsOnCall[len(fake.createApplicationDeploymentArgsForCall)]
	fake.createApplicationDeploymentArgsForCall = append(fake.createApplicationDeploymentArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateApplicationDeployment", []interface{}{arg1, arg2})
	fake.createApplicationDeploymentMutex.Unlock()
	if fake.CreateApplicationDeploymentStub != nil {
		return fake.CreateApplicationDeploymentStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationDeploymentReturns
	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(string, string) (string, ccv3.Warnings, error)) {
	fake.createApplicationDeploymentMutex.Lock()
	defer fake.createApplicationDeploymentMutex.Unlock()
	fake.CreateApplicationDeploymentStub = stub
}

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

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 ccv3.Process) (ccv3.Process, ccv3.Warnings, error) {
	fake.createApplicationProcessScaleMutex.Lock()
	ret, specificReturn := fake.createApplicationProcessScaleReturnsOnCall[len(fake.createApplicationProcessScaleArgsForCall)]
	fake.createApplicationProcessScaleArgsForCall = append(fake.createApplicationProcessScaleArgsForCall, struct {
		arg1 string
		arg2 ccv3.Process
	}{arg1, arg2})
	fake.recordInvocation("CreateApplicationProcessScale", []interface{}{arg1, arg2})
	fake.createApplicationProcessScaleMutex.Unlock()
	if fake.CreateApplicationProcessScaleStub != nil {
		return fake.CreateApplicationProcessScaleStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationProcessScaleReturns
	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, ccv3.Process) (ccv3.Process, ccv3.Warnings, error)) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = stub
}

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

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

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturnsOnCall(i int, result1 ccv3.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 ccv3.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationProcessScaleReturnsOnCall[i] = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) CreateApplicationTaskReturnsOnCall(i int, result1 ccv3.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 ccv3.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationTaskReturnsOnCall[i] = struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) CreateBuildReturnsOnCall(i int, result1 ccv3.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 ccv3.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createBuildReturnsOnCall[i] = struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturnsOnCall(i int, result1 ccv3.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 ccv3.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) CreatePackageReturnsOnCall(i int, result1 ccv3.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 ccv3.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createPackageReturnsOnCall[i] = struct {
		result1 ccv3.Package
		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})
	fake.recordInvocation("DeleteApplication", []interface{}{arg1})
	fake.deleteApplicationMutex.Unlock()
	if fake.DeleteApplicationStub != nil {
		return fake.DeleteApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteApplicationReturns
	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})
	fake.recordInvocation("DeleteApplicationProcessInstance", []interface{}{arg1, arg2, arg3})
	fake.deleteApplicationProcessInstanceMutex.Unlock()
	if fake.DeleteApplicationProcessInstanceStub != nil {
		return fake.DeleteApplicationProcessInstanceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteApplicationProcessInstanceReturns
	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) 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})
	fake.recordInvocation("DeleteIsolationSegment", []interface{}{arg1})
	fake.deleteIsolationSegmentMutex.Unlock()
	if fake.DeleteIsolationSegmentStub != nil {
		return fake.DeleteIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentReturns
	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})
	fake.recordInvocation("DeleteIsolationSegmentOrganization", []interface{}{arg1, arg2})
	fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	if fake.DeleteIsolationSegmentOrganizationStub != nil {
		return fake.DeleteIsolationSegmentOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentOrganizationReturns
	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) DeleteServiceInstanceRelationshipsSharedSpace(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall[len(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall)]
	fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall = append(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteServiceInstanceRelationshipsSharedSpace", []interface{}{arg1, arg2})
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	if fake.DeleteServiceInstanceRelationshipsSharedSpaceStub != nil {
		return fake.DeleteServiceInstanceRelationshipsSharedSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteServiceInstanceRelationshipsSharedSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceCallCount() int {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RUnlock()
	return len(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = nil
	fake.deleteServiceInstanceRelationshipsSharedSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = nil
	if fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall == nil {
		fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

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})
	fake.recordInvocation("EntitleIsolationSegmentToOrganizations", []interface{}{arg1, arg2Copy})
	fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	if fake.EntitleIsolationSegmentToOrganizationsStub != nil {
		return fake.EntitleIsolationSegmentToOrganizationsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.entitleIsolationSegmentToOrganizationsReturns
	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) 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})
	fake.recordInvocation("GetApplicationDropletCurrent", []interface{}{arg1})
	fake.getApplicationDropletCurrentMutex.Unlock()
	if fake.GetApplicationDropletCurrentStub != nil {
		return fake.GetApplicationDropletCurrentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationDropletCurrentReturns
	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})
	fake.recordInvocation("GetApplicationEnvironment", []interface{}{arg1})
	fake.getApplicationEnvironmentMutex.Unlock()
	if fake.GetApplicationEnvironmentStub != nil {
		return fake.GetApplicationEnvironmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationEnvironmentReturns
	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) GetApplicationProcessByType(arg1 string, arg2 string) (ccv3.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})
	fake.recordInvocation("GetApplicationProcessByType", []interface{}{arg1, arg2})
	fake.getApplicationProcessByTypeMutex.Unlock()
	if fake.GetApplicationProcessByTypeStub != nil {
		return fake.GetApplicationProcessByTypeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationProcessByTypeReturns
	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) (ccv3.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 ccv3.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = nil
	fake.getApplicationProcessByTypeReturns = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturnsOnCall(i int, result1 ccv3.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 ccv3.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessByTypeReturnsOnCall[i] = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturnsOnCall(i int, result1 []ccv3.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 []ccv3.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessesReturnsOnCall[i] = struct {
		result1 []ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasks(arg1 string, arg2 ...ccv3.Query) ([]ccv3.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})
	fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2})
	fake.getApplicationTasksMutex.Unlock()
	if fake.GetApplicationTasksStub != nil {
		return fake.GetApplicationTasksStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationTasksReturns
	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) ([]ccv3.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 []ccv3.Task, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = nil
	fake.getApplicationTasksReturns = struct {
		result1 []ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturnsOnCall(i int, result1 []ccv3.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 []ccv3.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationTasksReturnsOnCall[i] = struct {
		result1 []ccv3.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})
	fake.recordInvocation("GetApplications", []interface{}{arg1})
	fake.getApplicationsMutex.Unlock()
	if fake.GetApplicationsStub != nil {
		return fake.GetApplicationsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationsReturns
	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) (ccv3.Build, ccv3.Warnings, error) {
	fake.getBuildMutex.Lock()
	ret, specificReturn := fake.getBuildReturnsOnCall[len(fake.getBuildArgsForCall)]
	fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetBuild", []interface{}{arg1})
	fake.getBuildMutex.Unlock()
	if fake.GetBuildStub != nil {
		return fake.GetBuildStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getBuildReturns
	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) (ccv3.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 ccv3.Build, result2 ccv3.Warnings, result3 error) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = nil
	fake.getBuildReturns = struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildReturnsOnCall(i int, result1 ccv3.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 ccv3.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getBuildReturnsOnCall[i] = struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetDeploymentReturnsOnCall(i int, result1 ccv3.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 ccv3.Deployment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDeploymentReturnsOnCall[i] = struct {
		result1 ccv3.Deployment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetDeploymentsReturnsOnCall(i int, result1 []ccv3.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 []ccv3.Deployment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDeploymentsReturnsOnCall[i] = struct {
		result1 []ccv3.Deployment
		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})
	fake.recordInvocation("GetDroplet", []interface{}{arg1})
	fake.getDropletMutex.Unlock()
	if fake.GetDropletStub != nil {
		return fake.GetDropletStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDropletReturns
	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})
	fake.recordInvocation("GetDroplets", []interface{}{arg1})
	fake.getDropletsMutex.Unlock()
	if fake.GetDropletsStub != nil {
		return fake.GetDropletsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDropletsReturns
	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) GetInfo() (ccv3.Info, ccv3.ResourceLinks, ccv3.Warnings, error) {
	fake.getInfoMutex.Lock()
	ret, specificReturn := fake.getInfoReturnsOnCall[len(fake.getInfoArgsForCall)]
	fake.getInfoArgsForCall = append(fake.getInfoArgsForCall, struct {
	}{})
	fake.recordInvocation("GetInfo", []interface{}{})
	fake.getInfoMutex.Unlock()
	if fake.GetInfoStub != nil {
		return fake.GetInfoStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	fakeReturns := fake.getInfoReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

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.ResourceLinks, ccv3.Warnings, error)) {
	fake.getInfoMutex.Lock()
	defer fake.getInfoMutex.Unlock()
	fake.GetInfoStub = stub
}

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

func (fake *FakeCloudControllerClient) GetInfoReturnsOnCall(i int, result1 ccv3.Info, result2 ccv3.ResourceLinks, result3 ccv3.Warnings, result4 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.ResourceLinks
			result3 ccv3.Warnings
			result4 error
		})
	}
	fake.getInfoReturnsOnCall[i] = struct {
		result1 ccv3.Info
		result2 ccv3.ResourceLinks
		result3 ccv3.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

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

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturnsOnCall(i int, result1 ccv3.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 ccv3.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.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})
	fake.recordInvocation("GetIsolationSegmentOrganizations", []interface{}{arg1})
	fake.getIsolationSegmentOrganizationsMutex.Unlock()
	if fake.GetIsolationSegmentOrganizationsStub != nil {
		return fake.GetIsolationSegmentOrganizationsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentOrganizationsReturns
	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) ([]ccv3.IsolationSegment, ccv3.Warnings, error) {
	fake.getIsolationSegmentsMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentsReturnsOnCall[len(fake.getIsolationSegmentsArgsForCall)]
	fake.getIsolationSegmentsArgsForCall = append(fake.getIsolationSegmentsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetIsolationSegments", []interface{}{arg1})
	fake.getIsolationSegmentsMutex.Unlock()
	if fake.GetIsolationSegmentsStub != nil {
		return fake.GetIsolationSegmentsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentsReturns
	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) ([]ccv3.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 []ccv3.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = nil
	fake.getIsolationSegmentsReturns = struct {
		result1 []ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturnsOnCall(i int, result1 []ccv3.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 []ccv3.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentsReturnsOnCall[i] = struct {
		result1 []ccv3.IsolationSegment
		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})
	fake.recordInvocation("GetOrganizationDefaultIsolationSegment", []interface{}{arg1})
	fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.GetOrganizationDefaultIsolationSegmentStub != nil {
		return fake.GetOrganizationDefaultIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationDefaultIsolationSegmentReturns
	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) 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})
	fake.recordInvocation("GetOrganizations", []interface{}{arg1})
	fake.getOrganizationsMutex.Unlock()
	if fake.GetOrganizationsStub != nil {
		return fake.GetOrganizationsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationsReturns
	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) (ccv3.Package, ccv3.Warnings, error) {
	fake.getPackageMutex.Lock()
	ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)]
	fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetPackage", []interface{}{arg1})
	fake.getPackageMutex.Unlock()
	if fake.GetPackageStub != nil {
		return fake.GetPackageStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getPackageReturns
	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) (ccv3.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 ccv3.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = nil
	fake.getPackageReturns = struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackageReturnsOnCall(i int, result1 ccv3.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 ccv3.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackageReturnsOnCall[i] = struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) GetPackagesReturnsOnCall(i int, result1 []ccv3.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 []ccv3.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackagesReturnsOnCall[i] = struct {
		result1 []ccv3.Package
		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})
	fake.recordInvocation("GetProcessInstances", []interface{}{arg1})
	fake.getProcessInstancesMutex.Unlock()
	if fake.GetProcessInstancesStub != nil {
		return fake.GetProcessInstancesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getProcessInstancesReturns
	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) GetServiceInstances(arg1 ...ccv3.Query) ([]resources.ServiceInstance, ccv3.Warnings, error) {
	fake.getServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetServiceInstances", []interface{}{arg1})
	fake.getServiceInstancesMutex.Unlock()
	if fake.GetServiceInstancesStub != nil {
		return fake.GetServiceInstancesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstancesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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.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.Warnings, result3 error) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = nil
	fake.getServiceInstancesReturns = struct {
		result1 []resources.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturnsOnCall(i int, result1 []resources.ServiceInstance, result2 ccv3.Warnings, result3 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.Warnings
			result3 error
		})
	}
	fake.getServiceInstancesReturnsOnCall[i] = struct {
		result1 []resources.ServiceInstance
		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})
	fake.recordInvocation("GetSpaceIsolationSegment", []interface{}{arg1})
	fake.getSpaceIsolationSegmentMutex.Unlock()
	if fake.GetSpaceIsolationSegmentStub != nil {
		return fake.GetSpaceIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceIsolationSegmentReturns
	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) 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})
	fake.recordInvocation("GetSpaces", []interface{}{arg1})
	fake.getSpacesMutex.Unlock()
	if fake.GetSpacesStub != nil {
		return fake.GetSpacesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	fakeReturns := fake.getSpacesReturns
	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) 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})
	fake.recordInvocation("PollJob", []interface{}{arg1})
	fake.pollJobMutex.Unlock()
	if fake.PollJobStub != nil {
		return fake.PollJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.pollJobReturns
	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) 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})
	fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2})
	fake.setApplicationDropletMutex.Unlock()
	if fake.SetApplicationDropletStub != nil {
		return fake.SetApplicationDropletStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.setApplicationDropletReturns
	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) 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})
	fake.recordInvocation("ShareServiceInstanceToSpaces", []interface{}{arg1, arg2Copy})
	fake.shareServiceInstanceToSpacesMutex.Unlock()
	if fake.ShareServiceInstanceToSpacesStub != nil {
		return fake.ShareServiceInstanceToSpacesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.shareServiceInstanceToSpacesReturns
	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) (ccv3.Info, ccv3.Warnings, error) {
	fake.targetCFMutex.Lock()
	ret, specificReturn := fake.targetCFReturnsOnCall[len(fake.targetCFArgsForCall)]
	fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, struct {
		arg1 ccv3.TargetSettings
	}{arg1})
	fake.recordInvocation("TargetCF", []interface{}{arg1})
	fake.targetCFMutex.Unlock()
	if fake.TargetCFStub != nil {
		return fake.TargetCFStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.targetCFReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeCloudControllerClient) TargetCFCalls(stub func(ccv3.TargetSettings) (ccv3.Info, ccv3.Warnings, error)) {
	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) TargetCFReturns(result1 ccv3.Info, result2 ccv3.Warnings, result3 error) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = nil
	fake.targetCFReturns = struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) TargetCFReturnsOnCall(i int, result1 ccv3.Info, result2 ccv3.Warnings, result3 error) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = nil
	if fake.targetCFReturnsOnCall == nil {
		fake.targetCFReturnsOnCall = make(map[int]struct {
			result1 ccv3.Info
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.targetCFReturnsOnCall[i] = struct {
		result1 ccv3.Info
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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})
	fake.recordInvocation("UpdateApplication", []interface{}{arg1})
	fake.updateApplicationMutex.Unlock()
	if fake.UpdateApplicationStub != nil {
		return fake.UpdateApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationReturns
	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})
	fake.recordInvocation("UpdateApplicationApplyManifest", []interface{}{arg1, arg2Copy})
	fake.updateApplicationApplyManifestMutex.Unlock()
	if fake.UpdateApplicationApplyManifestStub != nil {
		return fake.UpdateApplicationApplyManifestStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationApplyManifestReturns
	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 ccv3.EnvironmentVariables) (ccv3.EnvironmentVariables, ccv3.Warnings, error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	ret, specificReturn := fake.updateApplicationEnvironmentVariablesReturnsOnCall[len(fake.updateApplicationEnvironmentVariablesArgsForCall)]
	fake.updateApplicationEnvironmentVariablesArgsForCall = append(fake.updateApplicationEnvironmentVariablesArgsForCall, struct {
		arg1 string
		arg2 ccv3.EnvironmentVariables
	}{arg1, arg2})
	fake.recordInvocation("UpdateApplicationEnvironmentVariables", []interface{}{arg1, arg2})
	fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	if fake.UpdateApplicationEnvironmentVariablesStub != nil {
		return fake.UpdateApplicationEnvironmentVariablesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationEnvironmentVariablesReturns
	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, ccv3.EnvironmentVariables) (ccv3.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesArgsForCall(i int) (string, ccv3.EnvironmentVariables) {
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	argsForCall := fake.updateApplicationEnvironmentVariablesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturns(result1 ccv3.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = nil
	fake.updateApplicationEnvironmentVariablesReturns = struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturnsOnCall(i int, result1 ccv3.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 ccv3.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationEnvironmentVariablesReturnsOnCall[i] = struct {
		result1 ccv3.EnvironmentVariables
		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})
	fake.recordInvocation("UpdateApplicationRestart", []interface{}{arg1})
	fake.updateApplicationRestartMutex.Unlock()
	if fake.UpdateApplicationRestartStub != nil {
		return fake.UpdateApplicationRestartStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationRestartReturns
	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})
	fake.recordInvocation("UpdateApplicationStart", []interface{}{arg1})
	fake.updateApplicationStartMutex.Unlock()
	if fake.UpdateApplicationStartStub != nil {
		return fake.UpdateApplicationStartStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationStartReturns
	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})
	fake.recordInvocation("UpdateApplicationStop", []interface{}{arg1})
	fake.updateApplicationStopMutex.Unlock()
	if fake.UpdateApplicationStopStub != nil {
		return fake.UpdateApplicationStopStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationStopReturns
	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) 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})
	fake.recordInvocation("UpdateOrganizationDefaultIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	if fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub != nil {
		return fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns
	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) UpdateProcess(arg1 ccv3.Process) (ccv3.Process, ccv3.Warnings, error) {
	fake.updateProcessMutex.Lock()
	ret, specificReturn := fake.updateProcessReturnsOnCall[len(fake.updateProcessArgsForCall)]
	fake.updateProcessArgsForCall = append(fake.updateProcessArgsForCall, struct {
		arg1 ccv3.Process
	}{arg1})
	fake.recordInvocation("UpdateProcess", []interface{}{arg1})
	fake.updateProcessMutex.Unlock()
	if fake.UpdateProcessStub != nil {
		return fake.UpdateProcessStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateProcessReturns
	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(ccv3.Process) (ccv3.Process, ccv3.Warnings, error)) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = stub
}

func (fake *FakeCloudControllerClient) UpdateProcessArgsForCall(i int) ccv3.Process {
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	argsForCall := fake.updateProcessArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateProcessReturns(result1 ccv3.Process, result2 ccv3.Warnings, result3 error) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = nil
	fake.updateProcessReturns = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateProcessReturnsOnCall(i int, result1 ccv3.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 ccv3.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateProcessReturnsOnCall[i] = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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})
	fake.recordInvocation("UpdateSpaceIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	if fake.UpdateSpaceIsolationSegmentRelationshipStub != nil {
		return fake.UpdateSpaceIsolationSegmentRelationshipStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateSpaceIsolationSegmentRelationshipReturns
	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) UpdateTaskCancel(arg1 string) (ccv3.Task, ccv3.Warnings, error) {
	fake.updateTaskCancelMutex.Lock()
	ret, specificReturn := fake.updateTaskCancelReturnsOnCall[len(fake.updateTaskCancelArgsForCall)]
	fake.updateTaskCancelArgsForCall = append(fake.updateTaskCancelArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("UpdateTaskCancel", []interface{}{arg1})
	fake.updateTaskCancelMutex.Unlock()
	if fake.UpdateTaskCancelStub != nil {
		return fake.UpdateTaskCancelStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateTaskCancelReturns
	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) (ccv3.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 ccv3.Task, result2 ccv3.Warnings, result3 error) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = nil
	fake.updateTaskCancelReturns = struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelReturnsOnCall(i int, result1 ccv3.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 ccv3.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateTaskCancelReturnsOnCall[i] = struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackage(arg1 ccv3.Package, arg2 []ccv3.Resource, arg3 io.Reader, arg4 int64) (ccv3.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 ccv3.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2Copy, arg3, arg4})
	fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4})
	fake.uploadBitsPackageMutex.Unlock()
	if fake.UploadBitsPackageStub != nil {
		return fake.UploadBitsPackageStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadBitsPackageReturns
	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(ccv3.Package, []ccv3.Resource, io.Reader, int64) (ccv3.Package, ccv3.Warnings, error)) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadBitsPackageArgsForCall(i int) (ccv3.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 ccv3.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	fake.uploadBitsPackageReturns = struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackageReturnsOnCall(i int, result1 ccv3.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 ccv3.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadBitsPackageReturnsOnCall[i] = struct {
		result1 ccv3.Package
		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})
	fake.recordInvocation("UploadDropletBits", []interface{}{arg1, arg2, arg3, arg4})
	fake.uploadDropletBitsMutex.Unlock()
	if fake.UploadDropletBitsStub != nil {
		return fake.UploadDropletBitsStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadDropletBitsReturns
	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 ccv3.Package, arg2 string) (ccv3.Package, ccv3.Warnings, error) {
	fake.uploadPackageMutex.Lock()
	ret, specificReturn := fake.uploadPackageReturnsOnCall[len(fake.uploadPackageArgsForCall)]
	fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, struct {
		arg1 ccv3.Package
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UploadPackage", []interface{}{arg1, arg2})
	fake.uploadPackageMutex.Unlock()
	if fake.UploadPackageStub != nil {
		return fake.UploadPackageStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadPackageReturns
	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(ccv3.Package, string) (ccv3.Package, ccv3.Warnings, error)) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadPackageArgsForCall(i int) (ccv3.Package, string) {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	argsForCall := fake.uploadPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UploadPackageReturns(result1 ccv3.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = nil
	fake.uploadPackageReturns = struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadPackageReturnsOnCall(i int, result1 ccv3.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 ccv3.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadPackageReturnsOnCall[i] = struct {
		result1 ccv3.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.appSSHEndpointMutex.RLock()
	defer fake.appSSHEndpointMutex.RUnlock()
	fake.appSSHHostKeyFingerprintMutex.RLock()
	defer fake.appSSHHostKeyFingerprintMutex.RUnlock()
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	fake.cloudControllerAPIVersionMutex.RLock()
	defer fake.cloudControllerAPIVersionMutex.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.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RUnlock()
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	fake.getDeploymentMutex.RLock()
	defer fake.getDeploymentMutex.RUnlock()
	fake.getDeploymentsMutex.RLock()
	defer fake.getDeploymentsMutex.RUnlock()
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.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.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	fake.uploadDropletBitsMutex.RLock()
	defer fake.uploadDropletBitsMutex.RUnlock()
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.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 _ v3action.CloudControllerClient = new(FakeCloudControllerClient)