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

import (
	"sync"

	"github.com/operator-framework/operator-lifecycle-manager/pkg/lib/operatorlister"
	v1 "k8s.io/client-go/listers/core/v1"
)

type FakeCoreV1Lister struct {
	ConfigMapListerStub        func() v1.ConfigMapLister
	configMapListerMutex       sync.RWMutex
	configMapListerArgsForCall []struct {
	}
	configMapListerReturns struct {
		result1 v1.ConfigMapLister
	}
	configMapListerReturnsOnCall map[int]struct {
		result1 v1.ConfigMapLister
	}
	NamespaceListerStub        func() v1.NamespaceLister
	namespaceListerMutex       sync.RWMutex
	namespaceListerArgsForCall []struct {
	}
	namespaceListerReturns struct {
		result1 v1.NamespaceLister
	}
	namespaceListerReturnsOnCall map[int]struct {
		result1 v1.NamespaceLister
	}
	PodListerStub        func() v1.PodLister
	podListerMutex       sync.RWMutex
	podListerArgsForCall []struct {
	}
	podListerReturns struct {
		result1 v1.PodLister
	}
	podListerReturnsOnCall map[int]struct {
		result1 v1.PodLister
	}
	RegisterConfigMapListerStub        func(string, v1.ConfigMapLister)
	registerConfigMapListerMutex       sync.RWMutex
	registerConfigMapListerArgsForCall []struct {
		arg1 string
		arg2 v1.ConfigMapLister
	}
	RegisterNamespaceListerStub        func(v1.NamespaceLister)
	registerNamespaceListerMutex       sync.RWMutex
	registerNamespaceListerArgsForCall []struct {
		arg1 v1.NamespaceLister
	}
	RegisterPodListerStub        func(string, v1.PodLister)
	registerPodListerMutex       sync.RWMutex
	registerPodListerArgsForCall []struct {
		arg1 string
		arg2 v1.PodLister
	}
	RegisterSecretListerStub        func(string, v1.SecretLister)
	registerSecretListerMutex       sync.RWMutex
	registerSecretListerArgsForCall []struct {
		arg1 string
		arg2 v1.SecretLister
	}
	RegisterServiceAccountListerStub        func(string, v1.ServiceAccountLister)
	registerServiceAccountListerMutex       sync.RWMutex
	registerServiceAccountListerArgsForCall []struct {
		arg1 string
		arg2 v1.ServiceAccountLister
	}
	RegisterServiceListerStub        func(string, v1.ServiceLister)
	registerServiceListerMutex       sync.RWMutex
	registerServiceListerArgsForCall []struct {
		arg1 string
		arg2 v1.ServiceLister
	}
	SecretListerStub        func() v1.SecretLister
	secretListerMutex       sync.RWMutex
	secretListerArgsForCall []struct {
	}
	secretListerReturns struct {
		result1 v1.SecretLister
	}
	secretListerReturnsOnCall map[int]struct {
		result1 v1.SecretLister
	}
	ServiceAccountListerStub        func() v1.ServiceAccountLister
	serviceAccountListerMutex       sync.RWMutex
	serviceAccountListerArgsForCall []struct {
	}
	serviceAccountListerReturns struct {
		result1 v1.ServiceAccountLister
	}
	serviceAccountListerReturnsOnCall map[int]struct {
		result1 v1.ServiceAccountLister
	}
	ServiceListerStub        func() v1.ServiceLister
	serviceListerMutex       sync.RWMutex
	serviceListerArgsForCall []struct {
	}
	serviceListerReturns struct {
		result1 v1.ServiceLister
	}
	serviceListerReturnsOnCall map[int]struct {
		result1 v1.ServiceLister
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCoreV1Lister) ConfigMapLister() v1.ConfigMapLister {
	fake.configMapListerMutex.Lock()
	ret, specificReturn := fake.configMapListerReturnsOnCall[len(fake.configMapListerArgsForCall)]
	fake.configMapListerArgsForCall = append(fake.configMapListerArgsForCall, struct {
	}{})
	fake.recordInvocation("ConfigMapLister", []interface{}{})
	fake.configMapListerMutex.Unlock()
	if fake.ConfigMapListerStub != nil {
		return fake.ConfigMapListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.configMapListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) ConfigMapListerCallCount() int {
	fake.configMapListerMutex.RLock()
	defer fake.configMapListerMutex.RUnlock()
	return len(fake.configMapListerArgsForCall)
}

func (fake *FakeCoreV1Lister) ConfigMapListerCalls(stub func() v1.ConfigMapLister) {
	fake.configMapListerMutex.Lock()
	defer fake.configMapListerMutex.Unlock()
	fake.ConfigMapListerStub = stub
}

func (fake *FakeCoreV1Lister) ConfigMapListerReturns(result1 v1.ConfigMapLister) {
	fake.configMapListerMutex.Lock()
	defer fake.configMapListerMutex.Unlock()
	fake.ConfigMapListerStub = nil
	fake.configMapListerReturns = struct {
		result1 v1.ConfigMapLister
	}{result1}
}

func (fake *FakeCoreV1Lister) ConfigMapListerReturnsOnCall(i int, result1 v1.ConfigMapLister) {
	fake.configMapListerMutex.Lock()
	defer fake.configMapListerMutex.Unlock()
	fake.ConfigMapListerStub = nil
	if fake.configMapListerReturnsOnCall == nil {
		fake.configMapListerReturnsOnCall = make(map[int]struct {
			result1 v1.ConfigMapLister
		})
	}
	fake.configMapListerReturnsOnCall[i] = struct {
		result1 v1.ConfigMapLister
	}{result1}
}

func (fake *FakeCoreV1Lister) NamespaceLister() v1.NamespaceLister {
	fake.namespaceListerMutex.Lock()
	ret, specificReturn := fake.namespaceListerReturnsOnCall[len(fake.namespaceListerArgsForCall)]
	fake.namespaceListerArgsForCall = append(fake.namespaceListerArgsForCall, struct {
	}{})
	fake.recordInvocation("NamespaceLister", []interface{}{})
	fake.namespaceListerMutex.Unlock()
	if fake.NamespaceListerStub != nil {
		return fake.NamespaceListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.namespaceListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) NamespaceListerCallCount() int {
	fake.namespaceListerMutex.RLock()
	defer fake.namespaceListerMutex.RUnlock()
	return len(fake.namespaceListerArgsForCall)
}

func (fake *FakeCoreV1Lister) NamespaceListerCalls(stub func() v1.NamespaceLister) {
	fake.namespaceListerMutex.Lock()
	defer fake.namespaceListerMutex.Unlock()
	fake.NamespaceListerStub = stub
}

func (fake *FakeCoreV1Lister) NamespaceListerReturns(result1 v1.NamespaceLister) {
	fake.namespaceListerMutex.Lock()
	defer fake.namespaceListerMutex.Unlock()
	fake.NamespaceListerStub = nil
	fake.namespaceListerReturns = struct {
		result1 v1.NamespaceLister
	}{result1}
}

func (fake *FakeCoreV1Lister) NamespaceListerReturnsOnCall(i int, result1 v1.NamespaceLister) {
	fake.namespaceListerMutex.Lock()
	defer fake.namespaceListerMutex.Unlock()
	fake.NamespaceListerStub = nil
	if fake.namespaceListerReturnsOnCall == nil {
		fake.namespaceListerReturnsOnCall = make(map[int]struct {
			result1 v1.NamespaceLister
		})
	}
	fake.namespaceListerReturnsOnCall[i] = struct {
		result1 v1.NamespaceLister
	}{result1}
}

func (fake *FakeCoreV1Lister) PodLister() v1.PodLister {
	fake.podListerMutex.Lock()
	ret, specificReturn := fake.podListerReturnsOnCall[len(fake.podListerArgsForCall)]
	fake.podListerArgsForCall = append(fake.podListerArgsForCall, struct {
	}{})
	fake.recordInvocation("PodLister", []interface{}{})
	fake.podListerMutex.Unlock()
	if fake.PodListerStub != nil {
		return fake.PodListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.podListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) PodListerCallCount() int {
	fake.podListerMutex.RLock()
	defer fake.podListerMutex.RUnlock()
	return len(fake.podListerArgsForCall)
}

func (fake *FakeCoreV1Lister) PodListerCalls(stub func() v1.PodLister) {
	fake.podListerMutex.Lock()
	defer fake.podListerMutex.Unlock()
	fake.PodListerStub = stub
}

func (fake *FakeCoreV1Lister) PodListerReturns(result1 v1.PodLister) {
	fake.podListerMutex.Lock()
	defer fake.podListerMutex.Unlock()
	fake.PodListerStub = nil
	fake.podListerReturns = struct {
		result1 v1.PodLister
	}{result1}
}

func (fake *FakeCoreV1Lister) PodListerReturnsOnCall(i int, result1 v1.PodLister) {
	fake.podListerMutex.Lock()
	defer fake.podListerMutex.Unlock()
	fake.PodListerStub = nil
	if fake.podListerReturnsOnCall == nil {
		fake.podListerReturnsOnCall = make(map[int]struct {
			result1 v1.PodLister
		})
	}
	fake.podListerReturnsOnCall[i] = struct {
		result1 v1.PodLister
	}{result1}
}

func (fake *FakeCoreV1Lister) RegisterConfigMapLister(arg1 string, arg2 v1.ConfigMapLister) {
	fake.registerConfigMapListerMutex.Lock()
	fake.registerConfigMapListerArgsForCall = append(fake.registerConfigMapListerArgsForCall, struct {
		arg1 string
		arg2 v1.ConfigMapLister
	}{arg1, arg2})
	fake.recordInvocation("RegisterConfigMapLister", []interface{}{arg1, arg2})
	fake.registerConfigMapListerMutex.Unlock()
	if fake.RegisterConfigMapListerStub != nil {
		fake.RegisterConfigMapListerStub(arg1, arg2)
	}
}

func (fake *FakeCoreV1Lister) RegisterConfigMapListerCallCount() int {
	fake.registerConfigMapListerMutex.RLock()
	defer fake.registerConfigMapListerMutex.RUnlock()
	return len(fake.registerConfigMapListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterConfigMapListerCalls(stub func(string, v1.ConfigMapLister)) {
	fake.registerConfigMapListerMutex.Lock()
	defer fake.registerConfigMapListerMutex.Unlock()
	fake.RegisterConfigMapListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterConfigMapListerArgsForCall(i int) (string, v1.ConfigMapLister) {
	fake.registerConfigMapListerMutex.RLock()
	defer fake.registerConfigMapListerMutex.RUnlock()
	argsForCall := fake.registerConfigMapListerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCoreV1Lister) RegisterNamespaceLister(arg1 v1.NamespaceLister) {
	fake.registerNamespaceListerMutex.Lock()
	fake.registerNamespaceListerArgsForCall = append(fake.registerNamespaceListerArgsForCall, struct {
		arg1 v1.NamespaceLister
	}{arg1})
	fake.recordInvocation("RegisterNamespaceLister", []interface{}{arg1})
	fake.registerNamespaceListerMutex.Unlock()
	if fake.RegisterNamespaceListerStub != nil {
		fake.RegisterNamespaceListerStub(arg1)
	}
}

func (fake *FakeCoreV1Lister) RegisterNamespaceListerCallCount() int {
	fake.registerNamespaceListerMutex.RLock()
	defer fake.registerNamespaceListerMutex.RUnlock()
	return len(fake.registerNamespaceListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterNamespaceListerCalls(stub func(v1.NamespaceLister)) {
	fake.registerNamespaceListerMutex.Lock()
	defer fake.registerNamespaceListerMutex.Unlock()
	fake.RegisterNamespaceListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterNamespaceListerArgsForCall(i int) v1.NamespaceLister {
	fake.registerNamespaceListerMutex.RLock()
	defer fake.registerNamespaceListerMutex.RUnlock()
	argsForCall := fake.registerNamespaceListerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCoreV1Lister) RegisterPodLister(arg1 string, arg2 v1.PodLister) {
	fake.registerPodListerMutex.Lock()
	fake.registerPodListerArgsForCall = append(fake.registerPodListerArgsForCall, struct {
		arg1 string
		arg2 v1.PodLister
	}{arg1, arg2})
	fake.recordInvocation("RegisterPodLister", []interface{}{arg1, arg2})
	fake.registerPodListerMutex.Unlock()
	if fake.RegisterPodListerStub != nil {
		fake.RegisterPodListerStub(arg1, arg2)
	}
}

func (fake *FakeCoreV1Lister) RegisterPodListerCallCount() int {
	fake.registerPodListerMutex.RLock()
	defer fake.registerPodListerMutex.RUnlock()
	return len(fake.registerPodListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterPodListerCalls(stub func(string, v1.PodLister)) {
	fake.registerPodListerMutex.Lock()
	defer fake.registerPodListerMutex.Unlock()
	fake.RegisterPodListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterPodListerArgsForCall(i int) (string, v1.PodLister) {
	fake.registerPodListerMutex.RLock()
	defer fake.registerPodListerMutex.RUnlock()
	argsForCall := fake.registerPodListerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCoreV1Lister) RegisterSecretLister(arg1 string, arg2 v1.SecretLister) {
	fake.registerSecretListerMutex.Lock()
	fake.registerSecretListerArgsForCall = append(fake.registerSecretListerArgsForCall, struct {
		arg1 string
		arg2 v1.SecretLister
	}{arg1, arg2})
	fake.recordInvocation("RegisterSecretLister", []interface{}{arg1, arg2})
	fake.registerSecretListerMutex.Unlock()
	if fake.RegisterSecretListerStub != nil {
		fake.RegisterSecretListerStub(arg1, arg2)
	}
}

func (fake *FakeCoreV1Lister) RegisterSecretListerCallCount() int {
	fake.registerSecretListerMutex.RLock()
	defer fake.registerSecretListerMutex.RUnlock()
	return len(fake.registerSecretListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterSecretListerCalls(stub func(string, v1.SecretLister)) {
	fake.registerSecretListerMutex.Lock()
	defer fake.registerSecretListerMutex.Unlock()
	fake.RegisterSecretListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterSecretListerArgsForCall(i int) (string, v1.SecretLister) {
	fake.registerSecretListerMutex.RLock()
	defer fake.registerSecretListerMutex.RUnlock()
	argsForCall := fake.registerSecretListerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCoreV1Lister) RegisterServiceAccountLister(arg1 string, arg2 v1.ServiceAccountLister) {
	fake.registerServiceAccountListerMutex.Lock()
	fake.registerServiceAccountListerArgsForCall = append(fake.registerServiceAccountListerArgsForCall, struct {
		arg1 string
		arg2 v1.ServiceAccountLister
	}{arg1, arg2})
	fake.recordInvocation("RegisterServiceAccountLister", []interface{}{arg1, arg2})
	fake.registerServiceAccountListerMutex.Unlock()
	if fake.RegisterServiceAccountListerStub != nil {
		fake.RegisterServiceAccountListerStub(arg1, arg2)
	}
}

func (fake *FakeCoreV1Lister) RegisterServiceAccountListerCallCount() int {
	fake.registerServiceAccountListerMutex.RLock()
	defer fake.registerServiceAccountListerMutex.RUnlock()
	return len(fake.registerServiceAccountListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterServiceAccountListerCalls(stub func(string, v1.ServiceAccountLister)) {
	fake.registerServiceAccountListerMutex.Lock()
	defer fake.registerServiceAccountListerMutex.Unlock()
	fake.RegisterServiceAccountListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterServiceAccountListerArgsForCall(i int) (string, v1.ServiceAccountLister) {
	fake.registerServiceAccountListerMutex.RLock()
	defer fake.registerServiceAccountListerMutex.RUnlock()
	argsForCall := fake.registerServiceAccountListerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCoreV1Lister) RegisterServiceLister(arg1 string, arg2 v1.ServiceLister) {
	fake.registerServiceListerMutex.Lock()
	fake.registerServiceListerArgsForCall = append(fake.registerServiceListerArgsForCall, struct {
		arg1 string
		arg2 v1.ServiceLister
	}{arg1, arg2})
	fake.recordInvocation("RegisterServiceLister", []interface{}{arg1, arg2})
	fake.registerServiceListerMutex.Unlock()
	if fake.RegisterServiceListerStub != nil {
		fake.RegisterServiceListerStub(arg1, arg2)
	}
}

func (fake *FakeCoreV1Lister) RegisterServiceListerCallCount() int {
	fake.registerServiceListerMutex.RLock()
	defer fake.registerServiceListerMutex.RUnlock()
	return len(fake.registerServiceListerArgsForCall)
}

func (fake *FakeCoreV1Lister) RegisterServiceListerCalls(stub func(string, v1.ServiceLister)) {
	fake.registerServiceListerMutex.Lock()
	defer fake.registerServiceListerMutex.Unlock()
	fake.RegisterServiceListerStub = stub
}

func (fake *FakeCoreV1Lister) RegisterServiceListerArgsForCall(i int) (string, v1.ServiceLister) {
	fake.registerServiceListerMutex.RLock()
	defer fake.registerServiceListerMutex.RUnlock()
	argsForCall := fake.registerServiceListerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCoreV1Lister) SecretLister() v1.SecretLister {
	fake.secretListerMutex.Lock()
	ret, specificReturn := fake.secretListerReturnsOnCall[len(fake.secretListerArgsForCall)]
	fake.secretListerArgsForCall = append(fake.secretListerArgsForCall, struct {
	}{})
	fake.recordInvocation("SecretLister", []interface{}{})
	fake.secretListerMutex.Unlock()
	if fake.SecretListerStub != nil {
		return fake.SecretListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.secretListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) SecretListerCallCount() int {
	fake.secretListerMutex.RLock()
	defer fake.secretListerMutex.RUnlock()
	return len(fake.secretListerArgsForCall)
}

func (fake *FakeCoreV1Lister) SecretListerCalls(stub func() v1.SecretLister) {
	fake.secretListerMutex.Lock()
	defer fake.secretListerMutex.Unlock()
	fake.SecretListerStub = stub
}

func (fake *FakeCoreV1Lister) SecretListerReturns(result1 v1.SecretLister) {
	fake.secretListerMutex.Lock()
	defer fake.secretListerMutex.Unlock()
	fake.SecretListerStub = nil
	fake.secretListerReturns = struct {
		result1 v1.SecretLister
	}{result1}
}

func (fake *FakeCoreV1Lister) SecretListerReturnsOnCall(i int, result1 v1.SecretLister) {
	fake.secretListerMutex.Lock()
	defer fake.secretListerMutex.Unlock()
	fake.SecretListerStub = nil
	if fake.secretListerReturnsOnCall == nil {
		fake.secretListerReturnsOnCall = make(map[int]struct {
			result1 v1.SecretLister
		})
	}
	fake.secretListerReturnsOnCall[i] = struct {
		result1 v1.SecretLister
	}{result1}
}

func (fake *FakeCoreV1Lister) ServiceAccountLister() v1.ServiceAccountLister {
	fake.serviceAccountListerMutex.Lock()
	ret, specificReturn := fake.serviceAccountListerReturnsOnCall[len(fake.serviceAccountListerArgsForCall)]
	fake.serviceAccountListerArgsForCall = append(fake.serviceAccountListerArgsForCall, struct {
	}{})
	fake.recordInvocation("ServiceAccountLister", []interface{}{})
	fake.serviceAccountListerMutex.Unlock()
	if fake.ServiceAccountListerStub != nil {
		return fake.ServiceAccountListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.serviceAccountListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) ServiceAccountListerCallCount() int {
	fake.serviceAccountListerMutex.RLock()
	defer fake.serviceAccountListerMutex.RUnlock()
	return len(fake.serviceAccountListerArgsForCall)
}

func (fake *FakeCoreV1Lister) ServiceAccountListerCalls(stub func() v1.ServiceAccountLister) {
	fake.serviceAccountListerMutex.Lock()
	defer fake.serviceAccountListerMutex.Unlock()
	fake.ServiceAccountListerStub = stub
}

func (fake *FakeCoreV1Lister) ServiceAccountListerReturns(result1 v1.ServiceAccountLister) {
	fake.serviceAccountListerMutex.Lock()
	defer fake.serviceAccountListerMutex.Unlock()
	fake.ServiceAccountListerStub = nil
	fake.serviceAccountListerReturns = struct {
		result1 v1.ServiceAccountLister
	}{result1}
}

func (fake *FakeCoreV1Lister) ServiceAccountListerReturnsOnCall(i int, result1 v1.ServiceAccountLister) {
	fake.serviceAccountListerMutex.Lock()
	defer fake.serviceAccountListerMutex.Unlock()
	fake.ServiceAccountListerStub = nil
	if fake.serviceAccountListerReturnsOnCall == nil {
		fake.serviceAccountListerReturnsOnCall = make(map[int]struct {
			result1 v1.ServiceAccountLister
		})
	}
	fake.serviceAccountListerReturnsOnCall[i] = struct {
		result1 v1.ServiceAccountLister
	}{result1}
}

func (fake *FakeCoreV1Lister) ServiceLister() v1.ServiceLister {
	fake.serviceListerMutex.Lock()
	ret, specificReturn := fake.serviceListerReturnsOnCall[len(fake.serviceListerArgsForCall)]
	fake.serviceListerArgsForCall = append(fake.serviceListerArgsForCall, struct {
	}{})
	fake.recordInvocation("ServiceLister", []interface{}{})
	fake.serviceListerMutex.Unlock()
	if fake.ServiceListerStub != nil {
		return fake.ServiceListerStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.serviceListerReturns
	return fakeReturns.result1
}

func (fake *FakeCoreV1Lister) ServiceListerCallCount() int {
	fake.serviceListerMutex.RLock()
	defer fake.serviceListerMutex.RUnlock()
	return len(fake.serviceListerArgsForCall)
}

func (fake *FakeCoreV1Lister) ServiceListerCalls(stub func() v1.ServiceLister) {
	fake.serviceListerMutex.Lock()
	defer fake.serviceListerMutex.Unlock()
	fake.ServiceListerStub = stub
}

func (fake *FakeCoreV1Lister) ServiceListerReturns(result1 v1.ServiceLister) {
	fake.serviceListerMutex.Lock()
	defer fake.serviceListerMutex.Unlock()
	fake.ServiceListerStub = nil
	fake.serviceListerReturns = struct {
		result1 v1.ServiceLister
	}{result1}
}

func (fake *FakeCoreV1Lister) ServiceListerReturnsOnCall(i int, result1 v1.ServiceLister) {
	fake.serviceListerMutex.Lock()
	defer fake.serviceListerMutex.Unlock()
	fake.ServiceListerStub = nil
	if fake.serviceListerReturnsOnCall == nil {
		fake.serviceListerReturnsOnCall = make(map[int]struct {
			result1 v1.ServiceLister
		})
	}
	fake.serviceListerReturnsOnCall[i] = struct {
		result1 v1.ServiceLister
	}{result1}
}

func (fake *FakeCoreV1Lister) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.configMapListerMutex.RLock()
	defer fake.configMapListerMutex.RUnlock()
	fake.namespaceListerMutex.RLock()
	defer fake.namespaceListerMutex.RUnlock()
	fake.podListerMutex.RLock()
	defer fake.podListerMutex.RUnlock()
	fake.registerConfigMapListerMutex.RLock()
	defer fake.registerConfigMapListerMutex.RUnlock()
	fake.registerNamespaceListerMutex.RLock()
	defer fake.registerNamespaceListerMutex.RUnlock()
	fake.registerPodListerMutex.RLock()
	defer fake.registerPodListerMutex.RUnlock()
	fake.registerSecretListerMutex.RLock()
	defer fake.registerSecretListerMutex.RUnlock()
	fake.registerServiceAccountListerMutex.RLock()
	defer fake.registerServiceAccountListerMutex.RUnlock()
	fake.registerServiceListerMutex.RLock()
	defer fake.registerServiceListerMutex.RUnlock()
	fake.secretListerMutex.RLock()
	defer fake.secretListerMutex.RUnlock()
	fake.serviceAccountListerMutex.RLock()
	defer fake.serviceAccountListerMutex.RUnlock()
	fake.serviceListerMutex.RLock()
	defer fake.serviceListerMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeCoreV1Lister) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ operatorlister.CoreV1Lister = new(FakeCoreV1Lister)
