// Code generated by MockGen. DO NOT EDIT.
// Source: ./task.go
//
// Generated by this command:
//
//	mockgen -source=./task.go -destination=./task_mock.go -package=task
//

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

import (
	reflect "reflect"

	rcmgr "github.com/bnb-chain/greenfield-storage-provider/core/rcmgr"
	types "github.com/bnb-chain/greenfield/x/sp/types"
	types0 "github.com/bnb-chain/greenfield/x/storage/types"
	types1 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	gomock "go.uber.org/mock/gomock"
)

// MockTask is a mock of Task interface.
type MockTask struct {
	ctrl     *gomock.Controller
	recorder *MockTaskMockRecorder
}

// MockTaskMockRecorder is the mock recorder for MockTask.
type MockTaskMockRecorder struct {
	mock *MockTask
}

// NewMockTask creates a new mock instance.
func NewMockTask(ctrl *gomock.Controller) *MockTask {
	mock := &MockTask{ctrl: ctrl}
	mock.recorder = &MockTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAddress mocks base method.
func (m *MockTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockTask)(nil).SetUserAddress), arg0)
}

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

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

// MockApprovalTask is a mock of ApprovalTask interface.
type MockApprovalTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalTaskMockRecorder
}

// MockApprovalTaskMockRecorder is the mock recorder for MockApprovalTask.
type MockApprovalTaskMockRecorder struct {
	mock *MockApprovalTask
}

// NewMockApprovalTask creates a new mock instance.
func NewMockApprovalTask(ctrl *gomock.Controller) *MockApprovalTask {
	mock := &MockApprovalTask{ctrl: ctrl}
	mock.recorder = &MockApprovalTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockApprovalTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAddress mocks base method.
func (m *MockApprovalTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockApprovalTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalTask)(nil).SetUserAddress), arg0)
}

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

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

// MockApprovalCreateBucketTask is a mock of ApprovalCreateBucketTask interface.
type MockApprovalCreateBucketTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalCreateBucketTaskMockRecorder
}

// MockApprovalCreateBucketTaskMockRecorder is the mock recorder for MockApprovalCreateBucketTask.
type MockApprovalCreateBucketTaskMockRecorder struct {
	mock *MockApprovalCreateBucketTask
}

// NewMockApprovalCreateBucketTask creates a new mock instance.
func NewMockApprovalCreateBucketTask(ctrl *gomock.Controller) *MockApprovalCreateBucketTask {
	mock := &MockApprovalCreateBucketTask{ctrl: ctrl}
	mock.recorder = &MockApprovalCreateBucketTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockApprovalCreateBucketTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalCreateBucketTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitApprovalCreateBucketTask mocks base method.
func (m *MockApprovalCreateBucketTask) InitApprovalCreateBucketTask(arg0 string, arg1 *types0.MsgCreateBucket, arg2 []byte, arg3 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitApprovalCreateBucketTask", arg0, arg1, arg2, arg3)
}

// InitApprovalCreateBucketTask indicates an expected call of InitApprovalCreateBucketTask.
func (mr *MockApprovalCreateBucketTaskMockRecorder) InitApprovalCreateBucketTask(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalCreateBucketTask", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).InitApprovalCreateBucketTask), arg0, arg1, arg2, arg3)
}

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

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

// SetAddress mocks base method.
func (m *MockApprovalCreateBucketTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetAddress), arg0)
}

// SetCreateBucketInfo mocks base method.
func (m *MockApprovalCreateBucketTask) SetCreateBucketInfo(arg0 *types0.MsgCreateBucket) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateBucketInfo", arg0)
}

// SetCreateBucketInfo indicates an expected call of SetCreateBucketInfo.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateBucketInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateBucketInfo", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetCreateBucketInfo), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalCreateBucketTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockApprovalCreateBucketTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalCreateBucketTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalCreateBucketTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalCreateBucketTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalCreateBucketTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalCreateBucketTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalCreateBucketTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalCreateBucketTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalCreateBucketTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalCreateBucketTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalCreateBucketTask)(nil).SetUserAddress), arg0)
}

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

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

// MockApprovalMigrateBucketTask is a mock of ApprovalMigrateBucketTask interface.
type MockApprovalMigrateBucketTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalMigrateBucketTaskMockRecorder
}

// MockApprovalMigrateBucketTaskMockRecorder is the mock recorder for MockApprovalMigrateBucketTask.
type MockApprovalMigrateBucketTaskMockRecorder struct {
	mock *MockApprovalMigrateBucketTask
}

// NewMockApprovalMigrateBucketTask creates a new mock instance.
func NewMockApprovalMigrateBucketTask(ctrl *gomock.Controller) *MockApprovalMigrateBucketTask {
	mock := &MockApprovalMigrateBucketTask{ctrl: ctrl}
	mock.recorder = &MockApprovalMigrateBucketTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockApprovalMigrateBucketTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitApprovalMigrateBucketTask mocks base method.
func (m *MockApprovalMigrateBucketTask) InitApprovalMigrateBucketTask(arg0 *types0.MsgMigrateBucket, arg1 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitApprovalMigrateBucketTask", arg0, arg1)
}

// InitApprovalMigrateBucketTask indicates an expected call of InitApprovalMigrateBucketTask.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) InitApprovalMigrateBucketTask(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalMigrateBucketTask", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).InitApprovalMigrateBucketTask), arg0, arg1)
}

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

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

// SetAddress mocks base method.
func (m *MockApprovalMigrateBucketTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalMigrateBucketTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockApprovalMigrateBucketTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalMigrateBucketTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalMigrateBucketTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalMigrateBucketTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetMaxRetry), arg0)
}

// SetMigrateBucketInfo mocks base method.
func (m *MockApprovalMigrateBucketTask) SetMigrateBucketInfo(arg0 *types0.MsgMigrateBucket) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMigrateBucketInfo", arg0)
}

// SetMigrateBucketInfo indicates an expected call of SetMigrateBucketInfo.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetMigrateBucketInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMigrateBucketInfo", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetMigrateBucketInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalMigrateBucketTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalMigrateBucketTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalMigrateBucketTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalMigrateBucketTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalMigrateBucketTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalMigrateBucketTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalMigrateBucketTask)(nil).SetUserAddress), arg0)
}

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

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

// MockApprovalCreateObjectTask is a mock of ApprovalCreateObjectTask interface.
type MockApprovalCreateObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalCreateObjectTaskMockRecorder
}

// MockApprovalCreateObjectTaskMockRecorder is the mock recorder for MockApprovalCreateObjectTask.
type MockApprovalCreateObjectTaskMockRecorder struct {
	mock *MockApprovalCreateObjectTask
}

// NewMockApprovalCreateObjectTask creates a new mock instance.
func NewMockApprovalCreateObjectTask(ctrl *gomock.Controller) *MockApprovalCreateObjectTask {
	mock := &MockApprovalCreateObjectTask{ctrl: ctrl}
	mock.recorder = &MockApprovalCreateObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockApprovalCreateObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalCreateObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitApprovalCreateObjectTask mocks base method.
func (m *MockApprovalCreateObjectTask) InitApprovalCreateObjectTask(arg0 string, arg1 *types0.MsgCreateObject, arg2 []byte, arg3 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitApprovalCreateObjectTask", arg0, arg1, arg2, arg3)
}

// InitApprovalCreateObjectTask indicates an expected call of InitApprovalCreateObjectTask.
func (mr *MockApprovalCreateObjectTaskMockRecorder) InitApprovalCreateObjectTask(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalCreateObjectTask", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).InitApprovalCreateObjectTask), arg0, arg1, arg2, arg3)
}

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

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

// SetAddress mocks base method.
func (m *MockApprovalCreateObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetAddress), arg0)
}

// SetCreateObjectInfo mocks base method.
func (m *MockApprovalCreateObjectTask) SetCreateObjectInfo(arg0 *types0.MsgCreateObject) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateObjectInfo", arg0)
}

// SetCreateObjectInfo indicates an expected call of SetCreateObjectInfo.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateObjectInfo", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetCreateObjectInfo), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalCreateObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockApprovalCreateObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalCreateObjectTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalCreateObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalCreateObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalCreateObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalCreateObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalCreateObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalCreateObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalCreateObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalCreateObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalCreateObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockApprovalReplicatePieceTask is a mock of ApprovalReplicatePieceTask interface.
type MockApprovalReplicatePieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalReplicatePieceTaskMockRecorder
}

// MockApprovalReplicatePieceTaskMockRecorder is the mock recorder for MockApprovalReplicatePieceTask.
type MockApprovalReplicatePieceTaskMockRecorder struct {
	mock *MockApprovalReplicatePieceTask
}

// NewMockApprovalReplicatePieceTask creates a new mock instance.
func NewMockApprovalReplicatePieceTask(ctrl *gomock.Controller) *MockApprovalReplicatePieceTask {
	mock := &MockApprovalReplicatePieceTask{ctrl: ctrl}
	mock.recorder = &MockApprovalReplicatePieceTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockApprovalReplicatePieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitApprovalReplicatePieceTask mocks base method.
func (m *MockApprovalReplicatePieceTask) InitApprovalReplicatePieceTask(object *types0.ObjectInfo, params *types0.Params, priority TPriority, askOpAddress string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitApprovalReplicatePieceTask", object, params, priority, askOpAddress)
}

// InitApprovalReplicatePieceTask indicates an expected call of InitApprovalReplicatePieceTask.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) InitApprovalReplicatePieceTask(object, params, priority, askOpAddress any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalReplicatePieceTask", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).InitApprovalReplicatePieceTask), object, params, priority, askOpAddress)
}

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

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

// SetAddress mocks base method.
func (m *MockApprovalReplicatePieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAddress), arg0)
}

// SetApprovedSignature mocks base method.
func (m *MockApprovalReplicatePieceTask) SetApprovedSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetApprovedSignature", arg0)
}

// SetApprovedSignature indicates an expected call of SetApprovedSignature.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSignature(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSignature", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSignature), arg0)
}

// SetApprovedSpApprovalAddress mocks base method.
func (m *MockApprovalReplicatePieceTask) SetApprovedSpApprovalAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetApprovedSpApprovalAddress", arg0)
}

// SetApprovedSpApprovalAddress indicates an expected call of SetApprovedSpApprovalAddress.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpApprovalAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpApprovalAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpApprovalAddress), arg0)
}

// SetApprovedSpEndpoint mocks base method.
func (m *MockApprovalReplicatePieceTask) SetApprovedSpEndpoint(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetApprovedSpEndpoint", arg0)
}

// SetApprovedSpEndpoint indicates an expected call of SetApprovedSpEndpoint.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpEndpoint(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpEndpoint", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpEndpoint), arg0)
}

// SetApprovedSpOperatorAddress mocks base method.
func (m *MockApprovalReplicatePieceTask) SetApprovedSpOperatorAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetApprovedSpOperatorAddress", arg0)
}

// SetApprovedSpOperatorAddress indicates an expected call of SetApprovedSpOperatorAddress.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetApprovedSpOperatorAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetApprovedSpOperatorAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetApprovedSpOperatorAddress), arg0)
}

// SetAskSignature mocks base method.
func (m *MockApprovalReplicatePieceTask) SetAskSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAskSignature", arg0)
}

// SetAskSignature indicates an expected call of SetAskSignature.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSignature(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAskSignature", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAskSignature), arg0)
}

// SetAskSpOperatorAddress mocks base method.
func (m *MockApprovalReplicatePieceTask) SetAskSpOperatorAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAskSpOperatorAddress", arg0)
}

// SetAskSpOperatorAddress indicates an expected call of SetAskSpOperatorAddress.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetAskSpOperatorAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAskSpOperatorAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetAskSpOperatorAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalReplicatePieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockApprovalReplicatePieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalReplicatePieceTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalReplicatePieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalReplicatePieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockApprovalReplicatePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalReplicatePieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalReplicatePieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockApprovalReplicatePieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalReplicatePieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalReplicatePieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalReplicatePieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalReplicatePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalReplicatePieceTask)(nil).SetUserAddress), arg0)
}

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

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

// MockObjectTask is a mock of ObjectTask interface.
type MockObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockObjectTaskMockRecorder
}

// MockObjectTaskMockRecorder is the mock recorder for MockObjectTask.
type MockObjectTaskMockRecorder struct {
	mock *MockObjectTask
}

// NewMockObjectTask creates a new mock instance.
func NewMockObjectTask(ctrl *gomock.Controller) *MockObjectTask {
	mock := &MockObjectTask{ctrl: ctrl}
	mock.recorder = &MockObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAddress mocks base method.
func (m *MockObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockObjectTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockObjectTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockObjectTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockObjectTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockObjectTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockUploadObjectTask is a mock of UploadObjectTask interface.
type MockUploadObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockUploadObjectTaskMockRecorder
}

// MockUploadObjectTaskMockRecorder is the mock recorder for MockUploadObjectTask.
type MockUploadObjectTaskMockRecorder struct {
	mock *MockUploadObjectTask
}

// NewMockUploadObjectTask creates a new mock instance.
func NewMockUploadObjectTask(ctrl *gomock.Controller) *MockUploadObjectTask {
	mock := &MockUploadObjectTask{ctrl: ctrl}
	mock.recorder = &MockUploadObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockUploadObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockUploadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockUploadObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitUploadObjectTask mocks base method.
func (m *MockUploadObjectTask) InitUploadObjectTask(vgfID uint32, object *types0.ObjectInfo, params *types0.Params, timeout int64, isAgentUpload bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitUploadObjectTask", vgfID, object, params, timeout, isAgentUpload)
}

// InitUploadObjectTask indicates an expected call of InitUploadObjectTask.
func (mr *MockUploadObjectTaskMockRecorder) InitUploadObjectTask(vgfID, object, params, timeout, isAgentUpload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitUploadObjectTask", reflect.TypeOf((*MockUploadObjectTask)(nil).InitUploadObjectTask), vgfID, object, params, timeout, isAgentUpload)
}

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

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

// SetAddress mocks base method.
func (m *MockUploadObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockUploadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockUploadObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockUploadObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockUploadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockUploadObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockUploadObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockUploadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockUploadObjectTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockUploadObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockUploadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockUploadObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockUploadObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockUploadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockUploadObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockUploadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockUploadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockUploadObjectTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockUploadObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockUploadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockUploadObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockUploadObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockUploadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockUploadObjectTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockUploadObjectTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockUploadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockUploadObjectTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockUploadObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockUploadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockUploadObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockUploadObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockUploadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockUploadObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockUploadObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockUploadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockUploadObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockResumableUploadObjectTask is a mock of ResumableUploadObjectTask interface.
type MockResumableUploadObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockResumableUploadObjectTaskMockRecorder
}

// MockResumableUploadObjectTaskMockRecorder is the mock recorder for MockResumableUploadObjectTask.
type MockResumableUploadObjectTaskMockRecorder struct {
	mock *MockResumableUploadObjectTask
}

// NewMockResumableUploadObjectTask creates a new mock instance.
func NewMockResumableUploadObjectTask(ctrl *gomock.Controller) *MockResumableUploadObjectTask {
	mock := &MockResumableUploadObjectTask{ctrl: ctrl}
	mock.recorder = &MockResumableUploadObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockResumableUploadObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockResumableUploadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitResumableUploadObjectTask mocks base method.
func (m *MockResumableUploadObjectTask) InitResumableUploadObjectTask(vgfID uint32, object *types0.ObjectInfo, params *types0.Params, timeout int64, complete bool, offset uint64, isAgentUpload bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitResumableUploadObjectTask", vgfID, object, params, timeout, complete, offset, isAgentUpload)
}

// InitResumableUploadObjectTask indicates an expected call of InitResumableUploadObjectTask.
func (mr *MockResumableUploadObjectTaskMockRecorder) InitResumableUploadObjectTask(vgfID, object, params, timeout, complete, offset, isAgentUpload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitResumableUploadObjectTask", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).InitResumableUploadObjectTask), vgfID, object, params, timeout, complete, offset, isAgentUpload)
}

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

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

// SetAddress mocks base method.
func (m *MockResumableUploadObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetAddress), arg0)
}

// SetCompleted mocks base method.
func (m *MockResumableUploadObjectTask) SetCompleted(completed bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCompleted", completed)
}

// SetCompleted indicates an expected call of SetCompleted.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetCompleted(completed any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCompleted", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetCompleted), completed)
}

// SetCreateTime mocks base method.
func (m *MockResumableUploadObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockResumableUploadObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockResumableUploadObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockResumableUploadObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockResumableUploadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockResumableUploadObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetPriority), arg0)
}

// SetResumeOffset mocks base method.
func (m *MockResumableUploadObjectTask) SetResumeOffset(offset uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetResumeOffset", offset)
}

// SetResumeOffset indicates an expected call of SetResumeOffset.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetResumeOffset(offset any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetResumeOffset", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetResumeOffset), offset)
}

// SetRetry mocks base method.
func (m *MockResumableUploadObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockResumableUploadObjectTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockResumableUploadObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockResumableUploadObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockResumableUploadObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockResumableUploadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockResumableUploadObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockReplicatePieceTask is a mock of ReplicatePieceTask interface.
type MockReplicatePieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockReplicatePieceTaskMockRecorder
}

// MockReplicatePieceTaskMockRecorder is the mock recorder for MockReplicatePieceTask.
type MockReplicatePieceTaskMockRecorder struct {
	mock *MockReplicatePieceTask
}

// NewMockReplicatePieceTask creates a new mock instance.
func NewMockReplicatePieceTask(ctrl *gomock.Controller) *MockReplicatePieceTask {
	mock := &MockReplicatePieceTask{ctrl: ctrl}
	mock.recorder = &MockReplicatePieceTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockReplicatePieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockReplicatePieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockReplicatePieceTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitReplicatePieceTask mocks base method.
func (m *MockReplicatePieceTask) InitReplicatePieceTask(object *types0.ObjectInfo, params *types0.Params, priority TPriority, timeout, retry int64, isAgentUpload bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitReplicatePieceTask", object, params, priority, timeout, retry, isAgentUpload)
}

// InitReplicatePieceTask indicates an expected call of InitReplicatePieceTask.
func (mr *MockReplicatePieceTaskMockRecorder) InitReplicatePieceTask(object, params, priority, timeout, retry, isAgentUpload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitReplicatePieceTask", reflect.TypeOf((*MockReplicatePieceTask)(nil).InitReplicatePieceTask), object, params, priority, timeout, retry, isAgentUpload)
}

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

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

// SetAddress mocks base method.
func (m *MockReplicatePieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockReplicatePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockReplicatePieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockReplicatePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockReplicatePieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockReplicatePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockReplicatePieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockReplicatePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockReplicatePieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockReplicatePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetMaxRetry), arg0)
}

// SetNotAvailableSpIdx mocks base method.
func (m *MockReplicatePieceTask) SetNotAvailableSpIdx(arg0 int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNotAvailableSpIdx", arg0)
}

// SetNotAvailableSpIdx indicates an expected call of SetNotAvailableSpIdx.
func (mr *MockReplicatePieceTaskMockRecorder) SetNotAvailableSpIdx(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotAvailableSpIdx", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetNotAvailableSpIdx), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockReplicatePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockReplicatePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockReplicatePieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockReplicatePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockReplicatePieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockReplicatePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetRetry), arg0)
}

// SetSealed mocks base method.
func (m *MockReplicatePieceTask) SetSealed(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSealed", arg0)
}

// SetSealed indicates an expected call of SetSealed.
func (mr *MockReplicatePieceTaskMockRecorder) SetSealed(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSealed", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSealed), arg0)
}

// SetSecondaryAddresses mocks base method.
func (m *MockReplicatePieceTask) SetSecondaryAddresses(arg0 []string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSecondaryAddresses", arg0)
}

// SetSecondaryAddresses indicates an expected call of SetSecondaryAddresses.
func (mr *MockReplicatePieceTaskMockRecorder) SetSecondaryAddresses(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondaryAddresses", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSecondaryAddresses), arg0)
}

// SetSecondarySignatures mocks base method.
func (m *MockReplicatePieceTask) SetSecondarySignatures(arg0 [][]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSecondarySignatures", arg0)
}

// SetSecondarySignatures indicates an expected call of SetSecondarySignatures.
func (mr *MockReplicatePieceTaskMockRecorder) SetSecondarySignatures(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondarySignatures", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetSecondarySignatures), arg0)
}

// SetStorageParams mocks base method.
func (m *MockReplicatePieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockReplicatePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockReplicatePieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockReplicatePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockReplicatePieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockReplicatePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockReplicatePieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockReplicatePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockReplicatePieceTask)(nil).SetUserAddress), arg0)
}

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

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

// MockReceivePieceTask is a mock of ReceivePieceTask interface.
type MockReceivePieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockReceivePieceTaskMockRecorder
}

// MockReceivePieceTaskMockRecorder is the mock recorder for MockReceivePieceTask.
type MockReceivePieceTaskMockRecorder struct {
	mock *MockReceivePieceTask
}

// NewMockReceivePieceTask creates a new mock instance.
func NewMockReceivePieceTask(ctrl *gomock.Controller) *MockReceivePieceTask {
	mock := &MockReceivePieceTask{ctrl: ctrl}
	mock.recorder = &MockReceivePieceTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockReceivePieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockReceivePieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockReceivePieceTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitReceivePieceTask mocks base method.
func (m *MockReceivePieceTask) InitReceivePieceTask(vgfID uint32, object *types0.ObjectInfo, params *types0.Params, priority TPriority, segmentIdx uint32, redundancyIdx int32, pieceSize int64, isAgentUpload bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitReceivePieceTask", vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize, isAgentUpload)
}

// InitReceivePieceTask indicates an expected call of InitReceivePieceTask.
func (mr *MockReceivePieceTaskMockRecorder) InitReceivePieceTask(vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize, isAgentUpload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitReceivePieceTask", reflect.TypeOf((*MockReceivePieceTask)(nil).InitReceivePieceTask), vgfID, object, params, priority, segmentIdx, redundancyIdx, pieceSize, isAgentUpload)
}

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

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

// SetAddress mocks base method.
func (m *MockReceivePieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockReceivePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockReceivePieceTask)(nil).SetAddress), arg0)
}

// SetBucketMigration mocks base method.
func (m *MockReceivePieceTask) SetBucketMigration(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketMigration", arg0)
}

// SetBucketMigration indicates an expected call of SetBucketMigration.
func (mr *MockReceivePieceTaskMockRecorder) SetBucketMigration(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketMigration", reflect.TypeOf((*MockReceivePieceTask)(nil).SetBucketMigration), arg0)
}

// SetCreateTime mocks base method.
func (m *MockReceivePieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockReceivePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockReceivePieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockReceivePieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockReceivePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockReceivePieceTask)(nil).SetError), arg0)
}

// SetFinished mocks base method.
func (m *MockReceivePieceTask) SetFinished(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFinished", arg0)
}

// SetFinished indicates an expected call of SetFinished.
func (mr *MockReceivePieceTaskMockRecorder) SetFinished(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockReceivePieceTask)(nil).SetFinished), arg0)
}

// SetGlobalVirtualGroupID mocks base method.
func (m *MockReceivePieceTask) SetGlobalVirtualGroupID(arg0 uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGlobalVirtualGroupID", arg0)
}

// SetGlobalVirtualGroupID indicates an expected call of SetGlobalVirtualGroupID.
func (mr *MockReceivePieceTaskMockRecorder) SetGlobalVirtualGroupID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGlobalVirtualGroupID", reflect.TypeOf((*MockReceivePieceTask)(nil).SetGlobalVirtualGroupID), arg0)
}

// SetLogs mocks base method.
func (m *MockReceivePieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockReceivePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockReceivePieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockReceivePieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockReceivePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockReceivePieceTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockReceivePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockReceivePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockReceivePieceTask)(nil).SetObjectInfo), arg0)
}

// SetPieceChecksum mocks base method.
func (m *MockReceivePieceTask) SetPieceChecksum(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPieceChecksum", arg0)
}

// SetPieceChecksum indicates an expected call of SetPieceChecksum.
func (mr *MockReceivePieceTaskMockRecorder) SetPieceChecksum(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceChecksum", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPieceChecksum), arg0)
}

// SetPieceSize mocks base method.
func (m *MockReceivePieceTask) SetPieceSize(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPieceSize", arg0)
}

// SetPieceSize indicates an expected call of SetPieceSize.
func (mr *MockReceivePieceTaskMockRecorder) SetPieceSize(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceSize", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPieceSize), arg0)
}

// SetPriority mocks base method.
func (m *MockReceivePieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockReceivePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockReceivePieceTask)(nil).SetPriority), arg0)
}

// SetRedundancyIdx mocks base method.
func (m *MockReceivePieceTask) SetRedundancyIdx(arg0 int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRedundancyIdx", arg0)
}

// SetRedundancyIdx indicates an expected call of SetRedundancyIdx.
func (mr *MockReceivePieceTaskMockRecorder) SetRedundancyIdx(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockReceivePieceTask)(nil).SetRedundancyIdx), arg0)
}

// SetRetry mocks base method.
func (m *MockReceivePieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockReceivePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockReceivePieceTask)(nil).SetRetry), arg0)
}

// SetSealed mocks base method.
func (m *MockReceivePieceTask) SetSealed(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSealed", arg0)
}

// SetSealed indicates an expected call of SetSealed.
func (mr *MockReceivePieceTaskMockRecorder) SetSealed(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSealed", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSealed), arg0)
}

// SetSegmentIdx mocks base method.
func (m *MockReceivePieceTask) SetSegmentIdx(arg0 uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSegmentIdx", arg0)
}

// SetSegmentIdx indicates an expected call of SetSegmentIdx.
func (mr *MockReceivePieceTaskMockRecorder) SetSegmentIdx(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSegmentIdx", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSegmentIdx), arg0)
}

// SetSignature mocks base method.
func (m *MockReceivePieceTask) SetSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSignature", arg0)
}

// SetSignature indicates an expected call of SetSignature.
func (mr *MockReceivePieceTaskMockRecorder) SetSignature(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockReceivePieceTask)(nil).SetSignature), arg0)
}

// SetStorageParams mocks base method.
func (m *MockReceivePieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockReceivePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockReceivePieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockReceivePieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockReceivePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockReceivePieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockReceivePieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockReceivePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockReceivePieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockReceivePieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockReceivePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockReceivePieceTask)(nil).SetUserAddress), arg0)
}

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

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

// MockSealObjectTask is a mock of SealObjectTask interface.
type MockSealObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockSealObjectTaskMockRecorder
}

// MockSealObjectTaskMockRecorder is the mock recorder for MockSealObjectTask.
type MockSealObjectTaskMockRecorder struct {
	mock *MockSealObjectTask
}

// NewMockSealObjectTask creates a new mock instance.
func NewMockSealObjectTask(ctrl *gomock.Controller) *MockSealObjectTask {
	mock := &MockSealObjectTask{ctrl: ctrl}
	mock.recorder = &MockSealObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockSealObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockSealObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockSealObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitSealObjectTask mocks base method.
func (m *MockSealObjectTask) InitSealObjectTask(vgfID uint32, object *types0.ObjectInfo, params *types0.Params, priority TPriority, addresses []string, signatures [][]byte, timeout, retry int64, isAgentUpload bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitSealObjectTask", vgfID, object, params, priority, addresses, signatures, timeout, retry, isAgentUpload)
}

// InitSealObjectTask indicates an expected call of InitSealObjectTask.
func (mr *MockSealObjectTaskMockRecorder) InitSealObjectTask(vgfID, object, params, priority, addresses, signatures, timeout, retry, isAgentUpload any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitSealObjectTask", reflect.TypeOf((*MockSealObjectTask)(nil).InitSealObjectTask), vgfID, object, params, priority, addresses, signatures, timeout, retry, isAgentUpload)
}

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

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

// SetAddress mocks base method.
func (m *MockSealObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockSealObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockSealObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockSealObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockSealObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockSealObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockSealObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockSealObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockSealObjectTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockSealObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockSealObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockSealObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockSealObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockSealObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockSealObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockSealObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockSealObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockSealObjectTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockSealObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockSealObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockSealObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockSealObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockSealObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockSealObjectTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockSealObjectTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockSealObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockSealObjectTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockSealObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockSealObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockSealObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockSealObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockSealObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockSealObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockSealObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockSealObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockSealObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockDownloadObjectTask is a mock of DownloadObjectTask interface.
type MockDownloadObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockDownloadObjectTaskMockRecorder
}

// MockDownloadObjectTaskMockRecorder is the mock recorder for MockDownloadObjectTask.
type MockDownloadObjectTaskMockRecorder struct {
	mock *MockDownloadObjectTask
}

// NewMockDownloadObjectTask creates a new mock instance.
func NewMockDownloadObjectTask(ctrl *gomock.Controller) *MockDownloadObjectTask {
	mock := &MockDownloadObjectTask{ctrl: ctrl}
	mock.recorder = &MockDownloadObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockDownloadObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockDownloadObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockDownloadObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitDownloadObjectTask mocks base method.
func (m *MockDownloadObjectTask) InitDownloadObjectTask(object *types0.ObjectInfo, bucket *types0.BucketInfo, params *types0.Params, priority TPriority, userAddress string, low, high, timeout, retry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitDownloadObjectTask", object, bucket, params, priority, userAddress, low, high, timeout, retry)
}

// InitDownloadObjectTask indicates an expected call of InitDownloadObjectTask.
func (mr *MockDownloadObjectTaskMockRecorder) InitDownloadObjectTask(object, bucket, params, priority, userAddress, low, high, timeout, retry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitDownloadObjectTask", reflect.TypeOf((*MockDownloadObjectTask)(nil).InitDownloadObjectTask), object, bucket, params, priority, userAddress, low, high, timeout, retry)
}

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

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

// SetAddress mocks base method.
func (m *MockDownloadObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockDownloadObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetAddress), arg0)
}

// SetBucketInfo mocks base method.
func (m *MockDownloadObjectTask) SetBucketInfo(arg0 *types0.BucketInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketInfo", arg0)
}

// SetBucketInfo indicates an expected call of SetBucketInfo.
func (mr *MockDownloadObjectTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetBucketInfo), arg0)
}

// SetCreateTime mocks base method.
func (m *MockDownloadObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockDownloadObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockDownloadObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockDownloadObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockDownloadObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockDownloadObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockDownloadObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockDownloadObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockDownloadObjectTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockDownloadObjectTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockDownloadObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockDownloadObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockDownloadObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockDownloadObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockDownloadObjectTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockDownloadObjectTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockDownloadObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockDownloadObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockDownloadObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockDownloadObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockDownloadObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockDownloadObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockDownloadObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockDownloadPieceTask is a mock of DownloadPieceTask interface.
type MockDownloadPieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockDownloadPieceTaskMockRecorder
}

// MockDownloadPieceTaskMockRecorder is the mock recorder for MockDownloadPieceTask.
type MockDownloadPieceTaskMockRecorder struct {
	mock *MockDownloadPieceTask
}

// NewMockDownloadPieceTask creates a new mock instance.
func NewMockDownloadPieceTask(ctrl *gomock.Controller) *MockDownloadPieceTask {
	mock := &MockDownloadPieceTask{ctrl: ctrl}
	mock.recorder = &MockDownloadPieceTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockDownloadPieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockDownloadPieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockDownloadPieceTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitDownloadPieceTask mocks base method.
func (m *MockDownloadPieceTask) InitDownloadPieceTask(object *types0.ObjectInfo, bucket *types0.BucketInfo, params *types0.Params, priority TPriority, enableCheck bool, userAddress string, totalSize uint64, pieceKey string, pieceOffset, pieceLength uint64, timeout, maxRetry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitDownloadPieceTask", object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry)
}

// InitDownloadPieceTask indicates an expected call of InitDownloadPieceTask.
func (mr *MockDownloadPieceTaskMockRecorder) InitDownloadPieceTask(object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitDownloadPieceTask", reflect.TypeOf((*MockDownloadPieceTask)(nil).InitDownloadPieceTask), object, bucket, params, priority, enableCheck, userAddress, totalSize, pieceKey, pieceOffset, pieceLength, timeout, maxRetry)
}

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

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

// SetAddress mocks base method.
func (m *MockDownloadPieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockDownloadPieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetAddress), arg0)
}

// SetBucketInfo mocks base method.
func (m *MockDownloadPieceTask) SetBucketInfo(arg0 *types0.BucketInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketInfo", arg0)
}

// SetBucketInfo indicates an expected call of SetBucketInfo.
func (mr *MockDownloadPieceTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetBucketInfo), arg0)
}

// SetCreateTime mocks base method.
func (m *MockDownloadPieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockDownloadPieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockDownloadPieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockDownloadPieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockDownloadPieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockDownloadPieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockDownloadPieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockDownloadPieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockDownloadPieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockDownloadPieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockDownloadPieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockDownloadPieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockDownloadPieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockDownloadPieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetRetry), arg0)
}

// SetStorageParams mocks base method.
func (m *MockDownloadPieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockDownloadPieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockDownloadPieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockDownloadPieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockDownloadPieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockDownloadPieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockDownloadPieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockDownloadPieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockDownloadPieceTask)(nil).SetUserAddress), arg0)
}

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

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

// MockChallengePieceTask is a mock of ChallengePieceTask interface.
type MockChallengePieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockChallengePieceTaskMockRecorder
}

// MockChallengePieceTaskMockRecorder is the mock recorder for MockChallengePieceTask.
type MockChallengePieceTaskMockRecorder struct {
	mock *MockChallengePieceTask
}

// NewMockChallengePieceTask creates a new mock instance.
func NewMockChallengePieceTask(ctrl *gomock.Controller) *MockChallengePieceTask {
	mock := &MockChallengePieceTask{ctrl: ctrl}
	mock.recorder = &MockChallengePieceTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockChallengePieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockChallengePieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockChallengePieceTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitChallengePieceTask mocks base method.
func (m *MockChallengePieceTask) InitChallengePieceTask(object *types0.ObjectInfo, bucket *types0.BucketInfo, params *types0.Params, priority TPriority, userAddress string, replicateIdx int32, segmentIdx uint32, timeout, retry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitChallengePieceTask", object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry)
}

// InitChallengePieceTask indicates an expected call of InitChallengePieceTask.
func (mr *MockChallengePieceTaskMockRecorder) InitChallengePieceTask(object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitChallengePieceTask", reflect.TypeOf((*MockChallengePieceTask)(nil).InitChallengePieceTask), object, bucket, params, priority, userAddress, replicateIdx, segmentIdx, timeout, retry)
}

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

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

// SetAddress mocks base method.
func (m *MockChallengePieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockChallengePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockChallengePieceTask)(nil).SetAddress), arg0)
}

// SetBucketInfo mocks base method.
func (m *MockChallengePieceTask) SetBucketInfo(arg0 *types0.BucketInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketInfo", arg0)
}

// SetBucketInfo indicates an expected call of SetBucketInfo.
func (mr *MockChallengePieceTaskMockRecorder) SetBucketInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockChallengePieceTask)(nil).SetBucketInfo), arg0)
}

// SetCreateTime mocks base method.
func (m *MockChallengePieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockChallengePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockChallengePieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockChallengePieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockChallengePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockChallengePieceTask)(nil).SetError), arg0)
}

// SetIntegrityHash mocks base method.
func (m *MockChallengePieceTask) SetIntegrityHash(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIntegrityHash", arg0)
}

// SetIntegrityHash indicates an expected call of SetIntegrityHash.
func (mr *MockChallengePieceTaskMockRecorder) SetIntegrityHash(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIntegrityHash", reflect.TypeOf((*MockChallengePieceTask)(nil).SetIntegrityHash), arg0)
}

// SetLogs mocks base method.
func (m *MockChallengePieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockChallengePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockChallengePieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockChallengePieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockChallengePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockChallengePieceTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockChallengePieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockChallengePieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockChallengePieceTask)(nil).SetObjectInfo), arg0)
}

// SetPieceDataSize mocks base method.
func (m *MockChallengePieceTask) SetPieceDataSize(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPieceDataSize", arg0)
}

// SetPieceDataSize indicates an expected call of SetPieceDataSize.
func (mr *MockChallengePieceTaskMockRecorder) SetPieceDataSize(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceDataSize", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPieceDataSize), arg0)
}

// SetPieceHash mocks base method.
func (m *MockChallengePieceTask) SetPieceHash(arg0 [][]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPieceHash", arg0)
}

// SetPieceHash indicates an expected call of SetPieceHash.
func (mr *MockChallengePieceTaskMockRecorder) SetPieceHash(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceHash", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPieceHash), arg0)
}

// SetPriority mocks base method.
func (m *MockChallengePieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockChallengePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockChallengePieceTask)(nil).SetPriority), arg0)
}

// SetRedundancyIdx mocks base method.
func (m *MockChallengePieceTask) SetRedundancyIdx(idx int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRedundancyIdx", idx)
}

// SetRedundancyIdx indicates an expected call of SetRedundancyIdx.
func (mr *MockChallengePieceTaskMockRecorder) SetRedundancyIdx(idx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockChallengePieceTask)(nil).SetRedundancyIdx), idx)
}

// SetRetry mocks base method.
func (m *MockChallengePieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockChallengePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockChallengePieceTask)(nil).SetRetry), arg0)
}

// SetSegmentIdx mocks base method.
func (m *MockChallengePieceTask) SetSegmentIdx(arg0 uint32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSegmentIdx", arg0)
}

// SetSegmentIdx indicates an expected call of SetSegmentIdx.
func (mr *MockChallengePieceTaskMockRecorder) SetSegmentIdx(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSegmentIdx", reflect.TypeOf((*MockChallengePieceTask)(nil).SetSegmentIdx), arg0)
}

// SetStorageParams mocks base method.
func (m *MockChallengePieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockChallengePieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockChallengePieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockChallengePieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockChallengePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockChallengePieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockChallengePieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockChallengePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockChallengePieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockChallengePieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockChallengePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockChallengePieceTask)(nil).SetUserAddress), arg0)
}

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

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

// MockGCTask is a mock of GCTask interface.
type MockGCTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCTaskMockRecorder
}

// MockGCTaskMockRecorder is the mock recorder for MockGCTask.
type MockGCTaskMockRecorder struct {
	mock *MockGCTask
}

// NewMockGCTask creates a new mock instance.
func NewMockGCTask(ctrl *gomock.Controller) *MockGCTask {
	mock := &MockGCTask{ctrl: ctrl}
	mock.recorder = &MockGCTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockGCTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAddress mocks base method.
func (m *MockGCTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockGCTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockGCTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockGCTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockGCTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockGCTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCTask)(nil).SetUserAddress), arg0)
}

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

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

// MockGCObjectTask is a mock of GCObjectTask interface.
type MockGCObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCObjectTaskMockRecorder
}

// MockGCObjectTaskMockRecorder is the mock recorder for MockGCObjectTask.
type MockGCObjectTaskMockRecorder struct {
	mock *MockGCObjectTask
}

// NewMockGCObjectTask creates a new mock instance.
func NewMockGCObjectTask(ctrl *gomock.Controller) *MockGCObjectTask {
	mock := &MockGCObjectTask{ctrl: ctrl}
	mock.recorder = &MockGCObjectTaskMockRecorder{mock}
	return mock
}

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

// AppendLog mocks base method.
func (m *MockGCObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCObjectTask)(nil).AppendLog), log)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// InitGCObjectTask mocks base method.
func (m *MockGCObjectTask) InitGCObjectTask(priority TPriority, start, end uint64, timeout int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitGCObjectTask", priority, start, end, timeout)
}

// InitGCObjectTask indicates an expected call of InitGCObjectTask.
func (mr *MockGCObjectTaskMockRecorder) InitGCObjectTask(priority, start, end, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCObjectTask", reflect.TypeOf((*MockGCObjectTask)(nil).InitGCObjectTask), priority, start, end, timeout)
}

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

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

// SetAddress mocks base method.
func (m *MockGCObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCObjectTask)(nil).SetCreateTime), arg0)
}

// SetCurrentBlockNumber mocks base method.
func (m *MockGCObjectTask) SetCurrentBlockNumber(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentBlockNumber", arg0)
}

// SetCurrentBlockNumber indicates an expected call of SetCurrentBlockNumber.
func (mr *MockGCObjectTaskMockRecorder) SetCurrentBlockNumber(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetCurrentBlockNumber), arg0)
}

// SetEndBlockNumber mocks base method.
func (m *MockGCObjectTask) SetEndBlockNumber(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEndBlockNumber", arg0)
}

// SetEndBlockNumber indicates an expected call of SetEndBlockNumber.
func (mr *MockGCObjectTaskMockRecorder) SetEndBlockNumber(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetEndBlockNumber), arg0)
}

// SetError mocks base method.
func (m *MockGCObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCObjectTask)(nil).SetError), arg0)
}

// SetGCObjectProgress mocks base method.
func (m *MockGCObjectTask) SetGCObjectProgress(arg0, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGCObjectProgress", arg0, arg1)
}

// SetGCObjectProgress indicates an expected call of SetGCObjectProgress.
func (mr *MockGCObjectTaskMockRecorder) SetGCObjectProgress(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCObjectProgress", reflect.TypeOf((*MockGCObjectTask)(nil).SetGCObjectProgress), arg0, arg1)
}

// SetLastDeletedObjectId mocks base method.
func (m *MockGCObjectTask) SetLastDeletedObjectId(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastDeletedObjectId", arg0)
}

// SetLastDeletedObjectId indicates an expected call of SetLastDeletedObjectId.
func (mr *MockGCObjectTaskMockRecorder) SetLastDeletedObjectId(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastDeletedObjectId", reflect.TypeOf((*MockGCObjectTask)(nil).SetLastDeletedObjectId), arg0)
}

// SetLogs mocks base method.
func (m *MockGCObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCObjectTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockGCObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockGCObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCObjectTask)(nil).SetRetry), arg0)
}

// SetStartBlockNumber mocks base method.
func (m *MockGCObjectTask) SetStartBlockNumber(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStartBlockNumber", arg0)
}

// SetStartBlockNumber indicates an expected call of SetStartBlockNumber.
func (mr *MockGCObjectTaskMockRecorder) SetStartBlockNumber(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStartBlockNumber", reflect.TypeOf((*MockGCObjectTask)(nil).SetStartBlockNumber), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockGCObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCObjectTask)(nil).SetUserAddress), arg0)
}

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

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

// MockGCZombiePieceTask is a mock of GCZombiePieceTask interface.
type MockGCZombiePieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCZombiePieceTaskMockRecorder
}

// MockGCZombiePieceTaskMockRecorder is the mock recorder for MockGCZombiePieceTask.
type MockGCZombiePieceTaskMockRecorder struct {
	mock *MockGCZombiePieceTask
}

// NewMockGCZombiePieceTask creates a new mock instance.
func NewMockGCZombiePieceTask(ctrl *gomock.Controller) *MockGCZombiePieceTask {
	mock := &MockGCZombiePieceTask{ctrl: ctrl}
	mock.recorder = &MockGCZombiePieceTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGCZombiePieceTask) EXPECT() *MockGCZombiePieceTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockGCZombiePieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCZombiePieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCZombiePieceTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockGCZombiePieceTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockGCZombiePieceTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockGCZombiePieceTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockGCZombiePieceTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockGCZombiePieceTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockGCZombiePieceTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockGCZombiePieceTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockGCZombiePieceTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockGCZombiePieceTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockGCZombiePieceTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockGCZombiePieceTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockGCZombiePieceTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockGCZombiePieceTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockGCZombiePieceTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockGCZombiePieceTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetAddress))
}

// GetCreateTime mocks base method.
func (m *MockGCZombiePieceTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockGCZombiePieceTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetCreateTime))
}

// GetEndObjectId mocks base method.
func (m *MockGCZombiePieceTask) GetEndObjectId() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEndObjectId")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetEndObjectId indicates an expected call of GetEndObjectId.
func (mr *MockGCZombiePieceTaskMockRecorder) GetEndObjectId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEndObjectId", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetEndObjectId))
}

// GetLogs mocks base method.
func (m *MockGCZombiePieceTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockGCZombiePieceTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockGCZombiePieceTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetMaxRetry))
}

// GetPriority mocks base method.
func (m *MockGCZombiePieceTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockGCZombiePieceTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetPriority))
}

// GetRetry mocks base method.
func (m *MockGCZombiePieceTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetRetry))
}

// GetStartObjectId mocks base method.
func (m *MockGCZombiePieceTask) GetStartObjectId() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStartObjectId")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetStartObjectId indicates an expected call of GetStartObjectId.
func (mr *MockGCZombiePieceTaskMockRecorder) GetStartObjectId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStartObjectId", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetStartObjectId))
}

// GetTimeout mocks base method.
func (m *MockGCZombiePieceTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockGCZombiePieceTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockGCZombiePieceTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockGCZombiePieceTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockGCZombiePieceTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockGCZombiePieceTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockGCZombiePieceTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockGCZombiePieceTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockGCZombiePieceTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockGCZombiePieceTask)(nil).Info))
}

// InitGCZombiePieceTask mocks base method.
func (m *MockGCZombiePieceTask) InitGCZombiePieceTask(priority TPriority, start, end uint64, timeout int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitGCZombiePieceTask", priority, start, end, timeout)
}

// InitGCZombiePieceTask indicates an expected call of InitGCZombiePieceTask.
func (mr *MockGCZombiePieceTaskMockRecorder) InitGCZombiePieceTask(priority, start, end, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCZombiePieceTask", reflect.TypeOf((*MockGCZombiePieceTask)(nil).InitGCZombiePieceTask), priority, start, end, timeout)
}

// Key mocks base method.
func (m *MockGCZombiePieceTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockGCZombiePieceTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockGCZombiePieceTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockGCZombiePieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCZombiePieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCZombiePieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCZombiePieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetCreateTime), arg0)
}

// SetEndObjectID mocks base method.
func (m *MockGCZombiePieceTask) SetEndObjectID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEndObjectID", arg0)
}

// SetEndObjectID indicates an expected call of SetEndObjectID.
func (mr *MockGCZombiePieceTaskMockRecorder) SetEndObjectID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndObjectID", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetEndObjectID), arg0)
}

// SetError mocks base method.
func (m *MockGCZombiePieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCZombiePieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockGCZombiePieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCZombiePieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCZombiePieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockGCZombiePieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCZombiePieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockGCZombiePieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCZombiePieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetRetry), arg0)
}

// SetStartObjectID mocks base method.
func (m *MockGCZombiePieceTask) SetStartObjectID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStartObjectID", arg0)
}

// SetStartObjectID indicates an expected call of SetStartObjectID.
func (mr *MockGCZombiePieceTaskMockRecorder) SetStartObjectID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStartObjectID", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetStartObjectID), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCZombiePieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCZombiePieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockGCZombiePieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCZombiePieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCZombiePieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCZombiePieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCZombiePieceTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockGCZombiePieceTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockGCZombiePieceTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockGCZombiePieceTask)(nil).Type))
}

// MockGCStaleVersionObjectTask is a mock of GCStaleVersionObjectTask interface.
type MockGCStaleVersionObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCStaleVersionObjectTaskMockRecorder
}

// MockGCStaleVersionObjectTaskMockRecorder is the mock recorder for MockGCStaleVersionObjectTask.
type MockGCStaleVersionObjectTaskMockRecorder struct {
	mock *MockGCStaleVersionObjectTask
}

// NewMockGCStaleVersionObjectTask creates a new mock instance.
func NewMockGCStaleVersionObjectTask(ctrl *gomock.Controller) *MockGCStaleVersionObjectTask {
	mock := &MockGCStaleVersionObjectTask{ctrl: ctrl}
	mock.recorder = &MockGCStaleVersionObjectTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGCStaleVersionObjectTask) EXPECT() *MockGCStaleVersionObjectTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockGCStaleVersionObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockGCStaleVersionObjectTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockGCStaleVersionObjectTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockGCStaleVersionObjectTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockGCStaleVersionObjectTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockGCStaleVersionObjectTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetAddress))
}

// GetCreateTime mocks base method.
func (m *MockGCStaleVersionObjectTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetCreateTime))
}

// GetIntegrityChecksum mocks base method.
func (m *MockGCStaleVersionObjectTask) GetIntegrityChecksum() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIntegrityChecksum")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetIntegrityChecksum indicates an expected call of GetIntegrityChecksum.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetIntegrityChecksum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIntegrityChecksum", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetIntegrityChecksum))
}

// GetLogs mocks base method.
func (m *MockGCStaleVersionObjectTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetMaxRetry))
}

// GetObjectId mocks base method.
func (m *MockGCStaleVersionObjectTask) GetObjectId() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectId")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetObjectId indicates an expected call of GetObjectId.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetObjectId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectId", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetObjectId))
}

// GetObjectSize mocks base method.
func (m *MockGCStaleVersionObjectTask) GetObjectSize() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectSize")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetObjectSize indicates an expected call of GetObjectSize.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetObjectSize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectSize", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetObjectSize))
}

// GetPieceChecksumList mocks base method.
func (m *MockGCStaleVersionObjectTask) GetPieceChecksumList() [][]byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPieceChecksumList")
	ret0, _ := ret[0].([][]byte)
	return ret0
}

// GetPieceChecksumList indicates an expected call of GetPieceChecksumList.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetPieceChecksumList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPieceChecksumList", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetPieceChecksumList))
}

// GetPriority mocks base method.
func (m *MockGCStaleVersionObjectTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetPriority))
}

// GetRedundancyIndex mocks base method.
func (m *MockGCStaleVersionObjectTask) GetRedundancyIndex() int32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRedundancyIndex")
	ret0, _ := ret[0].(int32)
	return ret0
}

// GetRedundancyIndex indicates an expected call of GetRedundancyIndex.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetRedundancyIndex() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRedundancyIndex", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetRedundancyIndex))
}

// GetRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetRetry))
}

// GetTimeout mocks base method.
func (m *MockGCStaleVersionObjectTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockGCStaleVersionObjectTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockGCStaleVersionObjectTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetUserAddress))
}

// GetVersion mocks base method.
func (m *MockGCStaleVersionObjectTask) GetVersion() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersion")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetVersion indicates an expected call of GetVersion.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) GetVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).GetVersion))
}

// IncRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockGCStaleVersionObjectTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).Info))
}

// InitGCStaleVersionObjectTask mocks base method.
func (m *MockGCStaleVersionObjectTask) InitGCStaleVersionObjectTask(priority TPriority, objectID uint64, redundancyIndex int32, integrityChecksum []byte, pieceChecksumList [][]byte, version int64, objectSize uint64, timeout int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitGCStaleVersionObjectTask", priority, objectID, redundancyIndex, integrityChecksum, pieceChecksumList, version, objectSize, timeout)
}

// InitGCStaleVersionObjectTask indicates an expected call of InitGCStaleVersionObjectTask.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) InitGCStaleVersionObjectTask(priority, objectID, redundancyIndex, integrityChecksum, pieceChecksumList, version, objectSize, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCStaleVersionObjectTask", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).InitGCStaleVersionObjectTask), priority, objectID, redundancyIndex, integrityChecksum, pieceChecksumList, version, objectSize, timeout)
}

// Key mocks base method.
func (m *MockGCStaleVersionObjectTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockGCStaleVersionObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCStaleVersionObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockGCStaleVersionObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetError), arg0)
}

// SetIntegrityChecksum mocks base method.
func (m *MockGCStaleVersionObjectTask) SetIntegrityChecksum(integrityChecksum []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIntegrityChecksum", integrityChecksum)
}

// SetIntegrityChecksum indicates an expected call of SetIntegrityChecksum.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetIntegrityChecksum(integrityChecksum any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIntegrityChecksum", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetIntegrityChecksum), integrityChecksum)
}

// SetLogs mocks base method.
func (m *MockGCStaleVersionObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetMaxRetry), arg0)
}

// SetObjectID mocks base method.
func (m *MockGCStaleVersionObjectTask) SetObjectID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectID", arg0)
}

// SetObjectID indicates an expected call of SetObjectID.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetObjectID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectID", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetObjectID), arg0)
}

// SetObjectSize mocks base method.
func (m *MockGCStaleVersionObjectTask) SetObjectSize(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectSize", arg0)
}

// SetObjectSize indicates an expected call of SetObjectSize.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetObjectSize(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectSize", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetObjectSize), arg0)
}

// SetPieceChecksumList mocks base method.
func (m *MockGCStaleVersionObjectTask) SetPieceChecksumList(pieceChecksumList [][]byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPieceChecksumList", pieceChecksumList)
}

// SetPieceChecksumList indicates an expected call of SetPieceChecksumList.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetPieceChecksumList(pieceChecksumList any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPieceChecksumList", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetPieceChecksumList), pieceChecksumList)
}

// SetPriority mocks base method.
func (m *MockGCStaleVersionObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetPriority), arg0)
}

// SetRedundancyIndex mocks base method.
func (m *MockGCStaleVersionObjectTask) SetRedundancyIndex(arg0 int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRedundancyIndex", arg0)
}

// SetRedundancyIndex indicates an expected call of SetRedundancyIndex.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetRedundancyIndex(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIndex", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetRedundancyIndex), arg0)
}

// SetRetry mocks base method.
func (m *MockGCStaleVersionObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCStaleVersionObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockGCStaleVersionObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCStaleVersionObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetUserAddress), arg0)
}

// SetVersion mocks base method.
func (m *MockGCStaleVersionObjectTask) SetVersion(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVersion", arg0)
}

// SetVersion indicates an expected call of SetVersion.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) SetVersion(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersion", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).SetVersion), arg0)
}

// Type mocks base method.
func (m *MockGCStaleVersionObjectTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockGCStaleVersionObjectTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockGCStaleVersionObjectTask)(nil).Type))
}

// MockGCMetaTask is a mock of GCMetaTask interface.
type MockGCMetaTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCMetaTaskMockRecorder
}

// MockGCMetaTaskMockRecorder is the mock recorder for MockGCMetaTask.
type MockGCMetaTaskMockRecorder struct {
	mock *MockGCMetaTask
}

// NewMockGCMetaTask creates a new mock instance.
func NewMockGCMetaTask(ctrl *gomock.Controller) *MockGCMetaTask {
	mock := &MockGCMetaTask{ctrl: ctrl}
	mock.recorder = &MockGCMetaTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGCMetaTask) EXPECT() *MockGCMetaTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockGCMetaTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCMetaTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCMetaTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockGCMetaTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockGCMetaTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockGCMetaTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockGCMetaTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockGCMetaTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockGCMetaTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockGCMetaTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockGCMetaTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockGCMetaTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockGCMetaTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockGCMetaTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockGCMetaTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockGCMetaTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockGCMetaTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockGCMetaTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockGCMetaTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockGCMetaTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockGCMetaTask)(nil).GetAddress))
}

// GetCreateTime mocks base method.
func (m *MockGCMetaTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockGCMetaTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockGCMetaTask)(nil).GetCreateTime))
}

// GetGCMetaStatus mocks base method.
func (m *MockGCMetaTask) GetGCMetaStatus() (uint64, uint64) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGCMetaStatus")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	return ret0, ret1
}

// GetGCMetaStatus indicates an expected call of GetGCMetaStatus.
func (mr *MockGCMetaTaskMockRecorder) GetGCMetaStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCMetaStatus", reflect.TypeOf((*MockGCMetaTask)(nil).GetGCMetaStatus))
}

// GetLogs mocks base method.
func (m *MockGCMetaTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockGCMetaTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockGCMetaTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockGCMetaTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockGCMetaTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockGCMetaTask)(nil).GetMaxRetry))
}

// GetPriority mocks base method.
func (m *MockGCMetaTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockGCMetaTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockGCMetaTask)(nil).GetPriority))
}

// GetRetry mocks base method.
func (m *MockGCMetaTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockGCMetaTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockGCMetaTask)(nil).GetRetry))
}

// GetTimeout mocks base method.
func (m *MockGCMetaTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockGCMetaTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockGCMetaTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockGCMetaTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockGCMetaTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockGCMetaTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockGCMetaTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockGCMetaTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockGCMetaTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockGCMetaTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockGCMetaTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockGCMetaTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockGCMetaTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockGCMetaTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockGCMetaTask)(nil).Info))
}

// Key mocks base method.
func (m *MockGCMetaTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockGCMetaTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockGCMetaTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockGCMetaTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCMetaTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCMetaTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCMetaTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCMetaTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCMetaTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockGCMetaTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCMetaTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCMetaTask)(nil).SetError), arg0)
}

// SetGCMetaStatus mocks base method.
func (m *MockGCMetaTask) SetGCMetaStatus(arg0, arg1 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGCMetaStatus", arg0, arg1)
}

// SetGCMetaStatus indicates an expected call of SetGCMetaStatus.
func (mr *MockGCMetaTaskMockRecorder) SetGCMetaStatus(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCMetaStatus", reflect.TypeOf((*MockGCMetaTask)(nil).SetGCMetaStatus), arg0, arg1)
}

// SetLogs mocks base method.
func (m *MockGCMetaTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCMetaTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCMetaTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCMetaTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCMetaTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCMetaTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockGCMetaTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCMetaTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCMetaTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockGCMetaTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCMetaTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCMetaTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCMetaTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCMetaTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCMetaTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockGCMetaTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCMetaTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCMetaTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCMetaTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCMetaTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCMetaTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockGCMetaTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockGCMetaTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockGCMetaTask)(nil).Type))
}

// MockRecoveryPieceTask is a mock of RecoveryPieceTask interface.
type MockRecoveryPieceTask struct {
	ctrl     *gomock.Controller
	recorder *MockRecoveryPieceTaskMockRecorder
}

// MockRecoveryPieceTaskMockRecorder is the mock recorder for MockRecoveryPieceTask.
type MockRecoveryPieceTaskMockRecorder struct {
	mock *MockRecoveryPieceTask
}

// NewMockRecoveryPieceTask creates a new mock instance.
func NewMockRecoveryPieceTask(ctrl *gomock.Controller) *MockRecoveryPieceTask {
	mock := &MockRecoveryPieceTask{ctrl: ctrl}
	mock.recorder = &MockRecoveryPieceTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRecoveryPieceTask) EXPECT() *MockRecoveryPieceTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockRecoveryPieceTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockRecoveryPieceTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockRecoveryPieceTask)(nil).AppendLog), log)
}

// BySuccessorSP mocks base method.
func (m *MockRecoveryPieceTask) BySuccessorSP() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BySuccessorSP")
	ret0, _ := ret[0].(bool)
	return ret0
}

// BySuccessorSP indicates an expected call of BySuccessorSP.
func (mr *MockRecoveryPieceTaskMockRecorder) BySuccessorSP() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BySuccessorSP", reflect.TypeOf((*MockRecoveryPieceTask)(nil).BySuccessorSP))
}

// Error mocks base method.
func (m *MockRecoveryPieceTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockRecoveryPieceTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockRecoveryPieceTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockRecoveryPieceTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockRecoveryPieceTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockRecoveryPieceTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockRecoveryPieceTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockRecoveryPieceTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockRecoveryPieceTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockRecoveryPieceTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockRecoveryPieceTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockRecoveryPieceTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockRecoveryPieceTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockRecoveryPieceTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockRecoveryPieceTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetAddress))
}

// GetCreateTime mocks base method.
func (m *MockRecoveryPieceTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockRecoveryPieceTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetCreateTime))
}

// GetEcIdx mocks base method.
func (m *MockRecoveryPieceTask) GetEcIdx() int32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEcIdx")
	ret0, _ := ret[0].(int32)
	return ret0
}

// GetEcIdx indicates an expected call of GetEcIdx.
func (mr *MockRecoveryPieceTaskMockRecorder) GetEcIdx() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEcIdx", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetEcIdx))
}

// GetGVGID mocks base method.
func (m *MockRecoveryPieceTask) GetGVGID() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGVGID")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// GetGVGID indicates an expected call of GetGVGID.
func (mr *MockRecoveryPieceTaskMockRecorder) GetGVGID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGVGID", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetGVGID))
}

// GetLogs mocks base method.
func (m *MockRecoveryPieceTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockRecoveryPieceTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockRecoveryPieceTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetMaxRetry))
}

// GetObjectInfo mocks base method.
func (m *MockRecoveryPieceTask) GetObjectInfo() *types0.ObjectInfo {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectInfo")
	ret0, _ := ret[0].(*types0.ObjectInfo)
	return ret0
}

// GetObjectInfo indicates an expected call of GetObjectInfo.
func (mr *MockRecoveryPieceTaskMockRecorder) GetObjectInfo() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectInfo", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetObjectInfo))
}

// GetPriority mocks base method.
func (m *MockRecoveryPieceTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockRecoveryPieceTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetPriority))
}

// GetRecovered mocks base method.
func (m *MockRecoveryPieceTask) GetRecovered() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRecovered")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GetRecovered indicates an expected call of GetRecovered.
func (mr *MockRecoveryPieceTaskMockRecorder) GetRecovered() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecovered", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetRecovered))
}

// GetRetry mocks base method.
func (m *MockRecoveryPieceTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetRetry))
}

// GetSegmentIdx mocks base method.
func (m *MockRecoveryPieceTask) GetSegmentIdx() uint32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSegmentIdx")
	ret0, _ := ret[0].(uint32)
	return ret0
}

// GetSegmentIdx indicates an expected call of GetSegmentIdx.
func (mr *MockRecoveryPieceTaskMockRecorder) GetSegmentIdx() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSegmentIdx", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetSegmentIdx))
}

// GetSignBytes mocks base method.
func (m *MockRecoveryPieceTask) GetSignBytes() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignBytes")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetSignBytes indicates an expected call of GetSignBytes.
func (mr *MockRecoveryPieceTaskMockRecorder) GetSignBytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignBytes", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetSignBytes))
}

// GetSignature mocks base method.
func (m *MockRecoveryPieceTask) GetSignature() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignature")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetSignature indicates an expected call of GetSignature.
func (mr *MockRecoveryPieceTaskMockRecorder) GetSignature() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignature", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetSignature))
}

// GetStorageParams mocks base method.
func (m *MockRecoveryPieceTask) GetStorageParams() *types0.Params {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageParams")
	ret0, _ := ret[0].(*types0.Params)
	return ret0
}

// GetStorageParams indicates an expected call of GetStorageParams.
func (mr *MockRecoveryPieceTaskMockRecorder) GetStorageParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageParams", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetStorageParams))
}

// GetTimeout mocks base method.
func (m *MockRecoveryPieceTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockRecoveryPieceTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockRecoveryPieceTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockRecoveryPieceTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockRecoveryPieceTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockRecoveryPieceTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockRecoveryPieceTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockRecoveryPieceTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockRecoveryPieceTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockRecoveryPieceTask)(nil).Info))
}

// InitRecoverPieceTask mocks base method.
func (m *MockRecoveryPieceTask) InitRecoverPieceTask(object *types0.ObjectInfo, params *types0.Params, priority TPriority, pieceIdx uint32, ecIdx int32, pieceSize uint64, timeout, retry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitRecoverPieceTask", object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry)
}

// InitRecoverPieceTask indicates an expected call of InitRecoverPieceTask.
func (mr *MockRecoveryPieceTaskMockRecorder) InitRecoverPieceTask(object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitRecoverPieceTask", reflect.TypeOf((*MockRecoveryPieceTask)(nil).InitRecoverPieceTask), object, params, priority, pieceIdx, ecIdx, pieceSize, timeout, retry)
}

// Key mocks base method.
func (m *MockRecoveryPieceTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockRecoveryPieceTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockRecoveryPieceTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockRecoveryPieceTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockRecoveryPieceTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockRecoveryPieceTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockRecoveryPieceTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockRecoveryPieceTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockRecoveryPieceTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetError), arg0)
}

// SetLogs mocks base method.
func (m *MockRecoveryPieceTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockRecoveryPieceTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockRecoveryPieceTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetMaxRetry), arg0)
}

// SetObjectInfo mocks base method.
func (m *MockRecoveryPieceTask) SetObjectInfo(arg0 *types0.ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", arg0)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockRecoveryPieceTaskMockRecorder) SetObjectInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetObjectInfo), arg0)
}

// SetPriority mocks base method.
func (m *MockRecoveryPieceTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockRecoveryPieceTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetPriority), arg0)
}

// SetRecoverDone mocks base method.
func (m *MockRecoveryPieceTask) SetRecoverDone() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRecoverDone")
}

// SetRecoverDone indicates an expected call of SetRecoverDone.
func (mr *MockRecoveryPieceTaskMockRecorder) SetRecoverDone() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRecoverDone", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetRecoverDone))
}

// SetRetry mocks base method.
func (m *MockRecoveryPieceTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockRecoveryPieceTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetRetry), arg0)
}

// SetSignature mocks base method.
func (m *MockRecoveryPieceTask) SetSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSignature", arg0)
}

// SetSignature indicates an expected call of SetSignature.
func (mr *MockRecoveryPieceTaskMockRecorder) SetSignature(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetSignature), arg0)
}

// SetStorageParams mocks base method.
func (m *MockRecoveryPieceTask) SetStorageParams(arg0 *types0.Params) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorageParams", arg0)
}

// SetStorageParams indicates an expected call of SetStorageParams.
func (mr *MockRecoveryPieceTaskMockRecorder) SetStorageParams(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorageParams", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetStorageParams), arg0)
}

// SetTimeout mocks base method.
func (m *MockRecoveryPieceTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockRecoveryPieceTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockRecoveryPieceTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockRecoveryPieceTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockRecoveryPieceTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockRecoveryPieceTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockRecoveryPieceTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockRecoveryPieceTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockRecoveryPieceTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockRecoveryPieceTask)(nil).Type))
}

// MockMigrateGVGTask is a mock of MigrateGVGTask interface.
type MockMigrateGVGTask struct {
	ctrl     *gomock.Controller
	recorder *MockMigrateGVGTaskMockRecorder
}

// MockMigrateGVGTaskMockRecorder is the mock recorder for MockMigrateGVGTask.
type MockMigrateGVGTaskMockRecorder struct {
	mock *MockMigrateGVGTask
}

// NewMockMigrateGVGTask creates a new mock instance.
func NewMockMigrateGVGTask(ctrl *gomock.Controller) *MockMigrateGVGTask {
	mock := &MockMigrateGVGTask{ctrl: ctrl}
	mock.recorder = &MockMigrateGVGTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMigrateGVGTask) EXPECT() *MockMigrateGVGTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockMigrateGVGTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockMigrateGVGTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockMigrateGVGTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockMigrateGVGTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockMigrateGVGTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockMigrateGVGTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockMigrateGVGTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockMigrateGVGTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockMigrateGVGTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockMigrateGVGTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockMigrateGVGTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockMigrateGVGTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockMigrateGVGTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockMigrateGVGTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockMigrateGVGTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockMigrateGVGTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockMigrateGVGTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockMigrateGVGTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockMigrateGVGTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetAddress))
}

// GetBucketID mocks base method.
func (m *MockMigrateGVGTask) GetBucketID() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketID")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetBucketID indicates an expected call of GetBucketID.
func (mr *MockMigrateGVGTaskMockRecorder) GetBucketID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketID", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetBucketID))
}

// GetCreateTime mocks base method.
func (m *MockMigrateGVGTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockMigrateGVGTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetCreateTime))
}

// GetDestGvg mocks base method.
func (m *MockMigrateGVGTask) GetDestGvg() *types1.GlobalVirtualGroup {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDestGvg")
	ret0, _ := ret[0].(*types1.GlobalVirtualGroup)
	return ret0
}

// GetDestGvg indicates an expected call of GetDestGvg.
func (mr *MockMigrateGVGTaskMockRecorder) GetDestGvg() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDestGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetDestGvg))
}

// GetFinished mocks base method.
func (m *MockMigrateGVGTask) GetFinished() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFinished")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GetFinished indicates an expected call of GetFinished.
func (mr *MockMigrateGVGTaskMockRecorder) GetFinished() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinished", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetFinished))
}

// GetLastMigratedObjectID mocks base method.
func (m *MockMigrateGVGTask) GetLastMigratedObjectID() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastMigratedObjectID")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetLastMigratedObjectID indicates an expected call of GetLastMigratedObjectID.
func (mr *MockMigrateGVGTaskMockRecorder) GetLastMigratedObjectID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastMigratedObjectID", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetLastMigratedObjectID))
}

// GetLogs mocks base method.
func (m *MockMigrateGVGTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockMigrateGVGTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockMigrateGVGTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockMigrateGVGTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetMaxRetry))
}

// GetMigratedBytesSize mocks base method.
func (m *MockMigrateGVGTask) GetMigratedBytesSize() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMigratedBytesSize")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetMigratedBytesSize indicates an expected call of GetMigratedBytesSize.
func (mr *MockMigrateGVGTaskMockRecorder) GetMigratedBytesSize() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMigratedBytesSize", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetMigratedBytesSize))
}

// GetPriority mocks base method.
func (m *MockMigrateGVGTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockMigrateGVGTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetPriority))
}

// GetRedundancyIdx mocks base method.
func (m *MockMigrateGVGTask) GetRedundancyIdx() int32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRedundancyIdx")
	ret0, _ := ret[0].(int32)
	return ret0
}

// GetRedundancyIdx indicates an expected call of GetRedundancyIdx.
func (mr *MockMigrateGVGTaskMockRecorder) GetRedundancyIdx() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRedundancyIdx", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetRedundancyIdx))
}

// GetRetry mocks base method.
func (m *MockMigrateGVGTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockMigrateGVGTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetRetry))
}

// GetSignBytes mocks base method.
func (m *MockMigrateGVGTask) GetSignBytes() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSignBytes")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// GetSignBytes indicates an expected call of GetSignBytes.
func (mr *MockMigrateGVGTaskMockRecorder) GetSignBytes() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSignBytes", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetSignBytes))
}

// GetSrcGvg mocks base method.
func (m *MockMigrateGVGTask) GetSrcGvg() *types1.GlobalVirtualGroup {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSrcGvg")
	ret0, _ := ret[0].(*types1.GlobalVirtualGroup)
	return ret0
}

// GetSrcGvg indicates an expected call of GetSrcGvg.
func (mr *MockMigrateGVGTaskMockRecorder) GetSrcGvg() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSrcGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetSrcGvg))
}

// GetSrcSp mocks base method.
func (m *MockMigrateGVGTask) GetSrcSp() *types.StorageProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSrcSp")
	ret0, _ := ret[0].(*types.StorageProvider)
	return ret0
}

// GetSrcSp indicates an expected call of GetSrcSp.
func (mr *MockMigrateGVGTaskMockRecorder) GetSrcSp() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSrcSp", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetSrcSp))
}

// GetTimeout mocks base method.
func (m *MockMigrateGVGTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockMigrateGVGTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockMigrateGVGTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockMigrateGVGTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockMigrateGVGTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockMigrateGVGTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockMigrateGVGTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockMigrateGVGTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockMigrateGVGTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockMigrateGVGTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockMigrateGVGTask)(nil).Info))
}

// InitMigrateGVGTask mocks base method.
func (m *MockMigrateGVGTask) InitMigrateGVGTask(priority TPriority, bucketID uint64, srcGvg *types1.GlobalVirtualGroup, redundancyIndex int32, srcSP *types.StorageProvider, timeout, retry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitMigrateGVGTask", priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry)
}

// InitMigrateGVGTask indicates an expected call of InitMigrateGVGTask.
func (mr *MockMigrateGVGTaskMockRecorder) InitMigrateGVGTask(priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitMigrateGVGTask", reflect.TypeOf((*MockMigrateGVGTask)(nil).InitMigrateGVGTask), priority, bucketID, srcGvg, redundancyIndex, srcSP, timeout, retry)
}

// Key mocks base method.
func (m *MockMigrateGVGTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockMigrateGVGTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockMigrateGVGTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockMigrateGVGTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockMigrateGVGTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetAddress), arg0)
}

// SetBucketID mocks base method.
func (m *MockMigrateGVGTask) SetBucketID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketID", arg0)
}

// SetBucketID indicates an expected call of SetBucketID.
func (mr *MockMigrateGVGTaskMockRecorder) SetBucketID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketID", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetBucketID), arg0)
}

// SetCreateTime mocks base method.
func (m *MockMigrateGVGTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockMigrateGVGTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetCreateTime), arg0)
}

// SetDestGvg mocks base method.
func (m *MockMigrateGVGTask) SetDestGvg(arg0 *types1.GlobalVirtualGroup) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDestGvg", arg0)
}

// SetDestGvg indicates an expected call of SetDestGvg.
func (mr *MockMigrateGVGTaskMockRecorder) SetDestGvg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDestGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetDestGvg), arg0)
}

// SetError mocks base method.
func (m *MockMigrateGVGTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockMigrateGVGTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetError), arg0)
}

// SetFinished mocks base method.
func (m *MockMigrateGVGTask) SetFinished(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFinished", arg0)
}

// SetFinished indicates an expected call of SetFinished.
func (mr *MockMigrateGVGTaskMockRecorder) SetFinished(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetFinished), arg0)
}

// SetLastMigratedObjectID mocks base method.
func (m *MockMigrateGVGTask) SetLastMigratedObjectID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastMigratedObjectID", arg0)
}

// SetLastMigratedObjectID indicates an expected call of SetLastMigratedObjectID.
func (mr *MockMigrateGVGTaskMockRecorder) SetLastMigratedObjectID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastMigratedObjectID", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetLastMigratedObjectID), arg0)
}

// SetLogs mocks base method.
func (m *MockMigrateGVGTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockMigrateGVGTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockMigrateGVGTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockMigrateGVGTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetMaxRetry), arg0)
}

// SetMigratedBytesSize mocks base method.
func (m *MockMigrateGVGTask) SetMigratedBytesSize(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMigratedBytesSize", arg0)
}

// SetMigratedBytesSize indicates an expected call of SetMigratedBytesSize.
func (mr *MockMigrateGVGTaskMockRecorder) SetMigratedBytesSize(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMigratedBytesSize", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetMigratedBytesSize), arg0)
}

// SetPriority mocks base method.
func (m *MockMigrateGVGTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockMigrateGVGTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetPriority), arg0)
}

// SetRedundancyIdx mocks base method.
func (m *MockMigrateGVGTask) SetRedundancyIdx(arg0 int32) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRedundancyIdx", arg0)
}

// SetRedundancyIdx indicates an expected call of SetRedundancyIdx.
func (mr *MockMigrateGVGTaskMockRecorder) SetRedundancyIdx(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRedundancyIdx", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetRedundancyIdx), arg0)
}

// SetRetry mocks base method.
func (m *MockMigrateGVGTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockMigrateGVGTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetRetry), arg0)
}

// SetSignature mocks base method.
func (m *MockMigrateGVGTask) SetSignature(arg0 []byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSignature", arg0)
}

// SetSignature indicates an expected call of SetSignature.
func (mr *MockMigrateGVGTaskMockRecorder) SetSignature(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSignature", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSignature), arg0)
}

// SetSrcGvg mocks base method.
func (m *MockMigrateGVGTask) SetSrcGvg(arg0 *types1.GlobalVirtualGroup) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSrcGvg", arg0)
}

// SetSrcGvg indicates an expected call of SetSrcGvg.
func (mr *MockMigrateGVGTaskMockRecorder) SetSrcGvg(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSrcGvg", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSrcGvg), arg0)
}

// SetSrcSp mocks base method.
func (m *MockMigrateGVGTask) SetSrcSp(arg0 *types.StorageProvider) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSrcSp", arg0)
}

// SetSrcSp indicates an expected call of SetSrcSp.
func (mr *MockMigrateGVGTaskMockRecorder) SetSrcSp(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSrcSp", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetSrcSp), arg0)
}

// SetTimeout mocks base method.
func (m *MockMigrateGVGTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockMigrateGVGTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockMigrateGVGTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockMigrateGVGTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockMigrateGVGTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockMigrateGVGTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockMigrateGVGTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockMigrateGVGTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockMigrateGVGTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockMigrateGVGTask)(nil).Type))
}

// MockGCBucketMigrationTask is a mock of GCBucketMigrationTask interface.
type MockGCBucketMigrationTask struct {
	ctrl     *gomock.Controller
	recorder *MockGCBucketMigrationTaskMockRecorder
}

// MockGCBucketMigrationTaskMockRecorder is the mock recorder for MockGCBucketMigrationTask.
type MockGCBucketMigrationTaskMockRecorder struct {
	mock *MockGCBucketMigrationTask
}

// NewMockGCBucketMigrationTask creates a new mock instance.
func NewMockGCBucketMigrationTask(ctrl *gomock.Controller) *MockGCBucketMigrationTask {
	mock := &MockGCBucketMigrationTask{ctrl: ctrl}
	mock.recorder = &MockGCBucketMigrationTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGCBucketMigrationTask) EXPECT() *MockGCBucketMigrationTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockGCBucketMigrationTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockGCBucketMigrationTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockGCBucketMigrationTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockGCBucketMigrationTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockGCBucketMigrationTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockGCBucketMigrationTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockGCBucketMigrationTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockGCBucketMigrationTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockGCBucketMigrationTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockGCBucketMigrationTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockGCBucketMigrationTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockGCBucketMigrationTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetAddress))
}

// GetBucketID mocks base method.
func (m *MockGCBucketMigrationTask) GetBucketID() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketID")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetBucketID indicates an expected call of GetBucketID.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetBucketID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetBucketID))
}

// GetCreateTime mocks base method.
func (m *MockGCBucketMigrationTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetCreateTime))
}

// GetFinished mocks base method.
func (m *MockGCBucketMigrationTask) GetFinished() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFinished")
	ret0, _ := ret[0].(bool)
	return ret0
}

// GetFinished indicates an expected call of GetFinished.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetFinished() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFinished", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetFinished))
}

// GetGCFinishedGvgNum mocks base method.
func (m *MockGCBucketMigrationTask) GetGCFinishedGvgNum() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGCFinishedGvgNum")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetGCFinishedGvgNum indicates an expected call of GetGCFinishedGvgNum.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetGCFinishedGvgNum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGCFinishedGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetGCFinishedGvgNum))
}

// GetLastGCGvgID mocks base method.
func (m *MockGCBucketMigrationTask) GetLastGCGvgID() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastGCGvgID")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetLastGCGvgID indicates an expected call of GetLastGCGvgID.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetLastGCGvgID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastGCGvgID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetLastGCGvgID))
}

// GetLastGCObjectID mocks base method.
func (m *MockGCBucketMigrationTask) GetLastGCObjectID() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLastGCObjectID")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetLastGCObjectID indicates an expected call of GetLastGCObjectID.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetLastGCObjectID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLastGCObjectID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetLastGCObjectID))
}

// GetLogs mocks base method.
func (m *MockGCBucketMigrationTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockGCBucketMigrationTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetMaxRetry))
}

// GetPriority mocks base method.
func (m *MockGCBucketMigrationTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetPriority))
}

// GetRetry mocks base method.
func (m *MockGCBucketMigrationTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetRetry))
}

// GetTimeout mocks base method.
func (m *MockGCBucketMigrationTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetTimeout))
}

// GetTotalGvgNum mocks base method.
func (m *MockGCBucketMigrationTask) GetTotalGvgNum() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTotalGvgNum")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetTotalGvgNum indicates an expected call of GetTotalGvgNum.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetTotalGvgNum() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetTotalGvgNum))
}

// GetUpdateTime mocks base method.
func (m *MockGCBucketMigrationTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockGCBucketMigrationTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockGCBucketMigrationTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockGCBucketMigrationTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockGCBucketMigrationTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockGCBucketMigrationTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).Info))
}

// InitGCBucketMigrationTask mocks base method.
func (m *MockGCBucketMigrationTask) InitGCBucketMigrationTask(priority TPriority, bucketID uint64, timeout, retry int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitGCBucketMigrationTask", priority, bucketID, timeout, retry)
}

// InitGCBucketMigrationTask indicates an expected call of InitGCBucketMigrationTask.
func (mr *MockGCBucketMigrationTaskMockRecorder) InitGCBucketMigrationTask(priority, bucketID, timeout, retry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGCBucketMigrationTask", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).InitGCBucketMigrationTask), priority, bucketID, timeout, retry)
}

// Key mocks base method.
func (m *MockGCBucketMigrationTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockGCBucketMigrationTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockGCBucketMigrationTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetAddress), arg0)
}

// SetBucketID mocks base method.
func (m *MockGCBucketMigrationTask) SetBucketID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketID", arg0)
}

// SetBucketID indicates an expected call of SetBucketID.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetBucketID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetBucketID), arg0)
}

// SetCreateTime mocks base method.
func (m *MockGCBucketMigrationTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetCreateTime), arg0)
}

// SetError mocks base method.
func (m *MockGCBucketMigrationTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetError), arg0)
}

// SetFinished mocks base method.
func (m *MockGCBucketMigrationTask) SetFinished(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFinished", arg0)
}

// SetFinished indicates an expected call of SetFinished.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetFinished(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinished", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetFinished), arg0)
}

// SetGCFinishedGvgNum mocks base method.
func (m *MockGCBucketMigrationTask) SetGCFinishedGvgNum(gvgGcNum uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGCFinishedGvgNum", gvgGcNum)
}

// SetGCFinishedGvgNum indicates an expected call of SetGCFinishedGvgNum.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetGCFinishedGvgNum(gvgGcNum any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGCFinishedGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetGCFinishedGvgNum), gvgGcNum)
}

// SetLastGCGvgID mocks base method.
func (m *MockGCBucketMigrationTask) SetLastGCGvgID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastGCGvgID", arg0)
}

// SetLastGCGvgID indicates an expected call of SetLastGCGvgID.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetLastGCGvgID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastGCGvgID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLastGCGvgID), arg0)
}

// SetLastGCObjectID mocks base method.
func (m *MockGCBucketMigrationTask) SetLastGCObjectID(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastGCObjectID", arg0)
}

// SetLastGCObjectID indicates an expected call of SetLastGCObjectID.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetLastGCObjectID(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLastGCObjectID", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLastGCObjectID), arg0)
}

// SetLogs mocks base method.
func (m *MockGCBucketMigrationTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockGCBucketMigrationTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockGCBucketMigrationTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockGCBucketMigrationTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockGCBucketMigrationTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetTimeout), arg0)
}

// SetTotalGvgNum mocks base method.
func (m *MockGCBucketMigrationTask) SetTotalGvgNum(gvgNum uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTotalGvgNum", gvgNum)
}

// SetTotalGvgNum indicates an expected call of SetTotalGvgNum.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetTotalGvgNum(gvgNum any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTotalGvgNum", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetTotalGvgNum), gvgNum)
}

// SetUpdateTime mocks base method.
func (m *MockGCBucketMigrationTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockGCBucketMigrationTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockGCBucketMigrationTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockGCBucketMigrationTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockGCBucketMigrationTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockGCBucketMigrationTask)(nil).Type))
}

// MockApprovalDelegateCreateObjectTask is a mock of ApprovalDelegateCreateObjectTask interface.
type MockApprovalDelegateCreateObjectTask struct {
	ctrl     *gomock.Controller
	recorder *MockApprovalDelegateCreateObjectTaskMockRecorder
}

// MockApprovalDelegateCreateObjectTaskMockRecorder is the mock recorder for MockApprovalDelegateCreateObjectTask.
type MockApprovalDelegateCreateObjectTaskMockRecorder struct {
	mock *MockApprovalDelegateCreateObjectTask
}

// NewMockApprovalDelegateCreateObjectTask creates a new mock instance.
func NewMockApprovalDelegateCreateObjectTask(ctrl *gomock.Controller) *MockApprovalDelegateCreateObjectTask {
	mock := &MockApprovalDelegateCreateObjectTask{ctrl: ctrl}
	mock.recorder = &MockApprovalDelegateCreateObjectTaskMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockApprovalDelegateCreateObjectTask) EXPECT() *MockApprovalDelegateCreateObjectTaskMockRecorder {
	return m.recorder
}

// AppendLog mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) AppendLog(log string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendLog", log)
}

// AppendLog indicates an expected call of AppendLog.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) AppendLog(log any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendLog", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).AppendLog), log)
}

// Error mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) Error() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Error")
	ret0, _ := ret[0].(error)
	return ret0
}

// Error indicates an expected call of Error.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Error", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).Error))
}

// EstimateLimit mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) EstimateLimit() rcmgr.Limit {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstimateLimit")
	ret0, _ := ret[0].(rcmgr.Limit)
	return ret0
}

// EstimateLimit indicates an expected call of EstimateLimit.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) EstimateLimit() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimateLimit", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).EstimateLimit))
}

// ExceedRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) ExceedRetry() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedRetry")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedRetry indicates an expected call of ExceedRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) ExceedRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).ExceedRetry))
}

// ExceedTimeout mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) ExceedTimeout() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExceedTimeout")
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExceedTimeout indicates an expected call of ExceedTimeout.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) ExceedTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExceedTimeout", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).ExceedTimeout))
}

// Expired mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) Expired() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expired")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Expired indicates an expected call of Expired.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) Expired() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expired", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).Expired))
}

// GetAddress mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetAddress indicates an expected call of GetAddress.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAddress", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetAddress))
}

// GetCreateTime mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetCreateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCreateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetCreateTime indicates an expected call of GetCreateTime.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetCreateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCreateTime", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetCreateTime))
}

// GetDelegateCreateObject mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetDelegateCreateObject() *types0.MsgDelegateCreateObject {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDelegateCreateObject")
	ret0, _ := ret[0].(*types0.MsgDelegateCreateObject)
	return ret0
}

// GetDelegateCreateObject indicates an expected call of GetDelegateCreateObject.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetDelegateCreateObject() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDelegateCreateObject", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetDelegateCreateObject))
}

// GetExpiredHeight mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetExpiredHeight() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExpiredHeight")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// GetExpiredHeight indicates an expected call of GetExpiredHeight.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetExpiredHeight() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExpiredHeight", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetExpiredHeight))
}

// GetLogs mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetLogs() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLogs")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetLogs indicates an expected call of GetLogs.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetLogs() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogs", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetLogs))
}

// GetMaxRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetMaxRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMaxRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetMaxRetry indicates an expected call of GetMaxRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetMaxRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMaxRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetMaxRetry))
}

// GetPriority mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetPriority() TPriority {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPriority")
	ret0, _ := ret[0].(TPriority)
	return ret0
}

// GetPriority indicates an expected call of GetPriority.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetPriority() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPriority", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetPriority))
}

// GetRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetRetry() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRetry")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetRetry indicates an expected call of GetRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetRetry))
}

// GetTimeout mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetTimeout() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTimeout")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetTimeout indicates an expected call of GetTimeout.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetTimeout() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeout", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetTimeout))
}

// GetUpdateTime mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetUpdateTime() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUpdateTime")
	ret0, _ := ret[0].(int64)
	return ret0
}

// GetUpdateTime indicates an expected call of GetUpdateTime.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetUpdateTime() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUpdateTime", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetUpdateTime))
}

// GetUserAddress mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) GetUserAddress() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserAddress")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetUserAddress indicates an expected call of GetUserAddress.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) GetUserAddress() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).GetUserAddress))
}

// IncRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) IncRetry() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncRetry")
}

// IncRetry indicates an expected call of IncRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) IncRetry() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).IncRetry))
}

// Info mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) Info() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(string)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) Info() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).Info))
}

// InitApprovalDelegateCreateObjectTask mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) InitApprovalDelegateCreateObjectTask(arg0 string, arg1 *types0.MsgDelegateCreateObject, arg2 []byte, arg3 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InitApprovalDelegateCreateObjectTask", arg0, arg1, arg2, arg3)
}

// InitApprovalDelegateCreateObjectTask indicates an expected call of InitApprovalDelegateCreateObjectTask.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) InitApprovalDelegateCreateObjectTask(arg0, arg1, arg2, arg3 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitApprovalDelegateCreateObjectTask", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).InitApprovalDelegateCreateObjectTask), arg0, arg1, arg2, arg3)
}

// Key mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) Key() TKey {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(TKey)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).Key))
}

// SetAddress mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAddress", arg0)
}

// SetAddress indicates an expected call of SetAddress.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddress", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetAddress), arg0)
}

// SetCreateTime mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetCreateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCreateTime", arg0)
}

// SetCreateTime indicates an expected call of SetCreateTime.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetCreateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCreateTime", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetCreateTime), arg0)
}

// SetDelegateCreateObject mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetDelegateCreateObject(arg0 *types0.MsgDelegateCreateObject) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDelegateCreateObject", arg0)
}

// SetDelegateCreateObject indicates an expected call of SetDelegateCreateObject.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetDelegateCreateObject(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDelegateCreateObject", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetDelegateCreateObject), arg0)
}

// SetError mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetError(arg0 error) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetError", arg0)
}

// SetError indicates an expected call of SetError.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetError(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetError", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetError), arg0)
}

// SetExpiredHeight mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetExpiredHeight(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExpiredHeight", arg0)
}

// SetExpiredHeight indicates an expected call of SetExpiredHeight.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetExpiredHeight(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpiredHeight", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetExpiredHeight), arg0)
}

// SetLogs mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetLogs(logs string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogs", logs)
}

// SetLogs indicates an expected call of SetLogs.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetLogs(logs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogs", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetLogs), logs)
}

// SetMaxRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetMaxRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetMaxRetry", arg0)
}

// SetMaxRetry indicates an expected call of SetMaxRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetMaxRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetMaxRetry), arg0)
}

// SetPriority mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetPriority(arg0 TPriority) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPriority", arg0)
}

// SetPriority indicates an expected call of SetPriority.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetPriority(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPriority", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetPriority), arg0)
}

// SetRetry mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetRetry(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", arg0)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetRetry(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetRetry), arg0)
}

// SetTimeout mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetTimeout(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTimeout", arg0)
}

// SetTimeout indicates an expected call of SetTimeout.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetTimeout(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTimeout", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetTimeout), arg0)
}

// SetUpdateTime mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetUpdateTime(arg0 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUpdateTime", arg0)
}

// SetUpdateTime indicates an expected call of SetUpdateTime.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetUpdateTime(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdateTime", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetUpdateTime), arg0)
}

// SetUserAddress mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) SetUserAddress(arg0 string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetUserAddress", arg0)
}

// SetUserAddress indicates an expected call of SetUserAddress.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) SetUserAddress(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserAddress", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).SetUserAddress), arg0)
}

// Type mocks base method.
func (m *MockApprovalDelegateCreateObjectTask) Type() TType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(TType)
	return ret0
}

// Type indicates an expected call of Type.
func (mr *MockApprovalDelegateCreateObjectTaskMockRecorder) Type() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockApprovalDelegateCreateObjectTask)(nil).Type))
}
