// Code generated by MockGen. DO NOT EDIT.
// Source: /home/users/weihaoyu/go/pkg/mod/github.com/apolloconfig/agollo/v4@v4.1.1/agcache/cache.go

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

import (
	reflect "reflect"

	agcache "github.com/apolloconfig/agollo/v4/agcache"
	gomock "github.com/golang/mock/gomock"
)

// MockCacheInterface is a mock of CacheInterface interface.
type MockCacheInterface struct {
	ctrl     *gomock.Controller
	recorder *MockCacheInterfaceMockRecorder
}

// MockCacheInterfaceMockRecorder is the mock recorder for MockCacheInterface.
type MockCacheInterfaceMockRecorder struct {
	mock *MockCacheInterface
}

// NewMockCacheInterface creates a new mock instance.
func NewMockCacheInterface(ctrl *gomock.Controller) *MockCacheInterface {
	mock := &MockCacheInterface{ctrl: ctrl}
	mock.recorder = &MockCacheInterfaceMockRecorder{mock}
	return mock
}

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

// Clear mocks base method.
func (m *MockCacheInterface) Clear() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Clear")
}

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

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

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

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

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

// Get mocks base method.
func (m *MockCacheInterface) Get(key string) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Range mocks base method.
func (m *MockCacheInterface) Range(f func(interface{}, interface{}) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Range", f)
}

// Range indicates an expected call of Range.
func (mr *MockCacheInterfaceMockRecorder) Range(f interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Range", reflect.TypeOf((*MockCacheInterface)(nil).Range), f)
}

// Set mocks base method.
func (m *MockCacheInterface) Set(key string, value interface{}, expireSeconds int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", key, value, expireSeconds)
	ret0, _ := ret[0].(error)
	return ret0
}

// Set indicates an expected call of Set.
func (mr *MockCacheInterfaceMockRecorder) Set(key, value, expireSeconds interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCacheInterface)(nil).Set), key, value, expireSeconds)
}

// MockCacheFactory is a mock of CacheFactory interface.
type MockCacheFactory struct {
	ctrl     *gomock.Controller
	recorder *MockCacheFactoryMockRecorder
}

// MockCacheFactoryMockRecorder is the mock recorder for MockCacheFactory.
type MockCacheFactoryMockRecorder struct {
	mock *MockCacheFactory
}

// NewMockCacheFactory creates a new mock instance.
func NewMockCacheFactory(ctrl *gomock.Controller) *MockCacheFactory {
	mock := &MockCacheFactory{ctrl: ctrl}
	mock.recorder = &MockCacheFactoryMockRecorder{mock}
	return mock
}

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

// Create mocks base method.
func (m *MockCacheFactory) Create() agcache.CacheInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create")
	ret0, _ := ret[0].(agcache.CacheInterface)
	return ret0
}

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