github.com/polarismesh/polaris@v1.17.8/cache/mock/cache_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: api/types.go

// Package mock is a generated GoMock package.
package mock

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	api "github.com/polarismesh/polaris/cache/api"
	model "github.com/polarismesh/polaris/common/model"
	store "github.com/polarismesh/polaris/store"
	security "github.com/polarismesh/specification/source/go/api/v1/security"
	service_manage "github.com/polarismesh/specification/source/go/api/v1/service_manage"
	traffic_manage "github.com/polarismesh/specification/source/go/api/v1/traffic_manage"
)

// MockCache is a mock of Cache interface.
type MockCache struct {
	ctrl     *gomock.Controller
	recorder *MockCacheMockRecorder
}

// MockCacheMockRecorder is the mock recorder for MockCache.
type MockCacheMockRecorder struct {
	mock *MockCache
}

// NewMockCache creates a new mock instance.
func NewMockCache(ctrl *gomock.Controller) *MockCache {
	mock := &MockCache{ctrl: ctrl}
	mock.recorder = &MockCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCache) EXPECT() *MockCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCache)(nil).Clear))
}

// Initialize mocks base method.
func (m *MockCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCache)(nil).Name))
}

// Update mocks base method.
func (m *MockCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCache)(nil).Update))
}

// MockCacheManager is a mock of CacheManager interface.
type MockCacheManager struct {
	ctrl     *gomock.Controller
	recorder *MockCacheManagerMockRecorder
}

// MockCacheManagerMockRecorder is the mock recorder for MockCacheManager.
type MockCacheManagerMockRecorder struct {
	mock *MockCacheManager
}

// NewMockCacheManager creates a new mock instance.
func NewMockCacheManager(ctrl *gomock.Controller) *MockCacheManager {
	mock := &MockCacheManager{ctrl: ctrl}
	mock.recorder = &MockCacheManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCacheManager) EXPECT() *MockCacheManagerMockRecorder {
	return m.recorder
}

// GetCacher mocks base method.
func (m *MockCacheManager) GetCacher(cacheIndex api.CacheIndex) api.Cache {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCacher", cacheIndex)
	ret0, _ := ret[0].(api.Cache)
	return ret0
}

// GetCacher indicates an expected call of GetCacher.
func (mr *MockCacheManagerMockRecorder) GetCacher(cacheIndex interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCacher", reflect.TypeOf((*MockCacheManager)(nil).GetCacher), cacheIndex)
}

// RegisterCacher mocks base method.
func (m *MockCacheManager) RegisterCacher(cacheIndex api.CacheIndex, item api.Cache) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterCacher", cacheIndex, item)
}

// RegisterCacher indicates an expected call of RegisterCacher.
func (mr *MockCacheManagerMockRecorder) RegisterCacher(cacheIndex, item interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterCacher", reflect.TypeOf((*MockCacheManager)(nil).RegisterCacher), cacheIndex, item)
}

// MockNamespaceCache is a mock of NamespaceCache interface.
type MockNamespaceCache struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceCacheMockRecorder
}

// MockNamespaceCacheMockRecorder is the mock recorder for MockNamespaceCache.
type MockNamespaceCacheMockRecorder struct {
	mock *MockNamespaceCache
}

// NewMockNamespaceCache creates a new mock instance.
func NewMockNamespaceCache(ctrl *gomock.Controller) *MockNamespaceCache {
	mock := &MockNamespaceCache{ctrl: ctrl}
	mock.recorder = &MockNamespaceCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockNamespaceCache) EXPECT() *MockNamespaceCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockNamespaceCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockNamespaceCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockNamespaceCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockNamespaceCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockNamespaceCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockNamespaceCache)(nil).Clear))
}

// GetNamespace mocks base method.
func (m *MockNamespaceCache) GetNamespace(id string) *model.Namespace {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", id)
	ret0, _ := ret[0].(*model.Namespace)
	return ret0
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockNamespaceCacheMockRecorder) GetNamespace(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespace), id)
}

// GetNamespaceList mocks base method.
func (m *MockNamespaceCache) GetNamespaceList() []*model.Namespace {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceList")
	ret0, _ := ret[0].([]*model.Namespace)
	return ret0
}

// GetNamespaceList indicates an expected call of GetNamespaceList.
func (mr *MockNamespaceCacheMockRecorder) GetNamespaceList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceList", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespaceList))
}

// GetNamespacesByName mocks base method.
func (m *MockNamespaceCache) GetNamespacesByName(names []string) []*model.Namespace {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespacesByName", names)
	ret0, _ := ret[0].([]*model.Namespace)
	return ret0
}

// GetNamespacesByName indicates an expected call of GetNamespacesByName.
func (mr *MockNamespaceCacheMockRecorder) GetNamespacesByName(names interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespacesByName", reflect.TypeOf((*MockNamespaceCache)(nil).GetNamespacesByName), names)
}

// Initialize mocks base method.
func (m *MockNamespaceCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockNamespaceCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockNamespaceCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockNamespaceCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockNamespaceCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockNamespaceCache)(nil).Name))
}

// Update mocks base method.
func (m *MockNamespaceCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockNamespaceCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNamespaceCache)(nil).Update))
}

// MockServiceCache is a mock of ServiceCache interface.
type MockServiceCache struct {
	ctrl     *gomock.Controller
	recorder *MockServiceCacheMockRecorder
}

// MockServiceCacheMockRecorder is the mock recorder for MockServiceCache.
type MockServiceCacheMockRecorder struct {
	mock *MockServiceCache
}

// NewMockServiceCache creates a new mock instance.
func NewMockServiceCache(ctrl *gomock.Controller) *MockServiceCache {
	mock := &MockServiceCache{ctrl: ctrl}
	mock.recorder = &MockServiceCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServiceCache) EXPECT() *MockServiceCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockServiceCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockServiceCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockServiceCache)(nil).AddListener), listeners)
}

// CleanNamespace mocks base method.
func (m *MockServiceCache) CleanNamespace(namespace string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CleanNamespace", namespace)
}

// CleanNamespace indicates an expected call of CleanNamespace.
func (mr *MockServiceCacheMockRecorder) CleanNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanNamespace", reflect.TypeOf((*MockServiceCache)(nil).CleanNamespace), namespace)
}

// Clear mocks base method.
func (m *MockServiceCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockServiceCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockServiceCache)(nil).Clear))
}

// GetAliasFor mocks base method.
func (m *MockServiceCache) GetAliasFor(name, namespace string) *model.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAliasFor", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	return ret0
}

// GetAliasFor indicates an expected call of GetAliasFor.
func (mr *MockServiceCacheMockRecorder) GetAliasFor(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAliasFor", reflect.TypeOf((*MockServiceCache)(nil).GetAliasFor), name, namespace)
}

// GetAllNamespaces mocks base method.
func (m *MockServiceCache) GetAllNamespaces() []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNamespaces")
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetAllNamespaces indicates an expected call of GetAllNamespaces.
func (mr *MockServiceCacheMockRecorder) GetAllNamespaces() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllNamespaces", reflect.TypeOf((*MockServiceCache)(nil).GetAllNamespaces))
}

// GetNamespaceCntInfo mocks base method.
func (m *MockServiceCache) GetNamespaceCntInfo(namespace string) model.NamespaceServiceCount {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceCntInfo", namespace)
	ret0, _ := ret[0].(model.NamespaceServiceCount)
	return ret0
}

// GetNamespaceCntInfo indicates an expected call of GetNamespaceCntInfo.
func (mr *MockServiceCacheMockRecorder) GetNamespaceCntInfo(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceCntInfo", reflect.TypeOf((*MockServiceCache)(nil).GetNamespaceCntInfo), namespace)
}

// GetRevisionWorker mocks base method.
func (m *MockServiceCache) GetRevisionWorker() api.ServiceRevisionWorker {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRevisionWorker")
	ret0, _ := ret[0].(api.ServiceRevisionWorker)
	return ret0
}

// GetRevisionWorker indicates an expected call of GetRevisionWorker.
func (mr *MockServiceCacheMockRecorder) GetRevisionWorker() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevisionWorker", reflect.TypeOf((*MockServiceCache)(nil).GetRevisionWorker))
}

// GetServiceByCl5Name mocks base method.
func (m *MockServiceCache) GetServiceByCl5Name(cl5Name string) *model.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceByCl5Name", cl5Name)
	ret0, _ := ret[0].(*model.Service)
	return ret0
}

// GetServiceByCl5Name indicates an expected call of GetServiceByCl5Name.
func (mr *MockServiceCacheMockRecorder) GetServiceByCl5Name(cl5Name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByCl5Name", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByCl5Name), cl5Name)
}

// GetServiceByID mocks base method.
func (m *MockServiceCache) GetServiceByID(id string) *model.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceByID", id)
	ret0, _ := ret[0].(*model.Service)
	return ret0
}

// GetServiceByID indicates an expected call of GetServiceByID.
func (mr *MockServiceCacheMockRecorder) GetServiceByID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByID", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByID), id)
}

// GetServiceByName mocks base method.
func (m *MockServiceCache) GetServiceByName(name, namespace string) *model.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceByName", name, namespace)
	ret0, _ := ret[0].(*model.Service)
	return ret0
}

// GetServiceByName indicates an expected call of GetServiceByName.
func (mr *MockServiceCacheMockRecorder) GetServiceByName(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceByName", reflect.TypeOf((*MockServiceCache)(nil).GetServiceByName), name, namespace)
}

// GetServicesByFilter mocks base method.
func (m *MockServiceCache) GetServicesByFilter(serviceFilters *api.ServiceArgs, instanceFilters *store.InstanceArgs, offset, limit uint32) (uint32, []*model.EnhancedService, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicesByFilter", serviceFilters, instanceFilters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.EnhancedService)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetServicesByFilter indicates an expected call of GetServicesByFilter.
func (mr *MockServiceCacheMockRecorder) GetServicesByFilter(serviceFilters, instanceFilters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesByFilter", reflect.TypeOf((*MockServiceCache)(nil).GetServicesByFilter), serviceFilters, instanceFilters, offset, limit)
}

// GetServicesCount mocks base method.
func (m *MockServiceCache) GetServicesCount() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicesCount")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetServicesCount indicates an expected call of GetServicesCount.
func (mr *MockServiceCacheMockRecorder) GetServicesCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicesCount", reflect.TypeOf((*MockServiceCache)(nil).GetServicesCount))
}

// Initialize mocks base method.
func (m *MockServiceCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockServiceCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockServiceCache)(nil).Initialize), c)
}

// IteratorServices mocks base method.
func (m *MockServiceCache) IteratorServices(iterProc api.ServiceIterProc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IteratorServices", iterProc)
	ret0, _ := ret[0].(error)
	return ret0
}

// IteratorServices indicates an expected call of IteratorServices.
func (mr *MockServiceCacheMockRecorder) IteratorServices(iterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorServices", reflect.TypeOf((*MockServiceCache)(nil).IteratorServices), iterProc)
}

// ListAllServices mocks base method.
func (m *MockServiceCache) ListAllServices() (string, []*model.Service) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAllServices")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]*model.Service)
	return ret0, ret1
}

// ListAllServices indicates an expected call of ListAllServices.
func (mr *MockServiceCacheMockRecorder) ListAllServices() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAllServices", reflect.TypeOf((*MockServiceCache)(nil).ListAllServices))
}

// ListServiceAlias mocks base method.
func (m *MockServiceCache) ListServiceAlias(namespace, name string) []*model.Service {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServiceAlias", namespace, name)
	ret0, _ := ret[0].([]*model.Service)
	return ret0
}

// ListServiceAlias indicates an expected call of ListServiceAlias.
func (mr *MockServiceCacheMockRecorder) ListServiceAlias(namespace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceAlias", reflect.TypeOf((*MockServiceCache)(nil).ListServiceAlias), namespace, name)
}

// ListServices mocks base method.
func (m *MockServiceCache) ListServices(ns string) (string, []*model.Service) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", ns)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].([]*model.Service)
	return ret0, ret1
}

// ListServices indicates an expected call of ListServices.
func (mr *MockServiceCacheMockRecorder) ListServices(ns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockServiceCache)(nil).ListServices), ns)
}

// Name mocks base method.
func (m *MockServiceCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockServiceCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockServiceCache)(nil).Name))
}

// Update mocks base method.
func (m *MockServiceCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockServiceCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockServiceCache)(nil).Update))
}

// MockServiceRevisionWorker is a mock of ServiceRevisionWorker interface.
type MockServiceRevisionWorker struct {
	ctrl     *gomock.Controller
	recorder *MockServiceRevisionWorkerMockRecorder
}

// MockServiceRevisionWorkerMockRecorder is the mock recorder for MockServiceRevisionWorker.
type MockServiceRevisionWorkerMockRecorder struct {
	mock *MockServiceRevisionWorker
}

// NewMockServiceRevisionWorker creates a new mock instance.
func NewMockServiceRevisionWorker(ctrl *gomock.Controller) *MockServiceRevisionWorker {
	mock := &MockServiceRevisionWorker{ctrl: ctrl}
	mock.recorder = &MockServiceRevisionWorkerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockServiceRevisionWorker) EXPECT() *MockServiceRevisionWorkerMockRecorder {
	return m.recorder
}

// GetServiceInstanceRevision mocks base method.
func (m *MockServiceRevisionWorker) GetServiceInstanceRevision(serviceID string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceInstanceRevision", serviceID)
	ret0, _ := ret[0].(string)
	return ret0
}

// GetServiceInstanceRevision indicates an expected call of GetServiceInstanceRevision.
func (mr *MockServiceRevisionWorkerMockRecorder) GetServiceInstanceRevision(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceInstanceRevision", reflect.TypeOf((*MockServiceRevisionWorker)(nil).GetServiceInstanceRevision), serviceID)
}

// GetServiceRevisionCount mocks base method.
func (m *MockServiceRevisionWorker) GetServiceRevisionCount() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceRevisionCount")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetServiceRevisionCount indicates an expected call of GetServiceRevisionCount.
func (mr *MockServiceRevisionWorkerMockRecorder) GetServiceRevisionCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceRevisionCount", reflect.TypeOf((*MockServiceRevisionWorker)(nil).GetServiceRevisionCount))
}

// Notify mocks base method.
func (m *MockServiceRevisionWorker) Notify(serviceID string, valid bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Notify", serviceID, valid)
}

// Notify indicates an expected call of Notify.
func (mr *MockServiceRevisionWorkerMockRecorder) Notify(serviceID, valid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Notify", reflect.TypeOf((*MockServiceRevisionWorker)(nil).Notify), serviceID, valid)
}

// MockInstanceCache is a mock of InstanceCache interface.
type MockInstanceCache struct {
	ctrl     *gomock.Controller
	recorder *MockInstanceCacheMockRecorder
}

// MockInstanceCacheMockRecorder is the mock recorder for MockInstanceCache.
type MockInstanceCacheMockRecorder struct {
	mock *MockInstanceCache
}

// NewMockInstanceCache creates a new mock instance.
func NewMockInstanceCache(ctrl *gomock.Controller) *MockInstanceCache {
	mock := &MockInstanceCache{ctrl: ctrl}
	mock.recorder = &MockInstanceCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockInstanceCache) EXPECT() *MockInstanceCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockInstanceCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockInstanceCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockInstanceCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockInstanceCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockInstanceCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockInstanceCache)(nil).Clear))
}

// GetInstance mocks base method.
func (m *MockInstanceCache) GetInstance(instanceID string) *model.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstance", instanceID)
	ret0, _ := ret[0].(*model.Instance)
	return ret0
}

// GetInstance indicates an expected call of GetInstance.
func (mr *MockInstanceCacheMockRecorder) GetInstance(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstance", reflect.TypeOf((*MockInstanceCache)(nil).GetInstance), instanceID)
}

// GetInstanceLabels mocks base method.
func (m *MockInstanceCache) GetInstanceLabels(serviceID string) *service_manage.InstanceLabels {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstanceLabels", serviceID)
	ret0, _ := ret[0].(*service_manage.InstanceLabels)
	return ret0
}

// GetInstanceLabels indicates an expected call of GetInstanceLabels.
func (mr *MockInstanceCacheMockRecorder) GetInstanceLabels(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceLabels", reflect.TypeOf((*MockInstanceCache)(nil).GetInstanceLabels), serviceID)
}

// GetInstancesByServiceID mocks base method.
func (m *MockInstanceCache) GetInstancesByServiceID(serviceID string) []*model.Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesByServiceID", serviceID)
	ret0, _ := ret[0].([]*model.Instance)
	return ret0
}

// GetInstancesByServiceID indicates an expected call of GetInstancesByServiceID.
func (mr *MockInstanceCacheMockRecorder) GetInstancesByServiceID(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesByServiceID", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesByServiceID), serviceID)
}

// GetInstancesCount mocks base method.
func (m *MockInstanceCache) GetInstancesCount() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesCount")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetInstancesCount indicates an expected call of GetInstancesCount.
func (mr *MockInstanceCacheMockRecorder) GetInstancesCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesCount", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesCount))
}

// GetInstancesCountByServiceID mocks base method.
func (m *MockInstanceCache) GetInstancesCountByServiceID(serviceID string) model.InstanceCount {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetInstancesCountByServiceID", serviceID)
	ret0, _ := ret[0].(model.InstanceCount)
	return ret0
}

// GetInstancesCountByServiceID indicates an expected call of GetInstancesCountByServiceID.
func (mr *MockInstanceCacheMockRecorder) GetInstancesCountByServiceID(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstancesCountByServiceID", reflect.TypeOf((*MockInstanceCache)(nil).GetInstancesCountByServiceID), serviceID)
}

// GetServicePorts mocks base method.
func (m *MockInstanceCache) GetServicePorts(serviceID string) []*model.ServicePort {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServicePorts", serviceID)
	ret0, _ := ret[0].([]*model.ServicePort)
	return ret0
}

// GetServicePorts indicates an expected call of GetServicePorts.
func (mr *MockInstanceCacheMockRecorder) GetServicePorts(serviceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServicePorts", reflect.TypeOf((*MockInstanceCache)(nil).GetServicePorts), serviceID)
}

// Initialize mocks base method.
func (m *MockInstanceCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockInstanceCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockInstanceCache)(nil).Initialize), c)
}

// IteratorInstances mocks base method.
func (m *MockInstanceCache) IteratorInstances(iterProc api.InstanceIterProc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IteratorInstances", iterProc)
	ret0, _ := ret[0].(error)
	return ret0
}

// IteratorInstances indicates an expected call of IteratorInstances.
func (mr *MockInstanceCacheMockRecorder) IteratorInstances(iterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstances", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstances), iterProc)
}

// IteratorInstancesWithService mocks base method.
func (m *MockInstanceCache) IteratorInstancesWithService(serviceID string, iterProc api.InstanceIterProc) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IteratorInstancesWithService", serviceID, iterProc)
	ret0, _ := ret[0].(error)
	return ret0
}

// IteratorInstancesWithService indicates an expected call of IteratorInstancesWithService.
func (mr *MockInstanceCacheMockRecorder) IteratorInstancesWithService(serviceID, iterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorInstancesWithService", reflect.TypeOf((*MockInstanceCache)(nil).IteratorInstancesWithService), serviceID, iterProc)
}

// Name mocks base method.
func (m *MockInstanceCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockInstanceCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockInstanceCache)(nil).Name))
}

// QueryInstances mocks base method.
func (m *MockInstanceCache) QueryInstances(filter, metaFilter map[string]string, offset, limit uint32) (uint32, []*model.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryInstances", filter, metaFilter, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryInstances indicates an expected call of QueryInstances.
func (mr *MockInstanceCacheMockRecorder) QueryInstances(filter, metaFilter, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryInstances", reflect.TypeOf((*MockInstanceCache)(nil).QueryInstances), filter, metaFilter, offset, limit)
}

// Update mocks base method.
func (m *MockInstanceCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockInstanceCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockInstanceCache)(nil).Update))
}

// MockFaultDetectCache is a mock of FaultDetectCache interface.
type MockFaultDetectCache struct {
	ctrl     *gomock.Controller
	recorder *MockFaultDetectCacheMockRecorder
}

// MockFaultDetectCacheMockRecorder is the mock recorder for MockFaultDetectCache.
type MockFaultDetectCacheMockRecorder struct {
	mock *MockFaultDetectCache
}

// NewMockFaultDetectCache creates a new mock instance.
func NewMockFaultDetectCache(ctrl *gomock.Controller) *MockFaultDetectCache {
	mock := &MockFaultDetectCache{ctrl: ctrl}
	mock.recorder = &MockFaultDetectCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFaultDetectCache) EXPECT() *MockFaultDetectCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockFaultDetectCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockFaultDetectCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockFaultDetectCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockFaultDetectCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockFaultDetectCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockFaultDetectCache)(nil).Clear))
}

// GetFaultDetectConfig mocks base method.
func (m *MockFaultDetectCache) GetFaultDetectConfig(svcName, namespace string) *model.ServiceWithFaultDetectRules {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFaultDetectConfig", svcName, namespace)
	ret0, _ := ret[0].(*model.ServiceWithFaultDetectRules)
	return ret0
}

// GetFaultDetectConfig indicates an expected call of GetFaultDetectConfig.
func (mr *MockFaultDetectCacheMockRecorder) GetFaultDetectConfig(svcName, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFaultDetectConfig", reflect.TypeOf((*MockFaultDetectCache)(nil).GetFaultDetectConfig), svcName, namespace)
}

// Initialize mocks base method.
func (m *MockFaultDetectCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockFaultDetectCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockFaultDetectCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockFaultDetectCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockFaultDetectCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockFaultDetectCache)(nil).Name))
}

// Update mocks base method.
func (m *MockFaultDetectCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockFaultDetectCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockFaultDetectCache)(nil).Update))
}

// MockRoutingConfigCache is a mock of RoutingConfigCache interface.
type MockRoutingConfigCache struct {
	ctrl     *gomock.Controller
	recorder *MockRoutingConfigCacheMockRecorder
}

// MockRoutingConfigCacheMockRecorder is the mock recorder for MockRoutingConfigCache.
type MockRoutingConfigCacheMockRecorder struct {
	mock *MockRoutingConfigCache
}

// NewMockRoutingConfigCache creates a new mock instance.
func NewMockRoutingConfigCache(ctrl *gomock.Controller) *MockRoutingConfigCache {
	mock := &MockRoutingConfigCache{ctrl: ctrl}
	mock.recorder = &MockRoutingConfigCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRoutingConfigCache) EXPECT() *MockRoutingConfigCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockRoutingConfigCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockRoutingConfigCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockRoutingConfigCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockRoutingConfigCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockRoutingConfigCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRoutingConfigCache)(nil).Clear))
}

// GetRouterConfig mocks base method.
func (m *MockRoutingConfigCache) GetRouterConfig(id, service, namespace string) (*traffic_manage.Routing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouterConfig", id, service, namespace)
	ret0, _ := ret[0].(*traffic_manage.Routing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRouterConfig indicates an expected call of GetRouterConfig.
func (mr *MockRoutingConfigCacheMockRecorder) GetRouterConfig(id, service, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouterConfig", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRouterConfig), id, service, namespace)
}

// GetRouterConfigV2 mocks base method.
func (m *MockRoutingConfigCache) GetRouterConfigV2(id, service, namespace string) (*traffic_manage.Routing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouterConfigV2", id, service, namespace)
	ret0, _ := ret[0].(*traffic_manage.Routing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRouterConfigV2 indicates an expected call of GetRouterConfigV2.
func (mr *MockRoutingConfigCacheMockRecorder) GetRouterConfigV2(id, service, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouterConfigV2", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRouterConfigV2), id, service, namespace)
}

// GetRoutingConfigCount mocks base method.
func (m *MockRoutingConfigCache) GetRoutingConfigCount() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRoutingConfigCount")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetRoutingConfigCount indicates an expected call of GetRoutingConfigCount.
func (mr *MockRoutingConfigCacheMockRecorder) GetRoutingConfigCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoutingConfigCount", reflect.TypeOf((*MockRoutingConfigCache)(nil).GetRoutingConfigCount))
}

// Initialize mocks base method.
func (m *MockRoutingConfigCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockRoutingConfigCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRoutingConfigCache)(nil).Initialize), c)
}

// IsConvertFromV1 mocks base method.
func (m *MockRoutingConfigCache) IsConvertFromV1(id string) (string, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsConvertFromV1", id)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// IsConvertFromV1 indicates an expected call of IsConvertFromV1.
func (mr *MockRoutingConfigCacheMockRecorder) IsConvertFromV1(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsConvertFromV1", reflect.TypeOf((*MockRoutingConfigCache)(nil).IsConvertFromV1), id)
}

// IteratorRouterRule mocks base method.
func (m *MockRoutingConfigCache) IteratorRouterRule(iterProc api.RouterRuleIterProc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IteratorRouterRule", iterProc)
}

// IteratorRouterRule indicates an expected call of IteratorRouterRule.
func (mr *MockRoutingConfigCacheMockRecorder) IteratorRouterRule(iterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorRouterRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).IteratorRouterRule), iterProc)
}

// ListRouterRule mocks base method.
func (m *MockRoutingConfigCache) ListRouterRule(service, namespace string) []*model.ExtendRouterConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListRouterRule", service, namespace)
	ret0, _ := ret[0].([]*model.ExtendRouterConfig)
	return ret0
}

// ListRouterRule indicates an expected call of ListRouterRule.
func (mr *MockRoutingConfigCacheMockRecorder) ListRouterRule(service, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListRouterRule", reflect.TypeOf((*MockRoutingConfigCache)(nil).ListRouterRule), service, namespace)
}

// Name mocks base method.
func (m *MockRoutingConfigCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockRoutingConfigCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRoutingConfigCache)(nil).Name))
}

// QueryRoutingConfigsV2 mocks base method.
func (m *MockRoutingConfigCache) QueryRoutingConfigsV2(args *api.RoutingArgs) (uint32, []*model.ExtendRouterConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRoutingConfigsV2", args)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ExtendRouterConfig)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryRoutingConfigsV2 indicates an expected call of QueryRoutingConfigsV2.
func (mr *MockRoutingConfigCacheMockRecorder) QueryRoutingConfigsV2(args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRoutingConfigsV2", reflect.TypeOf((*MockRoutingConfigCache)(nil).QueryRoutingConfigsV2), args)
}

// Update mocks base method.
func (m *MockRoutingConfigCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockRoutingConfigCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRoutingConfigCache)(nil).Update))
}

// MockRateLimitCache is a mock of RateLimitCache interface.
type MockRateLimitCache struct {
	ctrl     *gomock.Controller
	recorder *MockRateLimitCacheMockRecorder
}

// MockRateLimitCacheMockRecorder is the mock recorder for MockRateLimitCache.
type MockRateLimitCacheMockRecorder struct {
	mock *MockRateLimitCache
}

// NewMockRateLimitCache creates a new mock instance.
func NewMockRateLimitCache(ctrl *gomock.Controller) *MockRateLimitCache {
	mock := &MockRateLimitCache{ctrl: ctrl}
	mock.recorder = &MockRateLimitCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRateLimitCache) EXPECT() *MockRateLimitCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockRateLimitCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockRateLimitCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockRateLimitCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockRateLimitCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockRateLimitCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockRateLimitCache)(nil).Clear))
}

// GetRateLimitRules mocks base method.
func (m *MockRateLimitCache) GetRateLimitRules(serviceKey model.ServiceKey) ([]*model.RateLimit, string) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimitRules", serviceKey)
	ret0, _ := ret[0].([]*model.RateLimit)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// GetRateLimitRules indicates an expected call of GetRateLimitRules.
func (mr *MockRateLimitCacheMockRecorder) GetRateLimitRules(serviceKey interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitRules", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitRules), serviceKey)
}

// GetRateLimitsCount mocks base method.
func (m *MockRateLimitCache) GetRateLimitsCount() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimitsCount")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetRateLimitsCount indicates an expected call of GetRateLimitsCount.
func (mr *MockRateLimitCacheMockRecorder) GetRateLimitsCount() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRateLimitsCount", reflect.TypeOf((*MockRateLimitCache)(nil).GetRateLimitsCount))
}

// Initialize mocks base method.
func (m *MockRateLimitCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockRateLimitCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockRateLimitCache)(nil).Initialize), c)
}

// IteratorRateLimit mocks base method.
func (m *MockRateLimitCache) IteratorRateLimit(rateLimitIterProc api.RateLimitIterProc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IteratorRateLimit", rateLimitIterProc)
}

// IteratorRateLimit indicates an expected call of IteratorRateLimit.
func (mr *MockRateLimitCacheMockRecorder) IteratorRateLimit(rateLimitIterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorRateLimit", reflect.TypeOf((*MockRateLimitCache)(nil).IteratorRateLimit), rateLimitIterProc)
}

// Name mocks base method.
func (m *MockRateLimitCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockRateLimitCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockRateLimitCache)(nil).Name))
}

// QueryRateLimitRules mocks base method.
func (m *MockRateLimitCache) QueryRateLimitRules(args api.RateLimitRuleArgs) (uint32, []*model.RateLimit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryRateLimitRules", args)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.RateLimit)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryRateLimitRules indicates an expected call of QueryRateLimitRules.
func (mr *MockRateLimitCacheMockRecorder) QueryRateLimitRules(args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryRateLimitRules", reflect.TypeOf((*MockRateLimitCache)(nil).QueryRateLimitRules), args)
}

// Update mocks base method.
func (m *MockRateLimitCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockRateLimitCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockRateLimitCache)(nil).Update))
}

// MockL5Cache is a mock of L5Cache interface.
type MockL5Cache struct {
	ctrl     *gomock.Controller
	recorder *MockL5CacheMockRecorder
}

// MockL5CacheMockRecorder is the mock recorder for MockL5Cache.
type MockL5CacheMockRecorder struct {
	mock *MockL5Cache
}

// NewMockL5Cache creates a new mock instance.
func NewMockL5Cache(ctrl *gomock.Controller) *MockL5Cache {
	mock := &MockL5Cache{ctrl: ctrl}
	mock.recorder = &MockL5CacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockL5Cache) EXPECT() *MockL5CacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockL5Cache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockL5CacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockL5Cache)(nil).AddListener), listeners)
}

// CheckRouteExisted mocks base method.
func (m *MockL5Cache) CheckRouteExisted(ip, modID, cmdID uint32) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckRouteExisted", ip, modID, cmdID)
	ret0, _ := ret[0].(bool)
	return ret0
}

// CheckRouteExisted indicates an expected call of CheckRouteExisted.
func (mr *MockL5CacheMockRecorder) CheckRouteExisted(ip, modID, cmdID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRouteExisted", reflect.TypeOf((*MockL5Cache)(nil).CheckRouteExisted), ip, modID, cmdID)
}

// Clear mocks base method.
func (m *MockL5Cache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockL5CacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockL5Cache)(nil).Clear))
}

// GetIPConfig mocks base method.
func (m *MockL5Cache) GetIPConfig(ip uint32) *model.IPConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIPConfig", ip)
	ret0, _ := ret[0].(*model.IPConfig)
	return ret0
}

// GetIPConfig indicates an expected call of GetIPConfig.
func (mr *MockL5CacheMockRecorder) GetIPConfig(ip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIPConfig", reflect.TypeOf((*MockL5Cache)(nil).GetIPConfig), ip)
}

// GetPolicy mocks base method.
func (m *MockL5Cache) GetPolicy(modID uint32) *model.Policy {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicy", modID)
	ret0, _ := ret[0].(*model.Policy)
	return ret0
}

// GetPolicy indicates an expected call of GetPolicy.
func (mr *MockL5CacheMockRecorder) GetPolicy(modID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicy", reflect.TypeOf((*MockL5Cache)(nil).GetPolicy), modID)
}

// GetRouteByIP mocks base method.
func (m *MockL5Cache) GetRouteByIP(ip uint32) []*model.Route {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRouteByIP", ip)
	ret0, _ := ret[0].([]*model.Route)
	return ret0
}

// GetRouteByIP indicates an expected call of GetRouteByIP.
func (mr *MockL5CacheMockRecorder) GetRouteByIP(ip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRouteByIP", reflect.TypeOf((*MockL5Cache)(nil).GetRouteByIP), ip)
}

// GetSection mocks base method.
func (m *MockL5Cache) GetSection(modeID uint32) []*model.Section {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSection", modeID)
	ret0, _ := ret[0].([]*model.Section)
	return ret0
}

// GetSection indicates an expected call of GetSection.
func (mr *MockL5CacheMockRecorder) GetSection(modeID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSection", reflect.TypeOf((*MockL5Cache)(nil).GetSection), modeID)
}

// Initialize mocks base method.
func (m *MockL5Cache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockL5CacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockL5Cache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockL5Cache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockL5CacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockL5Cache)(nil).Name))
}

// Update mocks base method.
func (m *MockL5Cache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockL5CacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockL5Cache)(nil).Update))
}

// MockCircuitBreakerCache is a mock of CircuitBreakerCache interface.
type MockCircuitBreakerCache struct {
	ctrl     *gomock.Controller
	recorder *MockCircuitBreakerCacheMockRecorder
}

// MockCircuitBreakerCacheMockRecorder is the mock recorder for MockCircuitBreakerCache.
type MockCircuitBreakerCacheMockRecorder struct {
	mock *MockCircuitBreakerCache
}

// NewMockCircuitBreakerCache creates a new mock instance.
func NewMockCircuitBreakerCache(ctrl *gomock.Controller) *MockCircuitBreakerCache {
	mock := &MockCircuitBreakerCache{ctrl: ctrl}
	mock.recorder = &MockCircuitBreakerCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCircuitBreakerCache) EXPECT() *MockCircuitBreakerCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockCircuitBreakerCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockCircuitBreakerCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockCircuitBreakerCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockCircuitBreakerCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockCircuitBreakerCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Clear))
}

// GetCircuitBreakerConfig mocks base method.
func (m *MockCircuitBreakerCache) GetCircuitBreakerConfig(svcName, namespace string) *model.ServiceWithCircuitBreakerRules {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCircuitBreakerConfig", svcName, namespace)
	ret0, _ := ret[0].(*model.ServiceWithCircuitBreakerRules)
	return ret0
}

// GetCircuitBreakerConfig indicates an expected call of GetCircuitBreakerConfig.
func (mr *MockCircuitBreakerCacheMockRecorder) GetCircuitBreakerConfig(svcName, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCircuitBreakerConfig", reflect.TypeOf((*MockCircuitBreakerCache)(nil).GetCircuitBreakerConfig), svcName, namespace)
}

// Initialize mocks base method.
func (m *MockCircuitBreakerCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockCircuitBreakerCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockCircuitBreakerCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockCircuitBreakerCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Name))
}

// Update mocks base method.
func (m *MockCircuitBreakerCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockCircuitBreakerCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockCircuitBreakerCache)(nil).Update))
}

// MockConfigGroupCache is a mock of ConfigGroupCache interface.
type MockConfigGroupCache struct {
	ctrl     *gomock.Controller
	recorder *MockConfigGroupCacheMockRecorder
}

// MockConfigGroupCacheMockRecorder is the mock recorder for MockConfigGroupCache.
type MockConfigGroupCacheMockRecorder struct {
	mock *MockConfigGroupCache
}

// NewMockConfigGroupCache creates a new mock instance.
func NewMockConfigGroupCache(ctrl *gomock.Controller) *MockConfigGroupCache {
	mock := &MockConfigGroupCache{ctrl: ctrl}
	mock.recorder = &MockConfigGroupCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfigGroupCache) EXPECT() *MockConfigGroupCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockConfigGroupCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockConfigGroupCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockConfigGroupCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockConfigGroupCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockConfigGroupCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockConfigGroupCache)(nil).Clear))
}

// GetGroupByID mocks base method.
func (m *MockConfigGroupCache) GetGroupByID(id uint64) *model.ConfigFileGroup {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByID", id)
	ret0, _ := ret[0].(*model.ConfigFileGroup)
	return ret0
}

// GetGroupByID indicates an expected call of GetGroupByID.
func (mr *MockConfigGroupCacheMockRecorder) GetGroupByID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByID", reflect.TypeOf((*MockConfigGroupCache)(nil).GetGroupByID), id)
}

// GetGroupByName mocks base method.
func (m *MockConfigGroupCache) GetGroupByName(namespace, name string) *model.ConfigFileGroup {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupByName", namespace, name)
	ret0, _ := ret[0].(*model.ConfigFileGroup)
	return ret0
}

// GetGroupByName indicates an expected call of GetGroupByName.
func (mr *MockConfigGroupCacheMockRecorder) GetGroupByName(namespace, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupByName", reflect.TypeOf((*MockConfigGroupCache)(nil).GetGroupByName), namespace, name)
}

// Initialize mocks base method.
func (m *MockConfigGroupCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockConfigGroupCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigGroupCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockConfigGroupCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockConfigGroupCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigGroupCache)(nil).Name))
}

// Query mocks base method.
func (m *MockConfigGroupCache) Query(args *api.ConfigGroupArgs) (uint32, []*model.ConfigFileGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Query", args)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.ConfigFileGroup)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Query indicates an expected call of Query.
func (mr *MockConfigGroupCacheMockRecorder) Query(args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockConfigGroupCache)(nil).Query), args)
}

// Update mocks base method.
func (m *MockConfigGroupCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockConfigGroupCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigGroupCache)(nil).Update))
}

// MockConfigFileCache is a mock of ConfigFileCache interface.
type MockConfigFileCache struct {
	ctrl     *gomock.Controller
	recorder *MockConfigFileCacheMockRecorder
}

// MockConfigFileCacheMockRecorder is the mock recorder for MockConfigFileCache.
type MockConfigFileCacheMockRecorder struct {
	mock *MockConfigFileCache
}

// NewMockConfigFileCache creates a new mock instance.
func NewMockConfigFileCache(ctrl *gomock.Controller) *MockConfigFileCache {
	mock := &MockConfigFileCache{ctrl: ctrl}
	mock.recorder = &MockConfigFileCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockConfigFileCache) EXPECT() *MockConfigFileCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockConfigFileCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockConfigFileCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockConfigFileCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockConfigFileCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockConfigFileCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockConfigFileCache)(nil).Clear))
}

// GetActiveRelease mocks base method.
func (m *MockConfigFileCache) GetActiveRelease(namespace, group, fileName string) *model.ConfigFileRelease {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetActiveRelease", namespace, group, fileName)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	return ret0
}

// GetActiveRelease indicates an expected call of GetActiveRelease.
func (mr *MockConfigFileCacheMockRecorder) GetActiveRelease(namespace, group, fileName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetActiveRelease), namespace, group, fileName)
}

// GetGroupActiveReleases mocks base method.
func (m *MockConfigFileCache) GetGroupActiveReleases(namespace, group string) ([]*model.ConfigFileRelease, string) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupActiveReleases", namespace, group)
	ret0, _ := ret[0].([]*model.ConfigFileRelease)
	ret1, _ := ret[1].(string)
	return ret0, ret1
}

// GetGroupActiveReleases indicates an expected call of GetGroupActiveReleases.
func (mr *MockConfigFileCacheMockRecorder) GetGroupActiveReleases(namespace, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupActiveReleases", reflect.TypeOf((*MockConfigFileCache)(nil).GetGroupActiveReleases), namespace, group)
}

// GetRelease mocks base method.
func (m *MockConfigFileCache) GetRelease(key model.ConfigFileReleaseKey) *model.ConfigFileRelease {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRelease", key)
	ret0, _ := ret[0].(*model.ConfigFileRelease)
	return ret0
}

// GetRelease indicates an expected call of GetRelease.
func (mr *MockConfigFileCacheMockRecorder) GetRelease(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRelease", reflect.TypeOf((*MockConfigFileCache)(nil).GetRelease), key)
}

// Initialize mocks base method.
func (m *MockConfigFileCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockConfigFileCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockConfigFileCache)(nil).Initialize), c)
}

// Name mocks base method.
func (m *MockConfigFileCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockConfigFileCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockConfigFileCache)(nil).Name))
}

// QueryReleases mocks base method.
func (m *MockConfigFileCache) QueryReleases(args *api.ConfigReleaseArgs) (uint32, []*model.SimpleConfigFileRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryReleases", args)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.SimpleConfigFileRelease)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryReleases indicates an expected call of QueryReleases.
func (mr *MockConfigFileCacheMockRecorder) QueryReleases(args interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryReleases", reflect.TypeOf((*MockConfigFileCache)(nil).QueryReleases), args)
}

// Update mocks base method.
func (m *MockConfigFileCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockConfigFileCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConfigFileCache)(nil).Update))
}

// MockUserCache is a mock of UserCache interface.
type MockUserCache struct {
	ctrl     *gomock.Controller
	recorder *MockUserCacheMockRecorder
}

// MockUserCacheMockRecorder is the mock recorder for MockUserCache.
type MockUserCacheMockRecorder struct {
	mock *MockUserCache
}

// NewMockUserCache creates a new mock instance.
func NewMockUserCache(ctrl *gomock.Controller) *MockUserCache {
	mock := &MockUserCache{ctrl: ctrl}
	mock.recorder = &MockUserCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockUserCache) EXPECT() *MockUserCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockUserCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockUserCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockUserCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockUserCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockUserCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockUserCache)(nil).Clear))
}

// GetAdmin mocks base method.
func (m *MockUserCache) GetAdmin() *model.User {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAdmin")
	ret0, _ := ret[0].(*model.User)
	return ret0
}

// GetAdmin indicates an expected call of GetAdmin.
func (mr *MockUserCacheMockRecorder) GetAdmin() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAdmin", reflect.TypeOf((*MockUserCache)(nil).GetAdmin))
}

// GetGroup mocks base method.
func (m *MockUserCache) GetGroup(id string) *model.UserGroupDetail {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroup", id)
	ret0, _ := ret[0].(*model.UserGroupDetail)
	return ret0
}

// GetGroup indicates an expected call of GetGroup.
func (mr *MockUserCacheMockRecorder) GetGroup(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockUserCache)(nil).GetGroup), id)
}

// GetUserByID mocks base method.
func (m *MockUserCache) GetUserByID(id string) *model.User {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByID", id)
	ret0, _ := ret[0].(*model.User)
	return ret0
}

// GetUserByID indicates an expected call of GetUserByID.
func (mr *MockUserCacheMockRecorder) GetUserByID(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByID", reflect.TypeOf((*MockUserCache)(nil).GetUserByID), id)
}

// GetUserByName mocks base method.
func (m *MockUserCache) GetUserByName(name, ownerName string) *model.User {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserByName", name, ownerName)
	ret0, _ := ret[0].(*model.User)
	return ret0
}

// GetUserByName indicates an expected call of GetUserByName.
func (mr *MockUserCacheMockRecorder) GetUserByName(name, ownerName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByName", reflect.TypeOf((*MockUserCache)(nil).GetUserByName), name, ownerName)
}

// GetUserLinkGroupIds mocks base method.
func (m *MockUserCache) GetUserLinkGroupIds(id string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserLinkGroupIds", id)
	ret0, _ := ret[0].([]string)
	return ret0
}

// GetUserLinkGroupIds indicates an expected call of GetUserLinkGroupIds.
func (mr *MockUserCacheMockRecorder) GetUserLinkGroupIds(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserLinkGroupIds", reflect.TypeOf((*MockUserCache)(nil).GetUserLinkGroupIds), id)
}

// Initialize mocks base method.
func (m *MockUserCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockUserCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockUserCache)(nil).Initialize), c)
}

// IsOwner mocks base method.
func (m *MockUserCache) IsOwner(id string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsOwner", id)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsOwner indicates an expected call of IsOwner.
func (mr *MockUserCacheMockRecorder) IsOwner(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOwner", reflect.TypeOf((*MockUserCache)(nil).IsOwner), id)
}

// IsUserInGroup mocks base method.
func (m *MockUserCache) IsUserInGroup(userId, groupId string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsUserInGroup", userId, groupId)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsUserInGroup indicates an expected call of IsUserInGroup.
func (mr *MockUserCacheMockRecorder) IsUserInGroup(userId, groupId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUserInGroup", reflect.TypeOf((*MockUserCache)(nil).IsUserInGroup), userId, groupId)
}

// Name mocks base method.
func (m *MockUserCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockUserCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockUserCache)(nil).Name))
}

// Update mocks base method.
func (m *MockUserCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockUserCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockUserCache)(nil).Update))
}

// MockStrategyCache is a mock of StrategyCache interface.
type MockStrategyCache struct {
	ctrl     *gomock.Controller
	recorder *MockStrategyCacheMockRecorder
}

// MockStrategyCacheMockRecorder is the mock recorder for MockStrategyCache.
type MockStrategyCacheMockRecorder struct {
	mock *MockStrategyCache
}

// NewMockStrategyCache creates a new mock instance.
func NewMockStrategyCache(ctrl *gomock.Controller) *MockStrategyCache {
	mock := &MockStrategyCache{ctrl: ctrl}
	mock.recorder = &MockStrategyCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockStrategyCache) EXPECT() *MockStrategyCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockStrategyCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockStrategyCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockStrategyCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockStrategyCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockStrategyCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockStrategyCache)(nil).Clear))
}

// ForceSync mocks base method.
func (m *MockStrategyCache) ForceSync() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceSync")
	ret0, _ := ret[0].(error)
	return ret0
}

// ForceSync indicates an expected call of ForceSync.
func (mr *MockStrategyCacheMockRecorder) ForceSync() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceSync", reflect.TypeOf((*MockStrategyCache)(nil).ForceSync))
}

// GetStrategyDetailsByGroupID mocks base method.
func (m *MockStrategyCache) GetStrategyDetailsByGroupID(groupId string) []*model.StrategyDetail {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategyDetailsByGroupID", groupId)
	ret0, _ := ret[0].([]*model.StrategyDetail)
	return ret0
}

// GetStrategyDetailsByGroupID indicates an expected call of GetStrategyDetailsByGroupID.
func (mr *MockStrategyCacheMockRecorder) GetStrategyDetailsByGroupID(groupId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategyDetailsByGroupID", reflect.TypeOf((*MockStrategyCache)(nil).GetStrategyDetailsByGroupID), groupId)
}

// GetStrategyDetailsByUID mocks base method.
func (m *MockStrategyCache) GetStrategyDetailsByUID(uid string) []*model.StrategyDetail {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStrategyDetailsByUID", uid)
	ret0, _ := ret[0].([]*model.StrategyDetail)
	return ret0
}

// GetStrategyDetailsByUID indicates an expected call of GetStrategyDetailsByUID.
func (mr *MockStrategyCacheMockRecorder) GetStrategyDetailsByUID(uid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStrategyDetailsByUID", reflect.TypeOf((*MockStrategyCache)(nil).GetStrategyDetailsByUID), uid)
}

// Initialize mocks base method.
func (m *MockStrategyCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockStrategyCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockStrategyCache)(nil).Initialize), c)
}

// IsResourceEditable mocks base method.
func (m *MockStrategyCache) IsResourceEditable(principal model.Principal, resType security.ResourceType, resId string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsResourceEditable", principal, resType, resId)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsResourceEditable indicates an expected call of IsResourceEditable.
func (mr *MockStrategyCacheMockRecorder) IsResourceEditable(principal, resType, resId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResourceEditable", reflect.TypeOf((*MockStrategyCache)(nil).IsResourceEditable), principal, resType, resId)
}

// IsResourceLinkStrategy mocks base method.
func (m *MockStrategyCache) IsResourceLinkStrategy(resType security.ResourceType, resId string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsResourceLinkStrategy", resType, resId)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsResourceLinkStrategy indicates an expected call of IsResourceLinkStrategy.
func (mr *MockStrategyCacheMockRecorder) IsResourceLinkStrategy(resType, resId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResourceLinkStrategy", reflect.TypeOf((*MockStrategyCache)(nil).IsResourceLinkStrategy), resType, resId)
}

// Name mocks base method.
func (m *MockStrategyCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockStrategyCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockStrategyCache)(nil).Name))
}

// Update mocks base method.
func (m *MockStrategyCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockStrategyCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockStrategyCache)(nil).Update))
}

// MockClientCache is a mock of ClientCache interface.
type MockClientCache struct {
	ctrl     *gomock.Controller
	recorder *MockClientCacheMockRecorder
}

// MockClientCacheMockRecorder is the mock recorder for MockClientCache.
type MockClientCacheMockRecorder struct {
	mock *MockClientCache
}

// NewMockClientCache creates a new mock instance.
func NewMockClientCache(ctrl *gomock.Controller) *MockClientCache {
	mock := &MockClientCache{ctrl: ctrl}
	mock.recorder = &MockClientCacheMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClientCache) EXPECT() *MockClientCacheMockRecorder {
	return m.recorder
}

// AddListener mocks base method.
func (m *MockClientCache) AddListener(listeners []api.Listener) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddListener", listeners)
}

// AddListener indicates an expected call of AddListener.
func (mr *MockClientCacheMockRecorder) AddListener(listeners interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListener", reflect.TypeOf((*MockClientCache)(nil).AddListener), listeners)
}

// Clear mocks base method.
func (m *MockClientCache) Clear() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clear")
	ret0, _ := ret[0].(error)
	return ret0
}

// Clear indicates an expected call of Clear.
func (mr *MockClientCacheMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockClientCache)(nil).Clear))
}

// GetClient mocks base method.
func (m *MockClientCache) GetClient(id string) *model.Client {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient", id)
	ret0, _ := ret[0].(*model.Client)
	return ret0
}

// GetClient indicates an expected call of GetClient.
func (mr *MockClientCacheMockRecorder) GetClient(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientCache)(nil).GetClient), id)
}

// GetClientsByFilter mocks base method.
func (m *MockClientCache) GetClientsByFilter(filters map[string]string, offset, limit uint32) (uint32, []*model.Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClientsByFilter", filters, offset, limit)
	ret0, _ := ret[0].(uint32)
	ret1, _ := ret[1].([]*model.Client)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClientsByFilter indicates an expected call of GetClientsByFilter.
func (mr *MockClientCacheMockRecorder) GetClientsByFilter(filters, offset, limit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientsByFilter", reflect.TypeOf((*MockClientCache)(nil).GetClientsByFilter), filters, offset, limit)
}

// Initialize mocks base method.
func (m *MockClientCache) Initialize(c map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Initialize", c)
	ret0, _ := ret[0].(error)
	return ret0
}

// Initialize indicates an expected call of Initialize.
func (mr *MockClientCacheMockRecorder) Initialize(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Initialize", reflect.TypeOf((*MockClientCache)(nil).Initialize), c)
}

// IteratorClients mocks base method.
func (m *MockClientCache) IteratorClients(iterProc api.ClientIterProc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IteratorClients", iterProc)
}

// IteratorClients indicates an expected call of IteratorClients.
func (mr *MockClientCacheMockRecorder) IteratorClients(iterProc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IteratorClients", reflect.TypeOf((*MockClientCache)(nil).IteratorClients), iterProc)
}

// Name mocks base method.
func (m *MockClientCache) Name() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Name")
	ret0, _ := ret[0].(string)
	return ret0
}

// Name indicates an expected call of Name.
func (mr *MockClientCacheMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockClientCache)(nil).Name))
}

// Update mocks base method.
func (m *MockClientCache) Update() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update")
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockClientCacheMockRecorder) Update() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockClientCache)(nil).Update))
}