// Code generated by MockGen. DO NOT EDIT.
// Source: cache.go
//
// Generated by this command:
//
//	mockgen -package cache -source cache.go -destination interface_mock.go -self_package github.com/uber/cadence/common/cache
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"

	metrics "github.com/uber/cadence/common/metrics"
)

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

// 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
}

// Delete mocks base method.
func (m *MockCache) Delete(key any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Delete", key)
}

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

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

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

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

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

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

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

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

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

// Release mocks base method.
func (m *MockCache) Release(key any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Release", key)
}

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

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

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

// MockIterator is a mock of Iterator interface.
type MockIterator struct {
	ctrl     *gomock.Controller
	recorder *MockIteratorMockRecorder
	isgomock struct{}
}

// MockIteratorMockRecorder is the mock recorder for MockIterator.
type MockIteratorMockRecorder struct {
	mock *MockIterator
}

// NewMockIterator creates a new mock instance.
func NewMockIterator(ctrl *gomock.Controller) *MockIterator {
	mock := &MockIterator{ctrl: ctrl}
	mock.recorder = &MockIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockEntry is a mock of Entry interface.
type MockEntry struct {
	ctrl     *gomock.Controller
	recorder *MockEntryMockRecorder
	isgomock struct{}
}

// MockEntryMockRecorder is the mock recorder for MockEntry.
type MockEntryMockRecorder struct {
	mock *MockEntry
}

// NewMockEntry creates a new mock instance.
func NewMockEntry(ctrl *gomock.Controller) *MockEntry {
	mock := &MockEntry{ctrl: ctrl}
	mock.recorder = &MockEntryMockRecorder{mock}
	return mock
}

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

// CreateTime mocks base method.
func (m *MockEntry) CreateTime() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTime")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

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

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

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

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

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

// MockDomainMetricsScopeCache is a mock of DomainMetricsScopeCache interface.
type MockDomainMetricsScopeCache struct {
	ctrl     *gomock.Controller
	recorder *MockDomainMetricsScopeCacheMockRecorder
	isgomock struct{}
}

// MockDomainMetricsScopeCacheMockRecorder is the mock recorder for MockDomainMetricsScopeCache.
type MockDomainMetricsScopeCacheMockRecorder struct {
	mock *MockDomainMetricsScopeCache
}

// NewMockDomainMetricsScopeCache creates a new mock instance.
func NewMockDomainMetricsScopeCache(ctrl *gomock.Controller) *MockDomainMetricsScopeCache {
	mock := &MockDomainMetricsScopeCache{ctrl: ctrl}
	mock.recorder = &MockDomainMetricsScopeCacheMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockDomainMetricsScopeCache) Get(domainID string, scopeIdx metrics.ScopeIdx) (metrics.Scope, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", domainID, scopeIdx)
	ret0, _ := ret[0].(metrics.Scope)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockDomainMetricsScopeCacheMockRecorder) Get(domainID, scopeIdx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDomainMetricsScopeCache)(nil).Get), domainID, scopeIdx)
}

// Put mocks base method.
func (m *MockDomainMetricsScopeCache) Put(domainID string, scopeIdx metrics.ScopeIdx, metricsScope metrics.Scope) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", domainID, scopeIdx, metricsScope)
}

// Put indicates an expected call of Put.
func (mr *MockDomainMetricsScopeCacheMockRecorder) Put(domainID, scopeIdx, metricsScope any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockDomainMetricsScopeCache)(nil).Put), domainID, scopeIdx, metricsScope)
}

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

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

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

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

// MockSizeable is a mock of Sizeable interface.
type MockSizeable struct {
	ctrl     *gomock.Controller
	recorder *MockSizeableMockRecorder
	isgomock struct{}
}

// MockSizeableMockRecorder is the mock recorder for MockSizeable.
type MockSizeableMockRecorder struct {
	mock *MockSizeable
}

// NewMockSizeable creates a new mock instance.
func NewMockSizeable(ctrl *gomock.Controller) *MockSizeable {
	mock := &MockSizeable{ctrl: ctrl}
	mock.recorder = &MockSizeableMockRecorder{mock}
	return mock
}

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

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

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