fake_cloud_controller_client.go

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

import (
	"sync"

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

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
	}
	AssignSpaceToIsolationSegmentStub        func(spaceGUID string, isolationSegmentGUID string) (ccv3.Relationship, ccv3.Warnings, error)
	assignSpaceToIsolationSegmentMutex       sync.RWMutex
	assignSpaceToIsolationSegmentArgsForCall []struct {
		spaceGUID            string
		isolationSegmentGUID string
	}
	assignSpaceToIsolationSegmentReturns struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	assignSpaceToIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	CloudControllerAPIVersionStub        func() string
	cloudControllerAPIVersionMutex       sync.RWMutex
	cloudControllerAPIVersionArgsForCall []struct{}
	cloudControllerAPIVersionReturns     struct {
		result1 string
	}
	cloudControllerAPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	CreateApplicationStub        func(app ccv3.Application) (ccv3.Application, ccv3.Warnings, error)
	createApplicationMutex       sync.RWMutex
	createApplicationArgsForCall []struct {
		app ccv3.Application
	}
	createApplicationReturns struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationReturnsOnCall map[int]struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationProcessScaleStub        func(appGUID string, process ccv3.Process) (ccv3.Process, ccv3.Warnings, error)
	createApplicationProcessScaleMutex       sync.RWMutex
	createApplicationProcessScaleArgsForCall []struct {
		appGUID string
		process 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(appGUID string, task ccv3.Task) (ccv3.Task, ccv3.Warnings, error)
	createApplicationTaskMutex       sync.RWMutex
	createApplicationTaskArgsForCall []struct {
		appGUID string
		task    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(build ccv3.Build) (ccv3.Build, ccv3.Warnings, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		build 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(isolationSegment ccv3.IsolationSegment) (ccv3.IsolationSegment, ccv3.Warnings, error)
	createIsolationSegmentMutex       sync.RWMutex
	createIsolationSegmentArgsForCall []struct {
		isolationSegment 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(pkg ccv3.Package) (ccv3.Package, ccv3.Warnings, error)
	createPackageMutex       sync.RWMutex
	createPackageArgsForCall []struct {
		pkg 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(guid string) (string, ccv3.Warnings, error)
	deleteApplicationMutex       sync.RWMutex
	deleteApplicationArgsForCall []struct {
		guid string
	}
	deleteApplicationReturns struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	deleteApplicationReturnsOnCall map[int]struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	DeleteApplicationProcessInstanceStub        func(appGUID string, processType string, instanceIndex int) (ccv3.Warnings, error)
	deleteApplicationProcessInstanceMutex       sync.RWMutex
	deleteApplicationProcessInstanceArgsForCall []struct {
		appGUID       string
		processType   string
		instanceIndex int
	}
	deleteApplicationProcessInstanceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteApplicationProcessInstanceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteIsolationSegmentStub        func(guid string) (ccv3.Warnings, error)
	deleteIsolationSegmentMutex       sync.RWMutex
	deleteIsolationSegmentArgsForCall []struct {
		guid string
	}
	deleteIsolationSegmentReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	EntitleIsolationSegmentToOrganizationsStub        func(isoGUID string, orgGUIDs []string) (ccv3.RelationshipList, ccv3.Warnings, error)
	entitleIsolationSegmentToOrganizationsMutex       sync.RWMutex
	entitleIsolationSegmentToOrganizationsArgsForCall []struct {
		isoGUID  string
		orgGUIDs []string
	}
	entitleIsolationSegmentToOrganizationsReturns struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	entitleIsolationSegmentToOrganizationsReturnsOnCall map[int]struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationDropletCurrentStub        func(appGUID string) (ccv3.Droplet, ccv3.Warnings, error)
	getApplicationDropletCurrentMutex       sync.RWMutex
	getApplicationDropletCurrentArgsForCall []struct {
		appGUID string
	}
	getApplicationDropletCurrentReturns struct {
		result1 ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationDropletCurrentReturnsOnCall map[int]struct {
		result1 ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationEnvironmentVariablesStub        func(appGUID string) (ccv3.EnvironmentVariableGroups, ccv3.Warnings, error)
	getApplicationEnvironmentVariablesMutex       sync.RWMutex
	getApplicationEnvironmentVariablesArgsForCall []struct {
		appGUID string
	}
	getApplicationEnvironmentVariablesReturns struct {
		result1 ccv3.EnvironmentVariableGroups
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationEnvironmentVariablesReturnsOnCall map[int]struct {
		result1 ccv3.EnvironmentVariableGroups
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessByTypeStub        func(appGUID string, processType string) (ccv3.Process, ccv3.Warnings, error)
	getApplicationProcessByTypeMutex       sync.RWMutex
	getApplicationProcessByTypeArgsForCall []struct {
		appGUID     string
		processType 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(appGUID string) ([]ccv3.Process, ccv3.Warnings, error)
	getApplicationProcessesMutex       sync.RWMutex
	getApplicationProcessesArgsForCall []struct {
		appGUID string
	}
	getApplicationProcessesReturns struct {
		result1 []ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessesReturnsOnCall map[int]struct {
		result1 []ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationsStub        func(query ...ccv3.Query) ([]ccv3.Application, ccv3.Warnings, error)
	getApplicationsMutex       sync.RWMutex
	getApplicationsArgsForCall []struct {
		query []ccv3.Query
	}
	getApplicationsReturns struct {
		result1 []ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationsReturnsOnCall map[int]struct {
		result1 []ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationTasksStub        func(appGUID string, query ...ccv3.Query) ([]ccv3.Task, ccv3.Warnings, error)
	getApplicationTasksMutex       sync.RWMutex
	getApplicationTasksArgsForCall []struct {
		appGUID string
		query   []ccv3.Query
	}
	getApplicationTasksReturns struct {
		result1 []ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationTasksReturnsOnCall map[int]struct {
		result1 []ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	GetBuildStub        func(guid string) (ccv3.Build, ccv3.Warnings, error)
	getBuildMutex       sync.RWMutex
	getBuildArgsForCall []struct {
		guid string
	}
	getBuildReturns struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	getBuildReturnsOnCall map[int]struct {
		result1 ccv3.Build
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletStub        func(guid string) (ccv3.Droplet, ccv3.Warnings, error)
	getDropletMutex       sync.RWMutex
	getDropletArgsForCall []struct {
		guid string
	}
	getDropletReturns struct {
		result1 ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletReturnsOnCall map[int]struct {
		result1 ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletsStub        func(query ...ccv3.Query) ([]ccv3.Droplet, ccv3.Warnings, error)
	getDropletsMutex       sync.RWMutex
	getDropletsArgsForCall []struct {
		query []ccv3.Query
	}
	getDropletsReturns struct {
		result1 []ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletsReturnsOnCall map[int]struct {
		result1 []ccv3.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentStub        func(guid string) (ccv3.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentMutex       sync.RWMutex
	getIsolationSegmentArgsForCall []struct {
		guid string
	}
	getIsolationSegmentReturns struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentOrganizationsByIsolationSegmentStub        func(isolationSegmentGUID string) ([]ccv3.Organization, ccv3.Warnings, error)
	getIsolationSegmentOrganizationsByIsolationSegmentMutex       sync.RWMutex
	getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall []struct {
		isolationSegmentGUID string
	}
	getIsolationSegmentOrganizationsByIsolationSegmentReturns struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall map[int]struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentsStub        func(query ...ccv3.Query) ([]ccv3.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentsMutex       sync.RWMutex
	getIsolationSegmentsArgsForCall []struct {
		query []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(orgGUID string) (ccv3.Relationship, ccv3.Warnings, error)
	getOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	getOrganizationDefaultIsolationSegmentArgsForCall []struct {
		orgGUID string
	}
	getOrganizationDefaultIsolationSegmentReturns struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationsStub        func(query ...ccv3.Query) ([]ccv3.Organization, ccv3.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		query []ccv3.Query
	}
	getOrganizationsReturns struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationsReturnsOnCall map[int]struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetPackageStub        func(guid string) (ccv3.Package, ccv3.Warnings, error)
	getPackageMutex       sync.RWMutex
	getPackageArgsForCall []struct {
		guid 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(query ...ccv3.Query) ([]ccv3.Package, ccv3.Warnings, error)
	getPackagesMutex       sync.RWMutex
	getPackagesArgsForCall []struct {
		query []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(processGUID string) ([]ccv3.ProcessInstance, ccv3.Warnings, error)
	getProcessInstancesMutex       sync.RWMutex
	getProcessInstancesArgsForCall []struct {
		processGUID 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(query ...ccv3.Query) ([]ccv3.ServiceInstance, ccv3.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		query []ccv3.Query
	}
	getServiceInstancesReturns struct {
		result1 []ccv3.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstancesReturnsOnCall map[int]struct {
		result1 []ccv3.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceIsolationSegmentStub        func(spaceGUID string) (ccv3.Relationship, ccv3.Warnings, error)
	getSpaceIsolationSegmentMutex       sync.RWMutex
	getSpaceIsolationSegmentArgsForCall []struct {
		spaceGUID string
	}
	getSpaceIsolationSegmentReturns struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetSpacesStub        func(query ...ccv3.Query) ([]ccv3.Space, ccv3.Warnings, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		query []ccv3.Query
	}
	getSpacesReturns struct {
		result1 []ccv3.Space
		result2 ccv3.Warnings
		result3 error
	}
	getSpacesReturnsOnCall map[int]struct {
		result1 []ccv3.Space
		result2 ccv3.Warnings
		result3 error
	}
	PatchApplicationProcessHealthCheckStub        func(processGUID string, processHealthCheckType string, processHealthCheckEndpoint string) (ccv3.Process, ccv3.Warnings, error)
	patchApplicationProcessHealthCheckMutex       sync.RWMutex
	patchApplicationProcessHealthCheckArgsForCall []struct {
		processGUID                string
		processHealthCheckType     string
		processHealthCheckEndpoint string
	}
	patchApplicationProcessHealthCheckReturns struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	patchApplicationProcessHealthCheckReturnsOnCall map[int]struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}
	PatchApplicationUserProvidedEnvironmentVariablesStub        func(appGUID string, envVars ccv3.EnvironmentVariables) (ccv3.EnvironmentVariables, ccv3.Warnings, error)
	patchApplicationUserProvidedEnvironmentVariablesMutex       sync.RWMutex
	patchApplicationUserProvidedEnvironmentVariablesArgsForCall []struct {
		appGUID string
		envVars ccv3.EnvironmentVariables
	}
	patchApplicationUserProvidedEnvironmentVariablesReturns struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	patchApplicationUserProvidedEnvironmentVariablesReturnsOnCall map[int]struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	PatchOrganizationDefaultIsolationSegmentStub        func(orgGUID string, isolationSegmentGUID string) (ccv3.Relationship, ccv3.Warnings, error)
	patchOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	patchOrganizationDefaultIsolationSegmentArgsForCall []struct {
		orgGUID              string
		isolationSegmentGUID string
	}
	patchOrganizationDefaultIsolationSegmentReturns struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	patchOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	PollJobStub        func(jobURL string) (ccv3.Warnings, error)
	pollJobMutex       sync.RWMutex
	pollJobArgsForCall []struct {
		jobURL string
	}
	pollJobReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	pollJobReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	RevokeIsolationSegmentFromOrganizationStub        func(isolationSegmentGUID string, organizationGUID string) (ccv3.Warnings, error)
	revokeIsolationSegmentFromOrganizationMutex       sync.RWMutex
	revokeIsolationSegmentFromOrganizationArgsForCall []struct {
		isolationSegmentGUID string
		organizationGUID     string
	}
	revokeIsolationSegmentFromOrganizationReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	revokeIsolationSegmentFromOrganizationReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	SetApplicationDropletStub        func(appGUID string, dropletGUID string) (ccv3.Relationship, ccv3.Warnings, error)
	setApplicationDropletMutex       sync.RWMutex
	setApplicationDropletArgsForCall []struct {
		appGUID     string
		dropletGUID string
	}
	setApplicationDropletReturns struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	setApplicationDropletReturnsOnCall map[int]struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	ShareServiceInstanceToSpacesStub        func(serviceInstanceGUID string, spaceGUIDs []string) (ccv3.RelationshipList, ccv3.Warnings, error)
	shareServiceInstanceToSpacesMutex       sync.RWMutex
	shareServiceInstanceToSpacesArgsForCall []struct {
		serviceInstanceGUID string
		spaceGUIDs          []string
	}
	shareServiceInstanceToSpacesReturns struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	shareServiceInstanceToSpacesReturnsOnCall map[int]struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	StartApplicationStub        func(appGUID string) (ccv3.Application, ccv3.Warnings, error)
	startApplicationMutex       sync.RWMutex
	startApplicationArgsForCall []struct {
		appGUID string
	}
	startApplicationReturns struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	startApplicationReturnsOnCall map[int]struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	StopApplicationStub        func(appGUID string) (ccv3.Application, ccv3.Warnings, error)
	stopApplicationMutex       sync.RWMutex
	stopApplicationArgsForCall []struct {
		appGUID string
	}
	stopApplicationReturns struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	stopApplicationReturnsOnCall map[int]struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	UnshareServiceInstanceFromSpaceStub        func(serviceInstanceGUID string, spaceGUID string) (ccv3.Warnings, error)
	unshareServiceInstanceFromSpaceMutex       sync.RWMutex
	unshareServiceInstanceFromSpaceArgsForCall []struct {
		serviceInstanceGUID string
		spaceGUID           string
	}
	unshareServiceInstanceFromSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unshareServiceInstanceFromSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateApplicationStub        func(app ccv3.Application) (ccv3.Application, ccv3.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		app ccv3.Application
	}
	updateApplicationReturns struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateTaskStub        func(taskGUID string) (ccv3.Task, ccv3.Warnings, error)
	updateTaskMutex       sync.RWMutex
	updateTaskArgsForCall []struct {
		taskGUID string
	}
	updateTaskReturns struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	updateTaskReturnsOnCall map[int]struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}
	UploadPackageStub        func(pkg ccv3.Package, zipFilepath string) (ccv3.Package, ccv3.Warnings, error)
	uploadPackageMutex       sync.RWMutex
	uploadPackageArgsForCall []struct {
		pkg         ccv3.Package
		zipFilepath 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
	}
	return fake.appSSHEndpointReturns.result1
}

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

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

func (fake *FakeCloudControllerClient) AppSSHEndpointReturnsOnCall(i int, result1 string) {
	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
	}
	return fake.appSSHHostKeyFingerprintReturns.result1
}

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

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

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintReturnsOnCall(i int, result1 string) {
	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) AssignSpaceToIsolationSegment(spaceGUID string, isolationSegmentGUID string) (ccv3.Relationship, ccv3.Warnings, error) {
	fake.assignSpaceToIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.assignSpaceToIsolationSegmentReturnsOnCall[len(fake.assignSpaceToIsolationSegmentArgsForCall)]
	fake.assignSpaceToIsolationSegmentArgsForCall = append(fake.assignSpaceToIsolationSegmentArgsForCall, struct {
		spaceGUID            string
		isolationSegmentGUID string
	}{spaceGUID, isolationSegmentGUID})
	fake.recordInvocation("AssignSpaceToIsolationSegment", []interface{}{spaceGUID, isolationSegmentGUID})
	fake.assignSpaceToIsolationSegmentMutex.Unlock()
	if fake.AssignSpaceToIsolationSegmentStub != nil {
		return fake.AssignSpaceToIsolationSegmentStub(spaceGUID, isolationSegmentGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.assignSpaceToIsolationSegmentReturns.result1, fake.assignSpaceToIsolationSegmentReturns.result2, fake.assignSpaceToIsolationSegmentReturns.result3
}

func (fake *FakeCloudControllerClient) AssignSpaceToIsolationSegmentCallCount() int {
	fake.assignSpaceToIsolationSegmentMutex.RLock()
	defer fake.assignSpaceToIsolationSegmentMutex.RUnlock()
	return len(fake.assignSpaceToIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) AssignSpaceToIsolationSegmentArgsForCall(i int) (string, string) {
	fake.assignSpaceToIsolationSegmentMutex.RLock()
	defer fake.assignSpaceToIsolationSegmentMutex.RUnlock()
	return fake.assignSpaceToIsolationSegmentArgsForCall[i].spaceGUID, fake.assignSpaceToIsolationSegmentArgsForCall[i].isolationSegmentGUID
}

func (fake *FakeCloudControllerClient) AssignSpaceToIsolationSegmentReturns(result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.AssignSpaceToIsolationSegmentStub = nil
	fake.assignSpaceToIsolationSegmentReturns = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) AssignSpaceToIsolationSegmentReturnsOnCall(i int, result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.AssignSpaceToIsolationSegmentStub = nil
	if fake.assignSpaceToIsolationSegmentReturnsOnCall == nil {
		fake.assignSpaceToIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.assignSpaceToIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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
	}
	return fake.cloudControllerAPIVersionReturns.result1
}

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

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

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionReturnsOnCall(i int, result1 string) {
	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(app ccv3.Application) (ccv3.Application, ccv3.Warnings, error) {
	fake.createApplicationMutex.Lock()
	ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)]
	fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, struct {
		app ccv3.Application
	}{app})
	fake.recordInvocation("CreateApplication", []interface{}{app})
	fake.createApplicationMutex.Unlock()
	if fake.CreateApplicationStub != nil {
		return fake.CreateApplicationStub(app)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createApplicationReturns.result1, fake.createApplicationReturns.result2, fake.createApplicationReturns.result3
}

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleArgsForCall(i int) (string, ccv3.Process) {
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	return fake.createApplicationProcessScaleArgsForCall[i].appGUID, fake.createApplicationProcessScaleArgsForCall[i].process
}

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

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

func (fake *FakeCloudControllerClient) CreateApplicationTaskArgsForCall(i int) (string, ccv3.Task) {
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	return fake.createApplicationTaskArgsForCall[i].appGUID, fake.createApplicationTaskArgsForCall[i].task
}

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

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

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

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) CreatePackageReturns(result1 ccv3.Package, result2 ccv3.Warnings, result3 error) {
	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.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(guid string) (string, ccv3.Warnings, error) {
	fake.deleteApplicationMutex.Lock()
	ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)]
	fake.deleteApplicationArgsForCall = append(fake.deleteApplicationArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("DeleteApplication", []interface{}{guid})
	fake.deleteApplicationMutex.Unlock()
	if fake.DeleteApplicationStub != nil {
		return fake.DeleteApplicationStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.deleteApplicationReturns.result1, fake.deleteApplicationReturns.result2, fake.deleteApplicationReturns.result3
}

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

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

func (fake *FakeCloudControllerClient) DeleteApplicationReturns(result1 string, result2 ccv3.Warnings, result3 error) {
	fake.DeleteApplicationStub = nil
	fake.deleteApplicationReturns = struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceArgsForCall(i int) (string, string, int) {
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	return fake.deleteApplicationProcessInstanceArgsForCall[i].appGUID, fake.deleteApplicationProcessInstanceArgsForCall[i].processType, fake.deleteApplicationProcessInstanceArgsForCall[i].instanceIndex
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturns(result1 ccv3.Warnings, result2 error) {
	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.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(guid string) (ccv3.Warnings, error) {
	fake.deleteIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentReturnsOnCall[len(fake.deleteIsolationSegmentArgsForCall)]
	fake.deleteIsolationSegmentArgsForCall = append(fake.deleteIsolationSegmentArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("DeleteIsolationSegment", []interface{}{guid})
	fake.deleteIsolationSegmentMutex.Unlock()
	if fake.DeleteIsolationSegmentStub != nil {
		return fake.DeleteIsolationSegmentStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.deleteIsolationSegmentReturns.result1, fake.deleteIsolationSegmentReturns.result2
}

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

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

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturns(result1 ccv3.Warnings, result2 error) {
	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.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) EntitleIsolationSegmentToOrganizations(isoGUID string, orgGUIDs []string) (ccv3.RelationshipList, ccv3.Warnings, error) {
	var orgGUIDsCopy []string
	if orgGUIDs != nil {
		orgGUIDsCopy = make([]string, len(orgGUIDs))
		copy(orgGUIDsCopy, orgGUIDs)
	}
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	ret, specificReturn := fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)]
	fake.entitleIsolationSegmentToOrganizationsArgsForCall = append(fake.entitleIsolationSegmentToOrganizationsArgsForCall, struct {
		isoGUID  string
		orgGUIDs []string
	}{isoGUID, orgGUIDsCopy})
	fake.recordInvocation("EntitleIsolationSegmentToOrganizations", []interface{}{isoGUID, orgGUIDsCopy})
	fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	if fake.EntitleIsolationSegmentToOrganizationsStub != nil {
		return fake.EntitleIsolationSegmentToOrganizationsStub(isoGUID, orgGUIDs)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.entitleIsolationSegmentToOrganizationsReturns.result1, fake.entitleIsolationSegmentToOrganizationsReturns.result2, fake.entitleIsolationSegmentToOrganizationsReturns.result3
}

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

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsArgsForCall(i int) (string, []string) {
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	return fake.entitleIsolationSegmentToOrganizationsArgsForCall[i].isoGUID, fake.entitleIsolationSegmentToOrganizationsArgsForCall[i].orgGUIDs
}

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

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentVariables(appGUID string) (ccv3.EnvironmentVariableGroups, ccv3.Warnings, error) {
	fake.getApplicationEnvironmentVariablesMutex.Lock()
	ret, specificReturn := fake.getApplicationEnvironmentVariablesReturnsOnCall[len(fake.getApplicationEnvironmentVariablesArgsForCall)]
	fake.getApplicationEnvironmentVariablesArgsForCall = append(fake.getApplicationEnvironmentVariablesArgsForCall, struct {
		appGUID string
	}{appGUID})
	fake.recordInvocation("GetApplicationEnvironmentVariables", []interface{}{appGUID})
	fake.getApplicationEnvironmentVariablesMutex.Unlock()
	if fake.GetApplicationEnvironmentVariablesStub != nil {
		return fake.GetApplicationEnvironmentVariablesStub(appGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getApplicationEnvironmentVariablesReturns.result1, fake.getApplicationEnvironmentVariablesReturns.result2, fake.getApplicationEnvironmentVariablesReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentVariablesCallCount() int {
	fake.getApplicationEnvironmentVariablesMutex.RLock()
	defer fake.getApplicationEnvironmentVariablesMutex.RUnlock()
	return len(fake.getApplicationEnvironmentVariablesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentVariablesArgsForCall(i int) string {
	fake.getApplicationEnvironmentVariablesMutex.RLock()
	defer fake.getApplicationEnvironmentVariablesMutex.RUnlock()
	return fake.getApplicationEnvironmentVariablesArgsForCall[i].appGUID
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentVariablesReturns(result1 ccv3.EnvironmentVariableGroups, result2 ccv3.Warnings, result3 error) {
	fake.GetApplicationEnvironmentVariablesStub = nil
	fake.getApplicationEnvironmentVariablesReturns = struct {
		result1 ccv3.EnvironmentVariableGroups
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentVariablesReturnsOnCall(i int, result1 ccv3.EnvironmentVariableGroups, result2 ccv3.Warnings, result3 error) {
	fake.GetApplicationEnvironmentVariablesStub = nil
	if fake.getApplicationEnvironmentVariablesReturnsOnCall == nil {
		fake.getApplicationEnvironmentVariablesReturnsOnCall = make(map[int]struct {
			result1 ccv3.EnvironmentVariableGroups
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationEnvironmentVariablesReturnsOnCall[i] = struct {
		result1 ccv3.EnvironmentVariableGroups
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeArgsForCall(i int) (string, string) {
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	return fake.getApplicationProcessByTypeArgsForCall[i].appGUID, fake.getApplicationProcessByTypeArgsForCall[i].processType
}

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

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

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

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturns(result1 []ccv3.Process, result2 ccv3.Warnings, result3 error) {
	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.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) GetApplications(query ...ccv3.Query) ([]ccv3.Application, ccv3.Warnings, error) {
	fake.getApplicationsMutex.Lock()
	ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)]
	fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct {
		query []ccv3.Query
	}{query})
	fake.recordInvocation("GetApplications", []interface{}{query})
	fake.getApplicationsMutex.Unlock()
	if fake.GetApplicationsStub != nil {
		return fake.GetApplicationsStub(query...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getApplicationsReturns.result1, fake.getApplicationsReturns.result2, fake.getApplicationsReturns.result3
}

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) GetApplicationTasksArgsForCall(i int) (string, []ccv3.Query) {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	return fake.getApplicationTasksArgsForCall[i].appGUID, fake.getApplicationTasksArgsForCall[i].query
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturns(result1 []ccv3.Task, result2 ccv3.Warnings, result3 error) {
	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.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) GetBuild(guid string) (ccv3.Build, ccv3.Warnings, error) {
	fake.getBuildMutex.Lock()
	ret, specificReturn := fake.getBuildReturnsOnCall[len(fake.getBuildArgsForCall)]
	fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetBuild", []interface{}{guid})
	fake.getBuildMutex.Unlock()
	if fake.GetBuildStub != nil {
		return fake.GetBuildStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getBuildReturns.result1, fake.getBuildReturns.result2, fake.getBuildReturns.result3
}

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

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

func (fake *FakeCloudControllerClient) GetBuildReturns(result1 ccv3.Build, result2 ccv3.Warnings, result3 error) {
	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.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) GetDroplet(guid string) (ccv3.Droplet, ccv3.Warnings, error) {
	fake.getDropletMutex.Lock()
	ret, specificReturn := fake.getDropletReturnsOnCall[len(fake.getDropletArgsForCall)]
	fake.getDropletArgsForCall = append(fake.getDropletArgsForCall, struct {
		guid string
	}{guid})
	fake.recordInvocation("GetDroplet", []interface{}{guid})
	fake.getDropletMutex.Unlock()
	if fake.GetDropletStub != nil {
		return fake.GetDropletStub(guid)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getDropletReturns.result1, fake.getDropletReturns.result2, fake.getDropletReturns.result3
}

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

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

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

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

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

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

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturns(result1 ccv3.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	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.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) GetIsolationSegmentOrganizationsByIsolationSegment(isolationSegmentGUID string) ([]ccv3.Organization, ccv3.Warnings, error) {
	fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall[len(fake.getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall)]
	fake.getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall = append(fake.getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall, struct {
		isolationSegmentGUID string
	}{isolationSegmentGUID})
	fake.recordInvocation("GetIsolationSegmentOrganizationsByIsolationSegment", []interface{}{isolationSegmentGUID})
	fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.Unlock()
	if fake.GetIsolationSegmentOrganizationsByIsolationSegmentStub != nil {
		return fake.GetIsolationSegmentOrganizationsByIsolationSegmentStub(isolationSegmentGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getIsolationSegmentOrganizationsByIsolationSegmentReturns.result1, fake.getIsolationSegmentOrganizationsByIsolationSegmentReturns.result2, fake.getIsolationSegmentOrganizationsByIsolationSegmentReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsByIsolationSegmentCallCount() int {
	fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.RUnlock()
	return len(fake.getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsByIsolationSegmentArgsForCall(i int) string {
	fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.RUnlock()
	return fake.getIsolationSegmentOrganizationsByIsolationSegmentArgsForCall[i].isolationSegmentGUID
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsByIsolationSegmentReturns(result1 []ccv3.Organization, result2 ccv3.Warnings, result3 error) {
	fake.GetIsolationSegmentOrganizationsByIsolationSegmentStub = nil
	fake.getIsolationSegmentOrganizationsByIsolationSegmentReturns = struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall(i int, result1 []ccv3.Organization, result2 ccv3.Warnings, result3 error) {
	fake.GetIsolationSegmentOrganizationsByIsolationSegmentStub = nil
	if fake.getIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall == nil {
		fake.getIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 []ccv3.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentOrganizationsByIsolationSegmentReturnsOnCall[i] = struct {
		result1 []ccv3.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturns(result1 []ccv3.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	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.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(orgGUID string) (ccv3.Relationship, ccv3.Warnings, error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.getOrganizationDefaultIsolationSegmentArgsForCall = append(fake.getOrganizationDefaultIsolationSegmentArgsForCall, struct {
		orgGUID string
	}{orgGUID})
	fake.recordInvocation("GetOrganizationDefaultIsolationSegment", []interface{}{orgGUID})
	fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.GetOrganizationDefaultIsolationSegmentStub != nil {
		return fake.GetOrganizationDefaultIsolationSegmentStub(orgGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getOrganizationDefaultIsolationSegmentReturns.result1, fake.getOrganizationDefaultIsolationSegmentReturns.result2, fake.getOrganizationDefaultIsolationSegmentReturns.result3
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) GetPackagesReturns(result1 []ccv3.Package, result2 ccv3.Warnings, result3 error) {
	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.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(processGUID string) ([]ccv3.ProcessInstance, ccv3.Warnings, error) {
	fake.getProcessInstancesMutex.Lock()
	ret, specificReturn := fake.getProcessInstancesReturnsOnCall[len(fake.getProcessInstancesArgsForCall)]
	fake.getProcessInstancesArgsForCall = append(fake.getProcessInstancesArgsForCall, struct {
		processGUID string
	}{processGUID})
	fake.recordInvocation("GetProcessInstances", []interface{}{processGUID})
	fake.getProcessInstancesMutex.Unlock()
	if fake.GetProcessInstancesStub != nil {
		return fake.GetProcessInstancesStub(processGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getProcessInstancesReturns.result1, fake.getProcessInstancesReturns.result2, fake.getProcessInstancesReturns.result3
}

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

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

func (fake *FakeCloudControllerClient) GetProcessInstancesReturns(result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) {
	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.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(query ...ccv3.Query) ([]ccv3.ServiceInstance, ccv3.Warnings, error) {
	fake.getServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		query []ccv3.Query
	}{query})
	fake.recordInvocation("GetServiceInstances", []interface{}{query})
	fake.getServiceInstancesMutex.Unlock()
	if fake.GetServiceInstancesStub != nil {
		return fake.GetServiceInstancesStub(query...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.getServiceInstancesReturns.result1, fake.getServiceInstancesReturns.result2, fake.getServiceInstancesReturns.result3
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fake *FakeCloudControllerClient) PatchApplicationProcessHealthCheck(processGUID string, processHealthCheckType string, processHealthCheckEndpoint string) (ccv3.Process, ccv3.Warnings, error) {
	fake.patchApplicationProcessHealthCheckMutex.Lock()
	ret, specificReturn := fake.patchApplicationProcessHealthCheckReturnsOnCall[len(fake.patchApplicationProcessHealthCheckArgsForCall)]
	fake.patchApplicationProcessHealthCheckArgsForCall = append(fake.patchApplicationProcessHealthCheckArgsForCall, struct {
		processGUID                string
		processHealthCheckType     string
		processHealthCheckEndpoint string
	}{processGUID, processHealthCheckType, processHealthCheckEndpoint})
	fake.recordInvocation("PatchApplicationProcessHealthCheck", []interface{}{processGUID, processHealthCheckType, processHealthCheckEndpoint})
	fake.patchApplicationProcessHealthCheckMutex.Unlock()
	if fake.PatchApplicationProcessHealthCheckStub != nil {
		return fake.PatchApplicationProcessHealthCheckStub(processGUID, processHealthCheckType, processHealthCheckEndpoint)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.patchApplicationProcessHealthCheckReturns.result1, fake.patchApplicationProcessHealthCheckReturns.result2, fake.patchApplicationProcessHealthCheckReturns.result3
}

func (fake *FakeCloudControllerClient) PatchApplicationProcessHealthCheckCallCount() int {
	fake.patchApplicationProcessHealthCheckMutex.RLock()
	defer fake.patchApplicationProcessHealthCheckMutex.RUnlock()
	return len(fake.patchApplicationProcessHealthCheckArgsForCall)
}

func (fake *FakeCloudControllerClient) PatchApplicationProcessHealthCheckArgsForCall(i int) (string, string, string) {
	fake.patchApplicationProcessHealthCheckMutex.RLock()
	defer fake.patchApplicationProcessHealthCheckMutex.RUnlock()
	return fake.patchApplicationProcessHealthCheckArgsForCall[i].processGUID, fake.patchApplicationProcessHealthCheckArgsForCall[i].processHealthCheckType, fake.patchApplicationProcessHealthCheckArgsForCall[i].processHealthCheckEndpoint
}

func (fake *FakeCloudControllerClient) PatchApplicationProcessHealthCheckReturns(result1 ccv3.Process, result2 ccv3.Warnings, result3 error) {
	fake.PatchApplicationProcessHealthCheckStub = nil
	fake.patchApplicationProcessHealthCheckReturns = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PatchApplicationProcessHealthCheckReturnsOnCall(i int, result1 ccv3.Process, result2 ccv3.Warnings, result3 error) {
	fake.PatchApplicationProcessHealthCheckStub = nil
	if fake.patchApplicationProcessHealthCheckReturnsOnCall == nil {
		fake.patchApplicationProcessHealthCheckReturnsOnCall = make(map[int]struct {
			result1 ccv3.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.patchApplicationProcessHealthCheckReturnsOnCall[i] = struct {
		result1 ccv3.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PatchApplicationUserProvidedEnvironmentVariables(appGUID string, envVars ccv3.EnvironmentVariables) (ccv3.EnvironmentVariables, ccv3.Warnings, error) {
	fake.patchApplicationUserProvidedEnvironmentVariablesMutex.Lock()
	ret, specificReturn := fake.patchApplicationUserProvidedEnvironmentVariablesReturnsOnCall[len(fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall)]
	fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall = append(fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall, struct {
		appGUID string
		envVars ccv3.EnvironmentVariables
	}{appGUID, envVars})
	fake.recordInvocation("PatchApplicationUserProvidedEnvironmentVariables", []interface{}{appGUID, envVars})
	fake.patchApplicationUserProvidedEnvironmentVariablesMutex.Unlock()
	if fake.PatchApplicationUserProvidedEnvironmentVariablesStub != nil {
		return fake.PatchApplicationUserProvidedEnvironmentVariablesStub(appGUID, envVars)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.patchApplicationUserProvidedEnvironmentVariablesReturns.result1, fake.patchApplicationUserProvidedEnvironmentVariablesReturns.result2, fake.patchApplicationUserProvidedEnvironmentVariablesReturns.result3
}

func (fake *FakeCloudControllerClient) PatchApplicationUserProvidedEnvironmentVariablesCallCount() int {
	fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RLock()
	defer fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RUnlock()
	return len(fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall)
}

func (fake *FakeCloudControllerClient) PatchApplicationUserProvidedEnvironmentVariablesArgsForCall(i int) (string, ccv3.EnvironmentVariables) {
	fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RLock()
	defer fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RUnlock()
	return fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall[i].appGUID, fake.patchApplicationUserProvidedEnvironmentVariablesArgsForCall[i].envVars
}

func (fake *FakeCloudControllerClient) PatchApplicationUserProvidedEnvironmentVariablesReturns(result1 ccv3.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.PatchApplicationUserProvidedEnvironmentVariablesStub = nil
	fake.patchApplicationUserProvidedEnvironmentVariablesReturns = struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PatchApplicationUserProvidedEnvironmentVariablesReturnsOnCall(i int, result1 ccv3.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.PatchApplicationUserProvidedEnvironmentVariablesStub = nil
	if fake.patchApplicationUserProvidedEnvironmentVariablesReturnsOnCall == nil {
		fake.patchApplicationUserProvidedEnvironmentVariablesReturnsOnCall = make(map[int]struct {
			result1 ccv3.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.patchApplicationUserProvidedEnvironmentVariablesReturnsOnCall[i] = struct {
		result1 ccv3.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PatchOrganizationDefaultIsolationSegment(orgGUID string, isolationSegmentGUID string) (ccv3.Relationship, ccv3.Warnings, error) {
	fake.patchOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.patchOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.patchOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.patchOrganizationDefaultIsolationSegmentArgsForCall = append(fake.patchOrganizationDefaultIsolationSegmentArgsForCall, struct {
		orgGUID              string
		isolationSegmentGUID string
	}{orgGUID, isolationSegmentGUID})
	fake.recordInvocation("PatchOrganizationDefaultIsolationSegment", []interface{}{orgGUID, isolationSegmentGUID})
	fake.patchOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.PatchOrganizationDefaultIsolationSegmentStub != nil {
		return fake.PatchOrganizationDefaultIsolationSegmentStub(orgGUID, isolationSegmentGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.patchOrganizationDefaultIsolationSegmentReturns.result1, fake.patchOrganizationDefaultIsolationSegmentReturns.result2, fake.patchOrganizationDefaultIsolationSegmentReturns.result3
}

func (fake *FakeCloudControllerClient) PatchOrganizationDefaultIsolationSegmentCallCount() int {
	fake.patchOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.patchOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return len(fake.patchOrganizationDefaultIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) PatchOrganizationDefaultIsolationSegmentArgsForCall(i int) (string, string) {
	fake.patchOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.patchOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return fake.patchOrganizationDefaultIsolationSegmentArgsForCall[i].orgGUID, fake.patchOrganizationDefaultIsolationSegmentArgsForCall[i].isolationSegmentGUID
}

func (fake *FakeCloudControllerClient) PatchOrganizationDefaultIsolationSegmentReturns(result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.PatchOrganizationDefaultIsolationSegmentStub = nil
	fake.patchOrganizationDefaultIsolationSegmentReturns = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) PatchOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.PatchOrganizationDefaultIsolationSegmentStub = nil
	if fake.patchOrganizationDefaultIsolationSegmentReturnsOnCall == nil {
		fake.patchOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.patchOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

func (fake *FakeCloudControllerClient) PollJobReturns(result1 ccv3.Warnings, result2 error) {
	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.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) RevokeIsolationSegmentFromOrganization(isolationSegmentGUID string, organizationGUID string) (ccv3.Warnings, error) {
	fake.revokeIsolationSegmentFromOrganizationMutex.Lock()
	ret, specificReturn := fake.revokeIsolationSegmentFromOrganizationReturnsOnCall[len(fake.revokeIsolationSegmentFromOrganizationArgsForCall)]
	fake.revokeIsolationSegmentFromOrganizationArgsForCall = append(fake.revokeIsolationSegmentFromOrganizationArgsForCall, struct {
		isolationSegmentGUID string
		organizationGUID     string
	}{isolationSegmentGUID, organizationGUID})
	fake.recordInvocation("RevokeIsolationSegmentFromOrganization", []interface{}{isolationSegmentGUID, organizationGUID})
	fake.revokeIsolationSegmentFromOrganizationMutex.Unlock()
	if fake.RevokeIsolationSegmentFromOrganizationStub != nil {
		return fake.RevokeIsolationSegmentFromOrganizationStub(isolationSegmentGUID, organizationGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.revokeIsolationSegmentFromOrganizationReturns.result1, fake.revokeIsolationSegmentFromOrganizationReturns.result2
}

func (fake *FakeCloudControllerClient) RevokeIsolationSegmentFromOrganizationCallCount() int {
	fake.revokeIsolationSegmentFromOrganizationMutex.RLock()
	defer fake.revokeIsolationSegmentFromOrganizationMutex.RUnlock()
	return len(fake.revokeIsolationSegmentFromOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) RevokeIsolationSegmentFromOrganizationArgsForCall(i int) (string, string) {
	fake.revokeIsolationSegmentFromOrganizationMutex.RLock()
	defer fake.revokeIsolationSegmentFromOrganizationMutex.RUnlock()
	return fake.revokeIsolationSegmentFromOrganizationArgsForCall[i].isolationSegmentGUID, fake.revokeIsolationSegmentFromOrganizationArgsForCall[i].organizationGUID
}

func (fake *FakeCloudControllerClient) RevokeIsolationSegmentFromOrganizationReturns(result1 ccv3.Warnings, result2 error) {
	fake.RevokeIsolationSegmentFromOrganizationStub = nil
	fake.revokeIsolationSegmentFromOrganizationReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RevokeIsolationSegmentFromOrganizationReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.RevokeIsolationSegmentFromOrganizationStub = nil
	if fake.revokeIsolationSegmentFromOrganizationReturnsOnCall == nil {
		fake.revokeIsolationSegmentFromOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.revokeIsolationSegmentFromOrganizationReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) SetApplicationDroplet(appGUID string, dropletGUID string) (ccv3.Relationship, ccv3.Warnings, error) {
	fake.setApplicationDropletMutex.Lock()
	ret, specificReturn := fake.setApplicationDropletReturnsOnCall[len(fake.setApplicationDropletArgsForCall)]
	fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, struct {
		appGUID     string
		dropletGUID string
	}{appGUID, dropletGUID})
	fake.recordInvocation("SetApplicationDroplet", []interface{}{appGUID, dropletGUID})
	fake.setApplicationDropletMutex.Unlock()
	if fake.SetApplicationDropletStub != nil {
		return fake.SetApplicationDropletStub(appGUID, dropletGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.setApplicationDropletReturns.result1, fake.setApplicationDropletReturns.result2, fake.setApplicationDropletReturns.result3
}

func (fake *FakeCloudControllerClient) SetApplicationDropletCallCount() int {
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	return len(fake.setApplicationDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) SetApplicationDropletArgsForCall(i int) (string, string) {
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	return fake.setApplicationDropletArgsForCall[i].appGUID, fake.setApplicationDropletArgsForCall[i].dropletGUID
}

func (fake *FakeCloudControllerClient) SetApplicationDropletReturns(result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.SetApplicationDropletStub = nil
	fake.setApplicationDropletReturns = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SetApplicationDropletReturnsOnCall(i int, result1 ccv3.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.SetApplicationDropletStub = nil
	if fake.setApplicationDropletReturnsOnCall == nil {
		fake.setApplicationDropletReturnsOnCall = make(map[int]struct {
			result1 ccv3.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.setApplicationDropletReturnsOnCall[i] = struct {
		result1 ccv3.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpaces(serviceInstanceGUID string, spaceGUIDs []string) (ccv3.RelationshipList, ccv3.Warnings, error) {
	var spaceGUIDsCopy []string
	if spaceGUIDs != nil {
		spaceGUIDsCopy = make([]string, len(spaceGUIDs))
		copy(spaceGUIDsCopy, spaceGUIDs)
	}
	fake.shareServiceInstanceToSpacesMutex.Lock()
	ret, specificReturn := fake.shareServiceInstanceToSpacesReturnsOnCall[len(fake.shareServiceInstanceToSpacesArgsForCall)]
	fake.shareServiceInstanceToSpacesArgsForCall = append(fake.shareServiceInstanceToSpacesArgsForCall, struct {
		serviceInstanceGUID string
		spaceGUIDs          []string
	}{serviceInstanceGUID, spaceGUIDsCopy})
	fake.recordInvocation("ShareServiceInstanceToSpaces", []interface{}{serviceInstanceGUID, spaceGUIDsCopy})
	fake.shareServiceInstanceToSpacesMutex.Unlock()
	if fake.ShareServiceInstanceToSpacesStub != nil {
		return fake.ShareServiceInstanceToSpacesStub(serviceInstanceGUID, spaceGUIDs)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.shareServiceInstanceToSpacesReturns.result1, fake.shareServiceInstanceToSpacesReturns.result2, fake.shareServiceInstanceToSpacesReturns.result3
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesCallCount() int {
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	return len(fake.shareServiceInstanceToSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesArgsForCall(i int) (string, []string) {
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	return fake.shareServiceInstanceToSpacesArgsForCall[i].serviceInstanceGUID, fake.shareServiceInstanceToSpacesArgsForCall[i].spaceGUIDs
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturns(result1 ccv3.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.ShareServiceInstanceToSpacesStub = nil
	fake.shareServiceInstanceToSpacesReturns = struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturnsOnCall(i int, result1 ccv3.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.ShareServiceInstanceToSpacesStub = nil
	if fake.shareServiceInstanceToSpacesReturnsOnCall == nil {
		fake.shareServiceInstanceToSpacesReturnsOnCall = make(map[int]struct {
			result1 ccv3.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.shareServiceInstanceToSpacesReturnsOnCall[i] = struct {
		result1 ccv3.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) StartApplication(appGUID string) (ccv3.Application, ccv3.Warnings, error) {
	fake.startApplicationMutex.Lock()
	ret, specificReturn := fake.startApplicationReturnsOnCall[len(fake.startApplicationArgsForCall)]
	fake.startApplicationArgsForCall = append(fake.startApplicationArgsForCall, struct {
		appGUID string
	}{appGUID})
	fake.recordInvocation("StartApplication", []interface{}{appGUID})
	fake.startApplicationMutex.Unlock()
	if fake.StartApplicationStub != nil {
		return fake.StartApplicationStub(appGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.startApplicationReturns.result1, fake.startApplicationReturns.result2, fake.startApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) StartApplicationCallCount() int {
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	return len(fake.startApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) StartApplicationArgsForCall(i int) string {
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	return fake.startApplicationArgsForCall[i].appGUID
}

func (fake *FakeCloudControllerClient) StartApplicationReturns(result1 ccv3.Application, result2 ccv3.Warnings, result3 error) {
	fake.StartApplicationStub = nil
	fake.startApplicationReturns = struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) StartApplicationReturnsOnCall(i int, result1 ccv3.Application, result2 ccv3.Warnings, result3 error) {
	fake.StartApplicationStub = nil
	if fake.startApplicationReturnsOnCall == nil {
		fake.startApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.startApplicationReturnsOnCall[i] = struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) StopApplication(appGUID string) (ccv3.Application, ccv3.Warnings, error) {
	fake.stopApplicationMutex.Lock()
	ret, specificReturn := fake.stopApplicationReturnsOnCall[len(fake.stopApplicationArgsForCall)]
	fake.stopApplicationArgsForCall = append(fake.stopApplicationArgsForCall, struct {
		appGUID string
	}{appGUID})
	fake.recordInvocation("StopApplication", []interface{}{appGUID})
	fake.stopApplicationMutex.Unlock()
	if fake.StopApplicationStub != nil {
		return fake.StopApplicationStub(appGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.stopApplicationReturns.result1, fake.stopApplicationReturns.result2, fake.stopApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) StopApplicationCallCount() int {
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	return len(fake.stopApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) StopApplicationArgsForCall(i int) string {
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	return fake.stopApplicationArgsForCall[i].appGUID
}

func (fake *FakeCloudControllerClient) StopApplicationReturns(result1 ccv3.Application, result2 ccv3.Warnings, result3 error) {
	fake.StopApplicationStub = nil
	fake.stopApplicationReturns = struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) StopApplicationReturnsOnCall(i int, result1 ccv3.Application, result2 ccv3.Warnings, result3 error) {
	fake.StopApplicationStub = nil
	if fake.stopApplicationReturnsOnCall == nil {
		fake.stopApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.stopApplicationReturnsOnCall[i] = struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpace(serviceInstanceGUID string, spaceGUID string) (ccv3.Warnings, error) {
	fake.unshareServiceInstanceFromSpaceMutex.Lock()
	ret, specificReturn := fake.unshareServiceInstanceFromSpaceReturnsOnCall[len(fake.unshareServiceInstanceFromSpaceArgsForCall)]
	fake.unshareServiceInstanceFromSpaceArgsForCall = append(fake.unshareServiceInstanceFromSpaceArgsForCall, struct {
		serviceInstanceGUID string
		spaceGUID           string
	}{serviceInstanceGUID, spaceGUID})
	fake.recordInvocation("UnshareServiceInstanceFromSpace", []interface{}{serviceInstanceGUID, spaceGUID})
	fake.unshareServiceInstanceFromSpaceMutex.Unlock()
	if fake.UnshareServiceInstanceFromSpaceStub != nil {
		return fake.UnshareServiceInstanceFromSpaceStub(serviceInstanceGUID, spaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.unshareServiceInstanceFromSpaceReturns.result1, fake.unshareServiceInstanceFromSpaceReturns.result2
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceCallCount() int {
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	return len(fake.unshareServiceInstanceFromSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceArgsForCall(i int) (string, string) {
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	return fake.unshareServiceInstanceFromSpaceArgsForCall[i].serviceInstanceGUID, fake.unshareServiceInstanceFromSpaceArgsForCall[i].spaceGUID
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.UnshareServiceInstanceFromSpaceStub = nil
	fake.unshareServiceInstanceFromSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnshareServiceInstanceFromSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.UnshareServiceInstanceFromSpaceStub = nil
	if fake.unshareServiceInstanceFromSpaceReturnsOnCall == nil {
		fake.unshareServiceInstanceFromSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unshareServiceInstanceFromSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

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

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

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

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

func (fake *FakeCloudControllerClient) UpdateApplicationReturnsOnCall(i int, result1 ccv3.Application, result2 ccv3.Warnings, result3 error) {
	fake.UpdateApplicationStub = nil
	if fake.updateApplicationReturnsOnCall == nil {
		fake.updateApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationReturnsOnCall[i] = struct {
		result1 ccv3.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTask(taskGUID string) (ccv3.Task, ccv3.Warnings, error) {
	fake.updateTaskMutex.Lock()
	ret, specificReturn := fake.updateTaskReturnsOnCall[len(fake.updateTaskArgsForCall)]
	fake.updateTaskArgsForCall = append(fake.updateTaskArgsForCall, struct {
		taskGUID string
	}{taskGUID})
	fake.recordInvocation("UpdateTask", []interface{}{taskGUID})
	fake.updateTaskMutex.Unlock()
	if fake.UpdateTaskStub != nil {
		return fake.UpdateTaskStub(taskGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.updateTaskReturns.result1, fake.updateTaskReturns.result2, fake.updateTaskReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateTaskCallCount() int {
	fake.updateTaskMutex.RLock()
	defer fake.updateTaskMutex.RUnlock()
	return len(fake.updateTaskArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateTaskArgsForCall(i int) string {
	fake.updateTaskMutex.RLock()
	defer fake.updateTaskMutex.RUnlock()
	return fake.updateTaskArgsForCall[i].taskGUID
}

func (fake *FakeCloudControllerClient) UpdateTaskReturns(result1 ccv3.Task, result2 ccv3.Warnings, result3 error) {
	fake.UpdateTaskStub = nil
	fake.updateTaskReturns = struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskReturnsOnCall(i int, result1 ccv3.Task, result2 ccv3.Warnings, result3 error) {
	fake.UpdateTaskStub = nil
	if fake.updateTaskReturnsOnCall == nil {
		fake.updateTaskReturnsOnCall = make(map[int]struct {
			result1 ccv3.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateTaskReturnsOnCall[i] = struct {
		result1 ccv3.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadPackage(pkg ccv3.Package, zipFilepath string) (ccv3.Package, ccv3.Warnings, error) {
	fake.uploadPackageMutex.Lock()
	ret, specificReturn := fake.uploadPackageReturnsOnCall[len(fake.uploadPackageArgsForCall)]
	fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, struct {
		pkg         ccv3.Package
		zipFilepath string
	}{pkg, zipFilepath})
	fake.recordInvocation("UploadPackage", []interface{}{pkg, zipFilepath})
	fake.uploadPackageMutex.Unlock()
	if fake.UploadPackageStub != nil {
		return fake.UploadPackageStub(pkg, zipFilepath)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.uploadPackageReturns.result1, fake.uploadPackageReturns.result2, fake.uploadPackageReturns.result3
}

func (fake *FakeCloudControllerClient) UploadPackageCallCount() int {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	return len(fake.uploadPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadPackageArgsForCall(i int) (ccv3.Package, string) {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	return fake.uploadPackageArgsForCall[i].pkg, fake.uploadPackageArgsForCall[i].zipFilepath
}

func (fake *FakeCloudControllerClient) UploadPackageReturns(result1 ccv3.Package, result2 ccv3.Warnings, result3 error) {
	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.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.assignSpaceToIsolationSegmentMutex.RLock()
	defer fake.assignSpaceToIsolationSegmentMutex.RUnlock()
	fake.cloudControllerAPIVersionMutex.RLock()
	defer fake.cloudControllerAPIVersionMutex.RUnlock()
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.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.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	fake.getApplicationEnvironmentVariablesMutex.RLock()
	defer fake.getApplicationEnvironmentVariablesMutex.RUnlock()
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsByIsolationSegmentMutex.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.patchApplicationProcessHealthCheckMutex.RLock()
	defer fake.patchApplicationProcessHealthCheckMutex.RUnlock()
	fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RLock()
	defer fake.patchApplicationUserProvidedEnvironmentVariablesMutex.RUnlock()
	fake.patchOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.patchOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.revokeIsolationSegmentFromOrganizationMutex.RLock()
	defer fake.revokeIsolationSegmentFromOrganizationMutex.RUnlock()
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	fake.unshareServiceInstanceFromSpaceMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateTaskMutex.RLock()
	defer fake.updateTaskMutex.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)