Dragonfly2

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

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

17
	common "d7y.io/api/v2/pkg/apis/common/v1"
18
	storage "d7y.io/dragonfly/v2/client/daemon/storage"
19
	http "d7y.io/dragonfly/v2/pkg/net/http"
20
	gomock "go.uber.org/mock/gomock"
21
)
22

23
// MockTaskStorageDriver is a mock of TaskStorageDriver interface.
24
type MockTaskStorageDriver struct {
25
	ctrl     *gomock.Controller
26
	recorder *MockTaskStorageDriverMockRecorder
27
}
28

29
// MockTaskStorageDriverMockRecorder is the mock recorder for MockTaskStorageDriver.
30
type MockTaskStorageDriverMockRecorder struct {
31
	mock *MockTaskStorageDriver
32
}
33

34
// NewMockTaskStorageDriver creates a new mock instance.
35
func NewMockTaskStorageDriver(ctrl *gomock.Controller) *MockTaskStorageDriver {
36
	mock := &MockTaskStorageDriver{ctrl: ctrl}
37
	mock.recorder = &MockTaskStorageDriverMockRecorder{mock}
38
	return mock
39
}
40

41
// EXPECT returns an object that allows the caller to indicate expected use.
42
func (m *MockTaskStorageDriver) EXPECT() *MockTaskStorageDriverMockRecorder {
43
	return m.recorder
44
}
45

46
// GetExtendAttribute mocks base method.
47
func (m *MockTaskStorageDriver) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*common.ExtendAttribute, error) {
48
	m.ctrl.T.Helper()
49
	ret := m.ctrl.Call(m, "GetExtendAttribute", ctx, req)
50
	ret0, _ := ret[0].(*common.ExtendAttribute)
51
	ret1, _ := ret[1].(error)
52
	return ret0, ret1
53
}
54

55
// GetExtendAttribute indicates an expected call of GetExtendAttribute.
56
func (mr *MockTaskStorageDriverMockRecorder) GetExtendAttribute(ctx, req any) *gomock.Call {
57
	mr.mock.ctrl.T.Helper()
58
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExtendAttribute", reflect.TypeOf((*MockTaskStorageDriver)(nil).GetExtendAttribute), ctx, req)
59
}
60

61
// GetPieces mocks base method.
62
func (m *MockTaskStorageDriver) GetPieces(ctx context.Context, req *common.PieceTaskRequest) (*common.PiecePacket, error) {
63
	m.ctrl.T.Helper()
64
	ret := m.ctrl.Call(m, "GetPieces", ctx, req)
65
	ret0, _ := ret[0].(*common.PiecePacket)
66
	ret1, _ := ret[1].(error)
67
	return ret0, ret1
68
}
69

70
// GetPieces indicates an expected call of GetPieces.
71
func (mr *MockTaskStorageDriverMockRecorder) GetPieces(ctx, req any) *gomock.Call {
72
	mr.mock.ctrl.T.Helper()
73
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieces", reflect.TypeOf((*MockTaskStorageDriver)(nil).GetPieces), ctx, req)
74
}
75

76
// GetTotalPieces mocks base method.
77
func (m *MockTaskStorageDriver) GetTotalPieces(ctx context.Context, req *storage.PeerTaskMetadata) (int32, error) {
78
	m.ctrl.T.Helper()
79
	ret := m.ctrl.Call(m, "GetTotalPieces", ctx, req)
80
	ret0, _ := ret[0].(int32)
81
	ret1, _ := ret[1].(error)
82
	return ret0, ret1
83
}
84

85
// GetTotalPieces indicates an expected call of GetTotalPieces.
86
func (mr *MockTaskStorageDriverMockRecorder) GetTotalPieces(ctx, req any) *gomock.Call {
87
	mr.mock.ctrl.T.Helper()
88
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalPieces", reflect.TypeOf((*MockTaskStorageDriver)(nil).GetTotalPieces), ctx, req)
89
}
90

91
// IsInvalid mocks base method.
92
func (m *MockTaskStorageDriver) IsInvalid(req *storage.PeerTaskMetadata) (bool, error) {
93
	m.ctrl.T.Helper()
94
	ret := m.ctrl.Call(m, "IsInvalid", req)
95
	ret0, _ := ret[0].(bool)
96
	ret1, _ := ret[1].(error)
97
	return ret0, ret1
98
}
99

100
// IsInvalid indicates an expected call of IsInvalid.
101
func (mr *MockTaskStorageDriverMockRecorder) IsInvalid(req any) *gomock.Call {
102
	mr.mock.ctrl.T.Helper()
103
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInvalid", reflect.TypeOf((*MockTaskStorageDriver)(nil).IsInvalid), req)
104
}
105

106
// ReadAllPieces mocks base method.
107
func (m *MockTaskStorageDriver) ReadAllPieces(ctx context.Context, req *storage.ReadAllPiecesRequest) (io.ReadCloser, error) {
108
	m.ctrl.T.Helper()
109
	ret := m.ctrl.Call(m, "ReadAllPieces", ctx, req)
110
	ret0, _ := ret[0].(io.ReadCloser)
111
	ret1, _ := ret[1].(error)
112
	return ret0, ret1
113
}
114

115
// ReadAllPieces indicates an expected call of ReadAllPieces.
116
func (mr *MockTaskStorageDriverMockRecorder) ReadAllPieces(ctx, req any) *gomock.Call {
117
	mr.mock.ctrl.T.Helper()
118
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAllPieces", reflect.TypeOf((*MockTaskStorageDriver)(nil).ReadAllPieces), ctx, req)
119
}
120

121
// ReadPiece mocks base method.
122
func (m *MockTaskStorageDriver) ReadPiece(ctx context.Context, req *storage.ReadPieceRequest) (io.Reader, io.Closer, error) {
123
	m.ctrl.T.Helper()
124
	ret := m.ctrl.Call(m, "ReadPiece", ctx, req)
125
	ret0, _ := ret[0].(io.Reader)
126
	ret1, _ := ret[1].(io.Closer)
127
	ret2, _ := ret[2].(error)
128
	return ret0, ret1, ret2
129
}
130

131
// ReadPiece indicates an expected call of ReadPiece.
132
func (mr *MockTaskStorageDriverMockRecorder) ReadPiece(ctx, req any) *gomock.Call {
133
	mr.mock.ctrl.T.Helper()
134
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPiece", reflect.TypeOf((*MockTaskStorageDriver)(nil).ReadPiece), ctx, req)
135
}
136

137
// Store mocks base method.
138
func (m *MockTaskStorageDriver) Store(ctx context.Context, req *storage.StoreRequest) error {
139
	m.ctrl.T.Helper()
140
	ret := m.ctrl.Call(m, "Store", ctx, req)
141
	ret0, _ := ret[0].(error)
142
	return ret0
143
}
144

145
// Store indicates an expected call of Store.
146
func (mr *MockTaskStorageDriverMockRecorder) Store(ctx, req any) *gomock.Call {
147
	mr.mock.ctrl.T.Helper()
148
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Store", reflect.TypeOf((*MockTaskStorageDriver)(nil).Store), ctx, req)
149
}
150

151
// UpdateTask mocks base method.
152
func (m *MockTaskStorageDriver) UpdateTask(ctx context.Context, req *storage.UpdateTaskRequest) error {
153
	m.ctrl.T.Helper()
154
	ret := m.ctrl.Call(m, "UpdateTask", ctx, req)
155
	ret0, _ := ret[0].(error)
156
	return ret0
157
}
158

159
// UpdateTask indicates an expected call of UpdateTask.
160
func (mr *MockTaskStorageDriverMockRecorder) UpdateTask(ctx, req any) *gomock.Call {
161
	mr.mock.ctrl.T.Helper()
162
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockTaskStorageDriver)(nil).UpdateTask), ctx, req)
163
}
164

165
// ValidateDigest mocks base method.
166
func (m *MockTaskStorageDriver) ValidateDigest(req *storage.PeerTaskMetadata) error {
167
	m.ctrl.T.Helper()
168
	ret := m.ctrl.Call(m, "ValidateDigest", req)
169
	ret0, _ := ret[0].(error)
170
	return ret0
171
}
172

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

179
// WritePiece mocks base method.
180
func (m *MockTaskStorageDriver) WritePiece(ctx context.Context, req *storage.WritePieceRequest) (int64, error) {
181
	m.ctrl.T.Helper()
182
	ret := m.ctrl.Call(m, "WritePiece", ctx, req)
183
	ret0, _ := ret[0].(int64)
184
	ret1, _ := ret[1].(error)
185
	return ret0, ret1
186
}
187

188
// WritePiece indicates an expected call of WritePiece.
189
func (mr *MockTaskStorageDriverMockRecorder) WritePiece(ctx, req any) *gomock.Call {
190
	mr.mock.ctrl.T.Helper()
191
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WritePiece", reflect.TypeOf((*MockTaskStorageDriver)(nil).WritePiece), ctx, req)
192
}
193

194
// MockReclaimer is a mock of Reclaimer interface.
195
type MockReclaimer struct {
196
	ctrl     *gomock.Controller
197
	recorder *MockReclaimerMockRecorder
198
}
199

200
// MockReclaimerMockRecorder is the mock recorder for MockReclaimer.
201
type MockReclaimerMockRecorder struct {
202
	mock *MockReclaimer
203
}
204

205
// NewMockReclaimer creates a new mock instance.
206
func NewMockReclaimer(ctrl *gomock.Controller) *MockReclaimer {
207
	mock := &MockReclaimer{ctrl: ctrl}
208
	mock.recorder = &MockReclaimerMockRecorder{mock}
209
	return mock
210
}
211

212
// EXPECT returns an object that allows the caller to indicate expected use.
213
func (m *MockReclaimer) EXPECT() *MockReclaimerMockRecorder {
214
	return m.recorder
215
}
216

217
// CanReclaim mocks base method.
218
func (m *MockReclaimer) CanReclaim() bool {
219
	m.ctrl.T.Helper()
220
	ret := m.ctrl.Call(m, "CanReclaim")
221
	ret0, _ := ret[0].(bool)
222
	return ret0
223
}
224

225
// CanReclaim indicates an expected call of CanReclaim.
226
func (mr *MockReclaimerMockRecorder) CanReclaim() *gomock.Call {
227
	mr.mock.ctrl.T.Helper()
228
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CanReclaim", reflect.TypeOf((*MockReclaimer)(nil).CanReclaim))
229
}
230

231
// MarkReclaim mocks base method.
232
func (m *MockReclaimer) MarkReclaim() {
233
	m.ctrl.T.Helper()
234
	m.ctrl.Call(m, "MarkReclaim")
235
}
236

237
// MarkReclaim indicates an expected call of MarkReclaim.
238
func (mr *MockReclaimerMockRecorder) MarkReclaim() *gomock.Call {
239
	mr.mock.ctrl.T.Helper()
240
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkReclaim", reflect.TypeOf((*MockReclaimer)(nil).MarkReclaim))
241
}
242

243
// Reclaim mocks base method.
244
func (m *MockReclaimer) Reclaim() error {
245
	m.ctrl.T.Helper()
246
	ret := m.ctrl.Call(m, "Reclaim")
247
	ret0, _ := ret[0].(error)
248
	return ret0
249
}
250

251
// Reclaim indicates an expected call of Reclaim.
252
func (mr *MockReclaimerMockRecorder) Reclaim() *gomock.Call {
253
	mr.mock.ctrl.T.Helper()
254
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reclaim", reflect.TypeOf((*MockReclaimer)(nil).Reclaim))
255
}
256

257
// MockManager is a mock of Manager interface.
258
type MockManager struct {
259
	ctrl     *gomock.Controller
260
	recorder *MockManagerMockRecorder
261
}
262

263
// MockManagerMockRecorder is the mock recorder for MockManager.
264
type MockManagerMockRecorder struct {
265
	mock *MockManager
266
}
267

268
// NewMockManager creates a new mock instance.
269
func NewMockManager(ctrl *gomock.Controller) *MockManager {
270
	mock := &MockManager{ctrl: ctrl}
271
	mock.recorder = &MockManagerMockRecorder{mock}
272
	return mock
273
}
274

275
// EXPECT returns an object that allows the caller to indicate expected use.
276
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
277
	return m.recorder
278
}
279

280
// Alive mocks base method.
281
func (m *MockManager) Alive(alive time.Duration) bool {
282
	m.ctrl.T.Helper()
283
	ret := m.ctrl.Call(m, "Alive", alive)
284
	ret0, _ := ret[0].(bool)
285
	return ret0
286
}
287

288
// Alive indicates an expected call of Alive.
289
func (mr *MockManagerMockRecorder) Alive(alive any) *gomock.Call {
290
	mr.mock.ctrl.T.Helper()
291
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Alive", reflect.TypeOf((*MockManager)(nil).Alive), alive)
292
}
293

294
// CleanUp mocks base method.
295
func (m *MockManager) CleanUp() {
296
	m.ctrl.T.Helper()
297
	m.ctrl.Call(m, "CleanUp")
298
}
299

300
// CleanUp indicates an expected call of CleanUp.
301
func (mr *MockManagerMockRecorder) CleanUp() *gomock.Call {
302
	mr.mock.ctrl.T.Helper()
303
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanUp", reflect.TypeOf((*MockManager)(nil).CleanUp))
304
}
305

306
// FindCompletedSubTask mocks base method.
307
func (m *MockManager) FindCompletedSubTask(taskID string) *storage.ReusePeerTask {
308
	m.ctrl.T.Helper()
309
	ret := m.ctrl.Call(m, "FindCompletedSubTask", taskID)
310
	ret0, _ := ret[0].(*storage.ReusePeerTask)
311
	return ret0
312
}
313

314
// FindCompletedSubTask indicates an expected call of FindCompletedSubTask.
315
func (mr *MockManagerMockRecorder) FindCompletedSubTask(taskID any) *gomock.Call {
316
	mr.mock.ctrl.T.Helper()
317
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCompletedSubTask", reflect.TypeOf((*MockManager)(nil).FindCompletedSubTask), taskID)
318
}
319

320
// FindCompletedTask mocks base method.
321
func (m *MockManager) FindCompletedTask(taskID string) *storage.ReusePeerTask {
322
	m.ctrl.T.Helper()
323
	ret := m.ctrl.Call(m, "FindCompletedTask", taskID)
324
	ret0, _ := ret[0].(*storage.ReusePeerTask)
325
	return ret0
326
}
327

328
// FindCompletedTask indicates an expected call of FindCompletedTask.
329
func (mr *MockManagerMockRecorder) FindCompletedTask(taskID any) *gomock.Call {
330
	mr.mock.ctrl.T.Helper()
331
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCompletedTask", reflect.TypeOf((*MockManager)(nil).FindCompletedTask), taskID)
332
}
333

334
// FindPartialCompletedTask mocks base method.
335
func (m *MockManager) FindPartialCompletedTask(taskID string, rg *http.Range) *storage.ReusePeerTask {
336
	m.ctrl.T.Helper()
337
	ret := m.ctrl.Call(m, "FindPartialCompletedTask", taskID, rg)
338
	ret0, _ := ret[0].(*storage.ReusePeerTask)
339
	return ret0
340
}
341

342
// FindPartialCompletedTask indicates an expected call of FindPartialCompletedTask.
343
func (mr *MockManagerMockRecorder) FindPartialCompletedTask(taskID, rg any) *gomock.Call {
344
	mr.mock.ctrl.T.Helper()
345
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindPartialCompletedTask", reflect.TypeOf((*MockManager)(nil).FindPartialCompletedTask), taskID, rg)
346
}
347

348
// GetExtendAttribute mocks base method.
349
func (m *MockManager) GetExtendAttribute(ctx context.Context, req *storage.PeerTaskMetadata) (*common.ExtendAttribute, error) {
350
	m.ctrl.T.Helper()
351
	ret := m.ctrl.Call(m, "GetExtendAttribute", ctx, req)
352
	ret0, _ := ret[0].(*common.ExtendAttribute)
353
	ret1, _ := ret[1].(error)
354
	return ret0, ret1
355
}
356

357
// GetExtendAttribute indicates an expected call of GetExtendAttribute.
358
func (mr *MockManagerMockRecorder) GetExtendAttribute(ctx, req any) *gomock.Call {
359
	mr.mock.ctrl.T.Helper()
360
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExtendAttribute", reflect.TypeOf((*MockManager)(nil).GetExtendAttribute), ctx, req)
361
}
362

363
// GetPieces mocks base method.
364
func (m *MockManager) GetPieces(ctx context.Context, req *common.PieceTaskRequest) (*common.PiecePacket, error) {
365
	m.ctrl.T.Helper()
366
	ret := m.ctrl.Call(m, "GetPieces", ctx, req)
367
	ret0, _ := ret[0].(*common.PiecePacket)
368
	ret1, _ := ret[1].(error)
369
	return ret0, ret1
370
}
371

372
// GetPieces indicates an expected call of GetPieces.
373
func (mr *MockManagerMockRecorder) GetPieces(ctx, req any) *gomock.Call {
374
	mr.mock.ctrl.T.Helper()
375
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieces", reflect.TypeOf((*MockManager)(nil).GetPieces), ctx, req)
376
}
377

378
// GetTotalPieces mocks base method.
379
func (m *MockManager) GetTotalPieces(ctx context.Context, req *storage.PeerTaskMetadata) (int32, error) {
380
	m.ctrl.T.Helper()
381
	ret := m.ctrl.Call(m, "GetTotalPieces", ctx, req)
382
	ret0, _ := ret[0].(int32)
383
	ret1, _ := ret[1].(error)
384
	return ret0, ret1
385
}
386

387
// GetTotalPieces indicates an expected call of GetTotalPieces.
388
func (mr *MockManagerMockRecorder) GetTotalPieces(ctx, req any) *gomock.Call {
389
	mr.mock.ctrl.T.Helper()
390
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalPieces", reflect.TypeOf((*MockManager)(nil).GetTotalPieces), ctx, req)
391
}
392

393
// IsInvalid mocks base method.
394
func (m *MockManager) IsInvalid(req *storage.PeerTaskMetadata) (bool, error) {
395
	m.ctrl.T.Helper()
396
	ret := m.ctrl.Call(m, "IsInvalid", req)
397
	ret0, _ := ret[0].(bool)
398
	ret1, _ := ret[1].(error)
399
	return ret0, ret1
400
}
401

402
// IsInvalid indicates an expected call of IsInvalid.
403
func (mr *MockManagerMockRecorder) IsInvalid(req any) *gomock.Call {
404
	mr.mock.ctrl.T.Helper()
405
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsInvalid", reflect.TypeOf((*MockManager)(nil).IsInvalid), req)
406
}
407

408
// Keep mocks base method.
409
func (m *MockManager) Keep() {
410
	m.ctrl.T.Helper()
411
	m.ctrl.Call(m, "Keep")
412
}
413

414
// Keep indicates an expected call of Keep.
415
func (mr *MockManagerMockRecorder) Keep() *gomock.Call {
416
	mr.mock.ctrl.T.Helper()
417
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keep", reflect.TypeOf((*MockManager)(nil).Keep))
418
}
419

420
// ReadAllPieces mocks base method.
421
func (m *MockManager) ReadAllPieces(ctx context.Context, req *storage.ReadAllPiecesRequest) (io.ReadCloser, error) {
422
	m.ctrl.T.Helper()
423
	ret := m.ctrl.Call(m, "ReadAllPieces", ctx, req)
424
	ret0, _ := ret[0].(io.ReadCloser)
425
	ret1, _ := ret[1].(error)
426
	return ret0, ret1
427
}
428

429
// ReadAllPieces indicates an expected call of ReadAllPieces.
430
func (mr *MockManagerMockRecorder) ReadAllPieces(ctx, req any) *gomock.Call {
431
	mr.mock.ctrl.T.Helper()
432
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAllPieces", reflect.TypeOf((*MockManager)(nil).ReadAllPieces), ctx, req)
433
}
434

435
// ReadPiece mocks base method.
436
func (m *MockManager) ReadPiece(ctx context.Context, req *storage.ReadPieceRequest) (io.Reader, io.Closer, error) {
437
	m.ctrl.T.Helper()
438
	ret := m.ctrl.Call(m, "ReadPiece", ctx, req)
439
	ret0, _ := ret[0].(io.Reader)
440
	ret1, _ := ret[1].(io.Closer)
441
	ret2, _ := ret[2].(error)
442
	return ret0, ret1, ret2
443
}
444

445
// ReadPiece indicates an expected call of ReadPiece.
446
func (mr *MockManagerMockRecorder) ReadPiece(ctx, req any) *gomock.Call {
447
	mr.mock.ctrl.T.Helper()
448
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadPiece", reflect.TypeOf((*MockManager)(nil).ReadPiece), ctx, req)
449
}
450

451
// RegisterSubTask mocks base method.
452
func (m *MockManager) RegisterSubTask(ctx context.Context, req *storage.RegisterSubTaskRequest) (storage.TaskStorageDriver, error) {
453
	m.ctrl.T.Helper()
454
	ret := m.ctrl.Call(m, "RegisterSubTask", ctx, req)
455
	ret0, _ := ret[0].(storage.TaskStorageDriver)
456
	ret1, _ := ret[1].(error)
457
	return ret0, ret1
458
}
459

460
// RegisterSubTask indicates an expected call of RegisterSubTask.
461
func (mr *MockManagerMockRecorder) RegisterSubTask(ctx, req any) *gomock.Call {
462
	mr.mock.ctrl.T.Helper()
463
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterSubTask", reflect.TypeOf((*MockManager)(nil).RegisterSubTask), ctx, req)
464
}
465

466
// RegisterTask mocks base method.
467
func (m *MockManager) RegisterTask(ctx context.Context, req *storage.RegisterTaskRequest) (storage.TaskStorageDriver, error) {
468
	m.ctrl.T.Helper()
469
	ret := m.ctrl.Call(m, "RegisterTask", ctx, req)
470
	ret0, _ := ret[0].(storage.TaskStorageDriver)
471
	ret1, _ := ret[1].(error)
472
	return ret0, ret1
473
}
474

475
// RegisterTask indicates an expected call of RegisterTask.
476
func (mr *MockManagerMockRecorder) RegisterTask(ctx, req any) *gomock.Call {
477
	mr.mock.ctrl.T.Helper()
478
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTask", reflect.TypeOf((*MockManager)(nil).RegisterTask), ctx, req)
479
}
480

481
// Store mocks base method.
482
func (m *MockManager) Store(ctx context.Context, req *storage.StoreRequest) error {
483
	m.ctrl.T.Helper()
484
	ret := m.ctrl.Call(m, "Store", ctx, req)
485
	ret0, _ := ret[0].(error)
486
	return ret0
487
}
488

489
// Store indicates an expected call of Store.
490
func (mr *MockManagerMockRecorder) Store(ctx, req any) *gomock.Call {
491
	mr.mock.ctrl.T.Helper()
492
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Store", reflect.TypeOf((*MockManager)(nil).Store), ctx, req)
493
}
494

495
// UnregisterTask mocks base method.
496
func (m *MockManager) UnregisterTask(ctx context.Context, req storage.CommonTaskRequest) error {
497
	m.ctrl.T.Helper()
498
	ret := m.ctrl.Call(m, "UnregisterTask", ctx, req)
499
	ret0, _ := ret[0].(error)
500
	return ret0
501
}
502

503
// UnregisterTask indicates an expected call of UnregisterTask.
504
func (mr *MockManagerMockRecorder) UnregisterTask(ctx, req any) *gomock.Call {
505
	mr.mock.ctrl.T.Helper()
506
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterTask", reflect.TypeOf((*MockManager)(nil).UnregisterTask), ctx, req)
507
}
508

509
// UpdateTask mocks base method.
510
func (m *MockManager) UpdateTask(ctx context.Context, req *storage.UpdateTaskRequest) error {
511
	m.ctrl.T.Helper()
512
	ret := m.ctrl.Call(m, "UpdateTask", ctx, req)
513
	ret0, _ := ret[0].(error)
514
	return ret0
515
}
516

517
// UpdateTask indicates an expected call of UpdateTask.
518
func (mr *MockManagerMockRecorder) UpdateTask(ctx, req any) *gomock.Call {
519
	mr.mock.ctrl.T.Helper()
520
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTask", reflect.TypeOf((*MockManager)(nil).UpdateTask), ctx, req)
521
}
522

523
// ValidateDigest mocks base method.
524
func (m *MockManager) ValidateDigest(req *storage.PeerTaskMetadata) error {
525
	m.ctrl.T.Helper()
526
	ret := m.ctrl.Call(m, "ValidateDigest", req)
527
	ret0, _ := ret[0].(error)
528
	return ret0
529
}
530

531
// ValidateDigest indicates an expected call of ValidateDigest.
532
func (mr *MockManagerMockRecorder) ValidateDigest(req any) *gomock.Call {
533
	mr.mock.ctrl.T.Helper()
534
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDigest", reflect.TypeOf((*MockManager)(nil).ValidateDigest), req)
535
}
536

537
// WritePiece mocks base method.
538
func (m *MockManager) WritePiece(ctx context.Context, req *storage.WritePieceRequest) (int64, error) {
539
	m.ctrl.T.Helper()
540
	ret := m.ctrl.Call(m, "WritePiece", ctx, req)
541
	ret0, _ := ret[0].(int64)
542
	ret1, _ := ret[1].(error)
543
	return ret0, ret1
544
}
545

546
// WritePiece indicates an expected call of WritePiece.
547
func (mr *MockManagerMockRecorder) WritePiece(ctx, req any) *gomock.Call {
548
	mr.mock.ctrl.T.Helper()
549
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WritePiece", reflect.TypeOf((*MockManager)(nil).WritePiece), ctx, req)
550
}
551