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

import (
	"sync"
)

type OrgSpaceCli struct {
	CreateOrgStub        func(string) error
	createOrgMutex       sync.RWMutex
	createOrgArgsForCall []struct {
		arg1 string
	}
	createOrgReturns struct {
		result1 error
	}
	createOrgReturnsOnCall map[int]struct {
		result1 error
	}
	CreateQuotaStub        func(string, string, int, int, int, int, int) error
	createQuotaMutex       sync.RWMutex
	createQuotaArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 int
		arg4 int
		arg5 int
		arg6 int
		arg7 int
	}
	createQuotaReturns struct {
		result1 error
	}
	createQuotaReturnsOnCall map[int]struct {
		result1 error
	}
	CreateSpaceStub        func(string, string) error
	createSpaceMutex       sync.RWMutex
	createSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createSpaceReturns struct {
		result1 error
	}
	createSpaceReturnsOnCall map[int]struct {
		result1 error
	}
	SetQuotaStub        func(string, string) error
	setQuotaMutex       sync.RWMutex
	setQuotaArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setQuotaReturns struct {
		result1 error
	}
	setQuotaReturnsOnCall map[int]struct {
		result1 error
	}
	TargetOrgStub        func(string) error
	targetOrgMutex       sync.RWMutex
	targetOrgArgsForCall []struct {
		arg1 string
	}
	targetOrgReturns struct {
		result1 error
	}
	targetOrgReturnsOnCall map[int]struct {
		result1 error
	}
	TargetSpaceStub        func(string) error
	targetSpaceMutex       sync.RWMutex
	targetSpaceArgsForCall []struct {
		arg1 string
	}
	targetSpaceReturns struct {
		result1 error
	}
	targetSpaceReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

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

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

func (fake *OrgSpaceCli) CreateOrgCalls(stub func(string) error) {
	fake.createOrgMutex.Lock()
	defer fake.createOrgMutex.Unlock()
	fake.CreateOrgStub = stub
}

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

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

func (fake *OrgSpaceCli) CreateOrgReturnsOnCall(i int, result1 error) {
	fake.createOrgMutex.Lock()
	defer fake.createOrgMutex.Unlock()
	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) CreateQuota(arg1 string, arg2 string, arg3 int, arg4 int, arg5 int, arg6 int, arg7 int) error {
	fake.createQuotaMutex.Lock()
	ret, specificReturn := fake.createQuotaReturnsOnCall[len(fake.createQuotaArgsForCall)]
	fake.createQuotaArgsForCall = append(fake.createQuotaArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 int
		arg4 int
		arg5 int
		arg6 int
		arg7 int
	}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
	stub := fake.CreateQuotaStub
	fakeReturns := fake.createQuotaReturns
	fake.recordInvocation("CreateQuota", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7})
	fake.createQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *OrgSpaceCli) CreateQuotaCalls(stub func(string, string, int, int, int, int, int) error) {
	fake.createQuotaMutex.Lock()
	defer fake.createQuotaMutex.Unlock()
	fake.CreateQuotaStub = stub
}

func (fake *OrgSpaceCli) CreateQuotaArgsForCall(i int) (string, string, int, int, int, int, int) {
	fake.createQuotaMutex.RLock()
	defer fake.createQuotaMutex.RUnlock()
	argsForCall := fake.createQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7
}

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

func (fake *OrgSpaceCli) CreateQuotaReturnsOnCall(i int, result1 error) {
	fake.createQuotaMutex.Lock()
	defer fake.createQuotaMutex.Unlock()
	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) CreateSpace(arg1 string, arg2 string) error {
	fake.createSpaceMutex.Lock()
	ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)]
	fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.CreateSpaceStub
	fakeReturns := fake.createSpaceReturns
	fake.recordInvocation("CreateSpace", []interface{}{arg1, arg2})
	fake.createSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *OrgSpaceCli) CreateSpaceCalls(stub func(string, string) error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = stub
}

func (fake *OrgSpaceCli) CreateSpaceArgsForCall(i int) (string, string) {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	argsForCall := fake.createSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

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

func (fake *OrgSpaceCli) CreateSpaceReturnsOnCall(i int, result1 error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	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) SetQuota(arg1 string, arg2 string) error {
	fake.setQuotaMutex.Lock()
	ret, specificReturn := fake.setQuotaReturnsOnCall[len(fake.setQuotaArgsForCall)]
	fake.setQuotaArgsForCall = append(fake.setQuotaArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.SetQuotaStub
	fakeReturns := fake.setQuotaReturns
	fake.recordInvocation("SetQuota", []interface{}{arg1, arg2})
	fake.setQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *OrgSpaceCli) SetQuotaCalls(stub func(string, string) error) {
	fake.setQuotaMutex.Lock()
	defer fake.setQuotaMutex.Unlock()
	fake.SetQuotaStub = stub
}

func (fake *OrgSpaceCli) SetQuotaArgsForCall(i int) (string, string) {
	fake.setQuotaMutex.RLock()
	defer fake.setQuotaMutex.RUnlock()
	argsForCall := fake.setQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

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

func (fake *OrgSpaceCli) SetQuotaReturnsOnCall(i int, result1 error) {
	fake.setQuotaMutex.Lock()
	defer fake.setQuotaMutex.Unlock()
	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) TargetOrg(arg1 string) error {
	fake.targetOrgMutex.Lock()
	ret, specificReturn := fake.targetOrgReturnsOnCall[len(fake.targetOrgArgsForCall)]
	fake.targetOrgArgsForCall = append(fake.targetOrgArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.TargetOrgStub
	fakeReturns := fake.targetOrgReturns
	fake.recordInvocation("TargetOrg", []interface{}{arg1})
	fake.targetOrgMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *OrgSpaceCli) TargetOrgCalls(stub func(string) error) {
	fake.targetOrgMutex.Lock()
	defer fake.targetOrgMutex.Unlock()
	fake.TargetOrgStub = stub
}

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

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

func (fake *OrgSpaceCli) TargetOrgReturnsOnCall(i int, result1 error) {
	fake.targetOrgMutex.Lock()
	defer fake.targetOrgMutex.Unlock()
	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(arg1 string) error {
	fake.targetSpaceMutex.Lock()
	ret, specificReturn := fake.targetSpaceReturnsOnCall[len(fake.targetSpaceArgsForCall)]
	fake.targetSpaceArgsForCall = append(fake.targetSpaceArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.TargetSpaceStub
	fakeReturns := fake.targetSpaceReturns
	fake.recordInvocation("TargetSpace", []interface{}{arg1})
	fake.targetSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

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

func (fake *OrgSpaceCli) TargetSpaceCalls(stub func(string) error) {
	fake.targetSpaceMutex.Lock()
	defer fake.targetSpaceMutex.Unlock()
	fake.TargetSpaceStub = stub
}

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

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

func (fake *OrgSpaceCli) TargetSpaceReturnsOnCall(i int, result1 error) {
	fake.targetSpaceMutex.Lock()
	defer fake.targetSpaceMutex.Unlock()
	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) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createOrgMutex.RLock()
	defer fake.createOrgMutex.RUnlock()
	fake.createQuotaMutex.RLock()
	defer fake.createQuotaMutex.RUnlock()
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	fake.setQuotaMutex.RLock()
	defer fake.setQuotaMutex.RUnlock()
	fake.targetOrgMutex.RLock()
	defer fake.targetOrgMutex.RUnlock()
	fake.targetSpaceMutex.RLock()
	defer fake.targetSpaceMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

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)
}
