zz_generated_public_domain_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/admin.rio.cattle.io/v1"
	v1 "github.com/rancher/rio/pkg/generated/controllers/admin.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 (
	lockPublicDomainControllerMockAddGenericHandler       sync.RWMutex
	lockPublicDomainControllerMockAddGenericRemoveHandler sync.RWMutex
	lockPublicDomainControllerMockCache                   sync.RWMutex
	lockPublicDomainControllerMockCreate                  sync.RWMutex
	lockPublicDomainControllerMockDelete                  sync.RWMutex
	lockPublicDomainControllerMockEnqueue                 sync.RWMutex
	lockPublicDomainControllerMockGet                     sync.RWMutex
	lockPublicDomainControllerMockGroupVersionKind        sync.RWMutex
	lockPublicDomainControllerMockInformer                sync.RWMutex
	lockPublicDomainControllerMockList                    sync.RWMutex
	lockPublicDomainControllerMockOnChange                sync.RWMutex
	lockPublicDomainControllerMockOnRemove                sync.RWMutex
	lockPublicDomainControllerMockPatch                   sync.RWMutex
	lockPublicDomainControllerMockUpdate                  sync.RWMutex
	lockPublicDomainControllerMockUpdateStatus            sync.RWMutex
	lockPublicDomainControllerMockUpdater                 sync.RWMutex
	lockPublicDomainControllerMockWatch                   sync.RWMutex
)

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

// PublicDomainControllerMock is a mock implementation of PublicDomainController.
//
//     func TestSomethingThatUsesPublicDomainController(t *testing.T) {
//
//         // make and configure a mocked PublicDomainController
//         mockedPublicDomainController := &PublicDomainControllerMock{
//             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.PublicDomainCache {
// 	               panic("mock out the Cache method")
//             },
//             CreateFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain, 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.PublicDomainList, error) {
// 	               panic("mock out the List method")
//             },
//             OnChangeFunc: func(ctx context.Context, name string, sync v1.PublicDomainHandler)  {
// 	               panic("mock out the OnChange method")
//             },
//             OnRemoveFunc: func(ctx context.Context, name string, sync v1.PublicDomainHandler)  {
// 	               panic("mock out the OnRemove method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.PublicDomain, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, error) {
// 	               panic("mock out the Update method")
//             },
//             UpdateStatusFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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 mockedPublicDomainController in code that requires PublicDomainController
//         // and then make assertions.
//
//     }
type PublicDomainControllerMock 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.PublicDomainCache

	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain, 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.PublicDomainList, error)

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

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

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

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

	// UpdateStatusFunc mocks the UpdateStatus method.
	UpdateStatusFunc func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain
		}
		// 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.PublicDomainHandler
		}
		// 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.PublicDomainHandler
		}
		// 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.PublicDomain
		}
		// UpdateStatus holds details about calls to the UpdateStatus method.
		UpdateStatus []struct {
			// In1 is the in1 argument value.
			In1 *v1a.PublicDomain
		}
		// 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 *PublicDomainControllerMock) AddGenericHandler(ctx context.Context, name string, handler generic.Handler) {
	if mock.AddGenericHandlerFunc == nil {
		panic("PublicDomainControllerMock.AddGenericHandlerFunc: method is nil but PublicDomainController.AddGenericHandler was just called")
	}
	callInfo := struct {
		Ctx     context.Context
		Name    string
		Handler generic.Handler
	}{
		Ctx:     ctx,
		Name:    name,
		Handler: handler,
	}
	lockPublicDomainControllerMockAddGenericHandler.Lock()
	mock.calls.AddGenericHandler = append(mock.calls.AddGenericHandler, callInfo)
	lockPublicDomainControllerMockAddGenericHandler.Unlock()
	mock.AddGenericHandlerFunc(ctx, name, handler)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Patch calls PatchFunc.
func (mock *PublicDomainControllerMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.PublicDomain, error) {
	if mock.PatchFunc == nil {
		panic("PublicDomainControllerMock.PatchFunc: method is nil but PublicDomainController.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,
	}
	lockPublicDomainControllerMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockPublicDomainControllerMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedPublicDomainController.PatchCalls())
func (mock *PublicDomainControllerMock) 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
	}
	lockPublicDomainControllerMockPatch.RLock()
	calls = mock.calls.Patch
	lockPublicDomainControllerMockPatch.RUnlock()
	return calls
}

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

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

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

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

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

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

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

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

var (
	lockPublicDomainClientMockCreate       sync.RWMutex
	lockPublicDomainClientMockDelete       sync.RWMutex
	lockPublicDomainClientMockGet          sync.RWMutex
	lockPublicDomainClientMockList         sync.RWMutex
	lockPublicDomainClientMockPatch        sync.RWMutex
	lockPublicDomainClientMockUpdate       sync.RWMutex
	lockPublicDomainClientMockUpdateStatus sync.RWMutex
	lockPublicDomainClientMockWatch        sync.RWMutex
)

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

// PublicDomainClientMock is a mock implementation of PublicDomainClient.
//
//     func TestSomethingThatUsesPublicDomainClient(t *testing.T) {
//
//         // make and configure a mocked PublicDomainClient
//         mockedPublicDomainClient := &PublicDomainClientMock{
//             CreateFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain, error) {
// 	               panic("mock out the Get method")
//             },
//             ListFunc: func(namespace string, opts v1b.ListOptions) (*v1a.PublicDomainList, error) {
// 	               panic("mock out the List method")
//             },
//             PatchFunc: func(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.PublicDomain, error) {
// 	               panic("mock out the Patch method")
//             },
//             UpdateFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, error) {
// 	               panic("mock out the Update method")
//             },
//             UpdateStatusFunc: func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, error) {
// 	               panic("mock out the UpdateStatus method")
//             },
//             WatchFunc: func(namespace string, opts v1b.ListOptions) (watch.Interface, error) {
// 	               panic("mock out the Watch method")
//             },
//         }
//
//         // use mockedPublicDomainClient in code that requires PublicDomainClient
//         // and then make assertions.
//
//     }
type PublicDomainClientMock struct {
	// CreateFunc mocks the Create method.
	CreateFunc func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain, error)

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

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

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

	// UpdateStatusFunc mocks the UpdateStatus method.
	UpdateStatusFunc func(in1 *v1a.PublicDomain) (*v1a.PublicDomain, 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.PublicDomain
		}
		// 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.PublicDomain
		}
		// UpdateStatus holds details about calls to the UpdateStatus method.
		UpdateStatus []struct {
			// In1 is the in1 argument value.
			In1 *v1a.PublicDomain
		}
		// 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 *PublicDomainClientMock) Create(in1 *v1a.PublicDomain) (*v1a.PublicDomain, error) {
	if mock.CreateFunc == nil {
		panic("PublicDomainClientMock.CreateFunc: method is nil but PublicDomainClient.Create was just called")
	}
	callInfo := struct {
		In1 *v1a.PublicDomain
	}{
		In1: in1,
	}
	lockPublicDomainClientMockCreate.Lock()
	mock.calls.Create = append(mock.calls.Create, callInfo)
	lockPublicDomainClientMockCreate.Unlock()
	return mock.CreateFunc(in1)
}

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

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

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

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

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

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

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

// Patch calls PatchFunc.
func (mock *PublicDomainClientMock) Patch(namespace string, name string, pt types.PatchType, data []byte, subresources ...string) (*v1a.PublicDomain, error) {
	if mock.PatchFunc == nil {
		panic("PublicDomainClientMock.PatchFunc: method is nil but PublicDomainClient.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,
	}
	lockPublicDomainClientMockPatch.Lock()
	mock.calls.Patch = append(mock.calls.Patch, callInfo)
	lockPublicDomainClientMockPatch.Unlock()
	return mock.PatchFunc(namespace, name, pt, data, subresources...)
}

// PatchCalls gets all the calls that were made to Patch.
// Check the length with:
//     len(mockedPublicDomainClient.PatchCalls())
func (mock *PublicDomainClientMock) 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
	}
	lockPublicDomainClientMockPatch.RLock()
	calls = mock.calls.Patch
	lockPublicDomainClientMockPatch.RUnlock()
	return calls
}

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

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

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

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

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

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

var (
	lockPublicDomainCacheMockAddIndexer sync.RWMutex
	lockPublicDomainCacheMockGet        sync.RWMutex
	lockPublicDomainCacheMockGetByIndex sync.RWMutex
	lockPublicDomainCacheMockList       sync.RWMutex
)

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

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

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

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

	// ListFunc mocks the List method.
	ListFunc func(namespace string, selector labels.Selector) ([]*v1a.PublicDomain, 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.PublicDomainIndexer
		}
		// 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 *PublicDomainCacheMock) AddIndexer(indexName string, indexer v1.PublicDomainIndexer) {
	if mock.AddIndexerFunc == nil {
		panic("PublicDomainCacheMock.AddIndexerFunc: method is nil but PublicDomainCache.AddIndexer was just called")
	}
	callInfo := struct {
		IndexName string
		Indexer   v1.PublicDomainIndexer
	}{
		IndexName: indexName,
		Indexer:   indexer,
	}
	lockPublicDomainCacheMockAddIndexer.Lock()
	mock.calls.AddIndexer = append(mock.calls.AddIndexer, callInfo)
	lockPublicDomainCacheMockAddIndexer.Unlock()
	mock.AddIndexerFunc(indexName, indexer)
}

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

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

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

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

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

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

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