Dragonfly2

1
// Code generated by MockGen. DO NOT EDIT.
2
// Source: cache.go
3
//
4
// Generated by this command:
5
//
6
//	mockgen -destination cache_mock.go -source cache.go -package cache
7
//
8
// Package cache is a generated GoMock package.
9
package cache
10

11
import (
12
	io "io"
13
	reflect "reflect"
14
	time "time"
15

16
	gomock "go.uber.org/mock/gomock"
17
)
18

19
// MockCache is a mock of Cache interface.
20
type MockCache struct {
21
	ctrl     *gomock.Controller
22
	recorder *MockCacheMockRecorder
23
}
24

25
// MockCacheMockRecorder is the mock recorder for MockCache.
26
type MockCacheMockRecorder struct {
27
	mock *MockCache
28
}
29

30
// NewMockCache creates a new mock instance.
31
func NewMockCache(ctrl *gomock.Controller) *MockCache {
32
	mock := &MockCache{ctrl: ctrl}
33
	mock.recorder = &MockCacheMockRecorder{mock}
34
	return mock
35
}
36

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

42
// Add mocks base method.
43
func (m *MockCache) Add(k string, x any, d time.Duration) error {
44
	m.ctrl.T.Helper()
45
	ret := m.ctrl.Call(m, "Add", k, x, d)
46
	ret0, _ := ret[0].(error)
47
	return ret0
48
}
49

50
// Add indicates an expected call of Add.
51
func (mr *MockCacheMockRecorder) Add(k, x, d any) *gomock.Call {
52
	mr.mock.ctrl.T.Helper()
53
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockCache)(nil).Add), k, x, d)
54
}
55

56
// Delete mocks base method.
57
func (m *MockCache) Delete(k string) {
58
	m.ctrl.T.Helper()
59
	m.ctrl.Call(m, "Delete", k)
60
}
61

62
// Delete indicates an expected call of Delete.
63
func (mr *MockCacheMockRecorder) Delete(k any) *gomock.Call {
64
	mr.mock.ctrl.T.Helper()
65
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCache)(nil).Delete), k)
66
}
67

68
// DeleteExpired mocks base method.
69
func (m *MockCache) DeleteExpired() {
70
	m.ctrl.T.Helper()
71
	m.ctrl.Call(m, "DeleteExpired")
72
}
73

74
// DeleteExpired indicates an expected call of DeleteExpired.
75
func (mr *MockCacheMockRecorder) DeleteExpired() *gomock.Call {
76
	mr.mock.ctrl.T.Helper()
77
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExpired", reflect.TypeOf((*MockCache)(nil).DeleteExpired))
78
}
79

80
// Flush mocks base method.
81
func (m *MockCache) Flush() {
82
	m.ctrl.T.Helper()
83
	m.ctrl.Call(m, "Flush")
84
}
85

86
// Flush indicates an expected call of Flush.
87
func (mr *MockCacheMockRecorder) Flush() *gomock.Call {
88
	mr.mock.ctrl.T.Helper()
89
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockCache)(nil).Flush))
90
}
91

92
// Get mocks base method.
93
func (m *MockCache) Get(k string) (any, bool) {
94
	m.ctrl.T.Helper()
95
	ret := m.ctrl.Call(m, "Get", k)
96
	ret0, _ := ret[0].(any)
97
	ret1, _ := ret[1].(bool)
98
	return ret0, ret1
99
}
100

101
// Get indicates an expected call of Get.
102
func (mr *MockCacheMockRecorder) Get(k any) *gomock.Call {
103
	mr.mock.ctrl.T.Helper()
104
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCache)(nil).Get), k)
105
}
106

107
// GetWithExpiration mocks base method.
108
func (m *MockCache) GetWithExpiration(k string) (any, time.Time, bool) {
109
	m.ctrl.T.Helper()
110
	ret := m.ctrl.Call(m, "GetWithExpiration", k)
111
	ret0, _ := ret[0].(any)
112
	ret1, _ := ret[1].(time.Time)
113
	ret2, _ := ret[2].(bool)
114
	return ret0, ret1, ret2
115
}
116

117
// GetWithExpiration indicates an expected call of GetWithExpiration.
118
func (mr *MockCacheMockRecorder) GetWithExpiration(k any) *gomock.Call {
119
	mr.mock.ctrl.T.Helper()
120
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWithExpiration", reflect.TypeOf((*MockCache)(nil).GetWithExpiration), k)
121
}
122

123
// ItemCount mocks base method.
124
func (m *MockCache) ItemCount() int {
125
	m.ctrl.T.Helper()
126
	ret := m.ctrl.Call(m, "ItemCount")
127
	ret0, _ := ret[0].(int)
128
	return ret0
129
}
130

131
// ItemCount indicates an expected call of ItemCount.
132
func (mr *MockCacheMockRecorder) ItemCount() *gomock.Call {
133
	mr.mock.ctrl.T.Helper()
134
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ItemCount", reflect.TypeOf((*MockCache)(nil).ItemCount))
135
}
136

137
// Items mocks base method.
138
func (m *MockCache) Items() map[string]Item {
139
	m.ctrl.T.Helper()
140
	ret := m.ctrl.Call(m, "Items")
141
	ret0, _ := ret[0].(map[string]Item)
142
	return ret0
143
}
144

145
// Items indicates an expected call of Items.
146
func (mr *MockCacheMockRecorder) Items() *gomock.Call {
147
	mr.mock.ctrl.T.Helper()
148
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Items", reflect.TypeOf((*MockCache)(nil).Items))
149
}
150

151
// Keys mocks base method.
152
func (m *MockCache) Keys() []string {
153
	m.ctrl.T.Helper()
154
	ret := m.ctrl.Call(m, "Keys")
155
	ret0, _ := ret[0].([]string)
156
	return ret0
157
}
158

159
// Keys indicates an expected call of Keys.
160
func (mr *MockCacheMockRecorder) Keys() *gomock.Call {
161
	mr.mock.ctrl.T.Helper()
162
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCache)(nil).Keys))
163
}
164

165
// Load mocks base method.
166
func (m *MockCache) Load(r io.Reader) error {
167
	m.ctrl.T.Helper()
168
	ret := m.ctrl.Call(m, "Load", r)
169
	ret0, _ := ret[0].(error)
170
	return ret0
171
}
172

173
// Load indicates an expected call of Load.
174
func (mr *MockCacheMockRecorder) Load(r any) *gomock.Call {
175
	mr.mock.ctrl.T.Helper()
176
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockCache)(nil).Load), r)
177
}
178

179
// LoadFile mocks base method.
180
func (m *MockCache) LoadFile(fname string) error {
181
	m.ctrl.T.Helper()
182
	ret := m.ctrl.Call(m, "LoadFile", fname)
183
	ret0, _ := ret[0].(error)
184
	return ret0
185
}
186

187
// LoadFile indicates an expected call of LoadFile.
188
func (mr *MockCacheMockRecorder) LoadFile(fname any) *gomock.Call {
189
	mr.mock.ctrl.T.Helper()
190
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadFile", reflect.TypeOf((*MockCache)(nil).LoadFile), fname)
191
}
192

193
// OnEvicted mocks base method.
194
func (m *MockCache) OnEvicted(f func(string, any)) {
195
	m.ctrl.T.Helper()
196
	m.ctrl.Call(m, "OnEvicted", f)
197
}
198

199
// OnEvicted indicates an expected call of OnEvicted.
200
func (mr *MockCacheMockRecorder) OnEvicted(f any) *gomock.Call {
201
	mr.mock.ctrl.T.Helper()
202
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnEvicted", reflect.TypeOf((*MockCache)(nil).OnEvicted), f)
203
}
204

205
// Save mocks base method.
206
func (m *MockCache) Save(w io.Writer) error {
207
	m.ctrl.T.Helper()
208
	ret := m.ctrl.Call(m, "Save", w)
209
	ret0, _ := ret[0].(error)
210
	return ret0
211
}
212

213
// Save indicates an expected call of Save.
214
func (mr *MockCacheMockRecorder) Save(w any) *gomock.Call {
215
	mr.mock.ctrl.T.Helper()
216
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCache)(nil).Save), w)
217
}
218

219
// SaveFile mocks base method.
220
func (m *MockCache) SaveFile(fname string) error {
221
	m.ctrl.T.Helper()
222
	ret := m.ctrl.Call(m, "SaveFile", fname)
223
	ret0, _ := ret[0].(error)
224
	return ret0
225
}
226

227
// SaveFile indicates an expected call of SaveFile.
228
func (mr *MockCacheMockRecorder) SaveFile(fname any) *gomock.Call {
229
	mr.mock.ctrl.T.Helper()
230
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveFile", reflect.TypeOf((*MockCache)(nil).SaveFile), fname)
231
}
232

233
// Scan mocks base method.
234
func (m_2 *MockCache) Scan(m string, n int) ([]string, error) {
235
	m_2.ctrl.T.Helper()
236
	ret := m_2.ctrl.Call(m_2, "Scan", m, n)
237
	ret0, _ := ret[0].([]string)
238
	ret1, _ := ret[1].(error)
239
	return ret0, ret1
240
}
241

242
// Scan indicates an expected call of Scan.
243
func (mr *MockCacheMockRecorder) Scan(m, n any) *gomock.Call {
244
	mr.mock.ctrl.T.Helper()
245
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockCache)(nil).Scan), m, n)
246
}
247

248
// Set mocks base method.
249
func (m *MockCache) Set(k string, x any, d time.Duration) {
250
	m.ctrl.T.Helper()
251
	m.ctrl.Call(m, "Set", k, x, d)
252
}
253

254
// Set indicates an expected call of Set.
255
func (mr *MockCacheMockRecorder) Set(k, x, d any) *gomock.Call {
256
	mr.mock.ctrl.T.Helper()
257
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCache)(nil).Set), k, x, d)
258
}
259

260
// SetDefault mocks base method.
261
func (m *MockCache) SetDefault(k string, x any) {
262
	m.ctrl.T.Helper()
263
	m.ctrl.Call(m, "SetDefault", k, x)
264
}
265

266
// SetDefault indicates an expected call of SetDefault.
267
func (mr *MockCacheMockRecorder) SetDefault(k, x any) *gomock.Call {
268
	mr.mock.ctrl.T.Helper()
269
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefault", reflect.TypeOf((*MockCache)(nil).SetDefault), k, x)
270
}
271