github.com/swisscom/cloudfoundry-cli@v7.1.0+incompatible/cf/actors/servicebuilder/servicebuilderfakes/fake_service_builder.go

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

import (
	"sync"

	"code.cloudfoundry.org/cli/cf/actors/servicebuilder"
	"code.cloudfoundry.org/cli/cf/models"
)

type FakeServiceBuilder struct {
	GetAllServicesStub        func() ([]models.ServiceOffering, error)
	getAllServicesMutex       sync.RWMutex
	getAllServicesArgsForCall []struct {
	}
	getAllServicesReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getAllServicesReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetAllServicesWithPlansStub        func() ([]models.ServiceOffering, error)
	getAllServicesWithPlansMutex       sync.RWMutex
	getAllServicesWithPlansArgsForCall []struct {
	}
	getAllServicesWithPlansReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getAllServicesWithPlansReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetServiceByNameForOrgStub        func(string, string) (models.ServiceOffering, error)
	getServiceByNameForOrgMutex       sync.RWMutex
	getServiceByNameForOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceByNameForOrgReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceByNameForOrgReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceByNameForSpaceStub        func(string, string) (models.ServiceOffering, error)
	getServiceByNameForSpaceMutex       sync.RWMutex
	getServiceByNameForSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceByNameForSpaceReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceByNameForSpaceReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceByNameForSpaceWithPlansStub        func(string, string) (models.ServiceOffering, error)
	getServiceByNameForSpaceWithPlansMutex       sync.RWMutex
	getServiceByNameForSpaceWithPlansArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceByNameForSpaceWithPlansReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceByNameForSpaceWithPlansReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceByNameWithPlansStub        func(string) (models.ServiceOffering, error)
	getServiceByNameWithPlansMutex       sync.RWMutex
	getServiceByNameWithPlansArgsForCall []struct {
		arg1 string
	}
	getServiceByNameWithPlansReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceByNameWithPlansReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceByNameWithPlansWithOrgNamesStub        func(string) (models.ServiceOffering, error)
	getServiceByNameWithPlansWithOrgNamesMutex       sync.RWMutex
	getServiceByNameWithPlansWithOrgNamesArgsForCall []struct {
		arg1 string
	}
	getServiceByNameWithPlansWithOrgNamesReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceByNameWithPlansWithOrgNamesReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServiceVisibleToOrgStub        func(string, string) (models.ServiceOffering, error)
	getServiceVisibleToOrgMutex       sync.RWMutex
	getServiceVisibleToOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceVisibleToOrgReturns struct {
		result1 models.ServiceOffering
		result2 error
	}
	getServiceVisibleToOrgReturnsOnCall map[int]struct {
		result1 models.ServiceOffering
		result2 error
	}
	GetServicesByNameForSpaceWithPlansStub        func(string, string) (models.ServiceOfferings, error)
	getServicesByNameForSpaceWithPlansMutex       sync.RWMutex
	getServicesByNameForSpaceWithPlansArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServicesByNameForSpaceWithPlansReturns struct {
		result1 models.ServiceOfferings
		result2 error
	}
	getServicesByNameForSpaceWithPlansReturnsOnCall map[int]struct {
		result1 models.ServiceOfferings
		result2 error
	}
	GetServicesForBrokerStub        func(string) ([]models.ServiceOffering, error)
	getServicesForBrokerMutex       sync.RWMutex
	getServicesForBrokerArgsForCall []struct {
		arg1 string
	}
	getServicesForBrokerReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getServicesForBrokerReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetServicesForManyBrokersStub        func([]string) ([]models.ServiceOffering, error)
	getServicesForManyBrokersMutex       sync.RWMutex
	getServicesForManyBrokersArgsForCall []struct {
		arg1 []string
	}
	getServicesForManyBrokersReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getServicesForManyBrokersReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetServicesForSpaceStub        func(string) ([]models.ServiceOffering, error)
	getServicesForSpaceMutex       sync.RWMutex
	getServicesForSpaceArgsForCall []struct {
		arg1 string
	}
	getServicesForSpaceReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getServicesForSpaceReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetServicesForSpaceWithPlansStub        func(string) ([]models.ServiceOffering, error)
	getServicesForSpaceWithPlansMutex       sync.RWMutex
	getServicesForSpaceWithPlansArgsForCall []struct {
		arg1 string
	}
	getServicesForSpaceWithPlansReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getServicesForSpaceWithPlansReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	GetServicesVisibleToOrgStub        func(string) ([]models.ServiceOffering, error)
	getServicesVisibleToOrgMutex       sync.RWMutex
	getServicesVisibleToOrgArgsForCall []struct {
		arg1 string
	}
	getServicesVisibleToOrgReturns struct {
		result1 []models.ServiceOffering
		result2 error
	}
	getServicesVisibleToOrgReturnsOnCall map[int]struct {
		result1 []models.ServiceOffering
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeServiceBuilder) GetAllServices() ([]models.ServiceOffering, error) {
	fake.getAllServicesMutex.Lock()
	ret, specificReturn := fake.getAllServicesReturnsOnCall[len(fake.getAllServicesArgsForCall)]
	fake.getAllServicesArgsForCall = append(fake.getAllServicesArgsForCall, struct {
	}{})
	fake.recordInvocation("GetAllServices", []interface{}{})
	fake.getAllServicesMutex.Unlock()
	if fake.GetAllServicesStub != nil {
		return fake.GetAllServicesStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAllServicesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetAllServicesCallCount() int {
	fake.getAllServicesMutex.RLock()
	defer fake.getAllServicesMutex.RUnlock()
	return len(fake.getAllServicesArgsForCall)
}

func (fake *FakeServiceBuilder) GetAllServicesCalls(stub func() ([]models.ServiceOffering, error)) {
	fake.getAllServicesMutex.Lock()
	defer fake.getAllServicesMutex.Unlock()
	fake.GetAllServicesStub = stub
}

func (fake *FakeServiceBuilder) GetAllServicesReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getAllServicesMutex.Lock()
	defer fake.getAllServicesMutex.Unlock()
	fake.GetAllServicesStub = nil
	fake.getAllServicesReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetAllServicesReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getAllServicesMutex.Lock()
	defer fake.getAllServicesMutex.Unlock()
	fake.GetAllServicesStub = nil
	if fake.getAllServicesReturnsOnCall == nil {
		fake.getAllServicesReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getAllServicesReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetAllServicesWithPlans() ([]models.ServiceOffering, error) {
	fake.getAllServicesWithPlansMutex.Lock()
	ret, specificReturn := fake.getAllServicesWithPlansReturnsOnCall[len(fake.getAllServicesWithPlansArgsForCall)]
	fake.getAllServicesWithPlansArgsForCall = append(fake.getAllServicesWithPlansArgsForCall, struct {
	}{})
	fake.recordInvocation("GetAllServicesWithPlans", []interface{}{})
	fake.getAllServicesWithPlansMutex.Unlock()
	if fake.GetAllServicesWithPlansStub != nil {
		return fake.GetAllServicesWithPlansStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getAllServicesWithPlansReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetAllServicesWithPlansCallCount() int {
	fake.getAllServicesWithPlansMutex.RLock()
	defer fake.getAllServicesWithPlansMutex.RUnlock()
	return len(fake.getAllServicesWithPlansArgsForCall)
}

func (fake *FakeServiceBuilder) GetAllServicesWithPlansCalls(stub func() ([]models.ServiceOffering, error)) {
	fake.getAllServicesWithPlansMutex.Lock()
	defer fake.getAllServicesWithPlansMutex.Unlock()
	fake.GetAllServicesWithPlansStub = stub
}

func (fake *FakeServiceBuilder) GetAllServicesWithPlansReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getAllServicesWithPlansMutex.Lock()
	defer fake.getAllServicesWithPlansMutex.Unlock()
	fake.GetAllServicesWithPlansStub = nil
	fake.getAllServicesWithPlansReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetAllServicesWithPlansReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getAllServicesWithPlansMutex.Lock()
	defer fake.getAllServicesWithPlansMutex.Unlock()
	fake.GetAllServicesWithPlansStub = nil
	if fake.getAllServicesWithPlansReturnsOnCall == nil {
		fake.getAllServicesWithPlansReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getAllServicesWithPlansReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrg(arg1 string, arg2 string) (models.ServiceOffering, error) {
	fake.getServiceByNameForOrgMutex.Lock()
	ret, specificReturn := fake.getServiceByNameForOrgReturnsOnCall[len(fake.getServiceByNameForOrgArgsForCall)]
	fake.getServiceByNameForOrgArgsForCall = append(fake.getServiceByNameForOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceByNameForOrg", []interface{}{arg1, arg2})
	fake.getServiceByNameForOrgMutex.Unlock()
	if fake.GetServiceByNameForOrgStub != nil {
		return fake.GetServiceByNameForOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceByNameForOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrgCallCount() int {
	fake.getServiceByNameForOrgMutex.RLock()
	defer fake.getServiceByNameForOrgMutex.RUnlock()
	return len(fake.getServiceByNameForOrgArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrgCalls(stub func(string, string) (models.ServiceOffering, error)) {
	fake.getServiceByNameForOrgMutex.Lock()
	defer fake.getServiceByNameForOrgMutex.Unlock()
	fake.GetServiceByNameForOrgStub = stub
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrgArgsForCall(i int) (string, string) {
	fake.getServiceByNameForOrgMutex.RLock()
	defer fake.getServiceByNameForOrgMutex.RUnlock()
	argsForCall := fake.getServiceByNameForOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrgReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForOrgMutex.Lock()
	defer fake.getServiceByNameForOrgMutex.Unlock()
	fake.GetServiceByNameForOrgStub = nil
	fake.getServiceByNameForOrgReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForOrgReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForOrgMutex.Lock()
	defer fake.getServiceByNameForOrgMutex.Unlock()
	fake.GetServiceByNameForOrgStub = nil
	if fake.getServiceByNameForOrgReturnsOnCall == nil {
		fake.getServiceByNameForOrgReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceByNameForOrgReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpace(arg1 string, arg2 string) (models.ServiceOffering, error) {
	fake.getServiceByNameForSpaceMutex.Lock()
	ret, specificReturn := fake.getServiceByNameForSpaceReturnsOnCall[len(fake.getServiceByNameForSpaceArgsForCall)]
	fake.getServiceByNameForSpaceArgsForCall = append(fake.getServiceByNameForSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceByNameForSpace", []interface{}{arg1, arg2})
	fake.getServiceByNameForSpaceMutex.Unlock()
	if fake.GetServiceByNameForSpaceStub != nil {
		return fake.GetServiceByNameForSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceByNameForSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceCallCount() int {
	fake.getServiceByNameForSpaceMutex.RLock()
	defer fake.getServiceByNameForSpaceMutex.RUnlock()
	return len(fake.getServiceByNameForSpaceArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceCalls(stub func(string, string) (models.ServiceOffering, error)) {
	fake.getServiceByNameForSpaceMutex.Lock()
	defer fake.getServiceByNameForSpaceMutex.Unlock()
	fake.GetServiceByNameForSpaceStub = stub
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceArgsForCall(i int) (string, string) {
	fake.getServiceByNameForSpaceMutex.RLock()
	defer fake.getServiceByNameForSpaceMutex.RUnlock()
	argsForCall := fake.getServiceByNameForSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForSpaceMutex.Lock()
	defer fake.getServiceByNameForSpaceMutex.Unlock()
	fake.GetServiceByNameForSpaceStub = nil
	fake.getServiceByNameForSpaceReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForSpaceMutex.Lock()
	defer fake.getServiceByNameForSpaceMutex.Unlock()
	fake.GetServiceByNameForSpaceStub = nil
	if fake.getServiceByNameForSpaceReturnsOnCall == nil {
		fake.getServiceByNameForSpaceReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceByNameForSpaceReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlans(arg1 string, arg2 string) (models.ServiceOffering, error) {
	fake.getServiceByNameForSpaceWithPlansMutex.Lock()
	ret, specificReturn := fake.getServiceByNameForSpaceWithPlansReturnsOnCall[len(fake.getServiceByNameForSpaceWithPlansArgsForCall)]
	fake.getServiceByNameForSpaceWithPlansArgsForCall = append(fake.getServiceByNameForSpaceWithPlansArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceByNameForSpaceWithPlans", []interface{}{arg1, arg2})
	fake.getServiceByNameForSpaceWithPlansMutex.Unlock()
	if fake.GetServiceByNameForSpaceWithPlansStub != nil {
		return fake.GetServiceByNameForSpaceWithPlansStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceByNameForSpaceWithPlansReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlansCallCount() int {
	fake.getServiceByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.RUnlock()
	return len(fake.getServiceByNameForSpaceWithPlansArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlansCalls(stub func(string, string) (models.ServiceOffering, error)) {
	fake.getServiceByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServiceByNameForSpaceWithPlansStub = stub
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlansArgsForCall(i int) (string, string) {
	fake.getServiceByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.RUnlock()
	argsForCall := fake.getServiceByNameForSpaceWithPlansArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlansReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServiceByNameForSpaceWithPlansStub = nil
	fake.getServiceByNameForSpaceWithPlansReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameForSpaceWithPlansReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServiceByNameForSpaceWithPlansStub = nil
	if fake.getServiceByNameForSpaceWithPlansReturnsOnCall == nil {
		fake.getServiceByNameForSpaceWithPlansReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceByNameForSpaceWithPlansReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlans(arg1 string) (models.ServiceOffering, error) {
	fake.getServiceByNameWithPlansMutex.Lock()
	ret, specificReturn := fake.getServiceByNameWithPlansReturnsOnCall[len(fake.getServiceByNameWithPlansArgsForCall)]
	fake.getServiceByNameWithPlansArgsForCall = append(fake.getServiceByNameWithPlansArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceByNameWithPlans", []interface{}{arg1})
	fake.getServiceByNameWithPlansMutex.Unlock()
	if fake.GetServiceByNameWithPlansStub != nil {
		return fake.GetServiceByNameWithPlansStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceByNameWithPlansReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansCallCount() int {
	fake.getServiceByNameWithPlansMutex.RLock()
	defer fake.getServiceByNameWithPlansMutex.RUnlock()
	return len(fake.getServiceByNameWithPlansArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansCalls(stub func(string) (models.ServiceOffering, error)) {
	fake.getServiceByNameWithPlansMutex.Lock()
	defer fake.getServiceByNameWithPlansMutex.Unlock()
	fake.GetServiceByNameWithPlansStub = stub
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansArgsForCall(i int) string {
	fake.getServiceByNameWithPlansMutex.RLock()
	defer fake.getServiceByNameWithPlansMutex.RUnlock()
	argsForCall := fake.getServiceByNameWithPlansArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameWithPlansMutex.Lock()
	defer fake.getServiceByNameWithPlansMutex.Unlock()
	fake.GetServiceByNameWithPlansStub = nil
	fake.getServiceByNameWithPlansReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameWithPlansMutex.Lock()
	defer fake.getServiceByNameWithPlansMutex.Unlock()
	fake.GetServiceByNameWithPlansStub = nil
	if fake.getServiceByNameWithPlansReturnsOnCall == nil {
		fake.getServiceByNameWithPlansReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceByNameWithPlansReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNames(arg1 string) (models.ServiceOffering, error) {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.Lock()
	ret, specificReturn := fake.getServiceByNameWithPlansWithOrgNamesReturnsOnCall[len(fake.getServiceByNameWithPlansWithOrgNamesArgsForCall)]
	fake.getServiceByNameWithPlansWithOrgNamesArgsForCall = append(fake.getServiceByNameWithPlansWithOrgNamesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceByNameWithPlansWithOrgNames", []interface{}{arg1})
	fake.getServiceByNameWithPlansWithOrgNamesMutex.Unlock()
	if fake.GetServiceByNameWithPlansWithOrgNamesStub != nil {
		return fake.GetServiceByNameWithPlansWithOrgNamesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceByNameWithPlansWithOrgNamesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNamesCallCount() int {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.RLock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.RUnlock()
	return len(fake.getServiceByNameWithPlansWithOrgNamesArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNamesCalls(stub func(string) (models.ServiceOffering, error)) {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.Lock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.Unlock()
	fake.GetServiceByNameWithPlansWithOrgNamesStub = stub
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNamesArgsForCall(i int) string {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.RLock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.RUnlock()
	argsForCall := fake.getServiceByNameWithPlansWithOrgNamesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNamesReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.Lock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.Unlock()
	fake.GetServiceByNameWithPlansWithOrgNamesStub = nil
	fake.getServiceByNameWithPlansWithOrgNamesReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceByNameWithPlansWithOrgNamesReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceByNameWithPlansWithOrgNamesMutex.Lock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.Unlock()
	fake.GetServiceByNameWithPlansWithOrgNamesStub = nil
	if fake.getServiceByNameWithPlansWithOrgNamesReturnsOnCall == nil {
		fake.getServiceByNameWithPlansWithOrgNamesReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceByNameWithPlansWithOrgNamesReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrg(arg1 string, arg2 string) (models.ServiceOffering, error) {
	fake.getServiceVisibleToOrgMutex.Lock()
	ret, specificReturn := fake.getServiceVisibleToOrgReturnsOnCall[len(fake.getServiceVisibleToOrgArgsForCall)]
	fake.getServiceVisibleToOrgArgsForCall = append(fake.getServiceVisibleToOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceVisibleToOrg", []interface{}{arg1, arg2})
	fake.getServiceVisibleToOrgMutex.Unlock()
	if fake.GetServiceVisibleToOrgStub != nil {
		return fake.GetServiceVisibleToOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServiceVisibleToOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrgCallCount() int {
	fake.getServiceVisibleToOrgMutex.RLock()
	defer fake.getServiceVisibleToOrgMutex.RUnlock()
	return len(fake.getServiceVisibleToOrgArgsForCall)
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrgCalls(stub func(string, string) (models.ServiceOffering, error)) {
	fake.getServiceVisibleToOrgMutex.Lock()
	defer fake.getServiceVisibleToOrgMutex.Unlock()
	fake.GetServiceVisibleToOrgStub = stub
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrgArgsForCall(i int) (string, string) {
	fake.getServiceVisibleToOrgMutex.RLock()
	defer fake.getServiceVisibleToOrgMutex.RUnlock()
	argsForCall := fake.getServiceVisibleToOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrgReturns(result1 models.ServiceOffering, result2 error) {
	fake.getServiceVisibleToOrgMutex.Lock()
	defer fake.getServiceVisibleToOrgMutex.Unlock()
	fake.GetServiceVisibleToOrgStub = nil
	fake.getServiceVisibleToOrgReturns = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServiceVisibleToOrgReturnsOnCall(i int, result1 models.ServiceOffering, result2 error) {
	fake.getServiceVisibleToOrgMutex.Lock()
	defer fake.getServiceVisibleToOrgMutex.Unlock()
	fake.GetServiceVisibleToOrgStub = nil
	if fake.getServiceVisibleToOrgReturnsOnCall == nil {
		fake.getServiceVisibleToOrgReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOffering
			result2 error
		})
	}
	fake.getServiceVisibleToOrgReturnsOnCall[i] = struct {
		result1 models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlans(arg1 string, arg2 string) (models.ServiceOfferings, error) {
	fake.getServicesByNameForSpaceWithPlansMutex.Lock()
	ret, specificReturn := fake.getServicesByNameForSpaceWithPlansReturnsOnCall[len(fake.getServicesByNameForSpaceWithPlansArgsForCall)]
	fake.getServicesByNameForSpaceWithPlansArgsForCall = append(fake.getServicesByNameForSpaceWithPlansArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServicesByNameForSpaceWithPlans", []interface{}{arg1, arg2})
	fake.getServicesByNameForSpaceWithPlansMutex.Unlock()
	if fake.GetServicesByNameForSpaceWithPlansStub != nil {
		return fake.GetServicesByNameForSpaceWithPlansStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesByNameForSpaceWithPlansReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlansCallCount() int {
	fake.getServicesByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.RUnlock()
	return len(fake.getServicesByNameForSpaceWithPlansArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlansCalls(stub func(string, string) (models.ServiceOfferings, error)) {
	fake.getServicesByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServicesByNameForSpaceWithPlansStub = stub
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlansArgsForCall(i int) (string, string) {
	fake.getServicesByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.RUnlock()
	argsForCall := fake.getServicesByNameForSpaceWithPlansArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlansReturns(result1 models.ServiceOfferings, result2 error) {
	fake.getServicesByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServicesByNameForSpaceWithPlansStub = nil
	fake.getServicesByNameForSpaceWithPlansReturns = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesByNameForSpaceWithPlansReturnsOnCall(i int, result1 models.ServiceOfferings, result2 error) {
	fake.getServicesByNameForSpaceWithPlansMutex.Lock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.Unlock()
	fake.GetServicesByNameForSpaceWithPlansStub = nil
	if fake.getServicesByNameForSpaceWithPlansReturnsOnCall == nil {
		fake.getServicesByNameForSpaceWithPlansReturnsOnCall = make(map[int]struct {
			result1 models.ServiceOfferings
			result2 error
		})
	}
	fake.getServicesByNameForSpaceWithPlansReturnsOnCall[i] = struct {
		result1 models.ServiceOfferings
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForBroker(arg1 string) ([]models.ServiceOffering, error) {
	fake.getServicesForBrokerMutex.Lock()
	ret, specificReturn := fake.getServicesForBrokerReturnsOnCall[len(fake.getServicesForBrokerArgsForCall)]
	fake.getServicesForBrokerArgsForCall = append(fake.getServicesForBrokerArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServicesForBroker", []interface{}{arg1})
	fake.getServicesForBrokerMutex.Unlock()
	if fake.GetServicesForBrokerStub != nil {
		return fake.GetServicesForBrokerStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesForBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesForBrokerCallCount() int {
	fake.getServicesForBrokerMutex.RLock()
	defer fake.getServicesForBrokerMutex.RUnlock()
	return len(fake.getServicesForBrokerArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesForBrokerCalls(stub func(string) ([]models.ServiceOffering, error)) {
	fake.getServicesForBrokerMutex.Lock()
	defer fake.getServicesForBrokerMutex.Unlock()
	fake.GetServicesForBrokerStub = stub
}

func (fake *FakeServiceBuilder) GetServicesForBrokerArgsForCall(i int) string {
	fake.getServicesForBrokerMutex.RLock()
	defer fake.getServicesForBrokerMutex.RUnlock()
	argsForCall := fake.getServicesForBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServicesForBrokerReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForBrokerMutex.Lock()
	defer fake.getServicesForBrokerMutex.Unlock()
	fake.GetServicesForBrokerStub = nil
	fake.getServicesForBrokerReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForBrokerReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForBrokerMutex.Lock()
	defer fake.getServicesForBrokerMutex.Unlock()
	fake.GetServicesForBrokerStub = nil
	if fake.getServicesForBrokerReturnsOnCall == nil {
		fake.getServicesForBrokerReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getServicesForBrokerReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokers(arg1 []string) ([]models.ServiceOffering, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.getServicesForManyBrokersMutex.Lock()
	ret, specificReturn := fake.getServicesForManyBrokersReturnsOnCall[len(fake.getServicesForManyBrokersArgsForCall)]
	fake.getServicesForManyBrokersArgsForCall = append(fake.getServicesForManyBrokersArgsForCall, struct {
		arg1 []string
	}{arg1Copy})
	fake.recordInvocation("GetServicesForManyBrokers", []interface{}{arg1Copy})
	fake.getServicesForManyBrokersMutex.Unlock()
	if fake.GetServicesForManyBrokersStub != nil {
		return fake.GetServicesForManyBrokersStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesForManyBrokersReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokersCallCount() int {
	fake.getServicesForManyBrokersMutex.RLock()
	defer fake.getServicesForManyBrokersMutex.RUnlock()
	return len(fake.getServicesForManyBrokersArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokersCalls(stub func([]string) ([]models.ServiceOffering, error)) {
	fake.getServicesForManyBrokersMutex.Lock()
	defer fake.getServicesForManyBrokersMutex.Unlock()
	fake.GetServicesForManyBrokersStub = stub
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokersArgsForCall(i int) []string {
	fake.getServicesForManyBrokersMutex.RLock()
	defer fake.getServicesForManyBrokersMutex.RUnlock()
	argsForCall := fake.getServicesForManyBrokersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokersReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForManyBrokersMutex.Lock()
	defer fake.getServicesForManyBrokersMutex.Unlock()
	fake.GetServicesForManyBrokersStub = nil
	fake.getServicesForManyBrokersReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForManyBrokersReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForManyBrokersMutex.Lock()
	defer fake.getServicesForManyBrokersMutex.Unlock()
	fake.GetServicesForManyBrokersStub = nil
	if fake.getServicesForManyBrokersReturnsOnCall == nil {
		fake.getServicesForManyBrokersReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getServicesForManyBrokersReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForSpace(arg1 string) ([]models.ServiceOffering, error) {
	fake.getServicesForSpaceMutex.Lock()
	ret, specificReturn := fake.getServicesForSpaceReturnsOnCall[len(fake.getServicesForSpaceArgsForCall)]
	fake.getServicesForSpaceArgsForCall = append(fake.getServicesForSpaceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServicesForSpace", []interface{}{arg1})
	fake.getServicesForSpaceMutex.Unlock()
	if fake.GetServicesForSpaceStub != nil {
		return fake.GetServicesForSpaceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesForSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesForSpaceCallCount() int {
	fake.getServicesForSpaceMutex.RLock()
	defer fake.getServicesForSpaceMutex.RUnlock()
	return len(fake.getServicesForSpaceArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesForSpaceCalls(stub func(string) ([]models.ServiceOffering, error)) {
	fake.getServicesForSpaceMutex.Lock()
	defer fake.getServicesForSpaceMutex.Unlock()
	fake.GetServicesForSpaceStub = stub
}

func (fake *FakeServiceBuilder) GetServicesForSpaceArgsForCall(i int) string {
	fake.getServicesForSpaceMutex.RLock()
	defer fake.getServicesForSpaceMutex.RUnlock()
	argsForCall := fake.getServicesForSpaceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServicesForSpaceReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForSpaceMutex.Lock()
	defer fake.getServicesForSpaceMutex.Unlock()
	fake.GetServicesForSpaceStub = nil
	fake.getServicesForSpaceReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForSpaceReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForSpaceMutex.Lock()
	defer fake.getServicesForSpaceMutex.Unlock()
	fake.GetServicesForSpaceStub = nil
	if fake.getServicesForSpaceReturnsOnCall == nil {
		fake.getServicesForSpaceReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getServicesForSpaceReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlans(arg1 string) ([]models.ServiceOffering, error) {
	fake.getServicesForSpaceWithPlansMutex.Lock()
	ret, specificReturn := fake.getServicesForSpaceWithPlansReturnsOnCall[len(fake.getServicesForSpaceWithPlansArgsForCall)]
	fake.getServicesForSpaceWithPlansArgsForCall = append(fake.getServicesForSpaceWithPlansArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServicesForSpaceWithPlans", []interface{}{arg1})
	fake.getServicesForSpaceWithPlansMutex.Unlock()
	if fake.GetServicesForSpaceWithPlansStub != nil {
		return fake.GetServicesForSpaceWithPlansStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesForSpaceWithPlansReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlansCallCount() int {
	fake.getServicesForSpaceWithPlansMutex.RLock()
	defer fake.getServicesForSpaceWithPlansMutex.RUnlock()
	return len(fake.getServicesForSpaceWithPlansArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlansCalls(stub func(string) ([]models.ServiceOffering, error)) {
	fake.getServicesForSpaceWithPlansMutex.Lock()
	defer fake.getServicesForSpaceWithPlansMutex.Unlock()
	fake.GetServicesForSpaceWithPlansStub = stub
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlansArgsForCall(i int) string {
	fake.getServicesForSpaceWithPlansMutex.RLock()
	defer fake.getServicesForSpaceWithPlansMutex.RUnlock()
	argsForCall := fake.getServicesForSpaceWithPlansArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlansReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForSpaceWithPlansMutex.Lock()
	defer fake.getServicesForSpaceWithPlansMutex.Unlock()
	fake.GetServicesForSpaceWithPlansStub = nil
	fake.getServicesForSpaceWithPlansReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesForSpaceWithPlansReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getServicesForSpaceWithPlansMutex.Lock()
	defer fake.getServicesForSpaceWithPlansMutex.Unlock()
	fake.GetServicesForSpaceWithPlansStub = nil
	if fake.getServicesForSpaceWithPlansReturnsOnCall == nil {
		fake.getServicesForSpaceWithPlansReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getServicesForSpaceWithPlansReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrg(arg1 string) ([]models.ServiceOffering, error) {
	fake.getServicesVisibleToOrgMutex.Lock()
	ret, specificReturn := fake.getServicesVisibleToOrgReturnsOnCall[len(fake.getServicesVisibleToOrgArgsForCall)]
	fake.getServicesVisibleToOrgArgsForCall = append(fake.getServicesVisibleToOrgArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServicesVisibleToOrg", []interface{}{arg1})
	fake.getServicesVisibleToOrgMutex.Unlock()
	if fake.GetServicesVisibleToOrgStub != nil {
		return fake.GetServicesVisibleToOrgStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getServicesVisibleToOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrgCallCount() int {
	fake.getServicesVisibleToOrgMutex.RLock()
	defer fake.getServicesVisibleToOrgMutex.RUnlock()
	return len(fake.getServicesVisibleToOrgArgsForCall)
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrgCalls(stub func(string) ([]models.ServiceOffering, error)) {
	fake.getServicesVisibleToOrgMutex.Lock()
	defer fake.getServicesVisibleToOrgMutex.Unlock()
	fake.GetServicesVisibleToOrgStub = stub
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrgArgsForCall(i int) string {
	fake.getServicesVisibleToOrgMutex.RLock()
	defer fake.getServicesVisibleToOrgMutex.RUnlock()
	argsForCall := fake.getServicesVisibleToOrgArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrgReturns(result1 []models.ServiceOffering, result2 error) {
	fake.getServicesVisibleToOrgMutex.Lock()
	defer fake.getServicesVisibleToOrgMutex.Unlock()
	fake.GetServicesVisibleToOrgStub = nil
	fake.getServicesVisibleToOrgReturns = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) GetServicesVisibleToOrgReturnsOnCall(i int, result1 []models.ServiceOffering, result2 error) {
	fake.getServicesVisibleToOrgMutex.Lock()
	defer fake.getServicesVisibleToOrgMutex.Unlock()
	fake.GetServicesVisibleToOrgStub = nil
	if fake.getServicesVisibleToOrgReturnsOnCall == nil {
		fake.getServicesVisibleToOrgReturnsOnCall = make(map[int]struct {
			result1 []models.ServiceOffering
			result2 error
		})
	}
	fake.getServicesVisibleToOrgReturnsOnCall[i] = struct {
		result1 []models.ServiceOffering
		result2 error
	}{result1, result2}
}

func (fake *FakeServiceBuilder) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.getAllServicesMutex.RLock()
	defer fake.getAllServicesMutex.RUnlock()
	fake.getAllServicesWithPlansMutex.RLock()
	defer fake.getAllServicesWithPlansMutex.RUnlock()
	fake.getServiceByNameForOrgMutex.RLock()
	defer fake.getServiceByNameForOrgMutex.RUnlock()
	fake.getServiceByNameForSpaceMutex.RLock()
	defer fake.getServiceByNameForSpaceMutex.RUnlock()
	fake.getServiceByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServiceByNameForSpaceWithPlansMutex.RUnlock()
	fake.getServiceByNameWithPlansMutex.RLock()
	defer fake.getServiceByNameWithPlansMutex.RUnlock()
	fake.getServiceByNameWithPlansWithOrgNamesMutex.RLock()
	defer fake.getServiceByNameWithPlansWithOrgNamesMutex.RUnlock()
	fake.getServiceVisibleToOrgMutex.RLock()
	defer fake.getServiceVisibleToOrgMutex.RUnlock()
	fake.getServicesByNameForSpaceWithPlansMutex.RLock()
	defer fake.getServicesByNameForSpaceWithPlansMutex.RUnlock()
	fake.getServicesForBrokerMutex.RLock()
	defer fake.getServicesForBrokerMutex.RUnlock()
	fake.getServicesForManyBrokersMutex.RLock()
	defer fake.getServicesForManyBrokersMutex.RUnlock()
	fake.getServicesForSpaceMutex.RLock()
	defer fake.getServicesForSpaceMutex.RUnlock()
	fake.getServicesForSpaceWithPlansMutex.RLock()
	defer fake.getServicesForSpaceWithPlansMutex.RUnlock()
	fake.getServicesVisibleToOrgMutex.RLock()
	defer fake.getServicesVisibleToOrgMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeServiceBuilder) 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 _ servicebuilder.ServiceBuilder = new(FakeServiceBuilder)