fake_client.go

// This file was generated by counterfeiter
package fake_receptor

import (
	"sync"
	"time"

	"github.com/cloudfoundry-incubator/receptor"
)

type FakeClient struct {
	CreateTaskStub        func(receptor.TaskCreateRequest) error
	createTaskMutex       sync.RWMutex
	createTaskArgsForCall []struct {
		arg1 receptor.TaskCreateRequest
	}
	createTaskReturns struct {
		result1 error
	}
	TasksStub        func() ([]receptor.TaskResponse, error)
	tasksMutex       sync.RWMutex
	tasksArgsForCall []struct{}
	tasksReturns struct {
		result1 []receptor.TaskResponse
		result2 error
	}
	TasksByDomainStub        func(domain string) ([]receptor.TaskResponse, error)
	tasksByDomainMutex       sync.RWMutex
	tasksByDomainArgsForCall []struct {
		domain string
	}
	tasksByDomainReturns struct {
		result1 []receptor.TaskResponse
		result2 error
	}
	GetTaskStub        func(taskId string) (receptor.TaskResponse, error)
	getTaskMutex       sync.RWMutex
	getTaskArgsForCall []struct {
		taskId string
	}
	getTaskReturns struct {
		result1 receptor.TaskResponse
		result2 error
	}
	DeleteTaskStub        func(taskId string) error
	deleteTaskMutex       sync.RWMutex
	deleteTaskArgsForCall []struct {
		taskId string
	}
	deleteTaskReturns struct {
		result1 error
	}
	CancelTaskStub        func(taskId string) error
	cancelTaskMutex       sync.RWMutex
	cancelTaskArgsForCall []struct {
		taskId string
	}
	cancelTaskReturns struct {
		result1 error
	}
	CreateDesiredLRPStub        func(receptor.DesiredLRPCreateRequest) error
	createDesiredLRPMutex       sync.RWMutex
	createDesiredLRPArgsForCall []struct {
		arg1 receptor.DesiredLRPCreateRequest
	}
	createDesiredLRPReturns struct {
		result1 error
	}
	GetDesiredLRPStub        func(processGuid string) (receptor.DesiredLRPResponse, error)
	getDesiredLRPMutex       sync.RWMutex
	getDesiredLRPArgsForCall []struct {
		processGuid string
	}
	getDesiredLRPReturns struct {
		result1 receptor.DesiredLRPResponse
		result2 error
	}
	UpdateDesiredLRPStub        func(processGuid string, update receptor.DesiredLRPUpdateRequest) error
	updateDesiredLRPMutex       sync.RWMutex
	updateDesiredLRPArgsForCall []struct {
		processGuid string
		update      receptor.DesiredLRPUpdateRequest
	}
	updateDesiredLRPReturns struct {
		result1 error
	}
	DeleteDesiredLRPStub        func(processGuid string) error
	deleteDesiredLRPMutex       sync.RWMutex
	deleteDesiredLRPArgsForCall []struct {
		processGuid string
	}
	deleteDesiredLRPReturns struct {
		result1 error
	}
	DesiredLRPsStub        func() ([]receptor.DesiredLRPResponse, error)
	desiredLRPsMutex       sync.RWMutex
	desiredLRPsArgsForCall []struct{}
	desiredLRPsReturns struct {
		result1 []receptor.DesiredLRPResponse
		result2 error
	}
	DesiredLRPsByDomainStub        func(domain string) ([]receptor.DesiredLRPResponse, error)
	desiredLRPsByDomainMutex       sync.RWMutex
	desiredLRPsByDomainArgsForCall []struct {
		domain string
	}
	desiredLRPsByDomainReturns struct {
		result1 []receptor.DesiredLRPResponse
		result2 error
	}
	ActualLRPsStub        func() ([]receptor.ActualLRPResponse, error)
	actualLRPsMutex       sync.RWMutex
	actualLRPsArgsForCall []struct{}
	actualLRPsReturns struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}
	ActualLRPsByDomainStub        func(domain string) ([]receptor.ActualLRPResponse, error)
	actualLRPsByDomainMutex       sync.RWMutex
	actualLRPsByDomainArgsForCall []struct {
		domain string
	}
	actualLRPsByDomainReturns struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}
	ActualLRPsByProcessGuidStub        func(processGuid string) ([]receptor.ActualLRPResponse, error)
	actualLRPsByProcessGuidMutex       sync.RWMutex
	actualLRPsByProcessGuidArgsForCall []struct {
		processGuid string
	}
	actualLRPsByProcessGuidReturns struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}
	ActualLRPByProcessGuidAndIndexStub        func(processGuid string, index int) (receptor.ActualLRPResponse, error)
	actualLRPByProcessGuidAndIndexMutex       sync.RWMutex
	actualLRPByProcessGuidAndIndexArgsForCall []struct {
		processGuid string
		index       int
	}
	actualLRPByProcessGuidAndIndexReturns struct {
		result1 receptor.ActualLRPResponse
		result2 error
	}
	KillActualLRPByProcessGuidAndIndexStub        func(processGuid string, index int) error
	killActualLRPByProcessGuidAndIndexMutex       sync.RWMutex
	killActualLRPByProcessGuidAndIndexArgsForCall []struct {
		processGuid string
		index       int
	}
	killActualLRPByProcessGuidAndIndexReturns struct {
		result1 error
	}
	SubscribeToEventsStub        func() (receptor.EventSource, error)
	subscribeToEventsMutex       sync.RWMutex
	subscribeToEventsArgsForCall []struct{}
	subscribeToEventsReturns struct {
		result1 receptor.EventSource
		result2 error
	}
	CellsStub        func() ([]receptor.CellResponse, error)
	cellsMutex       sync.RWMutex
	cellsArgsForCall []struct{}
	cellsReturns struct {
		result1 []receptor.CellResponse
		result2 error
	}
	UpsertDomainStub        func(domain string, ttl time.Duration) error
	upsertDomainMutex       sync.RWMutex
	upsertDomainArgsForCall []struct {
		domain string
		ttl    time.Duration
	}
	upsertDomainReturns struct {
		result1 error
	}
	DomainsStub        func() ([]string, error)
	domainsMutex       sync.RWMutex
	domainsArgsForCall []struct{}
	domainsReturns struct {
		result1 []string
		result2 error
	}
}

func (fake *FakeClient) CreateTask(arg1 receptor.TaskCreateRequest) error {
	fake.createTaskMutex.Lock()
	fake.createTaskArgsForCall = append(fake.createTaskArgsForCall, struct {
		arg1 receptor.TaskCreateRequest
	}{arg1})
	fake.createTaskMutex.Unlock()
	if fake.CreateTaskStub != nil {
		return fake.CreateTaskStub(arg1)
	} else {
		return fake.createTaskReturns.result1
	}
}

func (fake *FakeClient) CreateTaskCallCount() int {
	fake.createTaskMutex.RLock()
	defer fake.createTaskMutex.RUnlock()
	return len(fake.createTaskArgsForCall)
}

func (fake *FakeClient) CreateTaskArgsForCall(i int) receptor.TaskCreateRequest {
	fake.createTaskMutex.RLock()
	defer fake.createTaskMutex.RUnlock()
	return fake.createTaskArgsForCall[i].arg1
}

func (fake *FakeClient) CreateTaskReturns(result1 error) {
	fake.CreateTaskStub = nil
	fake.createTaskReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) Tasks() ([]receptor.TaskResponse, error) {
	fake.tasksMutex.Lock()
	fake.tasksArgsForCall = append(fake.tasksArgsForCall, struct{}{})
	fake.tasksMutex.Unlock()
	if fake.TasksStub != nil {
		return fake.TasksStub()
	} else {
		return fake.tasksReturns.result1, fake.tasksReturns.result2
	}
}

func (fake *FakeClient) TasksCallCount() int {
	fake.tasksMutex.RLock()
	defer fake.tasksMutex.RUnlock()
	return len(fake.tasksArgsForCall)
}

func (fake *FakeClient) TasksReturns(result1 []receptor.TaskResponse, result2 error) {
	fake.TasksStub = nil
	fake.tasksReturns = struct {
		result1 []receptor.TaskResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) TasksByDomain(domain string) ([]receptor.TaskResponse, error) {
	fake.tasksByDomainMutex.Lock()
	fake.tasksByDomainArgsForCall = append(fake.tasksByDomainArgsForCall, struct {
		domain string
	}{domain})
	fake.tasksByDomainMutex.Unlock()
	if fake.TasksByDomainStub != nil {
		return fake.TasksByDomainStub(domain)
	} else {
		return fake.tasksByDomainReturns.result1, fake.tasksByDomainReturns.result2
	}
}

func (fake *FakeClient) TasksByDomainCallCount() int {
	fake.tasksByDomainMutex.RLock()
	defer fake.tasksByDomainMutex.RUnlock()
	return len(fake.tasksByDomainArgsForCall)
}

func (fake *FakeClient) TasksByDomainArgsForCall(i int) string {
	fake.tasksByDomainMutex.RLock()
	defer fake.tasksByDomainMutex.RUnlock()
	return fake.tasksByDomainArgsForCall[i].domain
}

func (fake *FakeClient) TasksByDomainReturns(result1 []receptor.TaskResponse, result2 error) {
	fake.TasksByDomainStub = nil
	fake.tasksByDomainReturns = struct {
		result1 []receptor.TaskResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) GetTask(taskId string) (receptor.TaskResponse, error) {
	fake.getTaskMutex.Lock()
	fake.getTaskArgsForCall = append(fake.getTaskArgsForCall, struct {
		taskId string
	}{taskId})
	fake.getTaskMutex.Unlock()
	if fake.GetTaskStub != nil {
		return fake.GetTaskStub(taskId)
	} else {
		return fake.getTaskReturns.result1, fake.getTaskReturns.result2
	}
}

func (fake *FakeClient) GetTaskCallCount() int {
	fake.getTaskMutex.RLock()
	defer fake.getTaskMutex.RUnlock()
	return len(fake.getTaskArgsForCall)
}

func (fake *FakeClient) GetTaskArgsForCall(i int) string {
	fake.getTaskMutex.RLock()
	defer fake.getTaskMutex.RUnlock()
	return fake.getTaskArgsForCall[i].taskId
}

func (fake *FakeClient) GetTaskReturns(result1 receptor.TaskResponse, result2 error) {
	fake.GetTaskStub = nil
	fake.getTaskReturns = struct {
		result1 receptor.TaskResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) DeleteTask(taskId string) error {
	fake.deleteTaskMutex.Lock()
	fake.deleteTaskArgsForCall = append(fake.deleteTaskArgsForCall, struct {
		taskId string
	}{taskId})
	fake.deleteTaskMutex.Unlock()
	if fake.DeleteTaskStub != nil {
		return fake.DeleteTaskStub(taskId)
	} else {
		return fake.deleteTaskReturns.result1
	}
}

func (fake *FakeClient) DeleteTaskCallCount() int {
	fake.deleteTaskMutex.RLock()
	defer fake.deleteTaskMutex.RUnlock()
	return len(fake.deleteTaskArgsForCall)
}

func (fake *FakeClient) DeleteTaskArgsForCall(i int) string {
	fake.deleteTaskMutex.RLock()
	defer fake.deleteTaskMutex.RUnlock()
	return fake.deleteTaskArgsForCall[i].taskId
}

func (fake *FakeClient) DeleteTaskReturns(result1 error) {
	fake.DeleteTaskStub = nil
	fake.deleteTaskReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) CancelTask(taskId string) error {
	fake.cancelTaskMutex.Lock()
	fake.cancelTaskArgsForCall = append(fake.cancelTaskArgsForCall, struct {
		taskId string
	}{taskId})
	fake.cancelTaskMutex.Unlock()
	if fake.CancelTaskStub != nil {
		return fake.CancelTaskStub(taskId)
	} else {
		return fake.cancelTaskReturns.result1
	}
}

func (fake *FakeClient) CancelTaskCallCount() int {
	fake.cancelTaskMutex.RLock()
	defer fake.cancelTaskMutex.RUnlock()
	return len(fake.cancelTaskArgsForCall)
}

func (fake *FakeClient) CancelTaskArgsForCall(i int) string {
	fake.cancelTaskMutex.RLock()
	defer fake.cancelTaskMutex.RUnlock()
	return fake.cancelTaskArgsForCall[i].taskId
}

func (fake *FakeClient) CancelTaskReturns(result1 error) {
	fake.CancelTaskStub = nil
	fake.cancelTaskReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) CreateDesiredLRP(arg1 receptor.DesiredLRPCreateRequest) error {
	fake.createDesiredLRPMutex.Lock()
	fake.createDesiredLRPArgsForCall = append(fake.createDesiredLRPArgsForCall, struct {
		arg1 receptor.DesiredLRPCreateRequest
	}{arg1})
	fake.createDesiredLRPMutex.Unlock()
	if fake.CreateDesiredLRPStub != nil {
		return fake.CreateDesiredLRPStub(arg1)
	} else {
		return fake.createDesiredLRPReturns.result1
	}
}

func (fake *FakeClient) CreateDesiredLRPCallCount() int {
	fake.createDesiredLRPMutex.RLock()
	defer fake.createDesiredLRPMutex.RUnlock()
	return len(fake.createDesiredLRPArgsForCall)
}

func (fake *FakeClient) CreateDesiredLRPArgsForCall(i int) receptor.DesiredLRPCreateRequest {
	fake.createDesiredLRPMutex.RLock()
	defer fake.createDesiredLRPMutex.RUnlock()
	return fake.createDesiredLRPArgsForCall[i].arg1
}

func (fake *FakeClient) CreateDesiredLRPReturns(result1 error) {
	fake.CreateDesiredLRPStub = nil
	fake.createDesiredLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) GetDesiredLRP(processGuid string) (receptor.DesiredLRPResponse, error) {
	fake.getDesiredLRPMutex.Lock()
	fake.getDesiredLRPArgsForCall = append(fake.getDesiredLRPArgsForCall, struct {
		processGuid string
	}{processGuid})
	fake.getDesiredLRPMutex.Unlock()
	if fake.GetDesiredLRPStub != nil {
		return fake.GetDesiredLRPStub(processGuid)
	} else {
		return fake.getDesiredLRPReturns.result1, fake.getDesiredLRPReturns.result2
	}
}

func (fake *FakeClient) GetDesiredLRPCallCount() int {
	fake.getDesiredLRPMutex.RLock()
	defer fake.getDesiredLRPMutex.RUnlock()
	return len(fake.getDesiredLRPArgsForCall)
}

func (fake *FakeClient) GetDesiredLRPArgsForCall(i int) string {
	fake.getDesiredLRPMutex.RLock()
	defer fake.getDesiredLRPMutex.RUnlock()
	return fake.getDesiredLRPArgsForCall[i].processGuid
}

func (fake *FakeClient) GetDesiredLRPReturns(result1 receptor.DesiredLRPResponse, result2 error) {
	fake.GetDesiredLRPStub = nil
	fake.getDesiredLRPReturns = struct {
		result1 receptor.DesiredLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) UpdateDesiredLRP(processGuid string, update receptor.DesiredLRPUpdateRequest) error {
	fake.updateDesiredLRPMutex.Lock()
	fake.updateDesiredLRPArgsForCall = append(fake.updateDesiredLRPArgsForCall, struct {
		processGuid string
		update      receptor.DesiredLRPUpdateRequest
	}{processGuid, update})
	fake.updateDesiredLRPMutex.Unlock()
	if fake.UpdateDesiredLRPStub != nil {
		return fake.UpdateDesiredLRPStub(processGuid, update)
	} else {
		return fake.updateDesiredLRPReturns.result1
	}
}

func (fake *FakeClient) UpdateDesiredLRPCallCount() int {
	fake.updateDesiredLRPMutex.RLock()
	defer fake.updateDesiredLRPMutex.RUnlock()
	return len(fake.updateDesiredLRPArgsForCall)
}

func (fake *FakeClient) UpdateDesiredLRPArgsForCall(i int) (string, receptor.DesiredLRPUpdateRequest) {
	fake.updateDesiredLRPMutex.RLock()
	defer fake.updateDesiredLRPMutex.RUnlock()
	return fake.updateDesiredLRPArgsForCall[i].processGuid, fake.updateDesiredLRPArgsForCall[i].update
}

func (fake *FakeClient) UpdateDesiredLRPReturns(result1 error) {
	fake.UpdateDesiredLRPStub = nil
	fake.updateDesiredLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) DeleteDesiredLRP(processGuid string) error {
	fake.deleteDesiredLRPMutex.Lock()
	fake.deleteDesiredLRPArgsForCall = append(fake.deleteDesiredLRPArgsForCall, struct {
		processGuid string
	}{processGuid})
	fake.deleteDesiredLRPMutex.Unlock()
	if fake.DeleteDesiredLRPStub != nil {
		return fake.DeleteDesiredLRPStub(processGuid)
	} else {
		return fake.deleteDesiredLRPReturns.result1
	}
}

func (fake *FakeClient) DeleteDesiredLRPCallCount() int {
	fake.deleteDesiredLRPMutex.RLock()
	defer fake.deleteDesiredLRPMutex.RUnlock()
	return len(fake.deleteDesiredLRPArgsForCall)
}

func (fake *FakeClient) DeleteDesiredLRPArgsForCall(i int) string {
	fake.deleteDesiredLRPMutex.RLock()
	defer fake.deleteDesiredLRPMutex.RUnlock()
	return fake.deleteDesiredLRPArgsForCall[i].processGuid
}

func (fake *FakeClient) DeleteDesiredLRPReturns(result1 error) {
	fake.DeleteDesiredLRPStub = nil
	fake.deleteDesiredLRPReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) DesiredLRPs() ([]receptor.DesiredLRPResponse, error) {
	fake.desiredLRPsMutex.Lock()
	fake.desiredLRPsArgsForCall = append(fake.desiredLRPsArgsForCall, struct{}{})
	fake.desiredLRPsMutex.Unlock()
	if fake.DesiredLRPsStub != nil {
		return fake.DesiredLRPsStub()
	} else {
		return fake.desiredLRPsReturns.result1, fake.desiredLRPsReturns.result2
	}
}

func (fake *FakeClient) DesiredLRPsCallCount() int {
	fake.desiredLRPsMutex.RLock()
	defer fake.desiredLRPsMutex.RUnlock()
	return len(fake.desiredLRPsArgsForCall)
}

func (fake *FakeClient) DesiredLRPsReturns(result1 []receptor.DesiredLRPResponse, result2 error) {
	fake.DesiredLRPsStub = nil
	fake.desiredLRPsReturns = struct {
		result1 []receptor.DesiredLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) DesiredLRPsByDomain(domain string) ([]receptor.DesiredLRPResponse, error) {
	fake.desiredLRPsByDomainMutex.Lock()
	fake.desiredLRPsByDomainArgsForCall = append(fake.desiredLRPsByDomainArgsForCall, struct {
		domain string
	}{domain})
	fake.desiredLRPsByDomainMutex.Unlock()
	if fake.DesiredLRPsByDomainStub != nil {
		return fake.DesiredLRPsByDomainStub(domain)
	} else {
		return fake.desiredLRPsByDomainReturns.result1, fake.desiredLRPsByDomainReturns.result2
	}
}

func (fake *FakeClient) DesiredLRPsByDomainCallCount() int {
	fake.desiredLRPsByDomainMutex.RLock()
	defer fake.desiredLRPsByDomainMutex.RUnlock()
	return len(fake.desiredLRPsByDomainArgsForCall)
}

func (fake *FakeClient) DesiredLRPsByDomainArgsForCall(i int) string {
	fake.desiredLRPsByDomainMutex.RLock()
	defer fake.desiredLRPsByDomainMutex.RUnlock()
	return fake.desiredLRPsByDomainArgsForCall[i].domain
}

func (fake *FakeClient) DesiredLRPsByDomainReturns(result1 []receptor.DesiredLRPResponse, result2 error) {
	fake.DesiredLRPsByDomainStub = nil
	fake.desiredLRPsByDomainReturns = struct {
		result1 []receptor.DesiredLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) ActualLRPs() ([]receptor.ActualLRPResponse, error) {
	fake.actualLRPsMutex.Lock()
	fake.actualLRPsArgsForCall = append(fake.actualLRPsArgsForCall, struct{}{})
	fake.actualLRPsMutex.Unlock()
	if fake.ActualLRPsStub != nil {
		return fake.ActualLRPsStub()
	} else {
		return fake.actualLRPsReturns.result1, fake.actualLRPsReturns.result2
	}
}

func (fake *FakeClient) ActualLRPsCallCount() int {
	fake.actualLRPsMutex.RLock()
	defer fake.actualLRPsMutex.RUnlock()
	return len(fake.actualLRPsArgsForCall)
}

func (fake *FakeClient) ActualLRPsReturns(result1 []receptor.ActualLRPResponse, result2 error) {
	fake.ActualLRPsStub = nil
	fake.actualLRPsReturns = struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) ActualLRPsByDomain(domain string) ([]receptor.ActualLRPResponse, error) {
	fake.actualLRPsByDomainMutex.Lock()
	fake.actualLRPsByDomainArgsForCall = append(fake.actualLRPsByDomainArgsForCall, struct {
		domain string
	}{domain})
	fake.actualLRPsByDomainMutex.Unlock()
	if fake.ActualLRPsByDomainStub != nil {
		return fake.ActualLRPsByDomainStub(domain)
	} else {
		return fake.actualLRPsByDomainReturns.result1, fake.actualLRPsByDomainReturns.result2
	}
}

func (fake *FakeClient) ActualLRPsByDomainCallCount() int {
	fake.actualLRPsByDomainMutex.RLock()
	defer fake.actualLRPsByDomainMutex.RUnlock()
	return len(fake.actualLRPsByDomainArgsForCall)
}

func (fake *FakeClient) ActualLRPsByDomainArgsForCall(i int) string {
	fake.actualLRPsByDomainMutex.RLock()
	defer fake.actualLRPsByDomainMutex.RUnlock()
	return fake.actualLRPsByDomainArgsForCall[i].domain
}

func (fake *FakeClient) ActualLRPsByDomainReturns(result1 []receptor.ActualLRPResponse, result2 error) {
	fake.ActualLRPsByDomainStub = nil
	fake.actualLRPsByDomainReturns = struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) ActualLRPsByProcessGuid(processGuid string) ([]receptor.ActualLRPResponse, error) {
	fake.actualLRPsByProcessGuidMutex.Lock()
	fake.actualLRPsByProcessGuidArgsForCall = append(fake.actualLRPsByProcessGuidArgsForCall, struct {
		processGuid string
	}{processGuid})
	fake.actualLRPsByProcessGuidMutex.Unlock()
	if fake.ActualLRPsByProcessGuidStub != nil {
		return fake.ActualLRPsByProcessGuidStub(processGuid)
	} else {
		return fake.actualLRPsByProcessGuidReturns.result1, fake.actualLRPsByProcessGuidReturns.result2
	}
}

func (fake *FakeClient) ActualLRPsByProcessGuidCallCount() int {
	fake.actualLRPsByProcessGuidMutex.RLock()
	defer fake.actualLRPsByProcessGuidMutex.RUnlock()
	return len(fake.actualLRPsByProcessGuidArgsForCall)
}

func (fake *FakeClient) ActualLRPsByProcessGuidArgsForCall(i int) string {
	fake.actualLRPsByProcessGuidMutex.RLock()
	defer fake.actualLRPsByProcessGuidMutex.RUnlock()
	return fake.actualLRPsByProcessGuidArgsForCall[i].processGuid
}

func (fake *FakeClient) ActualLRPsByProcessGuidReturns(result1 []receptor.ActualLRPResponse, result2 error) {
	fake.ActualLRPsByProcessGuidStub = nil
	fake.actualLRPsByProcessGuidReturns = struct {
		result1 []receptor.ActualLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) ActualLRPByProcessGuidAndIndex(processGuid string, index int) (receptor.ActualLRPResponse, error) {
	fake.actualLRPByProcessGuidAndIndexMutex.Lock()
	fake.actualLRPByProcessGuidAndIndexArgsForCall = append(fake.actualLRPByProcessGuidAndIndexArgsForCall, struct {
		processGuid string
		index       int
	}{processGuid, index})
	fake.actualLRPByProcessGuidAndIndexMutex.Unlock()
	if fake.ActualLRPByProcessGuidAndIndexStub != nil {
		return fake.ActualLRPByProcessGuidAndIndexStub(processGuid, index)
	} else {
		return fake.actualLRPByProcessGuidAndIndexReturns.result1, fake.actualLRPByProcessGuidAndIndexReturns.result2
	}
}

func (fake *FakeClient) ActualLRPByProcessGuidAndIndexCallCount() int {
	fake.actualLRPByProcessGuidAndIndexMutex.RLock()
	defer fake.actualLRPByProcessGuidAndIndexMutex.RUnlock()
	return len(fake.actualLRPByProcessGuidAndIndexArgsForCall)
}

func (fake *FakeClient) ActualLRPByProcessGuidAndIndexArgsForCall(i int) (string, int) {
	fake.actualLRPByProcessGuidAndIndexMutex.RLock()
	defer fake.actualLRPByProcessGuidAndIndexMutex.RUnlock()
	return fake.actualLRPByProcessGuidAndIndexArgsForCall[i].processGuid, fake.actualLRPByProcessGuidAndIndexArgsForCall[i].index
}

func (fake *FakeClient) ActualLRPByProcessGuidAndIndexReturns(result1 receptor.ActualLRPResponse, result2 error) {
	fake.ActualLRPByProcessGuidAndIndexStub = nil
	fake.actualLRPByProcessGuidAndIndexReturns = struct {
		result1 receptor.ActualLRPResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) KillActualLRPByProcessGuidAndIndex(processGuid string, index int) error {
	fake.killActualLRPByProcessGuidAndIndexMutex.Lock()
	fake.killActualLRPByProcessGuidAndIndexArgsForCall = append(fake.killActualLRPByProcessGuidAndIndexArgsForCall, struct {
		processGuid string
		index       int
	}{processGuid, index})
	fake.killActualLRPByProcessGuidAndIndexMutex.Unlock()
	if fake.KillActualLRPByProcessGuidAndIndexStub != nil {
		return fake.KillActualLRPByProcessGuidAndIndexStub(processGuid, index)
	} else {
		return fake.killActualLRPByProcessGuidAndIndexReturns.result1
	}
}

func (fake *FakeClient) KillActualLRPByProcessGuidAndIndexCallCount() int {
	fake.killActualLRPByProcessGuidAndIndexMutex.RLock()
	defer fake.killActualLRPByProcessGuidAndIndexMutex.RUnlock()
	return len(fake.killActualLRPByProcessGuidAndIndexArgsForCall)
}

func (fake *FakeClient) KillActualLRPByProcessGuidAndIndexArgsForCall(i int) (string, int) {
	fake.killActualLRPByProcessGuidAndIndexMutex.RLock()
	defer fake.killActualLRPByProcessGuidAndIndexMutex.RUnlock()
	return fake.killActualLRPByProcessGuidAndIndexArgsForCall[i].processGuid, fake.killActualLRPByProcessGuidAndIndexArgsForCall[i].index
}

func (fake *FakeClient) KillActualLRPByProcessGuidAndIndexReturns(result1 error) {
	fake.KillActualLRPByProcessGuidAndIndexStub = nil
	fake.killActualLRPByProcessGuidAndIndexReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) SubscribeToEvents() (receptor.EventSource, error) {
	fake.subscribeToEventsMutex.Lock()
	fake.subscribeToEventsArgsForCall = append(fake.subscribeToEventsArgsForCall, struct{}{})
	fake.subscribeToEventsMutex.Unlock()
	if fake.SubscribeToEventsStub != nil {
		return fake.SubscribeToEventsStub()
	} else {
		return fake.subscribeToEventsReturns.result1, fake.subscribeToEventsReturns.result2
	}
}

func (fake *FakeClient) SubscribeToEventsCallCount() int {
	fake.subscribeToEventsMutex.RLock()
	defer fake.subscribeToEventsMutex.RUnlock()
	return len(fake.subscribeToEventsArgsForCall)
}

func (fake *FakeClient) SubscribeToEventsReturns(result1 receptor.EventSource, result2 error) {
	fake.SubscribeToEventsStub = nil
	fake.subscribeToEventsReturns = struct {
		result1 receptor.EventSource
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) Cells() ([]receptor.CellResponse, error) {
	fake.cellsMutex.Lock()
	fake.cellsArgsForCall = append(fake.cellsArgsForCall, struct{}{})
	fake.cellsMutex.Unlock()
	if fake.CellsStub != nil {
		return fake.CellsStub()
	} else {
		return fake.cellsReturns.result1, fake.cellsReturns.result2
	}
}

func (fake *FakeClient) CellsCallCount() int {
	fake.cellsMutex.RLock()
	defer fake.cellsMutex.RUnlock()
	return len(fake.cellsArgsForCall)
}

func (fake *FakeClient) CellsReturns(result1 []receptor.CellResponse, result2 error) {
	fake.CellsStub = nil
	fake.cellsReturns = struct {
		result1 []receptor.CellResponse
		result2 error
	}{result1, result2}
}

func (fake *FakeClient) UpsertDomain(domain string, ttl time.Duration) error {
	fake.upsertDomainMutex.Lock()
	fake.upsertDomainArgsForCall = append(fake.upsertDomainArgsForCall, struct {
		domain string
		ttl    time.Duration
	}{domain, ttl})
	fake.upsertDomainMutex.Unlock()
	if fake.UpsertDomainStub != nil {
		return fake.UpsertDomainStub(domain, ttl)
	} else {
		return fake.upsertDomainReturns.result1
	}
}

func (fake *FakeClient) UpsertDomainCallCount() int {
	fake.upsertDomainMutex.RLock()
	defer fake.upsertDomainMutex.RUnlock()
	return len(fake.upsertDomainArgsForCall)
}

func (fake *FakeClient) UpsertDomainArgsForCall(i int) (string, time.Duration) {
	fake.upsertDomainMutex.RLock()
	defer fake.upsertDomainMutex.RUnlock()
	return fake.upsertDomainArgsForCall[i].domain, fake.upsertDomainArgsForCall[i].ttl
}

func (fake *FakeClient) UpsertDomainReturns(result1 error) {
	fake.UpsertDomainStub = nil
	fake.upsertDomainReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeClient) Domains() ([]string, error) {
	fake.domainsMutex.Lock()
	fake.domainsArgsForCall = append(fake.domainsArgsForCall, struct{}{})
	fake.domainsMutex.Unlock()
	if fake.DomainsStub != nil {
		return fake.DomainsStub()
	} else {
		return fake.domainsReturns.result1, fake.domainsReturns.result2
	}
}

func (fake *FakeClient) DomainsCallCount() int {
	fake.domainsMutex.RLock()
	defer fake.domainsMutex.RUnlock()
	return len(fake.domainsArgsForCall)
}

func (fake *FakeClient) DomainsReturns(result1 []string, result2 error) {
	fake.DomainsStub = nil
	fake.domainsReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

var _ receptor.Client = new(FakeClient)