// This file was generated by counterfeiter
package fakes

import (
	"sync"
)

type OrgSpaceCli struct {
	CreateOrgStub        func(name string) error
	createOrgMutex       sync.RWMutex
	createOrgArgsForCall []struct {
		name string
	}
	createOrgReturns struct {
		result1 error
	}
	createOrgReturnsOnCall map[int]struct {
		result1 error
	}
	CreateSpaceStub        func(spaceName, orgName string) error
	createSpaceMutex       sync.RWMutex
	createSpaceArgsForCall []struct {
		spaceName string
		orgName   string
	}
	createSpaceReturns struct {
		result1 error
	}
	createSpaceReturnsOnCall map[int]struct {
		result1 error
	}
	TargetOrgStub        func(name string) error
	targetOrgMutex       sync.RWMutex
	targetOrgArgsForCall []struct {
		name string
	}
	targetOrgReturns struct {
		result1 error
	}
	targetOrgReturnsOnCall map[int]struct {
		result1 error
	}
	TargetSpaceStub        func(name string) error
	targetSpaceMutex       sync.RWMutex
	targetSpaceArgsForCall []struct {
		name string
	}
	targetSpaceReturns struct {
		result1 error
	}
	targetSpaceReturnsOnCall map[int]struct {
		result1 error
	}
	CreateQuotaStub        func(name, memory string, instanceMemory, routes, serviceInstances, appInstances, routePorts int) error
	createQuotaMutex       sync.RWMutex
	createQuotaArgsForCall []struct {
		name             string
		memory           string
		instanceMemory   int
		routes           int
		serviceInstances int
		appInstances     int
		routePorts       int
	}
	createQuotaReturns struct {
		result1 error
	}
	createQuotaReturnsOnCall map[int]struct {
		result1 error
	}
	SetQuotaStub        func(org, quota string) error
	setQuotaMutex       sync.RWMutex
	setQuotaArgsForCall []struct {
		org   string
		quota string
	}
	setQuotaReturns struct {
		result1 error
	}
	setQuotaReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *OrgSpaceCli) CreateOrg(name string) error {
	fake.createOrgMutex.Lock()
	ret, specificReturn := fake.createOrgReturnsOnCall[len(fake.createOrgArgsForCall)]
	fake.createOrgArgsForCall = append(fake.createOrgArgsForCall, struct {
		name string
	}{name})
	fake.recordInvocation("CreateOrg", []interface{}{name})
	fake.createOrgMutex.Unlock()
	if fake.CreateOrgStub != nil {
		return fake.CreateOrgStub(name)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.createOrgReturns.result1
}

func (fake *OrgSpaceCli) CreateOrgCallCount() int {
	fake.createOrgMutex.RLock()
	defer fake.createOrgMutex.RUnlock()
	return len(fake.createOrgArgsForCall)
}

func (fake *OrgSpaceCli) CreateOrgArgsForCall(i int) string {
	fake.createOrgMutex.RLock()
	defer fake.createOrgMutex.RUnlock()
	return fake.createOrgArgsForCall[i].name
}

func (fake *OrgSpaceCli) CreateOrgReturns(result1 error) {
	fake.CreateOrgStub = nil
	fake.createOrgReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) CreateOrgReturnsOnCall(i int, result1 error) {
	fake.CreateOrgStub = nil
	if fake.createOrgReturnsOnCall == nil {
		fake.createOrgReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createOrgReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) CreateSpace(spaceName string, orgName string) error {
	fake.createSpaceMutex.Lock()
	ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)]
	fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct {
		spaceName string
		orgName   string
	}{spaceName, orgName})
	fake.recordInvocation("CreateSpace", []interface{}{spaceName, orgName})
	fake.createSpaceMutex.Unlock()
	if fake.CreateSpaceStub != nil {
		return fake.CreateSpaceStub(spaceName, orgName)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.createSpaceReturns.result1
}

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

func (fake *OrgSpaceCli) CreateSpaceArgsForCall(i int) (string, string) {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	return fake.createSpaceArgsForCall[i].spaceName, fake.createSpaceArgsForCall[i].orgName
}

func (fake *OrgSpaceCli) CreateSpaceReturns(result1 error) {
	fake.CreateSpaceStub = nil
	fake.createSpaceReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) CreateSpaceReturnsOnCall(i int, result1 error) {
	fake.CreateSpaceStub = nil
	if fake.createSpaceReturnsOnCall == nil {
		fake.createSpaceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createSpaceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) TargetOrg(name string) error {
	fake.targetOrgMutex.Lock()
	ret, specificReturn := fake.targetOrgReturnsOnCall[len(fake.targetOrgArgsForCall)]
	fake.targetOrgArgsForCall = append(fake.targetOrgArgsForCall, struct {
		name string
	}{name})
	fake.recordInvocation("TargetOrg", []interface{}{name})
	fake.targetOrgMutex.Unlock()
	if fake.TargetOrgStub != nil {
		return fake.TargetOrgStub(name)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.targetOrgReturns.result1
}

func (fake *OrgSpaceCli) TargetOrgCallCount() int {
	fake.targetOrgMutex.RLock()
	defer fake.targetOrgMutex.RUnlock()
	return len(fake.targetOrgArgsForCall)
}

func (fake *OrgSpaceCli) TargetOrgArgsForCall(i int) string {
	fake.targetOrgMutex.RLock()
	defer fake.targetOrgMutex.RUnlock()
	return fake.targetOrgArgsForCall[i].name
}

func (fake *OrgSpaceCli) TargetOrgReturns(result1 error) {
	fake.TargetOrgStub = nil
	fake.targetOrgReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) TargetOrgReturnsOnCall(i int, result1 error) {
	fake.TargetOrgStub = nil
	if fake.targetOrgReturnsOnCall == nil {
		fake.targetOrgReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.targetOrgReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) TargetSpace(name string) error {
	fake.targetSpaceMutex.Lock()
	ret, specificReturn := fake.targetSpaceReturnsOnCall[len(fake.targetSpaceArgsForCall)]
	fake.targetSpaceArgsForCall = append(fake.targetSpaceArgsForCall, struct {
		name string
	}{name})
	fake.recordInvocation("TargetSpace", []interface{}{name})
	fake.targetSpaceMutex.Unlock()
	if fake.TargetSpaceStub != nil {
		return fake.TargetSpaceStub(name)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.targetSpaceReturns.result1
}

func (fake *OrgSpaceCli) TargetSpaceCallCount() int {
	fake.targetSpaceMutex.RLock()
	defer fake.targetSpaceMutex.RUnlock()
	return len(fake.targetSpaceArgsForCall)
}

func (fake *OrgSpaceCli) TargetSpaceArgsForCall(i int) string {
	fake.targetSpaceMutex.RLock()
	defer fake.targetSpaceMutex.RUnlock()
	return fake.targetSpaceArgsForCall[i].name
}

func (fake *OrgSpaceCli) TargetSpaceReturns(result1 error) {
	fake.TargetSpaceStub = nil
	fake.targetSpaceReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) TargetSpaceReturnsOnCall(i int, result1 error) {
	fake.TargetSpaceStub = nil
	if fake.targetSpaceReturnsOnCall == nil {
		fake.targetSpaceReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.targetSpaceReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) CreateQuota(name string, memory string, instanceMemory int, routes int, serviceInstances int, appInstances int, routePorts int) error {
	fake.createQuotaMutex.Lock()
	ret, specificReturn := fake.createQuotaReturnsOnCall[len(fake.createQuotaArgsForCall)]
	fake.createQuotaArgsForCall = append(fake.createQuotaArgsForCall, struct {
		name             string
		memory           string
		instanceMemory   int
		routes           int
		serviceInstances int
		appInstances     int
		routePorts       int
	}{name, memory, instanceMemory, routes, serviceInstances, appInstances, routePorts})
	fake.recordInvocation("CreateQuota", []interface{}{name, memory, instanceMemory, routes, serviceInstances, appInstances, routePorts})
	fake.createQuotaMutex.Unlock()
	if fake.CreateQuotaStub != nil {
		return fake.CreateQuotaStub(name, memory, instanceMemory, routes, serviceInstances, appInstances, routePorts)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.createQuotaReturns.result1
}

func (fake *OrgSpaceCli) CreateQuotaCallCount() int {
	fake.createQuotaMutex.RLock()
	defer fake.createQuotaMutex.RUnlock()
	return len(fake.createQuotaArgsForCall)
}

func (fake *OrgSpaceCli) CreateQuotaArgsForCall(i int) (string, string, int, int, int, int, int) {
	fake.createQuotaMutex.RLock()
	defer fake.createQuotaMutex.RUnlock()
	return fake.createQuotaArgsForCall[i].name, fake.createQuotaArgsForCall[i].memory, fake.createQuotaArgsForCall[i].instanceMemory, fake.createQuotaArgsForCall[i].routes, fake.createQuotaArgsForCall[i].serviceInstances, fake.createQuotaArgsForCall[i].appInstances, fake.createQuotaArgsForCall[i].routePorts
}

func (fake *OrgSpaceCli) CreateQuotaReturns(result1 error) {
	fake.CreateQuotaStub = nil
	fake.createQuotaReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) CreateQuotaReturnsOnCall(i int, result1 error) {
	fake.CreateQuotaStub = nil
	if fake.createQuotaReturnsOnCall == nil {
		fake.createQuotaReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createQuotaReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) SetQuota(org string, quota string) error {
	fake.setQuotaMutex.Lock()
	ret, specificReturn := fake.setQuotaReturnsOnCall[len(fake.setQuotaArgsForCall)]
	fake.setQuotaArgsForCall = append(fake.setQuotaArgsForCall, struct {
		org   string
		quota string
	}{org, quota})
	fake.recordInvocation("SetQuota", []interface{}{org, quota})
	fake.setQuotaMutex.Unlock()
	if fake.SetQuotaStub != nil {
		return fake.SetQuotaStub(org, quota)
	}
	if specificReturn {
		return ret.result1
	}
	return fake.setQuotaReturns.result1
}

func (fake *OrgSpaceCli) SetQuotaCallCount() int {
	fake.setQuotaMutex.RLock()
	defer fake.setQuotaMutex.RUnlock()
	return len(fake.setQuotaArgsForCall)
}

func (fake *OrgSpaceCli) SetQuotaArgsForCall(i int) (string, string) {
	fake.setQuotaMutex.RLock()
	defer fake.setQuotaMutex.RUnlock()
	return fake.setQuotaArgsForCall[i].org, fake.setQuotaArgsForCall[i].quota
}

func (fake *OrgSpaceCli) SetQuotaReturns(result1 error) {
	fake.SetQuotaStub = nil
	fake.setQuotaReturns = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) SetQuotaReturnsOnCall(i int, result1 error) {
	fake.SetQuotaStub = nil
	if fake.setQuotaReturnsOnCall == nil {
		fake.setQuotaReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.setQuotaReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *OrgSpaceCli) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createOrgMutex.RLock()
	defer fake.createOrgMutex.RUnlock()
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	fake.targetOrgMutex.RLock()
	defer fake.targetOrgMutex.RUnlock()
	fake.targetSpaceMutex.RLock()
	defer fake.targetSpaceMutex.RUnlock()
	fake.createQuotaMutex.RLock()
	defer fake.createQuotaMutex.RUnlock()
	fake.setQuotaMutex.RLock()
	defer fake.setQuotaMutex.RUnlock()
	return fake.invocations
}

func (fake *OrgSpaceCli) 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)
}
