zz_generated_router_mock.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package fakes

import (
	context "context"
	sync "sync"

	v1a "github.com/rancher/rio/pkg/apis/rio.cattle.io/v1"
	v1 "github.com/rancher/rio/pkg/generated/controllers/rio.cattle.io/v1"
	generic "github.com/rancher/wrangler/pkg/generic"
	v1b "k8s.io/apimachinery/pkg/apis/meta/v1"
	labels "k8s.io/apimachinery/pkg/labels"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	cache "k8s.io/client-go/tools/cache"
)

var (
	lockRouterControllerMockAddGenericHandler       sync.RWMutex
	lockRouterControllerMockAddGenericRemoveHandler sync.RWMutex
	lockRouterControllerMockCache                   sync.RWMutex
	lockRouterControllerMockCreate                  sync.RWMutex
	lockRouterControllerMockDelete                  sync.RWMutex
	lockRouterControllerMockEnqueue                 sync.RWMutex
	lockRouterControllerMockGet                     sync.RWMutex
	lockRouterControllerMockGroupVersionKind        sync.RWMutex
	lockRouterControllerMockInformer                sync.RWMutex
	lockRouterControllerMockList                    sync.RWMutex
	lockRouterControllerMockOnChange                sync.RWMutex
	lockRouterControllerMockOnRemove                sync.RWMutex
	lockRouterControllerMockPatch                   sync.RWMutex
	lockRouterControllerMockUpdate                  sync.RWMutex
	lockRouterControllerMockUpdateStatus            sync.RWMutex
	lockRouterControllerMockUpdater                 sync.RWMutex
	lockRouterControllerMockWatch                   sync.RWMutex
)

// Ensure, that RouterControllerMock does implement RouterController.
// If this is not the case, regenerate this file with moq.
var _ v1.RouterController = &RouterControllerMock{}

// RouterControllerMock is a mock implementation of RouterController.
//
//     func TestSomethingThatUsesRouterController(t *testing.T) {
//
//         // make and configure a mocked RouterController
//         mockedRouterController := &RouterControllerMock{
//             AddGenericHandlerFunc: func(ctx context.Context, name string, handler generic.Handler)  {
// 	               panic("mock out the AddGenericHandler method")
//             },
//             AddGenericRemoveHandlerFunc: func(ctx context.Context, name string, handler generic.Handler)  {
// 	               panic("mock out the AddGenericRemoveHandler method")
//             },
//             CacheFunc: func() v1.RouterCache {
// 	               panic("mock out the Cache method")
//             },
//             CreateFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the Create method")
//             },
//             DeleteFunc: func(namespace string, name string, options *v1b.DeleteOptions) error {
// 	               panic("mock out the Delete method")
//             },
//             EnqueueFunc: func(namespace string, name string)  {
// 	               panic("mock out the Enqueue method")
//             },
//             GetFunc: func(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error) {
// 	               panic("mock out the Get method")
//             },
//             GroupVersionKindFunc: func() schema.GroupVersionKind {
// 	               panic("mock out the GroupVersionKind method")
//             },
//             InformerFunc: func() cache.SharedIndexInformer {
// 	               panic("mock out the Informer method")
//             },
//             ListFunc: func(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error) {
// 	               panic("mock out the List method")
//             },
//             OnChangeFunc: func(ctx context.Context, name string, sync v1.RouterHandler)  {
// 	               panic("mock out the OnChange method")
//             },
//             OnRemoveFunc: func(ctx context.Context, name string, sync v1.RouterHandler)  {
// 	               panic("mock out the OnRemove method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the Update method")
//             },
//             UpdateStatusFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the UpdateStatus method")
//             },
//             UpdaterFunc: func() generic.Updater {
// 	               panic("mock out the Updater method")
//             },
//             WatchFunc: func(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
// 	               panic("mock out the Watch method")
//             },
//         }
//
//         // use mockedRouterController in code that requires RouterController
//         // and then make assertions.
//
//     }
type RouterControllerMock struct {
	// AddGenericHandlerFunc mocks the AddGenericHandler method.
	AddGenericHandlerFunc func(ctx context.Context, name string, handler generic.Handler)

	// AddGenericRemoveHandlerFunc mocks the AddGenericRemoveHandler method.
	AddGenericRemoveHandlerFunc func(ctx context.Context, name string, handler generic.Handler)

	// CacheFunc mocks the Cache method.
	CacheFunc func() v1.RouterCache

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(namespace string, name string, options *v1b.DeleteOptions) error

	// EnqueueFunc mocks the Enqueue method.
	EnqueueFunc func(namespace string, name string)

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error)

	// GroupVersionKindFunc mocks the GroupVersionKind method.
	GroupVersionKindFunc func() schema.GroupVersionKind

	// InformerFunc mocks the Informer method.
	InformerFunc func() cache.SharedIndexInformer

	// ListFunc mocks the List method.
	ListFunc func(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error)

	// OnChangeFunc mocks the OnChange method.
	OnChangeFunc func(ctx context.Context, name string, sync v1.RouterHandler)

	// OnRemoveFunc mocks the OnRemove method.
	OnRemoveFunc func(ctx context.Context, name string, sync v1.RouterHandler)

	// PatchFunc mocks the Patch method.
	PatchFunc func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error)

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// UpdateStatusFunc mocks the UpdateStatus method.
	UpdateStatusFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// UpdaterFunc mocks the Updater method.
	UpdaterFunc func() generic.Updater

	// WatchFunc mocks the Watch method.
	WatchFunc func(namespace string, opts v1b.ListOptions) (watch.Interface, error)

	// calls tracks calls to the methods.
	calls struct {
		// AddGenericHandler holds details about calls to the AddGenericHandler method.
		AddGenericHandler []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Handler is the handler argument value.
			Handler generic.Handler
		}
		// AddGenericRemoveHandler holds details about calls to the AddGenericRemoveHandler method.
		AddGenericRemoveHandler []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Handler is the handler argument value.
			Handler generic.Handler
		}
		// Cache holds details about calls to the Cache method.
		Cache []struct {
		}
		// Create holds details about calls to the Create method.
		Create []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// Delete holds details about calls to the Delete method.
		Delete []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options *v1b.DeleteOptions
		}
		// Enqueue holds details about calls to the Enqueue method.
		Enqueue []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options v1b.GetOptions
		}
		// GroupVersionKind holds details about calls to the GroupVersionKind method.
		GroupVersionKind []struct {
		}
		// Informer holds details about calls to the Informer method.
		Informer []struct {
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
		// OnChange holds details about calls to the OnChange method.
		OnChange []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Sync is the sync argument value.
			Sync v1.RouterHandler
		}
		// OnRemove holds details about calls to the OnRemove method.
		OnRemove []struct {
			// Ctx is the ctx argument value.
			Ctx context.Context
			// Name is the name argument value.
			Name string
			// Sync is the sync argument value.
			Sync v1.RouterHandler
		}
		// Patch holds details about calls to the Patch method.
		Patch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Pt is the pt argument value.
			Pt types.PatchType
			// Data is the data argument value.
			Data []byte
			// Subresources is the subresources argument value.
			Subresources []string
		}
		// Update holds details about calls to the Update method.
		Update []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// UpdateStatus holds details about calls to the UpdateStatus method.
		UpdateStatus []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// Updater holds details about calls to the Updater method.
		Updater []struct {
		}
		// Watch holds details about calls to the Watch method.
		Watch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
	}
}

// AddGenericHandler calls AddGenericHandlerFunc.
func (mock *RouterControllerMock) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
	if mock.AddGenericHandlerFunc == nil {
		panic("RouterControllerMock.AddGenericHandlerFunc: method is nil but RouterController.AddGenericHandler was just called")
	}
	callInfo := struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}{
		Ctx:     ctx,
		Name:    name,
		Handler: handler,
	}
	lockRouterControllerMockAddGenericHandler.Lock()
	mock.calls.AddGenericHandler = append(mock.calls.AddGenericHandler, callInfo)
	lockRouterControllerMockAddGenericHandler.Unlock()
	mock.AddGenericHandlerFunc(ctx, name, handler)
}

// AddGenericHandlerCalls gets all the calls that were made to AddGenericHandler.
// Check the length with:
//     len(mockedRouterController.AddGenericHandlerCalls())
func (mock *RouterControllerMock) AddGenericHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler generic.Handler
} {
	var calls []struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}
	lockRouterControllerMockAddGenericHandler.RLock()
	calls = mock.calls.AddGenericHandler
	lockRouterControllerMockAddGenericHandler.RUnlock()
	return calls
}

// AddGenericRemoveHandler calls AddGenericRemoveHandlerFunc.
func (mock *RouterControllerMock) AddGenericRemoveHandler(ctx context.Context, name string, handler generic.Handler) {
	if mock.AddGenericRemoveHandlerFunc == nil {
		panic("RouterControllerMock.AddGenericRemoveHandlerFunc: method is nil but RouterController.AddGenericRemoveHandler was just called")
	}
	callInfo := struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}{
		Ctx:     ctx,
		Name:    name,
		Handler: handler,
	}
	lockRouterControllerMockAddGenericRemoveHandler.Lock()
	mock.calls.AddGenericRemoveHandler = append(mock.calls.AddGenericRemoveHandler, callInfo)
	lockRouterControllerMockAddGenericRemoveHandler.Unlock()
	mock.AddGenericRemoveHandlerFunc(ctx, name, handler)
}

// AddGenericRemoveHandlerCalls gets all the calls that were made to AddGenericRemoveHandler.
// Check the length with:
//     len(mockedRouterController.AddGenericRemoveHandlerCalls())
func (mock *RouterControllerMock) AddGenericRemoveHandlerCalls() []struct {
	Ctx     context.Context
	Name    string
	Handler generic.Handler
} {
	var calls []struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}
	lockRouterControllerMockAddGenericRemoveHandler.RLock()
	calls = mock.calls.AddGenericRemoveHandler
	lockRouterControllerMockAddGenericRemoveHandler.RUnlock()
	return calls
}

// Cache calls CacheFunc.
func (mock *RouterControllerMock) Cache() v1.RouterCache {
	if mock.CacheFunc == nil {
		panic("RouterControllerMock.CacheFunc: method is nil but RouterController.Cache was just called")
	}
	callInfo := struct {
	}{}
	lockRouterControllerMockCache.Lock()
	mock.calls.Cache = append(mock.calls.Cache, callInfo)
	lockRouterControllerMockCache.Unlock()
	return mock.CacheFunc()
}

// CacheCalls gets all the calls that were made to Cache.
// Check the length with:
//     len(mockedRouterController.CacheCalls())
func (mock *RouterControllerMock) CacheCalls() []struct {
} {
	var calls []struct {
	}
	lockRouterControllerMockCache.RLock()
	calls = mock.calls.Cache
	lockRouterControllerMockCache.RUnlock()
	return calls
}

// Create calls CreateFunc.
func (mock *RouterControllerMock) Create(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.CreateFunc == nil {
		panic("RouterControllerMock.CreateFunc: method is nil but RouterController.Create was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterControllerMockCreate.Lock()
	mock.calls.Create = append(mock.calls.Create, callInfo)
	lockRouterControllerMockCreate.Unlock()
	return mock.CreateFunc(in1)
}

// CreateCalls gets all the calls that were made to Create.
// Check the length with:
//     len(mockedRouterController.CreateCalls())
func (mock *RouterControllerMock) CreateCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterControllerMockCreate.RLock()
	calls = mock.calls.Create
	lockRouterControllerMockCreate.RUnlock()
	return calls
}

// Delete calls DeleteFunc.
func (mock *RouterControllerMock) Delete(namespace string, name string, options *v1b.DeleteOptions) error {
	if mock.DeleteFunc == nil {
		panic("RouterControllerMock.DeleteFunc: method is nil but RouterController.Delete was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockRouterControllerMockDelete.Lock()
	mock.calls.Delete = append(mock.calls.Delete, callInfo)
	lockRouterControllerMockDelete.Unlock()
	return mock.DeleteFunc(namespace, name, options)
}

// DeleteCalls gets all the calls that were made to Delete.
// Check the length with:
//     len(mockedRouterController.DeleteCalls())
func (mock *RouterControllerMock) DeleteCalls() []struct {
	Namespace string
	Name      string
	Options   *v1b.DeleteOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}
	lockRouterControllerMockDelete.RLock()
	calls = mock.calls.Delete
	lockRouterControllerMockDelete.RUnlock()
	return calls
}

// Enqueue calls EnqueueFunc.
func (mock *RouterControllerMock) Enqueue(namespace string, name string) {
	if mock.EnqueueFunc == nil {
		panic("RouterControllerMock.EnqueueFunc: method is nil but RouterController.Enqueue was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
	}{
		Namespace: namespace,
		Name:      name,
	}
	lockRouterControllerMockEnqueue.Lock()
	mock.calls.Enqueue = append(mock.calls.Enqueue, callInfo)
	lockRouterControllerMockEnqueue.Unlock()
	mock.EnqueueFunc(namespace, name)
}

// EnqueueCalls gets all the calls that were made to Enqueue.
// Check the length with:
//     len(mockedRouterController.EnqueueCalls())
func (mock *RouterControllerMock) EnqueueCalls() []struct {
	Namespace string
	Name      string
} {
	var calls []struct {
		Namespace string
		Name      string
	}
	lockRouterControllerMockEnqueue.RLock()
	calls = mock.calls.Enqueue
	lockRouterControllerMockEnqueue.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *RouterControllerMock) Get(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error) {
	if mock.GetFunc == nil {
		panic("RouterControllerMock.GetFunc: method is nil but RouterController.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockRouterControllerMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockRouterControllerMockGet.Unlock()
	return mock.GetFunc(namespace, name, options)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedRouterController.GetCalls())
func (mock *RouterControllerMock) GetCalls() []struct {
	Namespace string
	Name      string
	Options   v1b.GetOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}
	lockRouterControllerMockGet.RLock()
	calls = mock.calls.Get
	lockRouterControllerMockGet.RUnlock()
	return calls
}

// GroupVersionKind calls GroupVersionKindFunc.
func (mock *RouterControllerMock) GroupVersionKind() schema.GroupVersionKind {
	if mock.GroupVersionKindFunc == nil {
		panic("RouterControllerMock.GroupVersionKindFunc: method is nil but RouterController.GroupVersionKind was just called")
	}
	callInfo := struct {
	}{}
	lockRouterControllerMockGroupVersionKind.Lock()
	mock.calls.GroupVersionKind = append(mock.calls.GroupVersionKind, callInfo)
	lockRouterControllerMockGroupVersionKind.Unlock()
	return mock.GroupVersionKindFunc()
}

// GroupVersionKindCalls gets all the calls that were made to GroupVersionKind.
// Check the length with:
//     len(mockedRouterController.GroupVersionKindCalls())
func (mock *RouterControllerMock) GroupVersionKindCalls() []struct {
} {
	var calls []struct {
	}
	lockRouterControllerMockGroupVersionKind.RLock()
	calls = mock.calls.GroupVersionKind
	lockRouterControllerMockGroupVersionKind.RUnlock()
	return calls
}

// Informer calls InformerFunc.
func (mock *RouterControllerMock) Informer() cache.SharedIndexInformer {
	if mock.InformerFunc == nil {
		panic("RouterControllerMock.InformerFunc: method is nil but RouterController.Informer was just called")
	}
	callInfo := struct {
	}{}
	lockRouterControllerMockInformer.Lock()
	mock.calls.Informer = append(mock.calls.Informer, callInfo)
	lockRouterControllerMockInformer.Unlock()
	return mock.InformerFunc()
}

// InformerCalls gets all the calls that were made to Informer.
// Check the length with:
//     len(mockedRouterController.InformerCalls())
func (mock *RouterControllerMock) InformerCalls() []struct {
} {
	var calls []struct {
	}
	lockRouterControllerMockInformer.RLock()
	calls = mock.calls.Informer
	lockRouterControllerMockInformer.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *RouterControllerMock) List(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error) {
	if mock.ListFunc == nil {
		panic("RouterControllerMock.ListFunc: method is nil but RouterController.List was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockRouterControllerMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockRouterControllerMockList.Unlock()
	return mock.ListFunc(namespace, opts)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedRouterController.ListCalls())
func (mock *RouterControllerMock) ListCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockRouterControllerMockList.RLock()
	calls = mock.calls.List
	lockRouterControllerMockList.RUnlock()
	return calls
}

// OnChange calls OnChangeFunc.
func (mock *RouterControllerMock) OnChange(ctx context.Context, name string, sync v1.RouterHandler) {
	if mock.OnChangeFunc == nil {
		panic("RouterControllerMock.OnChangeFunc: method is nil but RouterController.OnChange was just called")
	}
	callInfo := struct {
		Ctx  context.Context
		Name string
		Sync v1.RouterHandler
	}{
		Ctx:  ctx,
		Name: name,
		Sync: sync,
	}
	lockRouterControllerMockOnChange.Lock()
	mock.calls.OnChange = append(mock.calls.OnChange, callInfo)
	lockRouterControllerMockOnChange.Unlock()
	mock.OnChangeFunc(ctx, name, sync)
}

// OnChangeCalls gets all the calls that were made to OnChange.
// Check the length with:
//     len(mockedRouterController.OnChangeCalls())
func (mock *RouterControllerMock) OnChangeCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1.RouterHandler
} {
	var calls []struct {
		Ctx  context.Context
		Name string
		Sync v1.RouterHandler
	}
	lockRouterControllerMockOnChange.RLock()
	calls = mock.calls.OnChange
	lockRouterControllerMockOnChange.RUnlock()
	return calls
}

// OnRemove calls OnRemoveFunc.
func (mock *RouterControllerMock) OnRemove(ctx context.Context, name string, sync v1.RouterHandler) {
	if mock.OnRemoveFunc == nil {
		panic("RouterControllerMock.OnRemoveFunc: method is nil but RouterController.OnRemove was just called")
	}
	callInfo := struct {
		Ctx  context.Context
		Name string
		Sync v1.RouterHandler
	}{
		Ctx:  ctx,
		Name: name,
		Sync: sync,
	}
	lockRouterControllerMockOnRemove.Lock()
	mock.calls.OnRemove = append(mock.calls.OnRemove, callInfo)
	lockRouterControllerMockOnRemove.Unlock()
	mock.OnRemoveFunc(ctx, name, sync)
}

// OnRemoveCalls gets all the calls that were made to OnRemove.
// Check the length with:
//     len(mockedRouterController.OnRemoveCalls())
func (mock *RouterControllerMock) OnRemoveCalls() []struct {
	Ctx  context.Context
	Name string
	Sync v1.RouterHandler
} {
	var calls []struct {
		Ctx  context.Context
		Name string
		Sync v1.RouterHandler
	}
	lockRouterControllerMockOnRemove.RLock()
	calls = mock.calls.OnRemove
	lockRouterControllerMockOnRemove.RUnlock()
	return calls
}

// Patch calls PatchFunc.
func (mock *RouterControllerMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error) {
	if mock.PatchFunc == nil {
		panic("RouterControllerMock.PatchFunc: method is nil but RouterController.Patch was just called")
	}
	callInfo := struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}{
		Namespace:    namespace,
		Name:         name,
		Pt:           pt,
		Data:         data,
		Subresources: subresources,
	}
	lockRouterControllerMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockRouterControllerMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedRouterController.PatchCalls())
func (mock *RouterControllerMock) PatchCalls() []struct {
	Namespace    string
	Name         string
	Pt           types.PatchType
	Data         []byte
	Subresources []string
} {
	var calls []struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}
	lockRouterControllerMockPatch.RLock()
	calls = mock.calls.Patch
	lockRouterControllerMockPatch.RUnlock()
	return calls
}

// Update calls UpdateFunc.
func (mock *RouterControllerMock) Update(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.UpdateFunc == nil {
		panic("RouterControllerMock.UpdateFunc: method is nil but RouterController.Update was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterControllerMockUpdate.Lock()
	mock.calls.Update = append(mock.calls.Update, callInfo)
	lockRouterControllerMockUpdate.Unlock()
	return mock.UpdateFunc(in1)
}

// UpdateCalls gets all the calls that were made to Update.
// Check the length with:
//     len(mockedRouterController.UpdateCalls())
func (mock *RouterControllerMock) UpdateCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterControllerMockUpdate.RLock()
	calls = mock.calls.Update
	lockRouterControllerMockUpdate.RUnlock()
	return calls
}

// UpdateStatus calls UpdateStatusFunc.
func (mock *RouterControllerMock) UpdateStatus(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.UpdateStatusFunc == nil {
		panic("RouterControllerMock.UpdateStatusFunc: method is nil but RouterController.UpdateStatus was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterControllerMockUpdateStatus.Lock()
	mock.calls.UpdateStatus = append(mock.calls.UpdateStatus, callInfo)
	lockRouterControllerMockUpdateStatus.Unlock()
	return mock.UpdateStatusFunc(in1)
}

// UpdateStatusCalls gets all the calls that were made to UpdateStatus.
// Check the length with:
//     len(mockedRouterController.UpdateStatusCalls())
func (mock *RouterControllerMock) UpdateStatusCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterControllerMockUpdateStatus.RLock()
	calls = mock.calls.UpdateStatus
	lockRouterControllerMockUpdateStatus.RUnlock()
	return calls
}

// Updater calls UpdaterFunc.
func (mock *RouterControllerMock) Updater() generic.Updater {
	if mock.UpdaterFunc == nil {
		panic("RouterControllerMock.UpdaterFunc: method is nil but RouterController.Updater was just called")
	}
	callInfo := struct {
	}{}
	lockRouterControllerMockUpdater.Lock()
	mock.calls.Updater = append(mock.calls.Updater, callInfo)
	lockRouterControllerMockUpdater.Unlock()
	return mock.UpdaterFunc()
}

// UpdaterCalls gets all the calls that were made to Updater.
// Check the length with:
//     len(mockedRouterController.UpdaterCalls())
func (mock *RouterControllerMock) UpdaterCalls() []struct {
} {
	var calls []struct {
	}
	lockRouterControllerMockUpdater.RLock()
	calls = mock.calls.Updater
	lockRouterControllerMockUpdater.RUnlock()
	return calls
}

// Watch calls WatchFunc.
func (mock *RouterControllerMock) Watch(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
	if mock.WatchFunc == nil {
		panic("RouterControllerMock.WatchFunc: method is nil but RouterController.Watch was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockRouterControllerMockWatch.Lock()
	mock.calls.Watch = append(mock.calls.Watch, callInfo)
	lockRouterControllerMockWatch.Unlock()
	return mock.WatchFunc(namespace, opts)
}

// WatchCalls gets all the calls that were made to Watch.
// Check the length with:
//     len(mockedRouterController.WatchCalls())
func (mock *RouterControllerMock) WatchCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockRouterControllerMockWatch.RLock()
	calls = mock.calls.Watch
	lockRouterControllerMockWatch.RUnlock()
	return calls
}

var (
	lockRouterClientMockCreate       sync.RWMutex
	lockRouterClientMockDelete       sync.RWMutex
	lockRouterClientMockGet          sync.RWMutex
	lockRouterClientMockList         sync.RWMutex
	lockRouterClientMockPatch        sync.RWMutex
	lockRouterClientMockUpdate       sync.RWMutex
	lockRouterClientMockUpdateStatus sync.RWMutex
	lockRouterClientMockWatch        sync.RWMutex
)

// Ensure, that RouterClientMock does implement RouterClient.
// If this is not the case, regenerate this file with moq.
var _ v1.RouterClient = &RouterClientMock{}

// RouterClientMock is a mock implementation of RouterClient.
//
//     func TestSomethingThatUsesRouterClient(t *testing.T) {
//
//         // make and configure a mocked RouterClient
//         mockedRouterClient := &RouterClientMock{
//             CreateFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the Create method")
//             },
//             DeleteFunc: func(namespace string, name string, options *v1b.DeleteOptions) error {
// 	               panic("mock out the Delete method")
//             },
//             GetFunc: func(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error) {
// 	               panic("mock out the Get method")
//             },
//             ListFunc: func(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error) {
// 	               panic("mock out the List method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the Update method")
//             },
//             UpdateStatusFunc: func(in1 *v1a.Router) (*v1a.Router, error) {
// 	               panic("mock out the UpdateStatus method")
//             },
//             WatchFunc: func(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
// 	               panic("mock out the Watch method")
//             },
//         }
//
//         // use mockedRouterClient in code that requires RouterClient
//         // and then make assertions.
//
//     }
type RouterClientMock struct {
	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// DeleteFunc mocks the Delete method.
	DeleteFunc func(namespace string, name string, options *v1b.DeleteOptions) error

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error)

	// PatchFunc mocks the Patch method.
	PatchFunc func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error)

	// UpdateFunc mocks the Update method.
	UpdateFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// UpdateStatusFunc mocks the UpdateStatus method.
	UpdateStatusFunc func(in1 *v1a.Router) (*v1a.Router, error)

	// WatchFunc mocks the Watch method.
	WatchFunc func(namespace string, opts v1b.ListOptions) (watch.Interface, error)

	// calls tracks calls to the methods.
	calls struct {
		// Create holds details about calls to the Create method.
		Create []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// Delete holds details about calls to the Delete method.
		Delete []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options *v1b.DeleteOptions
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Options is the options argument value.
			Options v1b.GetOptions
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
		// Patch holds details about calls to the Patch method.
		Patch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
			// Pt is the pt argument value.
			Pt types.PatchType
			// Data is the data argument value.
			Data []byte
			// Subresources is the subresources argument value.
			Subresources []string
		}
		// Update holds details about calls to the Update method.
		Update []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// UpdateStatus holds details about calls to the UpdateStatus method.
		UpdateStatus []struct {
			// In1 is the in1 argument value.
			In1 *v1a.Router
		}
		// Watch holds details about calls to the Watch method.
		Watch []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Opts is the opts argument value.
			Opts v1b.ListOptions
		}
	}
}

// Create calls CreateFunc.
func (mock *RouterClientMock) Create(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.CreateFunc == nil {
		panic("RouterClientMock.CreateFunc: method is nil but RouterClient.Create was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterClientMockCreate.Lock()
	mock.calls.Create = append(mock.calls.Create, callInfo)
	lockRouterClientMockCreate.Unlock()
	return mock.CreateFunc(in1)
}

// CreateCalls gets all the calls that were made to Create.
// Check the length with:
//     len(mockedRouterClient.CreateCalls())
func (mock *RouterClientMock) CreateCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterClientMockCreate.RLock()
	calls = mock.calls.Create
	lockRouterClientMockCreate.RUnlock()
	return calls
}

// Delete calls DeleteFunc.
func (mock *RouterClientMock) Delete(namespace string, name string, options *v1b.DeleteOptions) error {
	if mock.DeleteFunc == nil {
		panic("RouterClientMock.DeleteFunc: method is nil but RouterClient.Delete was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockRouterClientMockDelete.Lock()
	mock.calls.Delete = append(mock.calls.Delete, callInfo)
	lockRouterClientMockDelete.Unlock()
	return mock.DeleteFunc(namespace, name, options)
}

// DeleteCalls gets all the calls that were made to Delete.
// Check the length with:
//     len(mockedRouterClient.DeleteCalls())
func (mock *RouterClientMock) DeleteCalls() []struct {
	Namespace string
	Name      string
	Options   *v1b.DeleteOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   *v1b.DeleteOptions
	}
	lockRouterClientMockDelete.RLock()
	calls = mock.calls.Delete
	lockRouterClientMockDelete.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *RouterClientMock) Get(namespace string, name string, options v1b.GetOptions) (*v1a.Router, error) {
	if mock.GetFunc == nil {
		panic("RouterClientMock.GetFunc: method is nil but RouterClient.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}{
		Namespace: namespace,
		Name:      name,
		Options:   options,
	}
	lockRouterClientMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockRouterClientMockGet.Unlock()
	return mock.GetFunc(namespace, name, options)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedRouterClient.GetCalls())
func (mock *RouterClientMock) GetCalls() []struct {
	Namespace string
	Name      string
	Options   v1b.GetOptions
} {
	var calls []struct {
		Namespace string
		Name      string
		Options   v1b.GetOptions
	}
	lockRouterClientMockGet.RLock()
	calls = mock.calls.Get
	lockRouterClientMockGet.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *RouterClientMock) List(namespace string, opts v1b.ListOptions) (*v1a.RouterList, error) {
	if mock.ListFunc == nil {
		panic("RouterClientMock.ListFunc: method is nil but RouterClient.List was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockRouterClientMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockRouterClientMockList.Unlock()
	return mock.ListFunc(namespace, opts)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedRouterClient.ListCalls())
func (mock *RouterClientMock) ListCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockRouterClientMockList.RLock()
	calls = mock.calls.List
	lockRouterClientMockList.RUnlock()
	return calls
}

// Patch calls PatchFunc.
func (mock *RouterClientMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.Router, error) {
	if mock.PatchFunc == nil {
		panic("RouterClientMock.PatchFunc: method is nil but RouterClient.Patch was just called")
	}
	callInfo := struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}{
		Namespace:    namespace,
		Name:         name,
		Pt:           pt,
		Data:         data,
		Subresources: subresources,
	}
	lockRouterClientMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockRouterClientMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedRouterClient.PatchCalls())
func (mock *RouterClientMock) PatchCalls() []struct {
	Namespace    string
	Name         string
	Pt           types.PatchType
	Data         []byte
	Subresources []string
} {
	var calls []struct {
		Namespace    string
		Name         string
		Pt           types.PatchType
		Data         []byte
		Subresources []string
	}
	lockRouterClientMockPatch.RLock()
	calls = mock.calls.Patch
	lockRouterClientMockPatch.RUnlock()
	return calls
}

// Update calls UpdateFunc.
func (mock *RouterClientMock) Update(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.UpdateFunc == nil {
		panic("RouterClientMock.UpdateFunc: method is nil but RouterClient.Update was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterClientMockUpdate.Lock()
	mock.calls.Update = append(mock.calls.Update, callInfo)
	lockRouterClientMockUpdate.Unlock()
	return mock.UpdateFunc(in1)
}

// UpdateCalls gets all the calls that were made to Update.
// Check the length with:
//     len(mockedRouterClient.UpdateCalls())
func (mock *RouterClientMock) UpdateCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterClientMockUpdate.RLock()
	calls = mock.calls.Update
	lockRouterClientMockUpdate.RUnlock()
	return calls
}

// UpdateStatus calls UpdateStatusFunc.
func (mock *RouterClientMock) UpdateStatus(in1 *v1a.Router) (*v1a.Router, error) {
	if mock.UpdateStatusFunc == nil {
		panic("RouterClientMock.UpdateStatusFunc: method is nil but RouterClient.UpdateStatus was just called")
	}
	callInfo := struct {
		In1 *v1a.Router
	}{
		In1: in1,
	}
	lockRouterClientMockUpdateStatus.Lock()
	mock.calls.UpdateStatus = append(mock.calls.UpdateStatus, callInfo)
	lockRouterClientMockUpdateStatus.Unlock()
	return mock.UpdateStatusFunc(in1)
}

// UpdateStatusCalls gets all the calls that were made to UpdateStatus.
// Check the length with:
//     len(mockedRouterClient.UpdateStatusCalls())
func (mock *RouterClientMock) UpdateStatusCalls() []struct {
	In1 *v1a.Router
} {
	var calls []struct {
		In1 *v1a.Router
	}
	lockRouterClientMockUpdateStatus.RLock()
	calls = mock.calls.UpdateStatus
	lockRouterClientMockUpdateStatus.RUnlock()
	return calls
}

// Watch calls WatchFunc.
func (mock *RouterClientMock) Watch(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
	if mock.WatchFunc == nil {
		panic("RouterClientMock.WatchFunc: method is nil but RouterClient.Watch was just called")
	}
	callInfo := struct {
		Namespace string
		Opts      v1b.ListOptions
	}{
		Namespace: namespace,
		Opts:      opts,
	}
	lockRouterClientMockWatch.Lock()
	mock.calls.Watch = append(mock.calls.Watch, callInfo)
	lockRouterClientMockWatch.Unlock()
	return mock.WatchFunc(namespace, opts)
}

// WatchCalls gets all the calls that were made to Watch.
// Check the length with:
//     len(mockedRouterClient.WatchCalls())
func (mock *RouterClientMock) WatchCalls() []struct {
	Namespace string
	Opts      v1b.ListOptions
} {
	var calls []struct {
		Namespace string
		Opts      v1b.ListOptions
	}
	lockRouterClientMockWatch.RLock()
	calls = mock.calls.Watch
	lockRouterClientMockWatch.RUnlock()
	return calls
}

var (
	lockRouterCacheMockAddIndexer sync.RWMutex
	lockRouterCacheMockGet        sync.RWMutex
	lockRouterCacheMockGetByIndex sync.RWMutex
	lockRouterCacheMockList       sync.RWMutex
)

// Ensure, that RouterCacheMock does implement RouterCache.
// If this is not the case, regenerate this file with moq.
var _ v1.RouterCache = &RouterCacheMock{}

// RouterCacheMock is a mock implementation of RouterCache.
//
//     func TestSomethingThatUsesRouterCache(t *testing.T) {
//
//         // make and configure a mocked RouterCache
//         mockedRouterCache := &RouterCacheMock{
//             AddIndexerFunc: func(indexName string, indexer v1.RouterIndexer)  {
// 	               panic("mock out the AddIndexer method")
//             },
//             GetFunc: func(namespace string, name string) (*v1a.Router, error) {
// 	               panic("mock out the Get method")
//             },
//             GetByIndexFunc: func(indexName string, key string) ([]*v1a.Router, error) {
// 	               panic("mock out the GetByIndex method")
//             },
//             ListFunc: func(namespace string, selector labels.Selector) ([]*v1a.Router, error) {
// 	               panic("mock out the List method")
//             },
//         }
//
//         // use mockedRouterCache in code that requires RouterCache
//         // and then make assertions.
//
//     }
type RouterCacheMock struct {
	// AddIndexerFunc mocks the AddIndexer method.
	AddIndexerFunc func(indexName string, indexer v1.RouterIndexer)

	// GetFunc mocks the Get method.
	GetFunc func(namespace string, name string) (*v1a.Router, error)

	// GetByIndexFunc mocks the GetByIndex method.
	GetByIndexFunc func(indexName string, key string) ([]*v1a.Router, error)

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1a.Router, error)

	// calls tracks calls to the methods.
	calls struct {
		// AddIndexer holds details about calls to the AddIndexer method.
		AddIndexer []struct {
			// IndexName is the indexName argument value.
			IndexName string
			// Indexer is the indexer argument value.
			Indexer v1.RouterIndexer
		}
		// Get holds details about calls to the Get method.
		Get []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Name is the name argument value.
			Name string
		}
		// GetByIndex holds details about calls to the GetByIndex method.
		GetByIndex []struct {
			// IndexName is the indexName argument value.
			IndexName string
			// Key is the key argument value.
			Key string
		}
		// List holds details about calls to the List method.
		List []struct {
			// Namespace is the namespace argument value.
			Namespace string
			// Selector is the selector argument value.
			Selector labels.Selector
		}
	}
}

// AddIndexer calls AddIndexerFunc.
func (mock *RouterCacheMock) AddIndexer(indexName string, indexer v1.RouterIndexer) {
	if mock.AddIndexerFunc == nil {
		panic("RouterCacheMock.AddIndexerFunc: method is nil but RouterCache.AddIndexer was just called")
	}
	callInfo := struct {
		IndexName string
		Indexer   v1.RouterIndexer
	}{
		IndexName: indexName,
		Indexer:   indexer,
	}
	lockRouterCacheMockAddIndexer.Lock()
	mock.calls.AddIndexer = append(mock.calls.AddIndexer, callInfo)
	lockRouterCacheMockAddIndexer.Unlock()
	mock.AddIndexerFunc(indexName, indexer)
}

// AddIndexerCalls gets all the calls that were made to AddIndexer.
// Check the length with:
//     len(mockedRouterCache.AddIndexerCalls())
func (mock *RouterCacheMock) AddIndexerCalls() []struct {
	IndexName string
	Indexer   v1.RouterIndexer
} {
	var calls []struct {
		IndexName string
		Indexer   v1.RouterIndexer
	}
	lockRouterCacheMockAddIndexer.RLock()
	calls = mock.calls.AddIndexer
	lockRouterCacheMockAddIndexer.RUnlock()
	return calls
}

// Get calls GetFunc.
func (mock *RouterCacheMock) Get(namespace string, name string) (*v1a.Router, error) {
	if mock.GetFunc == nil {
		panic("RouterCacheMock.GetFunc: method is nil but RouterCache.Get was just called")
	}
	callInfo := struct {
		Namespace string
		Name      string
	}{
		Namespace: namespace,
		Name:      name,
	}
	lockRouterCacheMockGet.Lock()
	mock.calls.Get = append(mock.calls.Get, callInfo)
	lockRouterCacheMockGet.Unlock()
	return mock.GetFunc(namespace, name)
}

// GetCalls gets all the calls that were made to Get.
// Check the length with:
//     len(mockedRouterCache.GetCalls())
func (mock *RouterCacheMock) GetCalls() []struct {
	Namespace string
	Name      string
} {
	var calls []struct {
		Namespace string
		Name      string
	}
	lockRouterCacheMockGet.RLock()
	calls = mock.calls.Get
	lockRouterCacheMockGet.RUnlock()
	return calls
}

// GetByIndex calls GetByIndexFunc.
func (mock *RouterCacheMock) GetByIndex(indexName string, key string) ([]*v1a.Router, error) {
	if mock.GetByIndexFunc == nil {
		panic("RouterCacheMock.GetByIndexFunc: method is nil but RouterCache.GetByIndex was just called")
	}
	callInfo := struct {
		IndexName string
		Key       string
	}{
		IndexName: indexName,
		Key:       key,
	}
	lockRouterCacheMockGetByIndex.Lock()
	mock.calls.GetByIndex = append(mock.calls.GetByIndex, callInfo)
	lockRouterCacheMockGetByIndex.Unlock()
	return mock.GetByIndexFunc(indexName, key)
}

// GetByIndexCalls gets all the calls that were made to GetByIndex.
// Check the length with:
//     len(mockedRouterCache.GetByIndexCalls())
func (mock *RouterCacheMock) GetByIndexCalls() []struct {
	IndexName string
	Key       string
} {
	var calls []struct {
		IndexName string
		Key       string
	}
	lockRouterCacheMockGetByIndex.RLock()
	calls = mock.calls.GetByIndex
	lockRouterCacheMockGetByIndex.RUnlock()
	return calls
}

// List calls ListFunc.
func (mock *RouterCacheMock) List(namespace string, selector labels.Selector) ([]*v1a.Router, error) {
	if mock.ListFunc == nil {
		panic("RouterCacheMock.ListFunc: method is nil but RouterCache.List was just called")
	}
	callInfo := struct {
		Namespace string
		Selector  labels.Selector
	}{
		Namespace: namespace,
		Selector:  selector,
	}
	lockRouterCacheMockList.Lock()
	mock.calls.List = append(mock.calls.List, callInfo)
	lockRouterCacheMockList.Unlock()
	return mock.ListFunc(namespace, selector)
}

// ListCalls gets all the calls that were made to List.
// Check the length with:
//     len(mockedRouterCache.ListCalls())
func (mock *RouterCacheMock) ListCalls() []struct {
	Namespace string
	Selector  labels.Selector
} {
	var calls []struct {
		Namespace string
		Selector  labels.Selector
	}
	lockRouterCacheMockList.RLock()
	calls = mock.calls.List
	lockRouterCacheMockList.RUnlock()
	return calls
}