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

import (
	"sync"

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

type FakeRouteActor struct {
	BindRouteStub        func(models.Application, models.Route) error
	bindRouteMutex       sync.RWMutex
	bindRouteArgsForCall []struct {
		arg1 models.Application
		arg2 models.Route
	}
	bindRouteReturns struct {
		result1 error
	}
	bindRouteReturnsOnCall map[int]struct {
		result1 error
	}
	CreateRandomTCPRouteStub        func(models.DomainFields) (models.Route, error)
	createRandomTCPRouteMutex       sync.RWMutex
	createRandomTCPRouteArgsForCall []struct {
		arg1 models.DomainFields
	}
	createRandomTCPRouteReturns struct {
		result1 models.Route
		result2 error
	}
	createRandomTCPRouteReturnsOnCall map[int]struct {
		result1 models.Route
		result2 error
	}
	FindAndBindRouteStub        func(string, models.Application, models.AppParams) error
	findAndBindRouteMutex       sync.RWMutex
	findAndBindRouteArgsForCall []struct {
		arg1 string
		arg2 models.Application
		arg3 models.AppParams
	}
	findAndBindRouteReturns struct {
		result1 error
	}
	findAndBindRouteReturnsOnCall map[int]struct {
		result1 error
	}
	FindDomainStub        func(string) (string, models.DomainFields, error)
	findDomainMutex       sync.RWMutex
	findDomainArgsForCall []struct {
		arg1 string
	}
	findDomainReturns struct {
		result1 string
		result2 models.DomainFields
		result3 error
	}
	findDomainReturnsOnCall map[int]struct {
		result1 string
		result2 models.DomainFields
		result3 error
	}
	FindOrCreateRouteStub        func(string, models.DomainFields, string, int, bool) (models.Route, error)
	findOrCreateRouteMutex       sync.RWMutex
	findOrCreateRouteArgsForCall []struct {
		arg1 string
		arg2 models.DomainFields
		arg3 string
		arg4 int
		arg5 bool
	}
	findOrCreateRouteReturns struct {
		result1 models.Route
		result2 error
	}
	findOrCreateRouteReturnsOnCall map[int]struct {
		result1 models.Route
		result2 error
	}
	FindPathStub        func(string) (string, string)
	findPathMutex       sync.RWMutex
	findPathArgsForCall []struct {
		arg1 string
	}
	findPathReturns struct {
		result1 string
		result2 string
	}
	findPathReturnsOnCall map[int]struct {
		result1 string
		result2 string
	}
	FindPortStub        func(string) (string, int, error)
	findPortMutex       sync.RWMutex
	findPortArgsForCall []struct {
		arg1 string
	}
	findPortReturns struct {
		result1 string
		result2 int
		result3 error
	}
	findPortReturnsOnCall map[int]struct {
		result1 string
		result2 int
		result3 error
	}
	UnbindAllStub        func(models.Application) error
	unbindAllMutex       sync.RWMutex
	unbindAllArgsForCall []struct {
		arg1 models.Application
	}
	unbindAllReturns struct {
		result1 error
	}
	unbindAllReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeRouteActor) BindRoute(arg1 models.Application, arg2 models.Route) error {
	fake.bindRouteMutex.Lock()
	ret, specificReturn := fake.bindRouteReturnsOnCall[len(fake.bindRouteArgsForCall)]
	fake.bindRouteArgsForCall = append(fake.bindRouteArgsForCall, struct {
		arg1 models.Application
		arg2 models.Route
	}{arg1, arg2})
	fake.recordInvocation("BindRoute", []interface{}{arg1, arg2})
	fake.bindRouteMutex.Unlock()
	if fake.BindRouteStub != nil {
		return fake.BindRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.bindRouteReturns
	return fakeReturns.result1
}

func (fake *FakeRouteActor) BindRouteCallCount() int {
	fake.bindRouteMutex.RLock()
	defer fake.bindRouteMutex.RUnlock()
	return len(fake.bindRouteArgsForCall)
}

func (fake *FakeRouteActor) BindRouteCalls(stub func(models.Application, models.Route) error) {
	fake.bindRouteMutex.Lock()
	defer fake.bindRouteMutex.Unlock()
	fake.BindRouteStub = stub
}

func (fake *FakeRouteActor) BindRouteArgsForCall(i int) (models.Application, models.Route) {
	fake.bindRouteMutex.RLock()
	defer fake.bindRouteMutex.RUnlock()
	argsForCall := fake.bindRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRouteActor) BindRouteReturns(result1 error) {
	fake.bindRouteMutex.Lock()
	defer fake.bindRouteMutex.Unlock()
	fake.BindRouteStub = nil
	fake.bindRouteReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) BindRouteReturnsOnCall(i int, result1 error) {
	fake.bindRouteMutex.Lock()
	defer fake.bindRouteMutex.Unlock()
	fake.BindRouteStub = nil
	if fake.bindRouteReturnsOnCall == nil {
		fake.bindRouteReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.bindRouteReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) CreateRandomTCPRoute(arg1 models.DomainFields) (models.Route, error) {
	fake.createRandomTCPRouteMutex.Lock()
	ret, specificReturn := fake.createRandomTCPRouteReturnsOnCall[len(fake.createRandomTCPRouteArgsForCall)]
	fake.createRandomTCPRouteArgsForCall = append(fake.createRandomTCPRouteArgsForCall, struct {
		arg1 models.DomainFields
	}{arg1})
	fake.recordInvocation("CreateRandomTCPRoute", []interface{}{arg1})
	fake.createRandomTCPRouteMutex.Unlock()
	if fake.CreateRandomTCPRouteStub != nil {
		return fake.CreateRandomTCPRouteStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createRandomTCPRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRouteActor) CreateRandomTCPRouteCallCount() int {
	fake.createRandomTCPRouteMutex.RLock()
	defer fake.createRandomTCPRouteMutex.RUnlock()
	return len(fake.createRandomTCPRouteArgsForCall)
}

func (fake *FakeRouteActor) CreateRandomTCPRouteCalls(stub func(models.DomainFields) (models.Route, error)) {
	fake.createRandomTCPRouteMutex.Lock()
	defer fake.createRandomTCPRouteMutex.Unlock()
	fake.CreateRandomTCPRouteStub = stub
}

func (fake *FakeRouteActor) CreateRandomTCPRouteArgsForCall(i int) models.DomainFields {
	fake.createRandomTCPRouteMutex.RLock()
	defer fake.createRandomTCPRouteMutex.RUnlock()
	argsForCall := fake.createRandomTCPRouteArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRouteActor) CreateRandomTCPRouteReturns(result1 models.Route, result2 error) {
	fake.createRandomTCPRouteMutex.Lock()
	defer fake.createRandomTCPRouteMutex.Unlock()
	fake.CreateRandomTCPRouteStub = nil
	fake.createRandomTCPRouteReturns = struct {
		result1 models.Route
		result2 error
	}{result1, result2}
}

func (fake *FakeRouteActor) CreateRandomTCPRouteReturnsOnCall(i int, result1 models.Route, result2 error) {
	fake.createRandomTCPRouteMutex.Lock()
	defer fake.createRandomTCPRouteMutex.Unlock()
	fake.CreateRandomTCPRouteStub = nil
	if fake.createRandomTCPRouteReturnsOnCall == nil {
		fake.createRandomTCPRouteReturnsOnCall = make(map[int]struct {
			result1 models.Route
			result2 error
		})
	}
	fake.createRandomTCPRouteReturnsOnCall[i] = struct {
		result1 models.Route
		result2 error
	}{result1, result2}
}

func (fake *FakeRouteActor) FindAndBindRoute(arg1 string, arg2 models.Application, arg3 models.AppParams) error {
	fake.findAndBindRouteMutex.Lock()
	ret, specificReturn := fake.findAndBindRouteReturnsOnCall[len(fake.findAndBindRouteArgsForCall)]
	fake.findAndBindRouteArgsForCall = append(fake.findAndBindRouteArgsForCall, struct {
		arg1 string
		arg2 models.Application
		arg3 models.AppParams
	}{arg1, arg2, arg3})
	fake.recordInvocation("FindAndBindRoute", []interface{}{arg1, arg2, arg3})
	fake.findAndBindRouteMutex.Unlock()
	if fake.FindAndBindRouteStub != nil {
		return fake.FindAndBindRouteStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.findAndBindRouteReturns
	return fakeReturns.result1
}

func (fake *FakeRouteActor) FindAndBindRouteCallCount() int {
	fake.findAndBindRouteMutex.RLock()
	defer fake.findAndBindRouteMutex.RUnlock()
	return len(fake.findAndBindRouteArgsForCall)
}

func (fake *FakeRouteActor) FindAndBindRouteCalls(stub func(string, models.Application, models.AppParams) error) {
	fake.findAndBindRouteMutex.Lock()
	defer fake.findAndBindRouteMutex.Unlock()
	fake.FindAndBindRouteStub = stub
}

func (fake *FakeRouteActor) FindAndBindRouteArgsForCall(i int) (string, models.Application, models.AppParams) {
	fake.findAndBindRouteMutex.RLock()
	defer fake.findAndBindRouteMutex.RUnlock()
	argsForCall := fake.findAndBindRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRouteActor) FindAndBindRouteReturns(result1 error) {
	fake.findAndBindRouteMutex.Lock()
	defer fake.findAndBindRouteMutex.Unlock()
	fake.FindAndBindRouteStub = nil
	fake.findAndBindRouteReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) FindAndBindRouteReturnsOnCall(i int, result1 error) {
	fake.findAndBindRouteMutex.Lock()
	defer fake.findAndBindRouteMutex.Unlock()
	fake.FindAndBindRouteStub = nil
	if fake.findAndBindRouteReturnsOnCall == nil {
		fake.findAndBindRouteReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.findAndBindRouteReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) FindDomain(arg1 string) (string, models.DomainFields, error) {
	fake.findDomainMutex.Lock()
	ret, specificReturn := fake.findDomainReturnsOnCall[len(fake.findDomainArgsForCall)]
	fake.findDomainArgsForCall = append(fake.findDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindDomain", []interface{}{arg1})
	fake.findDomainMutex.Unlock()
	if fake.FindDomainStub != nil {
		return fake.FindDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeRouteActor) FindDomainCallCount() int {
	fake.findDomainMutex.RLock()
	defer fake.findDomainMutex.RUnlock()
	return len(fake.findDomainArgsForCall)
}

func (fake *FakeRouteActor) FindDomainCalls(stub func(string) (string, models.DomainFields, error)) {
	fake.findDomainMutex.Lock()
	defer fake.findDomainMutex.Unlock()
	fake.FindDomainStub = stub
}

func (fake *FakeRouteActor) FindDomainArgsForCall(i int) string {
	fake.findDomainMutex.RLock()
	defer fake.findDomainMutex.RUnlock()
	argsForCall := fake.findDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRouteActor) FindDomainReturns(result1 string, result2 models.DomainFields, result3 error) {
	fake.findDomainMutex.Lock()
	defer fake.findDomainMutex.Unlock()
	fake.FindDomainStub = nil
	fake.findDomainReturns = struct {
		result1 string
		result2 models.DomainFields
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeRouteActor) FindDomainReturnsOnCall(i int, result1 string, result2 models.DomainFields, result3 error) {
	fake.findDomainMutex.Lock()
	defer fake.findDomainMutex.Unlock()
	fake.FindDomainStub = nil
	if fake.findDomainReturnsOnCall == nil {
		fake.findDomainReturnsOnCall = make(map[int]struct {
			result1 string
			result2 models.DomainFields
			result3 error
		})
	}
	fake.findDomainReturnsOnCall[i] = struct {
		result1 string
		result2 models.DomainFields
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeRouteActor) FindOrCreateRoute(arg1 string, arg2 models.DomainFields, arg3 string, arg4 int, arg5 bool) (models.Route, error) {
	fake.findOrCreateRouteMutex.Lock()
	ret, specificReturn := fake.findOrCreateRouteReturnsOnCall[len(fake.findOrCreateRouteArgsForCall)]
	fake.findOrCreateRouteArgsForCall = append(fake.findOrCreateRouteArgsForCall, struct {
		arg1 string
		arg2 models.DomainFields
		arg3 string
		arg4 int
		arg5 bool
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("FindOrCreateRoute", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.findOrCreateRouteMutex.Unlock()
	if fake.FindOrCreateRouteStub != nil {
		return fake.FindOrCreateRouteStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findOrCreateRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRouteActor) FindOrCreateRouteCallCount() int {
	fake.findOrCreateRouteMutex.RLock()
	defer fake.findOrCreateRouteMutex.RUnlock()
	return len(fake.findOrCreateRouteArgsForCall)
}

func (fake *FakeRouteActor) FindOrCreateRouteCalls(stub func(string, models.DomainFields, string, int, bool) (models.Route, error)) {
	fake.findOrCreateRouteMutex.Lock()
	defer fake.findOrCreateRouteMutex.Unlock()
	fake.FindOrCreateRouteStub = stub
}

func (fake *FakeRouteActor) FindOrCreateRouteArgsForCall(i int) (string, models.DomainFields, string, int, bool) {
	fake.findOrCreateRouteMutex.RLock()
	defer fake.findOrCreateRouteMutex.RUnlock()
	argsForCall := fake.findOrCreateRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeRouteActor) FindOrCreateRouteReturns(result1 models.Route, result2 error) {
	fake.findOrCreateRouteMutex.Lock()
	defer fake.findOrCreateRouteMutex.Unlock()
	fake.FindOrCreateRouteStub = nil
	fake.findOrCreateRouteReturns = struct {
		result1 models.Route
		result2 error
	}{result1, result2}
}

func (fake *FakeRouteActor) FindOrCreateRouteReturnsOnCall(i int, result1 models.Route, result2 error) {
	fake.findOrCreateRouteMutex.Lock()
	defer fake.findOrCreateRouteMutex.Unlock()
	fake.FindOrCreateRouteStub = nil
	if fake.findOrCreateRouteReturnsOnCall == nil {
		fake.findOrCreateRouteReturnsOnCall = make(map[int]struct {
			result1 models.Route
			result2 error
		})
	}
	fake.findOrCreateRouteReturnsOnCall[i] = struct {
		result1 models.Route
		result2 error
	}{result1, result2}
}

func (fake *FakeRouteActor) FindPath(arg1 string) (string, string) {
	fake.findPathMutex.Lock()
	ret, specificReturn := fake.findPathReturnsOnCall[len(fake.findPathArgsForCall)]
	fake.findPathArgsForCall = append(fake.findPathArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindPath", []interface{}{arg1})
	fake.findPathMutex.Unlock()
	if fake.FindPathStub != nil {
		return fake.FindPathStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.findPathReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRouteActor) FindPathCallCount() int {
	fake.findPathMutex.RLock()
	defer fake.findPathMutex.RUnlock()
	return len(fake.findPathArgsForCall)
}

func (fake *FakeRouteActor) FindPathCalls(stub func(string) (string, string)) {
	fake.findPathMutex.Lock()
	defer fake.findPathMutex.Unlock()
	fake.FindPathStub = stub
}

func (fake *FakeRouteActor) FindPathArgsForCall(i int) string {
	fake.findPathMutex.RLock()
	defer fake.findPathMutex.RUnlock()
	argsForCall := fake.findPathArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRouteActor) FindPathReturns(result1 string, result2 string) {
	fake.findPathMutex.Lock()
	defer fake.findPathMutex.Unlock()
	fake.FindPathStub = nil
	fake.findPathReturns = struct {
		result1 string
		result2 string
	}{result1, result2}
}

func (fake *FakeRouteActor) FindPathReturnsOnCall(i int, result1 string, result2 string) {
	fake.findPathMutex.Lock()
	defer fake.findPathMutex.Unlock()
	fake.FindPathStub = nil
	if fake.findPathReturnsOnCall == nil {
		fake.findPathReturnsOnCall = make(map[int]struct {
			result1 string
			result2 string
		})
	}
	fake.findPathReturnsOnCall[i] = struct {
		result1 string
		result2 string
	}{result1, result2}
}

func (fake *FakeRouteActor) FindPort(arg1 string) (string, int, error) {
	fake.findPortMutex.Lock()
	ret, specificReturn := fake.findPortReturnsOnCall[len(fake.findPortArgsForCall)]
	fake.findPortArgsForCall = append(fake.findPortArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("FindPort", []interface{}{arg1})
	fake.findPortMutex.Unlock()
	if fake.FindPortStub != nil {
		return fake.FindPortStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.findPortReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeRouteActor) FindPortCallCount() int {
	fake.findPortMutex.RLock()
	defer fake.findPortMutex.RUnlock()
	return len(fake.findPortArgsForCall)
}

func (fake *FakeRouteActor) FindPortCalls(stub func(string) (string, int, error)) {
	fake.findPortMutex.Lock()
	defer fake.findPortMutex.Unlock()
	fake.FindPortStub = stub
}

func (fake *FakeRouteActor) FindPortArgsForCall(i int) string {
	fake.findPortMutex.RLock()
	defer fake.findPortMutex.RUnlock()
	argsForCall := fake.findPortArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRouteActor) FindPortReturns(result1 string, result2 int, result3 error) {
	fake.findPortMutex.Lock()
	defer fake.findPortMutex.Unlock()
	fake.FindPortStub = nil
	fake.findPortReturns = struct {
		result1 string
		result2 int
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeRouteActor) FindPortReturnsOnCall(i int, result1 string, result2 int, result3 error) {
	fake.findPortMutex.Lock()
	defer fake.findPortMutex.Unlock()
	fake.FindPortStub = nil
	if fake.findPortReturnsOnCall == nil {
		fake.findPortReturnsOnCall = make(map[int]struct {
			result1 string
			result2 int
			result3 error
		})
	}
	fake.findPortReturnsOnCall[i] = struct {
		result1 string
		result2 int
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeRouteActor) UnbindAll(arg1 models.Application) error {
	fake.unbindAllMutex.Lock()
	ret, specificReturn := fake.unbindAllReturnsOnCall[len(fake.unbindAllArgsForCall)]
	fake.unbindAllArgsForCall = append(fake.unbindAllArgsForCall, struct {
		arg1 models.Application
	}{arg1})
	fake.recordInvocation("UnbindAll", []interface{}{arg1})
	fake.unbindAllMutex.Unlock()
	if fake.UnbindAllStub != nil {
		return fake.UnbindAllStub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.unbindAllReturns
	return fakeReturns.result1
}

func (fake *FakeRouteActor) UnbindAllCallCount() int {
	fake.unbindAllMutex.RLock()
	defer fake.unbindAllMutex.RUnlock()
	return len(fake.unbindAllArgsForCall)
}

func (fake *FakeRouteActor) UnbindAllCalls(stub func(models.Application) error) {
	fake.unbindAllMutex.Lock()
	defer fake.unbindAllMutex.Unlock()
	fake.UnbindAllStub = stub
}

func (fake *FakeRouteActor) UnbindAllArgsForCall(i int) models.Application {
	fake.unbindAllMutex.RLock()
	defer fake.unbindAllMutex.RUnlock()
	argsForCall := fake.unbindAllArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeRouteActor) UnbindAllReturns(result1 error) {
	fake.unbindAllMutex.Lock()
	defer fake.unbindAllMutex.Unlock()
	fake.UnbindAllStub = nil
	fake.unbindAllReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) UnbindAllReturnsOnCall(i int, result1 error) {
	fake.unbindAllMutex.Lock()
	defer fake.unbindAllMutex.Unlock()
	fake.UnbindAllStub = nil
	if fake.unbindAllReturnsOnCall == nil {
		fake.unbindAllReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.unbindAllReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRouteActor) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.bindRouteMutex.RLock()
	defer fake.bindRouteMutex.RUnlock()
	fake.createRandomTCPRouteMutex.RLock()
	defer fake.createRandomTCPRouteMutex.RUnlock()
	fake.findAndBindRouteMutex.RLock()
	defer fake.findAndBindRouteMutex.RUnlock()
	fake.findDomainMutex.RLock()
	defer fake.findDomainMutex.RUnlock()
	fake.findOrCreateRouteMutex.RLock()
	defer fake.findOrCreateRouteMutex.RUnlock()
	fake.findPathMutex.RLock()
	defer fake.findPathMutex.RUnlock()
	fake.findPortMutex.RLock()
	defer fake.findPortMutex.RUnlock()
	fake.unbindAllMutex.RLock()
	defer fake.unbindAllMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeRouteActor) 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 _ actors.RouteActor = new(FakeRouteActor)
