github.com/loggregator/cli@v6.33.1-0.20180224010324-82334f081791+incompatible/actor/v3action/v3actionfakes/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
	}
	CreateApplicationActionsApplyManifestByApplicationStub        func(rawManifest []byte, appGUID string) (string, ccv3.Warnings, error)
	createApplicationActionsApplyManifestByApplicationMutex       sync.RWMutex
	createApplicationActionsApplyManifestByApplicationArgsForCall []struct {
		rawManifest []byte
		appGUID     string
	}
	createApplicationActionsApplyManifestByApplicationReturns struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationActionsApplyManifestByApplicationReturnsOnCall map[int]struct {
		result1 string
		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
	}
	DeleteServiceInstanceRelationshipsSharedSpaceStub        func(serviceInstanceGUID string, sharedToSpaceGUID string) (ccv3.Warnings, error)
	deleteServiceInstanceRelationshipsSharedSpaceMutex       sync.RWMutex
	deleteServiceInstanceRelationshipsSharedSpaceArgsForCall []struct {
		serviceInstanceGUID string
		sharedToSpaceGUID   string
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall 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
	}
	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) CreateApplicationActionsApplyManifestByApplication(rawManifest []byte, appGUID string) (string, ccv3.Warnings, error) {
	var rawManifestCopy []byte
	if rawManifest != nil {
		rawManifestCopy = make([]byte, len(rawManifest))
		copy(rawManifestCopy, rawManifest)
	}
	fake.createApplicationActionsApplyManifestByApplicationMutex.Lock()
	ret, specificReturn := fake.createApplicationActionsApplyManifestByApplicationReturnsOnCall[len(fake.createApplicationActionsApplyManifestByApplicationArgsForCall)]
	fake.createApplicationActionsApplyManifestByApplicationArgsForCall = append(fake.createApplicationActionsApplyManifestByApplicationArgsForCall, struct {
		rawManifest []byte
		appGUID     string
	}{rawManifestCopy, appGUID})
	fake.recordInvocation("CreateApplicationActionsApplyManifestByApplication", []interface{}{rawManifestCopy, appGUID})
	fake.createApplicationActionsApplyManifestByApplicationMutex.Unlock()
	if fake.CreateApplicationActionsApplyManifestByApplicationStub != nil {
		return fake.CreateApplicationActionsApplyManifestByApplicationStub(rawManifest, appGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fake.createApplicationActionsApplyManifestByApplicationReturns.result1, fake.createApplicationActionsApplyManifestByApplicationReturns.result2, fake.createApplicationActionsApplyManifestByApplicationReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationActionsApplyManifestByApplicationCallCount() int {
	fake.createApplicationActionsApplyManifestByApplicationMutex.RLock()
	defer fake.createApplicationActionsApplyManifestByApplicationMutex.RUnlock()
	return len(fake.createApplicationActionsApplyManifestByApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationActionsApplyManifestByApplicationArgsForCall(i int) ([]byte, string) {
	fake.createApplicationActionsApplyManifestByApplicationMutex.RLock()
	defer fake.createApplicationActionsApplyManifestByApplicationMutex.RUnlock()
	return fake.createApplicationActionsApplyManifestByApplicationArgsForCall[i].rawManifest, fake.createApplicationActionsApplyManifestByApplicationArgsForCall[i].appGUID
}

func (fake *FakeCloudControllerClient) CreateApplicationActionsApplyManifestByApplicationReturns(result1 string, result2 ccv3.Warnings, result3 error) {
	fake.CreateApplicationActionsApplyManifestByApplicationStub = nil
	fake.createApplicationActionsApplyManifestByApplicationReturns = struct {
		result1 string
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationActionsApplyManifestByApplicationReturnsOnCall(i int, result1 string, result2 ccv3.Warnings, result3 error) {
	fake.CreateApplicationActionsApplyManifestByApplicationStub = nil
	if fake.createApplicationActionsApplyManifestByApplicationReturnsOnCall == nil {
		fake.createApplicationActionsApplyManifestByApplicationReturnsOnCall = make(map[int]struct {
			result1 string
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationActionsApplyManifestByApplicationReturnsOnCall[i] = struct {
		result1 string
		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) DeleteServiceInstanceRelationshipsSharedSpace(serviceInstanceGUID string, sharedToSpaceGUID string) (ccv3.Warnings, error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall[len(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall)]
	fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall = append(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall, struct {
		serviceInstanceGUID string
		sharedToSpaceGUID   string
	}{serviceInstanceGUID, sharedToSpaceGUID})
	fake.recordInvocation("DeleteServiceInstanceRelationshipsSharedSpace", []interface{}{serviceInstanceGUID, sharedToSpaceGUID})
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	if fake.DeleteServiceInstanceRelationshipsSharedSpaceStub != nil {
		return fake.DeleteServiceInstanceRelationshipsSharedSpaceStub(serviceInstanceGUID, sharedToSpaceGUID)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fake.deleteServiceInstanceRelationshipsSharedSpaceReturns.result1, fake.deleteServiceInstanceRelationshipsSharedSpaceReturns.result2
}

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

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceArgsForCall(i int) (string, string) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RUnlock()
	return fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall[i].serviceInstanceGUID, fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall[i].sharedToSpaceGUID
}

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

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

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizations(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) 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.createApplicationActionsApplyManifestByApplicationMutex.RLock()
	defer fake.createApplicationActionsApplyManifestByApplicationMutex.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.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.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.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)